### La expresión del path del callback { #the-callback-path-expression }

El *path* del callback puede tener una <a href="https://github.com/OAI/OpenAPI-Specification/blob/master/versions/3.1.0.md#key-expression" class="external-link" target="_blank">expresión OpenAPI 3</a> que puede contener partes del request original enviado a *tu API*.

En este caso, es el `str`:

    with pytest.raises(ResponseValidationError) as excinfo:
        client.get("/response_model-no_annotation-return_invalid_dict")
    assert "missing" in str(excinfo.value)


def test_response_model_no_annotation_return_invalid_model():
    with pytest.raises(ResponseValidationError) as excinfo:
        client.get("/response_model-no_annotation-return_invalid_model")
    assert "missing" in str(excinfo.value)

            final String[] encodingPairs = value.split(",");
            for (final String pair : encodingPairs) {
                final String[] encInfos = pair.trim().split(":");
                if (encInfos.length == 2) {
                    encodingMap.put("/" + encInfos[0] + "/", encInfos[1]);
                }
            }
        }
    }

    /**

Hay casos donde quieres decirle a los **usuarios** de tu API que tu aplicación podría llamar a *su* aplicación (enviando una request) con algunos datos, normalmente para **notificar** de algún tipo de **evento**.

Esto significa que en lugar del proceso normal de tus usuarios enviando requests a tu API, es **tu API** (o tu aplicación) la que podría **enviar requests a su sistema** (a su API, su aplicación).

        try {
            FileInfo existing = children.get(childName);
            FileInfo newInfo = new FileInfo(childName, size, lastModified, isDirectory, attributes, creationTime, lastAccessTime);

            if (existing == null || !existing.matches(size, lastModified, attributes)) {
                children.put(childName, newInfo);
                hasChanges = true;
                lastUpdateTime = System.currentTimeMillis();

Así que tendrás que asegurarte de que tus datos son del tipo correcto. Por ejemplo, que sea compatible con JSON, si estás devolviendo un `JSONResponse`.

Y también que no estés enviando ningún dato que debería haber sido filtrado por un `response_model`.

///

### Más información { #more-info }

/// note | Detalles Técnicos

O processo que acontece quando sua aplicação de API chama a *API externa* é chamado de "callback". Porque o software que o desenvolvedor externo escreveu envia um request para sua API e então sua API *chama de volta*, enviando um request para uma *API externa* (que provavelmente foi criada pelo mesmo desenvolvedor).

Por ejemplo, para declarar un header de `X-Token` que puede aparecer más de una vez, puedes escribir:

{* ../../docs_src/header_params/tutorial003_an_py310.py hl[9] *}

Si te comunicas con esa *path operation* enviando dos headers HTTP como:

```
X-Token: foo
X-Token: bar
```

El response sería como:

```JSON
{
    "X-Token values": [
        "bar",
        "foo"
    ]
}
```

Pode ser uma função `async def` ou um `def` normal, o **FastAPI** saberá como lidar com isso corretamente.

Neste caso, a função da tarefa escreverá em um arquivo (simulando o envio de um e-mail).

E como a operação de escrita não usa `async` e `await`, definimos a função com um `def` normal:

{* ../../docs_src/background_tasks/tutorial001_py39.py hl[6:9] *}

Por exemplo, para declarar um cabeçalho de `X-Token` que pode aparecer mais de uma vez, você pode escrever:

{* ../../docs_src/header_params/tutorial003_an_py310.py hl[9] *}

Se você se comunicar com essa *operação de rota* enviando dois cabeçalhos HTTP como:

```
X-Token: foo
X-Token: bar
```

A resposta seria como:

```JSON
{
    "X-Token values": [
        "bar",
        "foo"
    ]
}
```