*** Resolve version of versionless parents based on relativePath (including ci-friendly versions)

      *** Resolve version of versionless dependencies that are part of the reactor

   []

   ** raw model validation: <<<ModelValidator>>> ({{{./apidocs/org/apache/maven/model/validation/ModelValidator.html}javadoc}}),
   with its <<<DefaultModelValidator>>> implementation

    <relativePath>../../</relativePath>
  </parent>

  <artifactId>maven-core</artifactId>

  <name>Maven 4 Core</name>
  <description>Maven Core classes.</description>

  <dependencies>
    <!--  Maven -->
    <dependency>
      <groupId>org.apache.maven</groupId>
      <artifactId>maven-di</artifactId>
    </dependency>
    <dependency>
      <groupId>org.apache.maven</groupId>

                ResolutionNode child = i.next();

                try {

                    // We leave in optional ones, but don't pick up its dependencies
                    if (!child.isResolved() && (!child.getArtifact().isOptional() || child.isChildOfRootNode())) {
                        Artifact artifact = child.getArtifact();

# installed into a virtual environment, and then that venv is used to run all
# bazel tests with a special flag "--define=no_tensorflow_py_deps=true", which
# drops all the bazel dependencies for each py_test; this makes all the tests
# use the wheel's TensorFlow installation instead of the one made available
# through bazel. This must be done in a different root directory, //bazel_pip/...,

                apply(plugin = "java-library")
                repositories {
                    mavenCentral()
                }

                dependencies {
                    "testImplementation"("org.junit.jupiter:junit-jupiter-engine:5.8.1")
                }

                tasks.named<Test>("test").configure {

            }

            assertEquals(
                stage.specificBuilds.size + stage.functionalTests.size + stage.performanceTests.size + stage.docsTests.size + (if (prevStage != null) 1 else 0),
                it.dependencies.items.size, stage.stageName.stageName
            )
        }
    }

    private
    val largeSubProjectRegex = """\((\w+(_\d+))\)""".toRegex()

    /**

    It takes a single "dependable" callable (like a function).

    Don't call it directly, FastAPI will call it for you.

    Read more about it in the
    [FastAPI docs for Dependencies](https://fastapi.tiangolo.com/tutorial/dependencies/).

    **Example**

    ```python
    from typing import Annotated

    from fastapi import Depends, FastAPI

    app = FastAPI()

    get_compat_model_name_map,
    get_definitions,
    get_schema_from_model_field,
    lenient_issubclass,
)
from fastapi.datastructures import DefaultPlaceholder
from fastapi.dependencies.models import Dependant
from fastapi.dependencies.utils import (
    _get_flat_fields_from_params,
    get_flat_dependant,
    get_flat_params,
)
from fastapi.encoders import jsonable_encoder

### 1. Prerequisites

Install MinIO - [MinIO Quickstart Guide](https://min.io/docs/minio/linux/index.html#quickstart-for-linux).

### 2. Run MinIO in federated mode

Bucket lookup from DNS federation requires two dependencies

- etcd (for bucket DNS service records)
- CoreDNS (for DNS management based on populated bucket DNS service records, optional)

## Architecture

👥 💪 ✔️ 🔬 💽 🎉/🔗 (`SessionLocal`) 📍 📨, ⚙️ 🎏 🎉 🔘 🌐 📨 & ⤴️ 🔐 ⚫️ ⏮️ 📨 🏁.

& ⤴️ 🆕 🎉 🔜 ✍ ⏭ 📨.

👈, 👥 🔜 ✍ 🆕 🔗 ⏮️ `yield`, 🔬 ⏭ 📄 🔃 [🔗 ⏮️ `yield`](dependencies/dependencies-with-yield.md){.internal-link target=_blank}.

👆 🔗 🔜 ✍ 🆕 🇸🇲 `SessionLocal` 👈 🔜 ⚙️ 👁 📨, & ⤴️ 🔐 ⚫️ 🕐 📨 🏁.

//// tab | 🐍 3️⃣.6️⃣ & 🔛

```Python hl_lines="15-20"