Conas a mhúnlaíonn tú tréithe iarratais neadaithe agus casta?

Question

Accepted Answer

Is féidir le samhlacha Pydantic a bheith **neadaithe** — is féidir le réimse samhla a bheith ina shamhail eile, i liosta de shamhlacha, nó i gcineálacha casta — rud a ligeann do FastAPI JSON go mór struchtúrtha (rudaí laistigh de rudaí, eagair de rudaí) a bhailíochtú go huathoibríoch.

## Samhlacha neadaithe

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

Is réimse samhla atá clóscríofa mar shamhail eile (nó `list[Model]`) a bhailítear go athchúrsach — tá rudaí neadaithe agus eagair de rudaí ar fad á bhailíochtú i gcoinne a scéim go huathoibríoch.

## Cineálacha casta agus speisialta

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

Baineann Pydantic le cineálacha saibhir: enums (teorannú ar luachanna ceadaithe), `datetime` (anailís ar theaghráin ISO), `HttpUrl`/`EmailStr` (bailíochtú formáid), agus typed dicts/tuples — ar fad bailíochithe go huathoibríoch.

## Balúnaidh ginearálta / athúsáidte

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

## Cén fáth a bhfuil sé tábhachtach

Ní dhéileálann API fíor-dhomhain go minic le sonraí fláine — déileálann siad le struchtúir chasta, neadaithe (úsáideoir le seoladh agus liosta orduithe, ordú le míreanna líne, rudaí cumraíochta), agus déanann cumas Pydantic **samhlacha a neadú** bailíochtú tréithe iarratais go mór struchtúrtha a dhéanamh gan dua.

Tá sé tábhachtach a thuiscint go féidir le réimse samhla a bheith ina shamhail eile, i liosta de shamhlacha, nó i gcineál saibhir — agus go **bailíochtaíonn FastAPI an struchtúr neadaithe ar fad go athchúrsach** agus go huathoibríoch — chun APIanna a thógáil a ghlacann ionchuir réadúil, chasta ar bhealach slán.

Soláthraíonn an tacaíocht chineála saibhir (enums do luachanna teoranta, anailís `datetime`, bailíochtú formáid `HttpUrl`/`EmailStr`, bailiú clóscríofa) breise ar fad gur bhfuil sonraí casta ceart gan sheiceálacha láimhe.

Is eolas praiticiúil í a bheith ar eolas conas a mhúnlaíonn tú tréithe neadaithe agus chasta (agus balúnaidh ginearálta athúsáidte do rudaí ar nós leathchéim) chun APIanna a thógáil a dhéileálann le sonraí struchtúrtha a éilíonn fíor-fheidhmchláir, le bailíochtú iomlán soláthraighte go huathoibríoch — láidreacht bhunúsach dhearadhain FastAPI bunaithe ar Pydantic.