### Other utility functions { #other-utility-functions }

Any other utility function that you call directly can be created with normal `def` or `async def` and FastAPI won't affect the way you call it.

        curtainFinallyHook = new FessCurtainFinallyHook();
    }

    // Test normal execution of hook method
    public void test_hook_normalExecution() {
        // Create a mock FwAssistantDirector
        FwAssistantDirector assistantDirector = createMockAssistantDirector();

        // Should not throw any exception during normal execution
        curtainFinallyHook.hook(assistantDirector);

Da mesma forma, você pode utilizar `finally` para garantir que os passos de saída são executados, com ou sem exceções.

```python hl_lines="3  5"
{!../../docs_src/dependencies/tutorial007.py!}
```

## Subdependências com `yield`

Você pode ter subdependências e "árvores" de subdependências de qualquer tamanho e forma, e qualquer uma ou todas elas podem utilizar `yield`.

protection bits added automatically to provide the regular safety for these objects up to 50% of the number of drives.
This will allow normal write operations to take place on systems that exceed the write tolerance.

## HTTPX { #httpx }

Even if your **FastAPI** application uses normal `def` functions instead of `async def`, it is still an `async` application underneath.

# Exceptions - `HTTPException` and `WebSocketException`

These are the exceptions that you can raise to show errors to the client.

When you raise an exception, as would happen with normal Python, the rest of the execution is aborted. This way you can raise these exceptions from anywhere in the code to abort a request and show the error to the client.

You can use:

* `HTTPException`
* `WebSocketException`

Es solo una función estándar que puede recibir parámetros.

Puede ser una función `async def` o una función normal `def`, **FastAPI** sabrá cómo manejarla correctamente.

En este caso, la función de tarea escribirá en un archivo (simulando el envío de un email).

Y como la operación de escritura no usa `async` y `await`, definimos la función con un `def` normal:

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

     * @throws IllegalAccessRuntimeException
     *             If the number of actual and formal parameters differ, if unwrapping of primitive arguments fails,
     *             or if after unwrapping, the parameter values cannot be converted to the corresponding formal parameter types,
     *             or if the constructor is related to an enum type
     * @see Constructor#newInstance(Object[])
     */

# Código de status de resposta

Da mesma forma que você pode especificar um modelo de resposta, você também pode declarar o código de status HTTP usado para a resposta com o parâmetro `status_code` em qualquer uma das *operações de caminho*:

* `@app.get()`
* `@app.post()`
* `@app.put()`
* `@app.delete()`
* etc.

{* ../../docs_src/response_status_code/tutorial001.py hl[6] *}

/// note | Nota

        void testMultimediaExtensions() throws IOException {
            // Common audio formats
            assertEquals("audio/x-wav", mimeMap.getMimeType("wav"));
            // mp3 has multiple mappings, first one wins
            assertEquals("audio/x-mpegurl", mimeMap.getMimeType("mp3"));

            // Common video formats
            assertEquals("video/x-msvideo", mimeMap.getMimeType("avi"));