Et nous analysons directement ce contenu YAML, puis nous utilisons à nouveau le même modèle Pydantic pour valider le contenu YAML :

```Python hl_lines="26-33"
{!../../../docs_src/path_operation_advanced_configuration/tutorial007.py!}
```

!!! tip "Astuce"
    Ici, nous réutilisons le même modèle Pydantic.

Nils Lindemann <******@****.***> 1713469999 +0200

		</get>
		<unzip dest="${modules.dir}/${module.name}" src="${target.dir}/${module.name.prefix}${module.name}-${module.zip.version}.zip">
			<patternset>
				<include name="**" />
			</patternset>
			<cutdirsmapper dirs="1" />
		</unzip>
	</target>

	<target name="remove.jars" if="with.fess">
		<delete>

    /**
     * Returns the modules required by this module.
     */
    Set<Module> getRequiredModules();

    /**
     * Returns the transitive closure of all modules required by this module, including the module itself.
     */
    Set<Module> getAllRequiredModules();

    /**
     * Returns the implementation + runtime classpath of the transitive closure of all modules required by this module, including the module itself.
     */

## Composition by architecture modules

Each [architecture module and platform](platforms.md) can contribute code to any of the elements.
Not every module contributes to every element.

```

!!! warning "Attention"
    Lorsque vous renvoyez une `Response` directement, comme dans l'exemple ci-dessus, elle sera renvoyée directement.

    Elle ne sera pas sérialisée avec un modèle.

    Assurez-vous qu'il contient les données souhaitées et que les valeurs soient dans un format JSON valides (si vous utilisez une `JSONResponse`).

!!! note "Détails techniques"

        expect:
        server.expectConcurrent(1, 'root', 'a', 'b')
        def models = withConnection {
            def action = action(new ActionRunsNestedActions())
            collectOutputs(action)
            action.addArguments(args)
            action.run()
        }

        !models.mayRunInParallel
        models.projects.path == [':', ':a', ':b']

        where:
        args << [
            ["--no-parallel"],

    private static void assertSameIdentifiers(def gradleProject, def model) {
        assertSameIdentifiers([gradleProject], [model])
    }

    private static void assertSameIdentifiers(List gradleProjects, List models) {
        def gradleProjectIdentifiers = gradleProjects.collect { it.projectIdentifier } as Set<ProjectIdentifier>
        def modelIdentifiers = models.collect { it.projectIdentifier } as Set<ProjectIdentifier>

{!../../../docs_src/body/tutorial001.py!}
```

## Crie seu modelo de dados

Então você declara seu modelo de dados como uma classe que herda `BaseModel`.

Utilize os tipos Python padrão para todos os atributos:

```Python hl_lines="7-11"
{!../../../docs_src/body/tutorial001.py!}
```

* data validation
* data serialization
* data documentation, etc.

This works the same way as with Pydantic models. And it is actually achieved in the same way underneath, using Pydantic.

!!! info
    Keep in mind that dataclasses can't do everything Pydantic models can do.

    So, you might still need to use Pydantic models.