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

## मुख्य भाग + पथ + क्वेरी एकत्र

```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` सारखी पद्धती समजणे हे कोणत्याही लेखन एंडपॉइंट बांधण्यासाठी मूलभूत दैनंदिन ज्ञान आहे.