Nested மற்றும் சிக்கலான request bodies-ஐ எவ்வாறு model செய்வீர்கள்?

Question

Accepted Answer

Pydantic models **nest** செய்ய முடியும் — ஒரு model field தானே மற்றொரு model, models-இன் ஒரு list, அல்லது சிக்கலான 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 ஆக (அல்லது `list[Model]` ஆக) type செய்யப்பட்ட ஒரு model field recursive-ஆக validate செய்யப்படுகிறது — nested objects மற்றும் objects-இன் arrays அனைத்தும் அவற்றின் schemas-க்கு எதிராக தானாகவே சரிபார்க்கப்படுகின்றன.

## சிக்கலான மற்றும் சிறப்பு 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 (அனுமதிக்கப்பட்ட values-க்கு கட்டுப்படுத்துகிறது), `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 }
```

## இது ஏன் முக்கியம்

Real-world APIs flat data-ஐ அரிதாகவே கையாளுகின்றன — அவை சிக்கலான, nested structures-ஐ கையாளுகின்றன (ஒரு address மற்றும் orders-இன் ஒரு list உள்ள ஒரு user, line items உள்ள ஒரு order, configuration objects), மேலும் Pydantic-இன் **models-ஐ nest** செய்யும் திறன் இந்த ஆழமாக கட்டமைக்கப்பட்ட request bodies-ஐ validate செய்வதை எளிதாக்குகிறது.

ஒரு model field மற்றொரு model, models-இன் ஒரு list, அல்லது ஒரு rich type ஆக இருக்கலாம் என்பதையும் — மேலும் FastAPI முழு nested structure-ஐயும் **recursive-ஆகவும் தானாகவும்** validate செய்கிறது என்பதையும் புரிந்துகொள்வது, நம்பகமான, சிக்கலான input-ஐ பாதுகாப்பாக ஏற்றுக்கொள்ளும் APIs-ஐ உருவாக்குவதற்கு முக்கியம்.

Rich type support (கட்டுப்படுத்தப்பட்ட values-க்கான enums, `datetime` parsing, `HttpUrl`/`EmailStr` format validation, typed collections) கூடுதலாக சிக்கலான data manual checks இல்லாமல் சரியானதாக இருப்பதை உறுதி செய்கிறது.

Nested மற்றும் சிக்கலான bodies-ஐ (மற்றும் pagination போன்றவற்றுக்கான reusable generic wrappers-ஐ) எவ்வாறு model செய்வது என்பதை அறிவது, உண்மையான applications தேவைப்படுத்தும் கட்டமைக்கப்பட்ட data-ஐ கையாளும் APIs-ஐ உருவாக்குவதற்கான நடைமுறை அறிவாகும், முழு validation தானாகவே வழங்கப்படுகிறது — இது FastAPI-இன் Pydantic-அடிப்படையிலான வடிவமைப்பின் ஒரு முக்கிய பலம்.