class Rules extends RuleSource {
              @Model
              void mapThings(ModelMap<ModelMap<Thing>> things) {
              }
              @Model
              void setThings(ModelMap<ModelSet<Thing>> things) {
              }
              @Model
              void setStrings(ModelMap<Set<String>> strings) {
              }
            }

            apply type: Rules

            model {

        abstract ModelMap<NamedThingInterface> getMap()
    }

    @Managed
    static abstract class WritableSetProperty {
        abstract void setSet(ModelSet<NamedThingInterface> set)
        abstract ModelSet<NamedThingInterface> getSet()
    }

    def "map cannot be writable"() {
        when: extract WritableMapProperty
        then: def ex = thrown InvalidManagedTypeException

         ⤷ PersonRules#setFirstName(Person)
    + age
          | Type:   	int
          | Value:  	0
          | Creator: 	PersonRules#person(Person)
    + children
          | Type:   	org.gradle.model.ModelSet<Person>
          | Creator: 	PersonRules#person(Person)
    + employed
          | Type:   	boolean
          | Value:  	false
          | Creator: 	PersonRules#person(Person)
    + father

 * <p>
 * The use of {@link WeakClassSet} as the cache key, opposed to just {@link Class}, is because a type may be composed of types from different classloaders.
 * An example of this would be something like {@code ModelSet<SomeCustomUserType>}.
 * The class set abstraction effectively creates a key for all classes involved in a type.
 * The {@link WeakClassSet#isCollected()} method returns true when any of the classes involved have been collected.

 * limitations under the License.
 */

package org.gradle.internal.cc.impl.cacheentry

import org.gradle.internal.hash.HashCode
import org.gradle.util.Path


internal
data class ModelKey(
    val identityPath: Path?,
    val modelName: String,
    val parameterHash: HashCode?

import static org.junit.jupiter.api.Assertions.assertNull;
import static org.junit.jupiter.api.Assertions.assertTrue;

/**
 * Tests {@code Model}.
 *
 */
class ModelTest {

    @Test
    void testHashCodeNullSafe() {
        new Model().hashCode();
    }

    @Test
    void testBuild() {
        Model model = new Model();
        Build build = new Build();

    Ce qui améliore le support pour les modèles Pydantic avec :

    * de l'auto-complétion
    * des vérifications de type
    * du "refactoring" (ou remaniement de code)
    * de la recherche
    * de l'inspection

## Utilisez le modèle

Dans la fonction, vous pouvez accéder à tous les attributs de l'objet du modèle directement :

```Python hl_lines="21"

Selbst für Dinge in Listen:

<img src="/img/tutorial/body-nested-models/image01.png">

Sie würden diese Editor-Unterstützung nicht erhalten, wenn Sie direkt mit `dict`, statt mit Pydantic-Modellen arbeiten würden.

Aber Sie müssen sich auch nicht weiter um die Modelle kümmern, hereinkommende Dicts werden automatisch in sie konvertiert. Und was Sie zurückgeben, wird automatisch nach JSON konvertiert.

## Bodys mit beliebigen `dict`s

* Dokumentation der Daten, usw.

Das funktioniert genauso wie mit Pydantic-Modellen. Und tatsächlich wird es unter der Haube mittels Pydantic auf die gleiche Weise bewerkstelligt.

!!! info
    Bedenken Sie, dass Datenklassen nicht alles können, was Pydantic-Modelle können.

    Daher müssen Sie möglicherweise weiterhin Pydantic-Modelle verwenden.

...viendra surement plus tard, suivant le temps que j'ai.  😅 🎉

## Modèles d'apprentissage automatique avec spaCy et FastAPI

GitHub : <a href="https://github.com/microsoft/cookiecutter-spacy-fastapi" class="external-link" target="_blank">https://github.com/microsoft/cookiecutter-spacy-fastapi</a>

## Modèles d'apprentissage automatique avec spaCy et FastAPI - Fonctionnalités

* Intégration d'un modèle NER **spaCy**.