మీరు 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` వంటి నమూనాలను అర్థం చేసుకోవడం ఏదైనా రాయటానికి ఎండ్‌పాయింట్ నిర్మించడానికి ప్రాథమిక దైనిక జ్ఞానం.