Request Body¶

जब आपको किसी client (मान लें, एक browser) से अपनी API को data भेजना होता है, तो आप उसे request body के रूप में भेजते हैं।

request body वह data है जो client आपकी API को भेजता है। response body वह data है जो आपकी API client को भेजती है।

आपकी API को लगभग हमेशा response body भेजनी होती है। लेकिन clients को हर समय request bodies भेजने की ज़रूरत नहीं होती, कभी-कभी वे केवल एक path request करते हैं, शायद कुछ query parameters के साथ, लेकिन body नहीं भेजते।

request body घोषित करने के लिए, आप Pydantic models का उनकी पूरी शक्ति और लाभों के साथ उपयोग करते हैं।

Pydantic के BaseModel को import करें¶

सबसे पहले, आपको pydantic से BaseModel import करना होगा:

from fastapi import FastAPI
from pydantic import BaseModel


class Item(BaseModel):
    name: str
    description: str | None = None
    price: float
    tax: float | None = None


app = FastAPI()


@app.post("/items/")
async def create_item(item: Item):
    return item

अपना data model बनाएँ¶

फिर आप अपने data model को एक class के रूप में घोषित करते हैं जो BaseModel से inherit करती है।

सभी attributes के लिए standard Python types का उपयोग करें:

from fastapi import FastAPI
from pydantic import BaseModel


class Item(BaseModel):
    name: str
    description: str | None = None
    price: float
    tax: float | None = None


app = FastAPI()


@app.post("/items/")
async def create_item(item: Item):
    return item

Query parameters घोषित करते समय की तरह, जब किसी model attribute का default value होता है, तो वह required नहीं होता। अन्यथा, वह required होता है। उसे केवल optional बनाने के लिए None का उपयोग करें।

उदाहरण के लिए, ऊपर दिया गया यह model इस तरह का JSON "object" (या Python dict) घोषित करता है:

{
    "name": "Foo",
    "description": "An optional description",
    "price": 45.2,
    "tax": 3.5
}

...क्योंकि description और tax optional हैं (None के default value के साथ), यह JSON "object" भी valid होगा:

{
    "name": "Foo",
    "price": 45.2
}

इसे एक parameter के रूप में घोषित करें¶

इसे अपनी path operation में जोड़ने के लिए, इसे उसी तरह घोषित करें जैसे आपने path और query parameters घोषित किए थे:

from fastapi import FastAPI
from pydantic import BaseModel


class Item(BaseModel):
    name: str
    description: str | None = None
    price: float
    tax: float | None = None


app = FastAPI()


@app.post("/items/")
async def create_item(item: Item):
    return item

...और इसके type को आपके बनाए हुए model, Item, के रूप में घोषित करें।

परिणाम¶

सिर्फ उस Python type declaration के साथ, FastAPI यह करेगा:

• request के body को JSON के रूप में पढ़ेगा।
• संबंधित types को convert करेगा (यदि ज़रूरत हो)।
• data को validate करेगा।
  • यदि data invalid है, तो यह एक अच्छा और स्पष्ट error return करेगा, जो ठीक-ठीक बताएगा कि गलत data कहाँ और क्या था।
• आपको प्राप्त data parameter item में देगा।
  • क्योंकि आपने इसे function में Item type का घोषित किया है, आपको इसके सभी attributes और उनके types के लिए पूरा editor support (completion, आदि) भी मिलेगा।
• आपके model के लिए JSON Schema definitions generate करेगा, यदि आपके project के लिए उचित हो तो आप उन्हें कहीं और भी उपयोग कर सकते हैं।
• वे schemas generated OpenAPI schema का हिस्सा होंगे, और automatic documentation UIs द्वारा उपयोग किए जाएँगे।

स्वचालित docs¶

आपके models के JSON Schemas आपके OpenAPI generated schema का हिस्सा होंगे, और interactive API docs में दिखाए जाएँगे:

और वे API docs में हर उस path operation के अंदर भी उपयोग किए जाएँगे जिसे उनकी ज़रूरत है:

Editor support¶

अपने editor में, अपने function के अंदर आपको हर जगह type hints और completion मिलेंगे (यदि आपको Pydantic model के बजाय dict मिला होता, तो ऐसा नहीं होता):

आपको incorrect type operations के लिए error checks भी मिलते हैं:

यह संयोग से नहीं है, पूरा framework इसी design के इर्द-गिर्द बनाया गया था।

और किसी भी implementation से पहले, design phase में इसे पूरी तरह test किया गया था, ताकि सुनिश्चित किया जा सके कि यह सभी editors के साथ काम करेगा।

इसे support करने के लिए Pydantic में भी कुछ बदलाव किए गए थे।

पिछले screenshots Visual Studio Code के साथ लिए गए थे।

लेकिन आपको PyCharm और अधिकांश अन्य Python editors के साथ भी वही editor support मिलेगा:

model का उपयोग करें¶

Function के अंदर, आप model object के सभी attributes को सीधे access कर सकते हैं:

from fastapi import FastAPI
from pydantic import BaseModel


class Item(BaseModel):
    name: str
    description: str | None = None
    price: float
    tax: float | None = None


app = FastAPI()


@app.post("/items/")
async def create_item(item: Item):
    item_dict = item.model_dump()
    if item.tax is not None:
        price_with_tax = item.price + item.tax
        item_dict.update({"price_with_tax": price_with_tax})
    return item_dict

Request body + path parameters¶

आप path parameters और request body को एक ही समय में घोषित कर सकते हैं।

FastAPI पहचानेगा कि वे function parameters जो path parameters से match करते हैं, उन्हें path से लिया जाना चाहिए, और वे function parameters जो Pydantic models के रूप में घोषित हैं, उन्हें request body से लिया जाना चाहिए।

from fastapi import FastAPI
from pydantic import BaseModel


class Item(BaseModel):
    name: str
    description: str | None = None
    price: float
    tax: float | None = None


app = FastAPI()


@app.put("/items/{item_id}")
async def update_item(item_id: int, item: Item):
    return {"item_id": item_id, **item.model_dump()}

Request body + path + query parameters¶

आप body, path और query parameters को भी एक ही समय में घोषित कर सकते हैं।

FastAPI उनमें से प्रत्येक को पहचानेगा और data को सही जगह से लेगा।

from fastapi import FastAPI
from pydantic import BaseModel


class Item(BaseModel):
    name: str
    description: str | None = None
    price: float
    tax: float | None = None


app = FastAPI()


@app.put("/items/{item_id}")
async def update_item(item_id: int, item: Item, q: str | None = None):
    result = {"item_id": item_id, **item.model_dump()}
    if q:
        result.update({"q": q})
    return result

Function parameters को इस प्रकार पहचाना जाएगा:

• यदि parameter path में भी घोषित है, तो उसे path parameter के रूप में उपयोग किया जाएगा।
• यदि parameter singular type का है (जैसे int, float, str, bool, आदि), तो उसे query parameter के रूप में interpret किया जाएगा।
• यदि parameter को Pydantic model के type का घोषित किया गया है, तो उसे request body के रूप में interpret किया जाएगा।

Pydantic के बिना¶

यदि आप Pydantic models का उपयोग नहीं करना चाहते, तो आप Body parameters का भी उपयोग कर सकते हैं। Body - Multiple Parameters: Singular values in body के docs देखें।