Qu'est-ce qui a changé dans Pydantic v2 et pourquoi c'est important pour FastAPI ?

Question

Accepted Answer

**Pydantic v2** (une réécriture majeure avec son cœur en **Rust**) a apporté des gains de performance importants et des changements d'API. Puisque Pydantic est central à FastAPI (validation, sérialisation, modèles), comprendre v2 est important tant pour la performance que pour écrire du code moderne correct.

## Pourquoi c'est important

```text
Pydantic v2's validation core (pydantic-core) is written in RUST → typically
5–50x faster validation/serialization than v1.
→ Since FastAPI validates every request and serializes every response with Pydantic,
  this directly speeds up FastAPI apps.
```

C'est le changement le plus impactant — une validation plus rapide signifie un FastAPI plus rapide, sans changement de code nécessaire au-delà de la mise à jour.

## Changements clés d'API (v1 → v2)

```python
# method renames
model.dict()        → model.model_dump()          # to a dict
model.json()        → model.model_dump_json()      # to JSON
Model.parse_obj()   → Model.model_validate()        # from a dict

# validator decorators renamed
@validator("field")      → @field_validator("field")    # + must be a @classmethod
@root_validator         → @model_validator(mode="after")  # cross-field

# config: a class Config → model_config dict
class Config: ...        → model_config = ConfigDict(...)
```

Les méthodes courantes et les décorateurs de validateurs ont été renommés — important lors de la lecture ou l'écriture de code, et lors de la migration des bases de code v1.

## Comportement plus strict et plus clair

```text
✓ Stricter type coercion by default (fewer surprising silent conversions)
✓ Clearer, more detailed validation errors
✓ Better support for strict vs lax modes, computed fields, serialization control
✓ pydantic-settings split into its own package (BaseSettings moved there)
```

## Pourquoi cela compte spécifiquement pour FastAPI

```text
FastAPI uses Pydantic for: request body validation, response_model serialization,
query/path validation, settings, and the OpenAPI schema. So Pydantic v2's:
  ✓ speed → faster request handling across the board
  ✓ API changes → you must use the v2 syntax (model_dump, field_validator, etc.)
  ✓ behavior → stricter, more predictable validation
Modern FastAPI versions require/use Pydantic v2.
```

## Pourquoi c'est important

Comprendre Pydantic v2 est important pour les développeurs FastAPI car Pydantic est la fondation des fonctionnalités principales de FastAPI (validation, sérialisation, modèles, paramètres, documentation), donc son changement de version majeure affecte directement à la fois la performance et la façon dont vous écrivez du code.

Le bénéfice principal — un **cœur basé sur Rust offrant une validation/sérialisation 5 à 50 fois plus rapide** — accélère directement les applications FastAPI (qui valident chaque requête et sérialisent chaque réponse via Pydantic), un gain de performance significatif obtenu simplement en passant à v2.

Également important sont les **changements d'API** : les méthodes renommées (`model_dump`/`model_validate`) et les décorateurs de validateurs (`field_validator`/`model_validator`) signifient que vous devez utiliser la syntaxe moderne pour écrire du code correct, et reconnaître ces changements est essentiel lors de la lecture du code actuel, l'écriture de nouveau code, ou la migration d'anciennes bases de code v1 (une tâche courante dans le monde réel).

Le comportement de validation plus strict et plus clair rend également les applications plus prévisibles.

Puisque les versions modernes de FastAPI sont construites sur Pydantic v2, savoir ce qui a changé — les gains de performance, la nouvelle API, et les différences de comportement — est une connaissance importante au niveau senior pour travailler efficacement avec FastAPI actuel, éviter les schémas v1 obsolètes, et comprendre pourquoi FastAPI fonctionne comme il le fait.

Cela reflète une conscience de l'évolution de la fondation du framework et devient de plus en plus pertinent alors que l'écosystème se normalise sur v2.