# Background Tasks - `BackgroundTasks`

You can declare a parameter in a *path operation function* or dependency function with the type `BackgroundTasks`, and then you can use it to schedule the execution of background tasks after the response is sent.

You can import it directly from `fastapi`:

```python
from fastapi import BackgroundTasks
```

        log(valueMap);
    }

    /**
     * Log the script execution activity.
     * @param scriptType The type of script (e.g., "groovy").
     * @param script The script content.
     * @param source The source of execution (e.g., "scheduler:JobName").
     * @param user The user who triggered the execution.
     * @param result The execution result (e.g., "success" or "failure:ExceptionType").
     */

    /**
     * Handles the prologue phase of action execution.
     * <p>
     * This method catches UserRoleLoginException and redirects to the
     * appropriate action class.
     * </p>
     *
     * @param runtime the action runtime context
     * @return the action response, or redirect response if login exception occurs
     */
    @Override

              <revisionOnScmFailure>NON_CANONICAL</revisionOnScmFailure>
            </configuration>
          </execution>
        </executions>
      </plugin>
      <plugin>
        <groupId>org.apache.maven.plugins</groupId>
        <artifactId>maven-failsafe-plugin</artifactId>
        <executions>
          <execution>
            <!--  <phase></phase> -->
            <goals>
              <goal>integration-test</goal>

        @Override
        public void close() {}
    }

    /**
     * Aggregating mojo executions (possibly) modify all MavenProjects, including those that are currently in use
     * by concurrently running mojo executions. To prevent race conditions, an aggregating execution will block
     * all other executions until finished.

    /**
     * Executes all applicable upgrade strategies in priority order.
     * Each strategy is checked for applicability before execution.
     *
     * @param context the upgrade context
     * @param pomMap map of all POM files in the project
     * @return the overall result of all strategy executions
     */
    public UpgradeResult executeStrategies(UpgradeContext context, Map<Path, Document> pomMap) {
        context.println();

 * under the License.
 */
package org.apache.maven.execution.scope;

import org.apache.maven.execution.MojoExecutionEvent;
import org.apache.maven.plugin.MojoExecutionException;

/**
 * Extension point that allows build extensions observe and possibly veto mojo executions.
 * <p>
 * Unlike {@link org.apache.maven.execution.MojoExecutionListener}, this extension point does not

        if (plugin != null) {
            if (pluginExecutionId != null && !pluginExecutionId.isEmpty()) {
                for (PluginExecution execution : plugin.getExecutions()) {
                    if (pluginExecutionId.equals(execution.getId())) {
                        setConfiguration(execution.getConfiguration());
                        break;
                    }
                }
            } else {

        }
    }

    @Nested
    @DisplayName("Execution")
    class ExecutionTests {

        @Test
        @DisplayName("should log appropriate header message")
        void shouldLogAppropriateHeaderMessage() throws Exception {
            UpgradeContext context = createMockContext();

            // Create a temporary directory with a POM file for the test

   *
   * <p>Exceptions thrown by a listener will be propagated up to the executor. Any exception thrown
   * during {@code Executor.execute} (e.g., a {@code RejectedExecutionException} or an exception
   * thrown by {@linkplain MoreExecutors#directExecutor direct execution}) will be caught and
   * logged.
   *
   * <p>Note: If your listener is lightweight -- and will not cause stack overflow by completing