Hva er Pydantic-modeller i FastAPI?

Question

Accepted Answer

**Pydantic-modeller** er klasser (underklasser av `BaseModel`) som definerer **strukturen, typene og valideringsreglene** for data. FastAPI bruker dem overalt — for request bodies, response shapes og innstillinger — noe som gjør dem til hjertet av dets type-driven design.

## Definere en modell

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

Hvert felt erklærer en type og valgfrie begrensninger/standardverdier. Pydantic validerer data mot denne definisjonen og konverterer typer hvor fornuftig.

## Automatisk validering og parsing

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

Når det brukes som parametertype, parser FastAPI JSON request body inn i modellen, **validerer** hvert felt og returnerer en strukturert 422-feil som lister nøyaktig hva som er galt — alt automatisk.

## Hva Pydantic gir deg

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

## En enkelt kilde til sannhet

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

## Hvorfor det er viktig

Pydantic-modeller er hjørnestenen i FastAPI — de er hvordan du definerer og validerer dataene som API-en din godtar og returnerer, og nesten hver FastAPI-funksjon går gjennom dem.

Det er essensielt å forstå dem fordi de gir automatisk **validering** (kritisk for sikkerhet og robusthet — aldri stole på råinput), parsing/coercion, serialisering og editor-støtte, alt fra en enkelt deklarativ klasse.

De fungerer som **en enkelt kilde til sannhet**: én modell driver request-validering, response shape og den autogenererte dokumentasjonen.

Denne type-driven, validate-by-default-tilnærmingen — få robust inputvalidering og tydelige feilmeldinger praktisk talt gratis — er en stor grunn til at FastAPI er så produktiv og sikker, noe som gjør Pydantic-modeller fundamental, must-master kunnskap.