ਤੁਸੀਂ 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` ਵਰਗੇ ਪੈਟਰਨ ਕਿਸੇ ਵੀ ਲਿਖਣ ਦੇ ਇਕ ਸਿਰੇ ਨੂੰ ਬਣਾਉਣ ਲਈ ਜ਼ਰੂਰੀ ਰੋਜ਼ਾਨਾ ਜ਼ਾਨਕਾਰੀ ਹੈ।