Cos'è cambiato in Pydantic v2 e perché è importante per FastAPI?

Question

Accepted Answer

**Pydantic v2** (una riscrittura completa con core in **Rust**) ha portato grandi miglioramenti di performance e cambiamenti nell'API. Poiché Pydantic è centrale in FastAPI (validazione, serializzazione, modelli), capire v2 è importante sia per la velocità che per scrivere codice moderno corretto.

## Perché è importante: molto più veloce (core in Rust)

```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.
```

Questo è il cambiamento più impattante — una validazione più veloce significa un FastAPI più veloce, senza necessità di cambiamenti al codice al di là dell'aggiornamento.

## Cambiamenti chiave dell'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(...)
```

I metodi comuni e i decorator per i validator sono stati rinominati — importante quando si legge o si scrive codice, e quando si migrano codebase di v1.

## Comportamento più rigoroso e più chiaro

```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)
```

## Perché questo è importante specificamente per 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.
```

## Perché è importante

Capire Pydantic v2 è importante per gli sviluppatori FastAPI perché Pydantic è la fondazione delle funzionalità core di FastAPI (validazione, serializzazione, modelli, settings, documentazione), quindi il suo cambio di versione major influisce direttamente sia sulla performance che su come si scrive il codice.

Il vantaggio principale — un **core basato su Rust che fornisce validazione/serializzazione da 5 a 50 volte più veloce** — accelera direttamente le applicazioni FastAPI (che validano ogni richiesta e serializzano ogni risposta attraverso Pydantic), un guadagno significativo di performance ottenuto semplicemente passando a v2.

Altrettanto importante sono i **cambiamenti dell'API**: i metodi rinominati (`model_dump`/`model_validate`) e i decorator per i validator (`field_validator`/`model_validator`) significano che devi usare la sintassi moderna per scrivere codice corretto, e riconoscere questi cambiamenti è essenziale quando leggi codice attuale, scrivi nuovo codice, o migri codebase più vecchie di v1 (un compito comune nel mondo reale).

Il comportamento di validazione più rigoroso e più chiaro rende anche le applicazioni più prevedibili.

Poiché le versioni moderne di FastAPI sono costruite su Pydantic v2, sapere cosa è cambiato — i guadagni di performance, la nuova API, e le differenze comportamentali — è una conoscenza importante a livello senior per lavorare efficacemente con FastAPI attuale, evitare pattern v1 obsoleti, e capire perché FastAPI ha le performance che ha.

Riflette la consapevolezza della fondazione in evoluzione del framework ed è sempre più rilevante man mano che l'ecosistema si standardizza su v2.