ਤੁਸੀਂ nested ਅਤੇ complex request bodies ਨੂੰ ਕਿਵੇਂ model ਕਰਦੇ ਹੋ?

Question

Accepted Answer

Pydantic models **nest** ਕਰ ਸਕਦੇ ਹਨ — ਇੱਕ model field ਆਪ ਵਿੱਚ ਇੱਕ ਹੋਰ model, models ਦੀ ਇੱਕ list, ਜਾਂ complex types ਹੋ ਸਕਦਾ ਹੈ — ਜਿਸ ਨਾਲ FastAPI deeply structured JSON (objects ਦੇ ਅੰਦਰ objects, objects ਦੀ arrays) ਨੂੰ automatically validate ਕਰਦਾ ਹੈ।

## Nested models

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

ਇੱਕ model field ਜੋ ਕਿ ਦੂਜੇ model ਦੀ ਕਿਸਮ ਦਾ ਹੋ (ਜਾਂ `list[Model]`) recursively validate ਹੁੰਦਾ ਹੈ — nested objects ਅਤੇ objects ਦੀ arrays ਦੀ ਉਹਨਾਂ ਦੀ schemas ਦੇ ਵਿਰੁੱਧ automatically check ਕੀਤੀ ਜਾਂਦੀ ਹੈ।

## Complex ਅਤੇ special types

```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 rich types ਨੂੰ handle ਕਰਦਾ ਹੈ: enums (allowed values ਤੱਕ محدود ਕਰਨਾ), `datetime` (ISO strings ਨੂੰ parse ਕਰਨਾ), `HttpUrl`/`EmailStr` (format validation), ਅਤੇ typed dicts/tuples — ਸਭ automatically validate ਹੋ ਜਾਂਦੇ ਹਨ।

## Generic / reusable wrappers

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

## ਇਹ ਕਿਉਂ ਮਾਇਨੇ ਰੱਖਦਾ ਹੈ

Real-world APIs ਰਾਹੀਂ flat data ਨਾਲ ਕੋਈ deal ਨਹੀਂ ਕਰਦੇ — ਉਹ complex, nested structures ਨੂੰ handle ਕਰਦੇ ਹਨ (ਇੱਕ user ਜਿਸ ਕੋਲ address ਅਤੇ orders ਦੀ ਲਿਸਟ ਹੈ, ਇੱਕ order ਜਿਸ ਕੋਲ line items ਹਨ, configuration objects), ਅਤੇ Pydantic ਦੀ models ਨੂੰ **nest ਕਰਨ** ਦੀ ਸਮਰੱਥਾ deeply structured request bodies ਨੂੰ validate ਕਰਨ ਨੂੰ effortless ਬਣਾਉਂਦੀ ਹੈ।

ey ਸਮਝ ਲੈਣਾ ਮਹੱਤਵਪੂਰਨ ਹੈ ਕਿ ਇੱਕ model field ਦੂਜਾ model, models ਦੀ ਲਿਸਟ, ਜਾਂ ਇੱਕ rich type ਹੋ ਸਕਦਾ ਹੈ — ਅਤੇ ਇਹ ਕਿ FastAPI **ਪੂਰੀ nested structure ਨੂੰ recursively ਅਤੇ automatically validate** ਕਰਦਾ ਹੈ — APIs ਬਣਾਉਣ ਲਈ ਮਹੱਤਵਪੂਰਨ ਹੈ ਜੋ realistic, complex input ਨੂੰ safely ਸਵੀਕਾਰ ਕਰਦੇ ਹਨ।

Rich type support (constrained values ਲਈ enums, `datetime` parsing, `HttpUrl`/`EmailStr` format validation, typed collections) ਹੋਰ ਵੀ ਯਕੀਨੀ ਬਣਾਉਂਦੀ ਹੈ ਕਿ complex data ਬਿਨਾ manual checks ਦੇ ਸਹੀ ਹੈ।

Nested ਅਤੇ complex bodies ਨੂੰ model ਕਰਨ ਬਾਰੇ ਜਾਣ ਲੈਣਾ (ਅਤੇ pagination ਵਰਗੀਆਂ ਚੀਜ਼ਾਂ ਲਈ reusable generic wrappers) ਅਮਲੀ ਗਿਆਨ ਹੈ APIs ਬਣਾਉਣ ਲਈ ਜੋ structured data ਨੂੰ handle ਕਰਦੇ ਹਨ ਜੋ real applications ਨੂੰ ਜ਼ਰੂਰਤ ਹੈ, full validation ਦੇ ਨਾਲ automatically provided — FastAPI ਦੇ Pydantic-based design ਦੀ ਇੱਕ ਮੁੱਖ ਤਾਕਤ।