subgraph core["core platform"]

        core_runtime["core-runtime module"]
        style core_runtime stroke:#1abc9c,fill:#b1f4e7,stroke-width:2px,color:#000;

        core_configuration["core-configuration module"]
        style core_configuration stroke:#1abc9c,fill:#b1f4e7,stroke-width:2px,color:#000;

        core_execution["core-execution module"]
        style core_execution stroke:#1abc9c,fill:#b1f4e7,stroke-width:2px,color:#000;

        // ArtifactId may differ only for multi-module projects, in which case
        // it must match the module name from a source root in modular sources.
        boolean isMultiModule = false;
        boolean validArtifactId = Objects.equals(a1, a2);
        for (SourceRoot sr : getSourceRoots(project)) {
            Optional<String> moduleName = sr.module();
            if (moduleName.isPresent()) {

import org.gradle.api.initialization.Settings

/**
 * Defines a top-level architecture module.
 */
fun Settings.module(moduleName: String, moduleConfiguration: ArchitectureModuleBuilder.() -> Unit) {
    val module = ArchitectureModuleBuilder(moduleName, this)
    extensions.findByType(ProjectStructure::class.java)!!.architectureElements.add(module)
    module.moduleConfiguration()
}

/**
 * Defines a platform.
 */

///

## Ajouter un modèle de sortie { #add-an-output-model }

Nous pouvons à la place créer un modèle d'entrée avec le mot de passe en clair et un modèle de sortie sans celui-ci :

{* ../../docs_src/response_model/tutorial003_py310.py hl[9,11,16] *}

Ici, même si notre *fonction de chemin d'accès* renvoie le même utilisateur d'entrée qui contient le mot de passe :

     * Tests the formatting of an option with a module name.
     */
    @Test
    public void testModularOption() {
        String[] formatted = JavaPathType.patchModule("my.module").option(paths());
        assertEquals(2, formatted.length);
        assertEquals("--patch-module", formatted[0]);
        assertEquals(toPlatformSpecific("my.module=src/foo.java:src/bar.java"), formatted[1]);
    }

    /**

     *       {@code {"--module-path", "dir/path1:dir/path2"}} on Unix or
     *       {@code {"--module-path", "dir\path1;dir\path2"}} on Windows.</li>
     *   <li>If this type was created by {@code JavaPathType.patchModule("foo.bar")}, then the method returns
     *       {@code {"--patch-module", "foo.bar=dir/path1:dir/path2"}} on Unix or
     *       {@code {"--patch-module", "foo.bar=dir\path1;dir\path2"}} on Windows.</li>

But in real cases you will get better results using the integrated [Security utilities](security/index.md).

///

## Another module with `APIRouter` { #another-module-with-apirouter }

Let's say you also have the endpoints dedicated to handling "items" from your application in the module at `app/routers/items.py`.

You have *path operations* for:

* `/items/`
* `/items/{item_id}`

            }

            for (String module : parent.getModules()) {
                module = module.replace('\\', '/');

                if (module.regionMatches(true, module.length() - 4, ".xml", 0, 4)) {
                    module = module.substring(0, module.lastIndexOf('/') + 1);
                }

                String moduleName = module;
                if (moduleName.endsWith("/")) {

        String content = Files.readString(pomPath);
        return new Parser().parse(content);
    }

    /**
     * Recursively discovers module POMs from the given parent POM.
     *
     * @param baseDirectory the base directory for resolving module paths
     * @param parentPom the parent POM document
     * @param pomMap the map to store discovered POMs
     * @throws IOException if there's an error reading files

library packages begin with a dotless path element.

The module requirements of std and cmd do not influence version
selection in other modules. They are only considered when running
module commands like 'go get' and 'go mod vendor' from a directory
in GOROOT/src.

Maintaining vendor directories
==============================

Before updating vendor directories, ensure that module mode is enabled.