}

    @Test
    public void test_setModel() {
        final LlmChatResponse response = new LlmChatResponse();

        response.setModel("llama3");
        assertEquals("llama3", response.getModel());

        response.setModel("gpt-3.5-turbo");
        assertEquals("gpt-3.5-turbo", response.getModel());
    }

    @Test
    public void test_nullValues() {

                .addAssistantMessage("Hi there!")
                .addUserMessage("How are you?")
                .setModel("llama3")
                .setMaxTokens(500)
                .setTemperature(0.5)
                .setStream(false);

        assertEquals(4, request.getMessages().size());
        assertEquals("llama3", request.getModel());
        assertEquals(Integer.valueOf(500), request.getMaxTokens());

Cualquier otra función de utilidad que llames directamente puede ser creada con `def` normal o `async def` y FastAPI no afectará la forma en que la llames.

Esto contrasta con las funciones que FastAPI llama por ti: *path operation functions* y dependencias.

## Llama a `uvicorn` { #call-uvicorn }

En tu aplicación de FastAPI, importa y ejecuta `uvicorn` directamente:

{* ../../docs_src/debugging/tutorial001_py310.py hl[1,15] *}

### Acerca de `__name__ == "__main__"` { #about-name-main }

El objetivo principal de `__name__ == "__main__"` es tener algo de código que se ejecute cuando tu archivo es llamado con:

<div class="termy">

```console

### Casos de uso: servicio externo { #use-cases-external-service }

Un ejemplo podría ser que tienes un proveedor de autenticación externo al que necesitas llamar.

Le envías un token y te devuelve un usuario autenticado.

Este proveedor podría estar cobrándote por cada request, y llamarlo podría tomar más tiempo adicional que si tuvieras un usuario mock fijo para los tests.

En realidad, todos (o la mayoría) de los frameworks web funcionan de esta misma manera.

Nunca llamas directamente a esas funciones. Son llamadas por tu framework (en este caso, **FastAPI**).

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

Para definirlo usas la <dfn title='también llamado "operador OR a nivel de bits", pero ese significado no es relevante aquí'>barra vertical (`|`)</dfn> para separar ambos tipos.

Esto se llama una "unión", porque la variable puede ser cualquiera en la unión de esos dos conjuntos de tipos.

```Python hl_lines="1"

El proceso que ocurre cuando tu aplicación API llama a la *API externa* se llama un "callback". Porque el software que escribió el desarrollador externo envía un request a tu API y luego tu API hace un *callback*, enviando un request a una *API externa* (que probablemente fue creada por el mismo desarrollador).

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.

Entonces, si tienes un objeto `something` (que podría _no_ ser una función) y puedes "llamarlo" (ejecutarlo) como:

```Python
something()
```

o

```Python

///

/// note | Detalles técnicos

Cuando importas `Query`, `Path` y otros de `fastapi`, en realidad son funciones.

Que cuando se llaman, retornan instances de clases con el mismo nombre.

Así que importas `Query`, que es una función. Y cuando la llamas, retorna una instance de una clase también llamada `Query`.

Estas funciones están allí (en lugar de usar simplemente las clases directamente) para que tu editor no marque errores sobre sus tipos.