{* ../../docs_src/extending_openapi/tutorial001.py hl[2,15:21] *}

### Modificar el esquema de OpenAPI

Ahora puedes añadir la extensión de ReDoc, agregando un `x-logo` personalizado al "objeto" `info` en el esquema de OpenAPI:

{* ../../docs_src/extending_openapi/tutorial001.py hl[22:24] *}

### Cachear el esquema de OpenAPI

Puedes usar la propiedad `.openapi_schema` como un "cache", para almacenar tu esquema generado.

# Body - Campos

De la misma manera que puedes declarar validaciones adicionales y metadatos en los parámetros de las *path operation function* con `Query`, `Path` y `Body`, puedes declarar validaciones y metadatos dentro de los modelos de Pydantic usando `Field` de Pydantic.

## Importar `Field`

Primero, tienes que importarlo:

{* ../../docs_src/body_fields/tutorial001_an_py310.py hl[4] *}

/// warning | Advertencia

				return
			}
		case "PoolIndex":
			z.PoolIndex, err = dc.ReadInt()
			if err != nil {
				err = msgp.WrapError(err, "PoolIndex")
				return
			}
		case "Queued":
			z.Queued, err = dc.ReadTime()
			if err != nil {
				err = msgp.WrapError(err, "Queued")
				return
			}
		case "BitrotScan":
			z.BitrotScan, err = dc.ReadBool()
			if err != nil {
				err = msgp.WrapError(err, "BitrotScan")
				return
			}

Puedes usar las mismas declaraciones de tipo con `str`, `float`, `bool` y muchos otros tipos de datos complejos.

Varios de estos se exploran en los siguientes capítulos del tutorial.

## El orden importa

Al crear *path operations*, puedes encontrarte en situaciones donde tienes un path fijo.

#### Union

Puedes declarar que una variable puede ser cualquier de **varios tipos**, por ejemplo, un `int` o un `str`.

En Python 3.6 y posterior (incluyendo Python 3.10) puedes usar el tipo `Union` de `typing` y poner dentro de los corchetes los posibles tipos a aceptar.

# Cookies de Response

## Usar un parámetro `Response`

Puedes declarar un parámetro de tipo `Response` en tu *path operation function*.

Y luego puedes establecer cookies en ese objeto de response *temporal*.

{* ../../docs_src/response_cookies/tutorial002.py hl[1, 8:9] *}

Y entonces puedes devolver cualquier objeto que necesites, como normalmente lo harías (un `dict`, un modelo de base de datos, etc).

# Modelo de Response - Tipo de Retorno

Puedes declarar el tipo utilizado para el response anotando el **tipo de retorno** de la *path operation function*.

Puedes utilizar **anotaciones de tipos** de la misma manera que lo harías para datos de entrada en **parámetros** de función, puedes utilizar modelos de Pydantic, listas, diccionarios, valores escalares como enteros, booleanos, etc.

{* ../../docs_src/response_model/tutorial001_01_py310.py hl[16,21] *}

### Incluye la documentación personalizada

Ahora puedes crear las *path operations* para la documentación personalizada.

Puedes reutilizar las funciones internas de FastAPI para crear las páginas HTML para la documentación, y pasarles los argumentos necesarios:

* `openapi_url`: la URL donde la página HTML para la documentación puede obtener el OpenAPI esquema de tu API. Puedes usar aquí el atributo `app.openapi_url`.

    startNs = queue.taskRunner.backend.nanoTime()
    log(task, queue, "starting")
  }

  var completedNormally = false
  try {
    val result = block()
    completedNormally = true
    return result
  } finally {
    if (loggingEnabled) {
      val elapsedNs = queue.taskRunner.backend.nanoTime() - startNs
      if (completedNormally) {
        log(task, queue, "finished run in ${formatDuration(elapsedNs)}")

Pero todavía quieres poder filtrar y convertir los datos que devuelves con un `response_model`.

Para esos casos, puedes usar un parámetro `Response`.

## Usa un parámetro `Response`

Puedes declarar un parámetro de tipo `Response` en tu *función de path operation* (como puedes hacer para cookies y headers).

Y luego puedes establecer el `status_code` en ese objeto de response *temporal*.