Aller au contenu

Approche modèle

L'interaction principale de la tip!!!avec la base de données est exposée via un objet QuerySet exposé en tant que modèle. objets sur chaque modèle, similaire à django orm.

1
Pour en savoir plus sur**quering, joining tables, excluding fields etc. Visit [queries][queries] section.**

Chaque instance de modèle dispose d'un ensemble de méthodes pour sauvegarder, mettre à jour ou se charger.

Les méthodes disponibles sont décrites ci-dessous.

La méthode pédante

Notez que chaque modèle. ormar est également un modèle.BaseModel pydantique, donc toutes les méthodes pydantiques sont également disponibles sur le modèle, en particulier les méthodes modèle_dump() et modèle_dump_json(), qui peuvent également accepter des exclusions, des inclusions et d'autres paramètres.

Pour en savoir plus, consultez la documentation pydantique

modèle_construct()

La construction modèle_est l'équivalent original de la méthode__init__utilisée pour construire une nouvelle instance.

La différence est que model_construct ignore la validation, donc vous devriez l'utiliser lorsque vous savez que les données sont correctes et dignes de confiance. l'avantage d'utiliser des constructions est une vitesse d'exécution accrue en raison de la validation ignorée.

Note!!!Notez que, contrairement à la méthode pydantic.model_construct, la méthode équivalente ormar traitera également les modèles imbriqués associés.

Attention Gardez à l'esprit que la méthode de construction n'effectue aucune transformation, vérification, etc. Vous êtes donc responsable de fournir des données valides et utilisables par la base de données, car la validation est ignorée.

1
2
3
4
Les deux seules choses qui construisent des performances stables sont:

*  fournit une valeur `default` pour les champs non fixés
*  Initialisez les modèles d'ordre supérieur si vous passez un dictionnaire ou une valeur de clé primaire

Modèle dump ()

modèle_dump est une méthode héritée de pydantic, mais ormar ajoute ses propres paramètres et il y a quelques nuances dans l'utilisation de la valeur par défaut, donc elle est listée ici pour plus de clarté.

modèle_dump, comme son nom l'indique, exporte des données de l'arbre modèle vers un dictionnaire.

Description du paramètre model_dump:

Inclus (ou modifiés)

include: Union[Set, Dict] = None

Ensemble de noms de champs ou dictionnaire à inclure dans le dictionnaire retourné.

Notez que pydantic a un mode peu commun d'inclure/exclure des champs d'une liste par indexation (comme c'est le cas pour les modèles imbriqués). Si vous voulez exclure des champs de tous les enfants, vous devez passer la clé__all__au dictionnaire.

Vous ne pouvez pas exclure les modèles imbriqués dans Sets dans pydantic, mais vous pouvez le faire dans ormar (en ajoutant un double soulignement aux noms de relations, c'est-à-dire en excluant les noms de catégories des livres que vous pouvez utiliser). exclude={"book__category__name"} ）

ormar ne prend pas en charge les exclusions/inclusions d'index et accepte une notation simplifiée et plus conviviale.

Pour vérifier comment les champs sont inclus/exclus, y compris les champs imbriqués, consultez la section Champs qui contient des explications et de nombreux exemples.

!!!note qu 'en fait, dans ormar, vous pouvez exclure des modèles imbriqués dans une collection, et vous pouvez exclure de l'arbre entier des modèles dans response_model_exclude et response_model_include dans fastapi!

Exclusion (ou modification) de

exclude: Union[Set, Dict] = None

Une collection ou un dictionnaire de noms de champs à exclure du dictionnaire retourné.

Notez que pydantic a un mode peu commun d'inclure/exclure des champs d'une liste par indexation (comme c'est le cas pour les modèles imbriqués). si vous voulez exclure des champs de tous les enfants, vous devez passer la clé__all__au dictionnaire.

Vous ne pouvez pas exclure les modèles imbriqués dans Sets dans pydantic, mais vous pouvez le faire dans ormar (en ajoutant un double soulignement au nom de la relation, c'est-à-dire en excluant le nom de la catégorie du livre que vous utilisez)exclude={"book__category__name"}).

ormar ne prend pas en charge les exclusions/inclusions d'index et accepte une notation simplifiée et plus conviviale.

Pour vérifier comment les champs sont inclus/exclus, y compris les champs imbriqués, consultez la section Champs qui contient des explications et de nombreux exemples.

!!!note qu 'en fait, dans ormar, vous pouvez exclure des modèles imbriqués dans une collection, et vous pouvez exclure de l'arbre entier des modèles dans response_model_exclude et response_model_include dans fastapi!

Exclure_Annuler la configuration

Exclusion non définie: Boolean = False

Le drapeau indique si les champs qui n'ont pas été explicitement définis lors de la création du modèle doivent être exclus du dictionnaire retourné.

!!!Attention Veuillez noter qu 'une fois que vous avez enregistré vos données dans la base de données, chaque champ a sa propre valeur->, qui peut être fournie par vous, par défaut ou non.

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
Cela signifie que lorsque vous chargez les données de la base de données,**tous les filets**sont définis, et ce drapeau arrête de fonctionner!


Catégorie de classe (modèle ormar):
    ormar_config = base_ormar_config.copy(tablename="catégories")

    id: int = ormar.Integer(primary_key=True)
    nom: str = ormar.String(max_length=100, default="Test")
    visibilité: bool = ormar. booléen (default=True)


Item de classe (modèle ormar):
    ormar_config = base_ormar_config.copy()

    id: int = ormar.Integer(primary_key=True)
    nom: str = ormar.String(max_length=100)
    price: float = ormar.Float(default= 9,99)
    Catégories: Liste [Catégorie] = ormar.ManyToMany(Catégorie)

Catégorie = Catégorie (nom ="Test 2")
assert category.model_dump() =={\displaystyle\id\: None,\items': [],\name\:\Test 2',
                           Visibilité: True}
assert category.model_dump(exclude_unset=True) == {'items': [], 'name': 'Test 2'}

await category.save ()
category2 = await Catégorie. objets.get()
catégorie assert 2.model_dump () =={\displaystyle\id\: 1,\items\:[],\name\:\Test 2\,\name\name\n\name\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\nbsp;;
                            Visibilité: True}
# NOTE comment après l'appel de db tous les champs sont définis explicitement
#comme ceci est ce qui arrive quand vous populez un modèle de db
catégorie assert 2.model_dump (exclude_unset=True) ==={\displaystyle 'id': 1,\items': [],
                                              'name':'Test 2', ' visibilité ': True}

Exclusion des defauts

exclude_defaults: bool = False

Les indicateurs de drapeau égaux à leur valeur par défaut, qu 'ils soient définis ou non, doivent être exclus du dictionnaire retourné.

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
Catégorie de classe (modèle ormar):
    ormar_config = base_ormar_config.copy(tablename="catégories")

    id: int = ormar.Integer(primary_key=True)
    name: str = ormar.String(max_length=100, default="Test")
    visibilité: bool = ormar. booléen (default=True)

Item de classe (modèle ormar):
    ormar_config = base_ormar_config.copy()

    id: int = ormar.Integer(primary_key=True)
    nom: str = ormar.String(max_length=100)
    price: float = ormar.Float(default= 9,99)
    Catégories: Liste [Catégorie] = ormar.ManyToMany(Catégorie)

Catégorie = Catégorie ()
#note que le pk integer est par défaut auto-incrètement si optionnel
assert category. model_dump ()== {'id': None, 'items': [], 'name': 'Test', 'visibility': True}
assert category. model_dump (exclude_defaults = True)== {'items': []}

#Sauvegarder et recharger les données
await www.example.com ()
category2 = await Catégorie. objets. get ()

assert category2.model_dump ()== {'id': 1, 'items': [], 'name': 'Test', 'visibility': True}
assert category2.model_dump (exclude_defaults = True)== {'id': 1, 'items': []}

Exclure_Aucune

Exclure_Aucun: booléen = False

Flag indique si un champ égal à None doit être exclu du dictionnaire retourné.

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
Catégorie de classe (modèle ormar):
    ormar_config = base_ormar_config. copy (tablename ="catégories ")

    id: int = ormar. Integer (primary_key = True)
    name: str = ormar. String (max_length = 100, default ="Test", nullable = True)
    visibilité: bool = ormar. booléen (default = true)


Item de classe (modèle ormar):
    ormar_config = base_ormar_config. copy ()

    id: int = ormar. Integer (primary_key = True)
    name: str = ormar. String (max_length = 100)
    price: float = ormar. float (default = 9,99)
    Catégories: Liste [Catégorie]= ormar. ManyToMany (Catégorie)


Catégorie = Catégorie (nom = None)
assert category. model_dump ()=={\displaystyle\id\: None,\items':[],\name': None,\name':\none\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\
                           Visibilité: True}
# note l'identifiant n'est pas défini yet donc non inclus et exclus
assert category.model_dump(exclude_none=True) == {'items': [], 'visibility': True}

await category.save ()
category2 = await Category.objects.get()
catégorie assert 2.model_dump () ==={\displaystyle\id\: 1,\items\:[],\name\: None,
                            Visibilité: True}
catégorie assert 2.model_dump (exclude_none=True) ==={\displaystyle 'id': 1,\items': [],
                                             Visibilité: True}

except_primary_keys (ormar uniquement)

exclude_primary_keys: bool = False

Définir le drapeau sur True exclut toutes les colonnes de clé primaire de l'arbre, y compris les modèles imbriqués.

1
2
3
4
5
6
7
8
9
Item de classe (modèle ormar):
    ormar_config = base_ormar_config.copy()

    id: int = ormar.Integer(primary_key=True)
    nom: str = ormar.String(max_length=100)

item1 = Item(id=1, name="Test Item")
assert item1.model_dump() == {"id": 1, "name": "Test Item"}
assert item1.model_dump(exclude_primary_keys=True) == {"name": "Test Item"}

except_through_models (ormar uniquement)

exclude_through_models: bool = False

Les modèles directs sont automatiquement ajoutés pour chaque relation plusieurs-à-plusieurs, et ils enregistrent des paramètres supplémentaires sur les modèles/tables liés.

Définir except_through_models=True exclut tous les modèles pass-through, y compris ceux des sous-modèles.

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
Catégorie de classe (modèle ormar):
    ormar_config = base_ormar_config.copy(tablename="catégories")

    id: int = ormar.Integer(primary_key=True)
    name: str = ormar.String(max_length=100)


Item de classe (modèle ormar):
    ormar_config = base_ormar_config.copy()

    id: int = ormar.Integer(primary_key=True)
    nom: str = ormar.String(max_length=100)
    Catégories: Liste [Catégorie] = ormar.ManyToMany(Catégorie)

# tree définit les modèles
item_dict = {
            "nom": "test",
            Catégories: [{"name": "test cat"},{"name": "test cat2"}],
        }
#Sauver tout l'arbre
await Item(**item_dict).save_related(follow=True, save_all=True)

#Obtenez les valeurs sauvées
item = await Item.objects.select_related("catégories").get()

#par défaut, vous pouvez voir les modèles (itemcategory)
assert item. modèle_dump() =={\displaystyle\id\: 1,\name\:\test',
                       Catégories:[
                           {\id\: 1,\name\:\test\cat',
                            'itemcategory': {'id': 1, 'category': None, 'item': None}}, 
                           {\id\: 2,\name\:\test cat2\,
                            'itemcategory':{'id': 2, 'category': None, 'item': None}
                       ]}

#Vous pouvez exclure ces champs/modèles
assert item.model_dump(exclude_through_models=True) == {
                       'id': 1, ' nom':'test',
                       Catégories:[
                           {'id': 1, 'name': 'test cat'}, 
                           {'id': 2, 'name': 'test cat2'}
                       ]}

modèle_dump_json()

modèle_dump_json() a exactement les mêmes arguments que modèle_dump(), vérifiez donc ce qui précède.

Le résultat final, bien sûr, est une chaîne de caractères représentée par json, pas un dictionnaire.

Obtenir_pydantic()

get_pydantic(include: Union[Set, Dict] = None, exclude: Union[Set, Dict] = None)

Cette méthode vous permet de générer un modèle pydantique à partir d'un modèle ormar sans avoir à ressaisir tous les champs.

Notez que si vous avez un modèle imbriqué, il générera tout l'arbre du modèle pydantique pour vous! mais d'une manière qui évite les problèmes de référence circulaire.

De plus, vous pouvez passer des paramètres d'exclusion et/ou d'inclusion pour ne conserver que les champs que vous souhaitez, y compris dans le modèle imbriqué.

Cela signifie que vous pouvez facilement créer des modèles pydantiques pour les demandes et les réponses dans fastapi.

!!! Remarque Pour en savoir plus sur les exclusions/inclusions possibles et sur la façon de construire un dictionnaire ou un paramètre d'exclusion, visitez la section Champs de la documentation.

Un exemple de modèle ormar donné est le suivant:

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
base_ormar_config = ormar.OrmarConfig(
    metadata=sqlalchemy.MetaData(),
    database=databases.Database(DATABASE_URL, force_rollback=True),
)


Catégorie de classe (modèle ormar):
    ormar_config = base_ormar_config.copy(tablename="catégories")

    id: int = ormar.Integer(primary_key=True)
    nom: str = ormar.String(max_length=100)


Item de classe (modèle ormar):
    ormar_config = base_ormar_config.copy()

    id: int = ormar.Integer(primary_key=True)
    name: str = ormar.String(max_length=100, default="test")
    Catégorie: Optional[Catégorie] = ormar.ForeignKey(Catégorie, nullable=True)

Vous pouvez générer un modèle pydantique avec un simple appel.

1
PydanticCategory = Category.get_pydantic(include={"id", "name"})

Cela produira un modèle équivalent à:

1
2
3
Catégorie de classe (BaseModel):
    id: Optionnel [int]
    name: Optional[str] = "test"

Attention, avoir plusieurs classes portant le même nom dans un module n'est pas une bonne habitude, et cela brise la documentation fastapi. c'est pourquoi ormar ajoute 3 lettres capitales aléatoires au nom de la classe. dans l'exemple ci-dessus, cela signifie que la classe sera nommée Catégorie_XIP(BaseModel).

Pour exclure ou inclure des champs imbriqués, vous pouvez utiliser un dictionnaire ou un soulignement double.

1
2
3
# both calls sont équivalentes
PydanticCategory = Category.get_pydantic(include={"id", "items__id"})
PydanticCategory = Category.get_pydantic(include={"id": ..., "items":{"id"}})

La structure générée est la suivante:

1
2
3
4
5
6
Item de classe (modèle de base)
    id: Optionnel [int]

Catégorie de classe (BaseModel):
    id: Optionnel [int]
    items: Optional[Liste [élément]]

Bien sûr, vous pouvez également utiliser une structure imbriquée profonde, et ormar générera son équivalent pydantique pour vous (de manière à exclure les boucles).

Remarquez comment le modèle d'élément ci-dessus ne fait pas référence à une catégorie, bien que les relations soient bidirectionnelles dans ormar (et que ormar.Item possède un champ de catégories).

Attention: le modèle pydantique résultant héritera de tous les validateurs de champ du modèle ormar original, y compris le validateur de sélection ormar ainsi que ceux définis avec le décorateur pydantic.validator.

1
2
Mais, au même moment, tous les validateurs racines présents sur les modèles `ormar` seront**NOT**être copié sur le modèle généré pydantique.
Si nécessaire, vous devez les redéfinir/les copier manuellement pour générer le modèle pydantique.

Chargement ()

Par défaut, lorsque vous interrogez une table sans pré-récupérer les modèles associés, ormar construira toujours vos modèles associés, mais ne les remplira qu 'avec la valeur pk. Vous pouvez charger les modèles associés en appelant la méthode load().

load() peut également être utilisé pour rafraîchir le modèle à partir de la base de données s'il est modifié par un autre processus.

1
2
3
4
5
6
7
track = await Track.objects.get(nom ='The Bird')
track.album.pk # will return malibu album pk (1)
track.album.name # will return None

#Vous devez charger les données en premier
await track.album.load()
track.album.name # will return 'Malibu'

Charger tout ()

load_all(follow: bool = False, exclude: Union[List, str, Set, Dict] = None) -> Model

Une méthode fonctionne de la même manière que load(), mais elle parcourt également toutes les relations du modèle qui l'appelle et les recharge à partir de la base de données.

Par défaut, la méthode load_all charge uniquement les modèles directement liés (à une étape) au modèle sur lequel la méthode est appelée.

Mais vous pouvez spécifier l'argument follow=True pour parcourir les modèles imbriqués et les charger tous dans l'arbre relationnel.

Avertissement Afin d'éviter les mises à jour récurrentes avec le paramètre follow=True, load_all conserve un ensemble de modèles visités et n'effectue pas de chargement imbriqué sur les modèles visités.

1
2
3
4
5
6
Donc, si vous avez un diamant ou des types de relations circulaires, vous avez besoin de perpétuer les loads d'une manière manuelle.

```python
# in example like this the second Street (coming from City) won't be load_all, so ZipCode won't be reloaded
Street -> District -> City -> Street -> ZipCode
```

Les méthodes acceptent également des paramètres d'exclusion optionnels qui fonctionnent exactement de la même manière que la méthode d'exclusion des champs dans QuerySet. vous pouvez ainsi supprimer des champs du modèle associé actualisé ou ignorer l'ensemble du modèle associé.

Les méthodes exécutent une requête de base de données une fois et sont donc plus efficaces que les appels imbriqués à load() et all() sur le modèle associé.

!!!tip Pour en savoir plus sur les exclusions, lisez except_fields

!!!Attention Toutes les relations sont effacées sur load_all(), donc si certains modèles imbriqués sont exclus, ils seront vides après l'appel.

Sauver ()

save() -> soi

Vous pouvez créer un nouveau modèle en utilisant la méthode QuerySet.create() ou en initialisant le modèle à un modèle pydantique normal et en appelant la méthode save().

save() peut également être utilisé pour enregistrer les modifications apportées au modèle, mais seulement si la clé primaire n'est pas définie ou si le modèle n'existe pas dans la base de données.

La méthode save() ne vérifie pas si le modèle existe dans la base de données, donc si c'est le cas, si vous essayez d'enregistrer le modèle avec une clé primaire déjà existante, vous recevrez une erreur d'intégrité du backend de la base de données sélectionnée.

1
2
3
4
5
track = Track(nom ="l'oiseau")
await track.save () # will persist the model in database

track = await Track.objects.get(nom ='The Bird')
await track.save () # will raise integrity Error as pk is populated

Mise à jour ()

update(_columns: List[str] = None, **kwargs) -> self

Vous pouvez mettre à jour le modèle en utilisant la méthode QuerySet.update() ou en mettant à jour les propriétés du modèle (champs) et en appelant la méthode update().

Si vous essayez de mettre à jour un modèle sans définir de clé primaire, une exception ModelPersistenceError est levée.

Pour conserver durablement le modèle nouvellement créé, utilisez save() ou upsert().**kwargs) méthode.

1
2
track = await Track.objects.get(nom ='The Bird')
await track.update(nom ="The Bird Strikes Again")

Pour mettre à jour uniquement les colonnes sélectionnées dans le modèle dans la base de données, fournissez une liste de colonnes qui doivent être mises à jour en tant que paramètre_columns.

Dans un exemple:

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
Classe Movie(modèle ormar):
    ormar_config = base_ormar_config.copy()

    id: int = ormar.Integer(primary_key=True)
    name: str = ormar.String(max_length=100, nullable=False, name="title")
    année: int = ormar.Integer()
    profit: float = ormar.Float()

terminator = await Movie(nom ='Terminator', année =1984, profit= 0,078).save()

terminator.name = "Terminateur 2"
terminator. année = 1991
terminator.profit = 0,520

# update uniquement nom
await terminator.update(_columns=["name"])

# note que l'instance terminator n'a pas été reloadée
assert terminator.year == 1991

#mais une fois que vous avez chargé les données de db vous voyez qu 'il n'a pas été mis à jour
await terminator.load()
assert terminator.year == 1984

Attention!!!Notez que update() n'actualise pas les instances du modèle, donc si vous modifiez plus de colonnes que dans la liste_columns entrante, votre instance du modèle aura une valeur différente de celle de la base de données!

Mise à jour Insertion ()

upsert(**kwargs) -> Self

C'est un proxy pour les méthodes save() ou update(**kwargs) décrites ci-dessus.

Si la clé primaire est définie sur->, la méthode de mise à jour est appelée.

Si pk n'est pas défini, la méthode save() est appelée.

1
2
3
4
5
track = Track(nom ="l'oiseau")
await track.upsert() # will call save as the pk is empty

track = await Track.objects.get(nom ='The Bird')
await track.upsert(nom ='The Bird Strikes Again') # will call update as pk is already populated

Supprimer ()

Vous pouvez supprimer un modèle en utilisant la méthode QuerySet.delete() ou en utilisant votre modèle et en appelant la méthode delete().

1
2
track = await Track.objects.get(nom ='The Bird')
await track.delete() #supprimera le modèle de la base de données

!!!Tip Notez que cet objet de suivi reste le même, seuls les enregistrements de la base de données sont supprimés.

Préservation liée ()

save_related(follow: bool = False, save_all: bool = False, exclude=Optional[Union[Set, Dict]]) -> None

Une méthode parcourt toutes les relations du modèle qui l'a appelée et appelle la méthode upsert() sur chaque modèle non enregistré.

Pour savoir quand un modèle est sauvegardé, consultez la section État de sauvegarde ci-dessus.

Par défaut, la méthode save_lated ne contient que les modèles qui sont directement liés (à une étape) au modèle sur lequel la méthode a été appelée.

Mais vous pouvez spécifier l'argument follow=True pour parcourir les modèles imbriqués et les enregistrer tous dans l'arbre relationnel.

Par défaut, save_lated ne contient que les modèles dans leur état non sauvegardé, ce qui signifie qu 'ils ont été modifiés dans la plage actuelle.

Si vous souhaitez forcer l'enregistrement de toutes les méthodes associées, utilisez l'attribut save_all=True, qui insère la mise à jour dans tous les modèles associés, quel que soit leur état de sauvegarde.

Si vous souhaitez ignorer la sauvegarde de certaines relations, vous pouvez passer le paramètre d'exclusion.

Exclure peut être un ensemble de ses propres relations de modèle ou un dictionnaire qui peut également contenir des éléments imbriqués.

!!!note Notez que les paramètres d'exclusion dans save_lated n'acceptent que les noms de champs relationnels, donc si vous passez d'autres champs, ils seront enregistrés de toute façon.

!!!Note Pour en savoir plus sur la structure passée aux valeurs possibles exclues, consultez la documentation de la méthode Queryset.fields.

Avertissement Pour éviter les mises à jour récurrentes avec le paramètre follow=True, save_lated conserve un ensemble de modèles visités sur chaque branche de l'arbre relationnel et ne fait pas de save_lated imbriqué sur les modèles visités.

1
Donc, si vous avez des types de relations circulaires, vous avez besoin de perpétuer les updates de manière manuelle.

Notez qu 'avec save_all=True et follow=True, vous pouvez utiliser save_lated() pour enregistrer l'ensemble de l'arbre des relations à la fois.

Exemples:

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
Département de classe (modèle d'ordre):
    ormar_config = base_ormar_config.copy()

    id: int = ormar.Integer(primary_key=True)
    department_name: str = ormar.String(max_length=100)


Classe Course(modèle. ormar):
    ormar_config = base_ormar_config.copy()

    id: int = ormar.Integer(primary_key=True)
    nom_course: str = ormar.String(max_length=100)
    bool = ormar.Boolean()
    Département: Optional[Département] = ormar.ForeignKey(Département)


Étudiant de classe (modèle ormar):
    ormar_config = base_ormar_config.copy()

    id: int = ormar.Integer(primary_key=True)
    nom: str = ormar.String(max_length=100)
    courses = ormar.ManyToMany(Course)

to_save = {
            "department_name": "Ormar",
            « Courses »: [
                {"nom_course": "basic1",
                 "Terminé": Vrai,
                 "Étudiants": [
                     {"name": "Jack"},
                     {"name": "Abi"}
                 ]},
                {"nom_course": "basic2",
                 "Terminé": Vrai,
                 "Étudiants": [
                     {"name": "Kate"},
                     {"name": "Miranda"}
                 ]
                 },
            ],
        }
#initialiser tout l'arbre
department = Department(**to_save)

# save all at once (un après un autre)
await department.save_related(follow=True, save_all=True)

department_check = await Department.objects.select_all(follow=True).get()

to_exclude = {
    "id": ...,
    "Courses": {
        "id": ...,
        "Étudiants": {"id", "studentcourse"}
    }
}
#après exclusion des enfants et à travers les modèles, vous obtenez exactement le même paiement utilisé pour charger
#construction de tout l'arbre
assert department_check.model_dump(exclude=to_exclude) == to_save

Attention save_lated() parcourt toutes les relations et tous les modèles et les met à jour un par un, de sorte qu 'il enregistre tous les modèles, mais peut ne pas être optimal en termes de nombre de requêtes de base de données.