آپ nested اور complex request bodies کو کیسے model کرتے ہیں؟

Question

Accepted Answer

Pydantic models **nest** کر سکتے ہیں — ایک model field خود ایک دوسرا model، models کی list، یا complex types ہو سکتا ہے — جو FastAPI کو گہری ساخت والے JSON (objects کے اندر objects، objects کی arrays) کو خودکار طور پر 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]` کے طور پر typed ہو recursively validate ہوتا ہے — nested objects اور objects کی arrays سب اپنے schemas کے خلاف خودکار طور پر چیک ہوتے ہیں۔

## 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 کو سنبھالتا ہے: enums (اقدار کو محدود کرتے ہیں)، `datetime` (ISO strings کو parse کرتے ہیں)، `HttpUrl`/`EmailStr` (format validation)، اور typed dicts/tuples — سب خودکار طور پر 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 }
```

## یہ اہم کیوں ہے

حقیقی دنیا کے APIs شاذ و نادر flat data سے نمٹتے ہیں — وہ complex، nested structures کو سنبھالتے ہیں (ایک user جس کے پاس ایک address اور orders کی list ہو، ایک order جس کے پاس line items ہوں، configuration objects)، اور Pydantic کی **nested models** کو nest کرنے کی صلاحیت ان گہری ساخت والے request bodies کو validate کرنا بے دردی کر دیتی ہے۔

ík کہنا ضروری ہے کہ ایک model field کوئی دوسرا model، models کی list، یا ایک rich type ہو سکتا ہے — اور FastAPI **پوری nested structure کو recursively اور خودکار طور پر** validate کرتا ہے — APIs بنانے کے لیے اہم ہے جو حقیقی، complex input کو محفوظ طریقے سے قبول کریں۔

Rich type support (enum کے لیے constrained values، `datetime` parsing، `HttpUrl`/`EmailStr` format validation، typed collections) مزید ensure کرتی ہے کہ complex data صحیح ہے بغیر manual checks کے۔

Nested اور complex bodies کو model کرنا جاننا (اور reusable generic wrappers جیسے pagination کے لیے) APIs بنانے کے لیے عملی علم ہے جو structured data کو سنبھالتے ہیں جو حقیقی applications کو ضرورت ہے، مکمل validation کے ساتھ خودکار طور پر فراہم کی جاتی ہے — FastAPI کے Pydantic-based design کی ایک اہم طاقت۔