Qu'est-ce que les modèles Pydantic dans FastAPI ?

Question

Accepted Answer

**Les modèles Pydantic** sont des classes (sous-classant `BaseModel`) qui définissent la **structure, les types et les règles de validation** des données. FastAPI les utilise partout — pour les corps de requête, les formes de réponse et les paramètres — ce qui en fait le cœur de sa conception basée sur les types.

## Définir un modèle

```python
from pydantic import BaseModel, EmailStr, Field

class User(BaseModel):
    name: str
    email: EmailStr                          # validates email format
    age: int = Field(ge=0, le=120)            # constraint: 0 <= age <= 120
    is_active: bool = True                    # default value
    tags: list[str] = []                      # typed list with a default
```

Chaque champ déclare un type et des contraintes/valeurs par défaut optionnelles. Pydantic valide les données par rapport à cette définition et convertit les types si approprié.

## Validation et analyse automatiques

```python
@app.post("/users")
def create_user(user: User):                  # FastAPI builds & validates a User from the body
    return user                               # already validated here
# valid JSON → a typed User object; invalid → automatic 422 with field-level errors
```

Lorsqu'il est utilisé comme type de paramètre, FastAPI analyse le corps de la requête JSON dans le modèle, **validant** chaque champ et renvoyant une erreur structurée 422 listant exactement ce qui ne va pas — tout automatiquement.

## Ce que Pydantic vous offre

```text
✓ Validation — type checks + constraints (lengths, ranges, formats), clear errors
✓ Parsing/coercion — "5" → 5, ISO string → datetime, etc.
✓ Serialization — model.model_dump() / model_dump_json() → dict/JSON
✓ Editor support — full autocomplete & type checking on model attributes
✓ Self-documenting — the model defines the schema used in the auto-generated docs
```

## Une source unique de vérité

```text
One Pydantic model drives: request validation, the response schema, the OpenAPI docs,
and typed access in your code → define the data shape ONCE.
```

## Pourquoi c'est important

Les modèles Pydantic sont la pierre angulaire de FastAPI — c'est ainsi que vous définissez et validez les données que votre API accepte et renvoie, et presque chaque fonctionnalité de FastAPI les traverse.

Les comprendre est essentiel car ils fournissent une **validation** automatique (critique pour la sécurité et la robustesse — ne jamais faire confiance aux données brutes), l'analyse/coercion, la sérialisation et le support des éditeurs, tout à partir d'une seule classe déclarative.

Ils servent de **source unique de vérité** : un modèle pilote la validation des requêtes, la forme de la réponse et la documentation générée automatiquement.

Cette approche basée sur les types, validée par défaut — obtenant une validation robuste des entrées et des messages d'erreur clairs essentiellement gratuitement — est une raison majeure pour laquelle FastAPI est si productif et sûr, rendant les modèles Pydantic une connaissance fondamentale à maîtriser.