# Codificador compatible con JSON { #json-compatible-encoder }

Hay algunos casos en los que podrías necesitar convertir un tipo de dato (como un modelo de Pydantic) a algo compatible con JSON (como un `dict`, `list`, etc).

Por ejemplo, si necesitas almacenarlo en una base de datos.

Para eso, **FastAPI** proporciona una función `jsonable_encoder()`.

## Usando el `jsonable_encoder` { #using-the-jsonable-encoder }

Se você verificar, a função está decorada com um `@asynccontextmanager`.

Isso converte a função em algo chamado "**gerenciador de contexto assíncrono**".

{* ../../docs_src/events/tutorial003_py39.py hl[1,13] *}

Um **gerenciador de contexto** em Python é algo que você pode usar em uma declaração `with`, por exemplo, `open()` pode ser usado como um gerenciador de contexto:

```Python

     */
    public boolean supportsAlgorithm(int algorithm) {
        if (this.compressionAlgorithms == null) {
            return false;
        }
        for (int algo : this.compressionAlgorithms) {
            if (algo == algorithm) {
                return true;
            }
        }
        return false;
    }

    @Override
    public int encode(byte[] dst, int dstIndex) {

Y envían un request con un nombre de usuario `johndoe` y una contraseña `love123`.

Entonces el código de Python en tu aplicación equivaldría a algo como:

```Python
if "johndoe" == "stanleyjobson" and "love123" == "swordfish":
    ...
```

Código assíncrono apenas significa que a linguagem 💬 tem um jeito de dizer para o computador / programa 🤖 que em certo ponto do código, ele 🤖 terá que esperar *algo* finalizar em outro lugar. Vamos dizer que esse *algo* seja chamado "arquivo lento" 📝.

Então, durante esse tempo, o computador pode ir e fazer outro trabalho, enquanto o "arquivo lento" 📝 termina.

Vamos imaginar que alguns invasores estão tentando adivinhar o usuário e a senha.

E eles enviam uma requisição com um usuário `johndoe` e uma senha `love123`.

Então o código Python em sua aplicação seria equivalente a algo como:

```Python
if "johndoe" == "stanleyjobson" and "love123" == "swordfish":
    ...
```

# Codificador Compatível com JSON { #json-compatible-encoder }

Existem alguns casos em que você pode precisar converter um tipo de dados (como um modelo Pydantic) para algo compatível com JSON (como um `dict`, `list`, etc).

Por exemplo, se você precisar armazená-lo em um banco de dados.

Para isso, **FastAPI** fornece uma função `jsonable_encoder()`.

## Usando a função `jsonable_encoder` { #using-the-jsonable-encoder }

    "servers": [
        {
            "url": "/api/v1"
        }
    ],
    "paths": {
            // Mais coisas aqui
    }
}
```

Neste exemplo, o "Proxy" poderia ser algo como **Traefik**. E o servidor seria algo como a CLI do FastAPI com **Uvicorn**, executando sua aplicação FastAPI.

### Fornecendo o `root_path` { #providing-the-root-path }

## Tipo de Retorno e Filtragem de Dados { #return-type-and-data-filtering }

Vamos continuar do exemplo anterior. Queríamos **anotar a função com um tipo**, mas queríamos poder retornar da função algo que realmente incluísse **mais dados**.

//// tab | Prueba

/// info | Información
Algo de texto
///

/// note | Nota
Algo de texto
///

/// note | Detalles técnicos
Algo de texto
///

/// check | Revisa
Algo de texto
///

/// tip | Consejo
Algo de texto
///

/// warning | Advertencia
Algo de texto
///

/// danger | Peligro
Algo de texto
///

////