તમે 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 બુદ્ધિમાનીથી પેરામીટર્સ રૂટ કરે છે: path પ્લેસહોલ્ડર → path param, Pydantic મોડેલ → વિનંતી બોડી, સાધારણ-ટાઈપ કરેલ પેરામીટર → query param.

## બહુવિધ body પેરામીટર્સ / આંશિક અપડેટ્સ

```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 ભૂલો સાથે), અને ટાઈપ કરેલ ઑબ્જેક્ટ આપે છે, કંટાળાજનક, ભૂલ-પ્રવણ મેનુઅલ પાર્સિંગ અને માન્યતા દૂર કરે છે જે અન્ય ફ્રેમવર્ક જરૂર છે.

માન્યતા પણ **સુરક્ષા/મજબૂતાઈ** ફાયદો માટે કી છે — ખરાબ રીતે બનેલ ઇનપુટ તમારા તર્કમાં પહોંચતા પહેલાં નકારી કાઢવામાં આવે છે.

મોડેલ body કેવી રીતે વ્યાખ્યાયિત કરવું, FastAPI કેવી રીતે body ને path/query પેરામીટર્સ પાસેથી આપમેળે અલગ કરે છે, અને `exclude_unset` જેવી પેટર્ન આંશિક અપડેટ્સ માટે સમજવું એ કોઈ પણ લેખન એન્ડપોઈન્ટ બનાવવા માટે મૂળભૂત દૈનિક જ્ઞાન છે.