Hvad ændrede sig i Pydantic v2, og hvorfor betyder det noget for FastAPI?

Question

Accepted Answer

**Pydantic v2** (en større omskrivning med sin kerne i **Rust**) bragte store præstationsforbedringer og API-ændringer. Da Pydantic er central for FastAPI (validering, serialisering, modeller), er det vigtigt at forstå v2 både for hastighed og for at skrive korrekt moderne kode.

## Hovedpunktet: meget hurtigere (Rust-kerne)

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

Dette er den mest påvirkende ændring — hurtigere validering betyder hurtigere FastAPI, uden kodændringer ud over opgradering.

## Vigtige API-ændringer (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(...)
```

De almindelige metoder og validator-dekoratører blev omdøbt — vigtig når man læser eller skriver kode, og når man migrerer v1-kodebaser.

## Strengere, tydeligere opførsel

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

## Hvorfor dette betyder noget for FastAPI specifikt

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

## Hvorfor det betyder noget

At forstå Pydantic v2 er vigtig for FastAPI-udvikler, fordi Pydantic er grundlaget for FastAPIs kernefunktioner (validering, serialisering, modeller, indstillinger, dokumentation), så dets store versionsændring påvirker direkte både ydeevne og hvordan du skriver kode.

Hovedfordelen — en **Rust-baseret kerne, der leverer 5–50x hurtigere validering/serialisering** — gør direkte FastAPI-applikationer hurtigere (som validerer hver anmodning og serialiserer hver respons gennem Pydantic), en betydelig præstationsgevinst opnået ved blot at være på v2.

Lige vigtig er **API-ændringerne**: de omdøbte metoder (`model_dump`/`model_validate`) og validator-dekoratører (`field_validator`/`model_validator`) betyder, at du skal bruge den moderne syntaks til at skrive korrekt kode, og at genkende disse ændringer er vigtig når du læser nuværende kode, skriver ny kode, eller migrerer ældre v1-kodebaser (en almindelig opgave i den virkelige verden).

Den strengere, tydeligere valideringsopførsel gør også applikationer mere forudsigelige.

Da moderne FastAPI-versioner bygger på Pydantic v2, er det vigtig viden på seniorNiveau at vide hvad der ændrede sig — præstationsforbedringerne, det nye API, og de adfærdsmæssige forskelle — for at arbejde effektivt med nuværende FastAPI, undgå forældede v1-mønstre, og forstå hvorfor FastAPI udfører som det gør.

Det afspejler kendskab til frameworkets udvikling af grundlaget og bliver stadig mere relevant, når økosystemet standardiserer på v2.