Pydantic : La fin des validations manuelles ! ✨

Pydantic est une bibliothèque de validation de données et de gestion des paramètres pour Python. Il utilise des indices de type Python pour valider et analyser les données, garantissant ainsi que votre code fonctionne avec des données correctement structurées et typées. En tirant parti de la structure de modèle de type classe de données de Python, Pydantic facilite la définition de schémas pour les données complexes et valide et sérialise/désérialise automatiquement les données d'une manière Pythonique propre. Explorons les principales fonctionnalités :

Validation des données

Validez automatiquement les données d'entrée par rapport à un schéma à l'aide des astuces de type Python.

from pydantic import BaseModel, ValidationError

class User(BaseModel):
    id: int
    name: str
    email: str

# Valid input
user = User(id=1, name="John Doe", email="john@example.com")
print(user)

# Invalid input
try:
    user = User(id="not-an-integer", name="Jane", email="jane@example.com")
except ValidationError as err:
    print(err)

Chaque fois que vous souhaitez définir un modèle de données, utilisez pydantic.BaseModel !

Validation des fonctions

Pydantic fournit des outils puissants pour valider non seulement les modèles de données, mais également les entrées et sorties des fonctions. Ceci est réalisé à l'aide du décorateur @validate_call, vous permettant d'appliquer une validation stricte des données pour les arguments de fonction et les valeurs de retour. Si les arguments fournis ou le type de retour ne correspondent pas aux types attendus, une ValidationError est levée.

from pydantic import validate_call

@validate_call
def greet(name: str, age: int) -> str:
    return f"Hello {name}, you are {age} years old."

# Valid input
print(greet("Alice", 30))  # Output: Hello Alice, you are 30 years old.

# Invalid input
try:
    greet("Bob", "not-a-number")
except Exception as e:
    print(e)

En activant l'indicateur validate_return dans @validate_call, Pydantic validera également la valeur de retour de la fonction par rapport à son type de retour annoté. Cela garantit que la fonction adhère au schéma de sortie attendu.

from pydantic import validate_call

@validate_call(validate_return=True)
def calculate_square(number: int) -> int:
    return number ** 2  # Correct return type

# Valid input and return
print(calculate_square(4))  # Output: 16

# Invalid return value
@validate_call(validate_return=True)
def broken_square(number: int) -> int:
    return str(number ** 2)  # Incorrect return type

try:
    broken_square(4)
except Exception as e:
    print(e)

Analyse

Pydantic peut analyser des structures imbriquées complexes, y compris des données JSON, dans des objets de modèle.

from pydantic import BaseModel
from typing import List

class Item(BaseModel):
    name: str
    price: float

class Order(BaseModel):
    items: List[Item]
    total: float

# JSON-like data
data = {
    "items": [
        {"name": "Apple", "price": 1.2},
        {"name": "Banana", "price": 0.8}
    ],
    "total": 2.0
}

order = Order(**data) 
print(order) # items=[Item(name='Apple', price=1.2), Item(name='Banana', price=0.8)] total=2.0

Sérialisation et désérialisation

Les modèles Pydantic peuvent être sérialisés en JSON ou dans des dictionnaires et reconstruits.

from pydantic import BaseModel

class User(BaseModel):
    id: int
    name: str
    email: str

# Create a model instance
user = User(id=1, name="Alice", email="alice@example.com")

# Serialize to dictionary and JSON
user_dict = user.model_dump()
user_json = user.model_dump(mode='json')

print("Dictionary:", user_dict)
print("JSON:", user_json)

# Deserialize back to the model
new_user = User.model_validate(user_json)
print("Parsed User:", new_user)

Validation flexible

La validation des données n'est pas une validation de type force. Par exemple, si vous définissez un modèle avec des champs id, due_date et priorité de types int, bool et datetime respectivement, vous pouvez transmettre :

• chaîne numérique comme identifiant
• ISO-8601, UTC ou des chaînes des autres formats de date comme due_date
• 'oui'/'non', 'on'/'off', 'vrai'/'faux', 1/0 etc. en priorité

from sensei import APIModel
from datetime import datetime


class Task(APIModel):
    id: int
    due_date: datetime
    priority: bool


task = Task(due_date='2024-10-15T15:30:00',>



<p>The result will be<br>
</p>

<pre class="brush:php;toolbar:false">Task(id=1, due_date=datetime.datetime(2024, 10, 15, 15, 30), priority=True)

Validation personnalisée

Vous pouvez également définir une logique de validation personnalisée dans votre modèle à l'aide de validateurs. Ils vous permettent d'appliquer des règles de validation plus complexes qui ne peuvent pas être facilement exprimées à l'aide des types intégrés ou des contraintes de champ. Le validateur est défini via le décorateur field_validator ou l'objet Field. Vous pouvez transmettre un ou plusieurs noms de champs à field_validator, pour déterminer quels champs utiliseront ce validateur, ou '*' pour appliquer le validateur à chaque champ.

en tapant import Any
à partir de l'importation pydantic Field, field_validator, EmailStr, BaseModel

Utilisateur de classe (BaseModel):
    identifiant : int
    nom d'utilisateur : str = Field(pattern=r'^w $')
    email : EmailStr
    âge : int = Champ (18, ge = 14)
    is_active : bool = Vrai
    rôles : liste[str]

    # Définir le validateur exécuté 'avant' l'analyse interne
    @field_validator('roles', mode='avant')
    def _validate_roles (cls, valeur : Any) :
        return value.split(',') si isinstance(value, str) sinon valeur

utilisateur = Utilisateur (id = 1, nom d'utilisateur = 'john', email = 'john@example.com', rôles = 'étudiant, chanteur')
imprimer (utilisateur) #>



<h2>
  
  
  Projets open source
</h2>

<p>Il existe de nombreux projets open source alimentés par Pydantic. Explorons les meilleurs d'entre eux :</p>

<h3>
  
  
  API rapide
</h3>

<p>L'un des cas d'utilisation les plus importants de Pydantic concerne FastAPI, un framework Web moderne permettant de créer des API avec Python. FastAPI utilise largement les modèles Pydantic pour la validation du corps de la requête, les paramètres de requête et les schémas de réponse.</p>

• Source : https://github.com/fastapi/fastapi
• Documents : https://fastapi.tiangolo.com

Sensei

Alors que FastAPI est conçu pour créer des API, Sensei est conçu pour envelopper ces API rapidement et facilement. Les clients API alimentés par Sensei garantissent aux utilisateurs qu'ils obtiendront des modèles de données pertinents et n'obtiendront pas d'erreurs déroutantes.

• Source : https://github.com/CrocoFactory/sensei
• Documents : https://sensei.crocofactory.dev

Modèle SQL et typeur

SQLModel et Typer sont deux projets remarquables développés par Sebastián Ramírez, le créateur de FastAPI.

SQLModel est une bibliothèque conçue pour rationaliser les interactions avec les bases de données dans les applications Python. Construit sur SQLAlchemy et Pydantic, SQLModel combine la puissance d'un ORM avec la commodité de la validation et de la sérialisation des données.

• Source : https://github.com/fastapi/sqlmodel
• Documents : https://sqlmodel.tiangolo.com

Typer est un framework permettant de créer des applications d'interface de ligne de commande (CLI) à l'aide de Python. Il simplifie le processus en utilisant les astuces de type Python pour générer automatiquement des commandes CLI conviviales et un texte d'aide.

• Source : https://github.com/fastapi/typer
• Documents : https://typer.tiangolo.com

Ce qui précède est le contenu détaillé de. pour plus d'informations, suivez d'autres articles connexes sur le site Web de PHP en chinois!