आप JSON अनुरोध निकाय को कैसे प्राप्त करते हैं?

Question

Accepted Answer

FastAPI में एक JSON अनुरोध निकाय प्राप्त करने के लिए, आप एक फ़ंक्शन पैरामीटर को **Pydantic मॉडल** के रूप में टाइप करते हैं। FastAPI निकाय को पढ़ता है, JSON को पार्स करता है, इसे मॉडल के विरुद्ध मान्य करता है, और आपको एक टाइप किया गया ऑब्जेक्ट पास करता है — स्वचालित रूप से।

## पैटर्न

```python
from pydantic import BaseModel

class Item(BaseModel):
    name: str
    price: float
    description: str | None = None      # optional field

@app.post("/items")
def create_item(item: Item):             # `item: Item` → read & validate the JSON body
    # `item` is a fully-validated Item object here
    return {"name": item.name, "total": item.price * 1.1}
```

```json
// request body the client sends:
{ "name": "Phone", "price": 999.0 }
```

`item: Item` की घोषणा FastAPI को अनुरोध निकाय को JSON के रूप में पढ़ने, इसे `Item` में पार्स करने, और इसे **मान्य** करने के लिए कहती है — आपका फ़ंक्शन एक टाइप किया गया, मान्य ऑब्जेक्ट प्राप्त करता है। खराब इनपुट स्वचालित रूप से अस्वीकार कर दिया जाता है:

```json
// POST { "name": "Phone" }  (missing price) → automatic 422:
{ "detail": [{ "loc": ["body", "price"], "msg": "field required" }] }
```

## Body + path + query एक साथ

```python
@app.put("/items/{item_id}")
def update(item_id: int, item: Item, notify: bool = False):
    # item_id = path param, item = JSON body (Pydantic model), notify = query param
    # FastAPI distinguishes them by type/location automatically
```

FastAPI बुद्धिमानी से पैरामीटर को रूट करता है: एक पथ प्लेसहोल्डर → पथ पैरामीटर, एक Pydantic मॉडल → अनुरोध निकाय, एक सरल-टाइप किया गया पैरामीटर → क्वेरी पैरामीटर।

## कई निकाय पैरामीटर / आंशिक अपडेट

```python
@app.patch("/items/{id}")
def patch(id: int, item: ItemUpdate):       # use a model with all-optional fields for PATCH
    update_data = item.model_dump(exclude_unset=True)   # only fields the client sent
```

## इसका महत्व क्यों है

अनुरोध निकाय को प्राप्त करना और मान्य करना आवश्यक है — लगभग हर API जो डेटा बनाता या अपडेट करता है उसे इसकी आवश्यकता होती है, और FastAPI इसे उल्लेखनीय रूप से स्वच्छ बनाता है: एक Pydantic-मॉडल पैरामीटर की घोषणा आपको स्वचालित JSON पार्सिंग, पूर्ण **सत्यापन** (स्पष्ट फ़ील्ड-स्तर 422 त्रुटियों के साथ), और एक टाइप किया गया ऑब्जेक्ट देता है, जो लाभदायक, त्रुटि-प्रवण मैनुअल पार्सिंग और सत्यापन को समाप्त करता है जो अन्य ढांचे की आवश्यकता होती है।

सत्यापन **सुरक्षा/मजबूती** लाभ के लिए भी महत्वपूर्ण है — खराब इनपुट आपके तर्क तक पहुंचने से पहले अस्वीकार कर दिया जाता है।

यह समझना कि निकाय मॉडल को कैसे परिभाषित किया जाए, FastAPI निकाय को पथ/क्वेरी पैरामीटर से कैसे स्वचालित रूप से अलग करता है, और आंशिक अपडेट के लिए `exclude_unset` जैसे पैटर्न किसी भी लेखन समापन बिंदु का निर्माण करने के लिए मौलिक दैनिक ज्ञान हैं।