Pydantic : arrête de faire confiance à tes données, valide-les en deux lignes

Quand ton script lit du JSON, un CSV ou une saisie utilisateur, tu ne sais jamais vraiment ce qui t'arrive. Le champ « age » peut contenir un entier, la chaîne "34", ou carrément rien du tout. Python, lui, s'en fiche royalement : il exécute ton code jusqu'au moment où tout explose, trois fonctions plus loin, avec une erreur illisible.

Pydantic règle le problème de manière radicale : tu déclares la forme de tes données avec des types Python, et la bibliothèque valide, convertit et lève des erreurs claires à ta place. C'est la brique cachée sous FastAPI, sous Instructor et sous des milliers de projets d'IA. Aujourd'hui, on l'apprivoise.

Imagine un script qui envoie des emails à partir d'un fichier CSV. Une ligne a un email vide, une autre un nombre à la place du nom. Sans validation, ton script tourne, envoie des emails foireux, et tu découvres le carnage une heure plus tard. Avec Pydantic, la première ligne corrompue arrête tout, avec un message qui pointe du doigt la cellule exacte.

Étape 1 — Installer Pydantic et créer ton premier modèle

Si tu connais déjà les annotations de type (def f(x: int) -> str), tu connais 90 % de la syntaxe. Pydantic les recycle pour en faire un outil de validation à l'exécution : les types ne sont plus décoratifs, ils deviennent contraignants.

Installe Pydantic (la version 2, moderne et plus rapide) :

pip install pydantic

Un modèle Pydantic, c'est une classe qui hérite de BaseModel. Chaque champ est déclaré avec un type, et c'est tout :

from pydantic import BaseModel

class User(BaseModel):
    nom: str
    age: int
    email: str

# Des données brutes qui arrivent d'une API : tout est en chaîne
brut = {"nom": "Alice", "age": "34", "email": "alice@example.com"}

user = User(**brut)
print(user)                       # nom='Alice' age=34 email='alice@example.com'
print(user.age, type(user.age))   # 34 <class 'int'>

Regarde bien : « 34 » est une chaîne dans le dict d'entrée, mais user.age est devenu un vrai int. Pydantic a converti automatiquement, sans que tu lèves le petit doigt. C'est ce qu'on appelle la coercition de types.

Étape 2 — Des erreurs claires au lieu d'un crash mystérieux

Le vrai super-pouvoir de Pydantic, c'est ce qui se passe quand les données sont fausses. Au lieu de planter silencieusement au milieu de ton pipeline, tu reçois une ValidationError qui te dit exactement quoi, où et pourquoi :

from pydantic import BaseModel, ValidationError

class User(BaseModel):
    nom: str
    age: int

try:
    User(nom="Bob", age="pas-un-nombre")
except ValidationError as e:
    print(e)
    # age
    #   Input should be a valid integer, unable to parse string as an integer

Le message indique le champ fautif, la valeur reçue et le type attendu. Fini les NoneType object has no attribute à deux heures du matin : tu sais immédiatement quelle donnée d'entrée est corrompue.

Étape 3 — Ajouter tes propres règles avec les validateurs

La validation des types ne suffit pas toujours. Tu veux aussi vérifier qu'un email est plausible, qu'un âge est réaliste. Les validateurs de champ font ça en une poignée de lignes :

from pydantic import BaseModel, field_validator

class User(BaseModel):
    email: str
    age: int

    @field_validator("email")
    @classmethod
    def email_propre(cls, v: str) -> str:
        v = v.strip().lower()
        if "@" not in v:
            raise ValueError("email invalide")
        return v

    @field_validator("age")
    @classmethod
    def age_realiste(cls, v: int) -> int:
        if not 0 <= v <= 130:
            raise ValueError("age hors limites")
        return v

print(User(email="  Alice@Example.COM ", age=34))
# email='alice@example.com' age=34

Note le @classmethod, une particularité de Pydantic v2. Le validateur nettoie la valeur et la renvoie ; s'il lève une ValueError, Pydantic la transforme en une ValidationError propre et lisible.