if (managedVersions.containsKey(childKey)) {
                                    // If this child node is a managed dependency, ensure
                                    // we are using the dependency management version
                                    // of this child if applicable b/c we want to use the

                String artifactId,
                String version,
                String scope,
                String systemPath,
                Exclusion exclusion) {
            Dependency d = new Dependency();
            d.setGroupId(groupId);
            d.setArtifactId(artifactId);
            d.setVersion(version);
            d.setScope(scope);

    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
    Note over dep_func: ✅ Dependency closed
    dep_func ->> client: Send response to client
    Note over client: Response sent

    /**
     * How the test project is set up:
     *
     * 1. dependencyManagement lists dependencies on a & b,
     *    with an exclusion on c in b.
     * 2. the child project lists a dependency on project a only
     * 3. a depends on b (which is transitive to the child project),
     *    and b depends on c.
     *
     * We should see that the resulting size of collected artifacts is two:
     * a & b only.

  // It's a constant, and we can't use ImmutableMap here without creating a circular dependency.
  @SuppressWarnings("ConstantCaseForConstants")
  private static final Map<Class<?>, Class<?>> PRIMITIVE_TO_WRAPPER_TYPE;

  /** A map from wrapper types to their corresponding primitive types. */
  // It's a constant, and we can't use ImmutableMap here without creating a circular dependency.
  @SuppressWarnings("ConstantCaseForConstants")

        testing/architecture-test/build/reports/binary-compatibility/report.html => binary-compatibility-reports
        build/reports/dependency-verification/** => dependency-verification-reports
        build/reports/problems/problems-report.html
        """.trimIndent()

    setArtifactRules(artifactRuleOverride ?: defaultArtifactRules)

  "durations" : [ {
    "testProject" : "excludeRuleMergingBuild",
    "linux" : 233
  } ]
}, {
  "scenario" : "org.gradle.performance.regression.corefeature.LargeDependencyGraphPerformanceTest.resolve large dependency graph (parallel = false, locking = true)",
  "durations" : [ {

     */
    public static final String CONSTITUTES_BUILD_PATH = "constitutesBuildPath";

    /**
     * When an artifact is both a regular dependency and a transitive dependency
     * of a processor, this property records the derived processor type ID.
     *
     * @since 4.0.0
     */
    public static final String PROCESSOR_TYPE = "maven.processor.type";

    /**

         * - For FAIL_FAST: Sets ReactorBuildStatus to halted, which causes executePlan to only process after:* steps
         * - For FAIL_AT_END: Blacklists the project and its dependents, which causes executePlan to skip them
         * - For FAIL_NEVER: Does nothing special, allowing all projects to continue building
         * <p>

# 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
```