Comment écrire une validation personnalisée dans Pydantic ?

Question

Accepted Answer

Au-delà des contraintes intégrées, Pydantic vous permet d'écrire **une logique de validation personnalisée** avec des validateurs de champs (valider un seul champ) et des validateurs de modèles (valider plusieurs champs) — pour les règles que les contraintes simples ne peuvent pas exprimer. (La syntaxe présentée est celle de Pydantic v2.)

## Validateurs de champs — valider/transformer un seul champ

```python
from pydantic import BaseModel, field_validator

class User(BaseModel):
    username: str
    password: str

@field_validator("username")
    @classmethod
    def username_alphanumeric(cls, v: str) -> str:
        if not v.isalnum():
            raise ValueError("username must be alphanumeric")   # → a 422 error
        return v.lower()                                         # can also TRANSFORM the value
```

Un `@field_validator` exécute une logique personnalisée sur un champ : levez une `ValueError` pour rejeter une entrée invalide (FastAPI la transforme en une réponse claire 422), ou retournez une valeur transformée (par ex. normalisation en minuscules).

## Validateurs de modèles — validation entre champs

```python
from pydantic import model_validator

class SignupForm(BaseModel):
    password: str
    confirm_password: str

@model_validator(mode="after")
    def passwords_match(self):
        if self.password != self.confirm_password:    # compare MULTIPLE fields
            raise ValueError("passwords do not match")
        return self
```

Un `@model_validator(mode="after")` s'exécute après la validation de tous les champs, avec accès à l'ensemble du modèle — utilisé pour les règles impliquant **plusieurs champs** (par ex. confirmer que les mots de passe correspondent, ou qu'une date de début précède une date de fin).

## La validation intégrée suffit souvent d'abord

```python
class Product(BaseModel):
    price: float = Field(gt=0)          # use Field constraints for simple rules
    sku: str = Field(pattern=r"^[A-Z]{3}-\d+$")
    email: EmailStr                      # specialized types for formats
# reach for custom validators only when constraints/types can't express the rule
```

Préférez les contraintes `Field` et les types spécialisés pour les règles simples ; utilisez des validateurs personnalisés pour la vraie logique métier.

## Pourquoi c'est important

La validation personnalisée de Pydantic est importante pour appliquer des règles métier qui vont au-delà des simples vérifications de type et contraintes — et comme la validation est critique pour la **sécurité et l'intégrité des données**, pouvoir exprimer n'importe quelle règle est précieux. Les **validateurs de champs** gèrent la logique au niveau d'un seul champ (vérifications de format personnalisées, normalisation/transformation), tandis que les **validateurs de modèles** traitent le besoin courant de **validation entre champs** (correspondance des mots de passe, plages de dates, exigences conditionnelles) que les règles au niveau du champ ne peuvent pas exprimer.

Les validateurs s'intègrent parfaitement avec FastAPI — une `ValueError` levée devient automatiquement une réponse 422 claire.

Comprendre quand utiliser les contraintes/types intégrés (pour les règles simples) par rapport aux validateurs personnalisés (pour la vraie logique métier), et comment les validateurs de champs et de modèles diffèrent, vous permet de vous assurer que les données entrantes satisfont pleinement les exigences de votre application, ce qui rend cette connaissance importante pour construire des APIs robustes et correctes.