Kif timmudella request bodies nested u kumplessi?

Question

Accepted Answer

Mudelli Pydantic jistgħu jkunu **nested** — qasam mudell jista' jkun mudell ieħor, lista ta' mudelli, jew tipi kumplessi — u jippermettu lil FastAPI jivvalida automatikament JSON strutturata profondament (oġġetti ġewwa oġġetti, arrays ta' oġġetti).

## Mudelli nested

```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"] }
```

Qasam mudell li t-tip tiegħu huwa mudell ieħor (jew `list[Model]`) jiġi validat b'mod rekursiv — oġġetti nested u arrays ta' oġġetti kollha jiġu ċċekkjati kontra l-iskemi tagħhom automatikament.

## Tipi kumplessi u speċjali

```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 jaħdem ma' tipi għonjod: enums (irkosta sal-valuri permessi), `datetime` (jipparsa l-istringi ISO), `HttpUrl`/`EmailStr` (validazzjoni tal-format), u typed dicts/tuples — kollha jiġu validati automatikament.

## Wrapper generiku / riusabbli

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

## Għaliex hija importanti

APIs tal-mundu reali rari jittrattaw data ċatta — jittrattaw strutturi kumplessi u nested (user b'indirizz u lista ta' ordnijiet, ordni b'line items, oġġetti ta' konfigurazzjoni), u l-abbiltà ta' Pydantic li **anna mudelli** tħalli l-validazzjoni ta' request bodies strutturati profondament tkun faċli.

L-għarfien li qasam mudell jista' jkun mudell ieħor, lista ta' mudelli, jew tip għonjod — u li FastAPI **jivvalida l-intera struttura nested b'mod rekursiv** u **automatikament** — huwa importanti għall-bini ta' APIs li jaċċettaw input realistiku u kumplessi b'mod sigur.

L-appoġġ tat-tipi għonjod (enums għal valuri vinkolati, parsing ta' `datetime`, validazzjoni tal-format `HttpUrl`/`EmailStr`, inqas tipizzati) għal-inqas jiżgura li d-data kumplessa tkun korretta mingħajr checks manuali.

Il-għarfien ta' kif timmudella bodies nested u kumplessi (u wrappers generiku riusabbli għal affarijiet bħal pagination) huwa għarfien prattiku għall-bini ta' APIs li jittrattaw data strutturata li l-applikazzjonijiet reali jeħtieġu, b'validazzjoni kompleta pprovduta automatikament — forza ewlenija tad-disinn ta' FastAPI ibbażat fuq Pydantic.