Hvordan modellerer du indlejrede og komplekse anmodningskroppe?

Question

Accepted Answer

Pydantic-modeller kan **indlejres** — et modelfeld kan være en anden model, en liste over modeller eller komplekse typer — hvilket gør det muligt for FastAPI at validere dybt struktureret JSON (objekter inden i objekter, arrays af objekter) automatisk.

## Indlejrede modeller

```python
from pydantic import BaseModel

class Address(BaseModel):
    street: str
    city: str
    zip: str

class User(BaseModel):
    name: str
    address: Address                    # a NESTED model
    tags: list[str] = []                # a list of strings
    addresses: list[Address] = []       # a list of NESTED models

@app.post("/users")
def create(user: User):                  # validates the WHOLE nested structure
    return user
```

```json
// FastAPI validates this entire structure, including the nested address:
{ "name": "Ann",
  "address": { "street": "1 Main", "city": "NY", "zip": "10001" },
  "tags": ["vip"] }
```

Et modelfeld skrevet som en anden model (eller `list[Model]`) valideres rekursivt — indlejrede objekter og arrays af objekter kontrolleres alle automatisk mod deres skemaer.

## Komplekse og specielle typer

```python
from pydantic import BaseModel, HttpUrl, EmailStr
from datetime import datetime
from enum import Enum

class Status(str, Enum):                 # enums constrain to allowed values
    active = "active"
    inactive = "inactive"

class Item(BaseModel):
    url: HttpUrl                          # validates URL format
    email: EmailStr                       # validates email format
    created: datetime                     # parses ISO 8601 strings → datetime
    status: Status                        # must be one of the enum values
    metadata: dict[str, int]              # typed dict
    coordinates: tuple[float, float]      # typed tuple
```

Pydantic håndterer avancerede typer: enums (begræns til tilladte værdier), `datetime` (parser ISO-strenge), `HttpUrl`/`EmailStr` (formatvalidering) og typede dicts/tuples — alle valideres automatisk.

## Generisk / genanvendelige wrappere

```python
from typing import Generic, TypeVar
T = TypeVar("T")
class Paginated(BaseModel, Generic[T]):   # a reusable generic response wrapper
    items: list[T]
    total: int
# Paginated[User] → { items: [User...], total: N }
```

## Hvorfor det betyder noget

Virkelige API'er har sjældent at gøre med flade data — de håndterer komplekse, indlejrede strukturer (en bruger med en adresse og en liste over ordrer, en ordre med linjeelementer, konfigurationsobjekter), og Pydantics evne til at **indlejre modeller** gør validering af dybere strukturerede anmodningskroppe ubesværet.

Forståelsen for, at et modelfeld kan være en anden model, en liste over modeller eller en avanceret type — og at FastAPI **validerer hele den indlejrede struktur rekursivt og automatisk** — er vigtig for at bygge API'er, der accepterer realistiske, komplekse input sikkert.

Den avancerede typestøtte (enums for begrænsede værdier, `datetime`-parsing, `HttpUrl`/`EmailStr`-formatvalidering, typede samlinger) sikrer yderligere, at komplekse data er korrekte uden manuelle kontroller.

At vide, hvordan man modellerer indlejrede og komplekse kroppe (og genanvendelige generiske wrappere til ting som sideinddeling) er praktisk viden for at bygge API'er, der håndterer de strukturerede data, som rigtige applikationer kræver, med fuld validering leveret automatisk — en nøglestyrke ved FastAPI's Pydantic-baserede design.