Aller au contenu

Migration vers la version 0.20.0 basée sur pydantic 2.XX

La version 0.20.0 fournit un support pour pydantic v2.XX, offrant aux développeurs un gain de vitesse significatif (la validation et la sérialisation sont écrites en rust) et un API plus propre, tout en abandonnant le support pour pydantic v.1.XX, il y a des modifications dans l'interface qui correspondent aux modifications apportées dans pydantic.

Changements significatifs

La migration vers la version>= 0.20.0 nécessite plusieurs modifications pour fonctionner correctement.

Configuration du modèle Auma

Maintenant, chaque modèle ormar nécessite un paramètre ormar_config qui est une instance de la classe OrmarConfig, plutôt que de définir la classe Meta. Notez que la propriété doit être nommée ormar_config et être une instance de la classe config.

 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
Importer des databases
Importer à Ormar
Import scalalchemy

databases.Database("sqlite:///db.sqlite")
metadata = sqlalchemy.MetaData()

# ormar <0,20
Classe Album(modèle ormar):
    Classe Méta:
        base de données = database
        Metadata = métadonnée
        tablename = "album"


    id: int = ormar.Integer(primary_key=True)
    nom: str = ormar.String(max_length=100)
    Favorite: bool = ormar. booléen (default=False)

# ormar >= 0,20
Classe AlbumV20(modèle ormar):
    ormar_config = ormar.OrmarConfig(
        database=database,
        Metadata=Metadata,
        tablename="albums_v20"
    )

    id: int = ormar.Integer(primary_key=True)
    nom: str = ormar.String(max_length=100)
    Favorite: bool = ormar. booléen (default=False)

OrmarConfig api/paramètres

ormar_config expose le même ensemble de paramètres que celui fourni par la classe Meta. cela signifie que vous pouvez initialiser la configuration avec l'un des paramètres suivants:

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
Metadata: Optional[sqlalchemy.MetaData]
Database: Optional[databases.Database]
engine: Optional[sqlalchemy.Engine.engine]
tablename: optionnel [str]
order_by: Optional[Liste [str]]
Abstract: bool
exclude_parent_fields: Optional[Liste [str]]
queryset_class: Type[QuerySet]
Extra: supplément
constraints: Optional[Liste [ColumnCollectionConstraint]]

Equivalents de BaseMeta-bonnes pratiques

Notez que pour réduire la duplication du code et simplifier le développement, il est toujours recommandé de créer une configuration de base et de fournir une copie de chaque modèle. OrmarConfig fournit une méthode de réplication pratique pour cela.

La méthode copy accepte les mêmes arguments que l'init OrmarConfig, vous pouvez donc remplacer autant que vous le souhaitez, mais par défaut, elle retournera les propriétés déjà existantes, à l'exception de tablename, order_by et les contraintes qui sont effacées par défaut.

 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
Importer des databases
Importer à Ormar
Import sqlalchemy

base_ormar_config = ormar.ormarConfig(
    database=databases.Database("sqlite:///db.sqlite"),
    metadata=sqlalchemy.MetaData()
)

Classe AlbumV20(modèle ormar):
    ormar_config = base_ormar_config.copy(
        tablename="albums_v20"
    )

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


Classe TrackV20(modèle ormar):
    ormar_config = base_ormar_config.copy(
        tablename="tracks_v20"
    )

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

Le paramètre de champ options n'est plus supporté.

Avant la version 0.20, vous pouviez limiter les valeurs acceptables en fournissant des paramètres d'option à n'importe quel champ ormar existant. Cette fonctionnalité a été supprimée et vous devez utiliser le champ ormar.Enum conçu à cet effet. Si vous souhaitez conserver le type de champ de base de données (c'est-à-dire le champ entier), vous pouvez toujours écrire un validateur personnalisé.

 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
Importer des databases
Import par Ormar
Import scalalchemy

databases.Database("sqlite:///db.sqlite")
metadata = sqlalchemy.MetaData()

# ormar < 0.20
Classe Artiste (modèle ormar):
    Classe Méta:
        base de données = database
        Metadata = métadonnée


    id: int = ormar.Integer(primary_key=True)
    nom: str = ormar.String(max_length=100)
    Pays: str = ormar.String(default=False, max_length=50, choices=["UK", "US", "Vietnam", "Colombia"])

# ormar >= 0,20
De enum à import Enum

Classe Pays (str, Enum):
    UK = "Royaume-Uni"
    US = "US"
    VIETNAM = "Vietnam"
    COLOMBIA = Colombie

Classe ArtistV20(modèle ormar):
    ormar_config = ormar.OrmarConfig(
        database=database,
        Metadata=Metadata,
        tablename= artists_v20
    )

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

Les arguments de champ ne sont plus supportés par pydantic_only

Le champ pydantic_only a été déprécié et supprimé dans v 0.20. Ormar permet de définir des champs pydantiques comme un modèle pydantique normal.

 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
Importer des databases
Import par Ormar
Import scalalchemy

databases.Database("sqlite:///db.sqlite")
metadata = sqlalchemy.MetaData()

# ormar < 0.20
Classe Dish(modèle ormar):
    Classe Méta:
        base de données = database
        Metadata = métadonnée
        tablename = "dishèmes"


    id: int = ormar.Integer(primary_key=True)
    name: str = ormar.String(max_length=100)
    cook: str = ormar.String(max_length=40, pydantic_only=True, default="sam")

# ormar >= 0.20
Classe DishV20(modèle. ormar):
    ormar_config = ormar.ormarConfig(
        database=database,
        Metadata=Metadata,
        tablename="dishes_v20"
    )

    id: int = ormar.Integer(primary_key=True)
    name: str = ormar.String(max_length=100)
    cook: str = "sam" # this is normal pydantic field

Le décorateur property_field n'est plus supporté

Le décorateur property_field est utilisé pour fournir un moyen de transmettre les champs calculés contenus dans la représentation json dictionnaire/sérialisée du modèle. pydantic version 2.X introduit cette possibilité, vous devriez donc passer à la version native de pydantic maintenant.

 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
Importer des databases
Importer à Ormar
Import sqlalchemy
Import Pydantic

databases.Database("sqlite:///db.sqlite")
metadata = sqlalchemy.MetaData()

# ormar < 0.20
Classe Employé (modèle ormar):
    Classe Méta:
        base de données = database
        Metadata = métadonnée


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

    @ ormar.property_field()
    def full_name(self) -> str:
        return f"{self.first_name} {self.last_name}»

# ormar >= 0.20
Classe EmployeeV20(modèle ormar):
    ormar_config = ormar.ormarConfig(
        database=database,
        Metadata=Metadata,
    )

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

    @pydantic.computed_field()
    def full_name(self) -> str:
        return f"{self.first_name} {self.last_name}»

Méthodes obsolètes

Toutes les méthodes énumérées ci-dessous sont obsolètes et seront supprimées dans la version 0.30 d'ormar.

dict() devient model_dump()

 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
Importer des databases
Importer à Ormar
Import sqlalchemy

databases.Database("sqlite:///db.sqlite")
metadata = sqlalchemy.MetaData()

Classe Album(modèle ormar):
    ormar_config = ormar.ormarConfig(
        database=database,
        Metadata=Metadata,
        tablename="album"
    )

    id: int = ormar.Integer(primary_key=True)
    name: str = ormar.String(max_length=100)
    Favorite: bool = ormar. booléen (default=False)

album = Album(nom ="Dark Side of the Moon")

# ormar < 0.20
album_dict = album.dict()

# ormar >= 0,20
new_album_dict = album.model_dump()

Notez que les paramètres restent les mêmes, c'est-à-dire inclus, exclus, etc.

json() devient model_dump_json()

 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
Importer des databases
Importer à Ormar
Import scalalchemy

databases.Database("sqlite:///db.sqlite")
metadata = sqlalchemy.MetaData()

Classe Album(modèle ormar):
    ormar_config = ormar.ormarConfig(
        database=database,
        Metadata=Metadata,
        tablename="album"
    )

    id: int = ormar.Integer(primary_key=True)
    name: str = ormar.String(max_length=100)
    Favorite: bool = ormar. booléen (default=False)

album = Album(nom ="Dark Side of the Moon")

# ormar <0,20
album_json= album.json()

# ormar >= 0,20
new_album_dict = album.model_dump_json()

Notez que les paramètres restent les mêmes, c'est-à-dire inclus, exclus, etc.

construct() devient model_construct()

 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
Importer des databases
Importer à Ormar
Import scalalchemy

databases.Database("sqlite:///db.sqlite")
metadata = sqlalchemy.MetaData()

Classe Album(modèle ormar):
    ormar_config = ormar.ormarConfig(
        database=database,
        Metadata=Metadata,
        tablename="album"
    )

    id: int = ormar.Integer(primary_key=True)
    nom: str = ormar.String(max_length=100)
    Favorite: bool = ormar. booléen (default=False)

Params = {
    "Nom": "Dark Side of the Moon",
    « Favorite »: True,
}
# ormar <0,20
Album = Album.construct(**params)

# ormar >= 0.20
album = Album. modèle_construct(**params)

Pour en savoir plus sur la construction, consultez la documentation pydantique.