* `security_scopes.scopes` contendrá `["me"]` para la *path operation* `read_users_me`, porque está declarado en la dependencia `get_current_active_user`.

## Usando `BackgroundTasks` { #using-backgroundtasks }

Primero, importa `BackgroundTasks` y define un parámetro en tu *path operation function* con una declaración de tipo de `BackgroundTasks`:

{* ../../docs_src/background_tasks/tutorial001_py310.py hl[1,13] *}

**FastAPI** creará el objeto de tipo `BackgroundTasks` por ti y lo pasará como ese parámetro.

participant dep_func as Dep scope="function"
participant operation as Path Operation

    client ->> dep_req: Start request
    Note over dep_req: Run code up to yield
    dep_req ->> dep_func: Pass dependency
    Note over dep_func: Run code up to yield
    dep_func ->> operation: Run path operation with dependency
    operation ->> dep_func: Return from path operation
    Note over dep_func: Run code after yield

///

Lors de la création d’une API, le « chemin » est la manière principale de séparer les « préoccupations » et les « ressources ».

#### Opération { #operation }

« Opération » fait ici référence à l’une des « méthodes » HTTP.

L’une de :

* `POST`
* `GET`
* `PUT`
* `DELETE`

... et les plus exotiques :

* `OPTIONS`
* `HEAD`

Bu gibi durumlarda, dönüş tipi yerine *path operation decorator* parametresi olan `response_model`’i kullanabilirsiniz.

`response_model` parametresini herhangi bir *path operation* içinde kullanabilirsiniz:

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

Pero también puedes declarar el `Response` que quieres usar (por ejemplo, cualquier subclase de `Response`), en el *path operation decorator* usando el parámetro `response_class`.

Los contenidos que devuelvas desde tu *path operation function* se colocarán dentro de esa `Response`.

/// note | Nota

    return ptr->getKind() == kGraph || ptr->getKind() == kMlir;
  }
};

// An abstract operation describes an operation by its type, name, and
// attributes. It can be "executed" by the context with some input tensors.
// It is allowed to reusing the same abstract operation for multiple execution
// on a given context, with the same or different input tensors.
class TracingOperation : public AbstractOperation {

But you can also declare the `Response` that you want to be used (e.g. any `Response` subclass), in the *path operation decorator* using the `response_class` parameter.

The contents that you return from your *path operation function* will be put inside of that `Response`.

/// note

    }

    /**
     * Returns a {@link CopyOptions} with the specified property names to include in the operation.
     *
     * @param propertyNames
     *            An array of property names. Must not be {@literal null} or an empty array.
     * @return A {@link CopyOptions} with the specified property names to include in the operation.
     * @see CopyOptions#include(CharSequence...)
     */

Swagger UI lo manejará detrás de escena para ti, pero necesita este auxiliar de "redirección".

///

### Crea una *path operation* para probarlo { #create-a-path-operation-to-test-it }

Ahora, para poder probar que todo funciona, crea una *path operation*:

{* ../../docs_src/custom_docs_ui/tutorial001_py310.py hl[36:38] *}

### Pruébalo { #test-it }