विषय पर बढ़ें

सीधे एक Response लौटाएँ

🌐 एआई और मनुष्यों द्वारा किया गया अनुवाद

यह अनुवाद मनुष्यों के मार्गदर्शन में एआई द्वारा किया गया है। 🤝

इसमें मूल अर्थ को गलत समझने या अप्राकृतिक लगने आदि जैसी गलतियाँ हो सकती हैं। 🤖

आप हमें एआई LLM को बेहतर मार्गदर्शन करने में मदद करके इस अनुवाद को बेहतर बना सकते हैं।

अंग्रेज़ी संस्करण

जब आप FastAPI path operation बनाते हैं, तो सामान्यतः आप उससे कोई भी data लौटा सकते हैं: एक dict, एक list, एक Pydantic model, एक database model, आदि।

अगर आप Response Model declare करते हैं, तो FastAPI Pydantic का उपयोग करके data को JSON में serialize करने के लिए उसका उपयोग करेगा।

अगर आप response model declare नहीं करते, तो FastAPI JSON Compatible Encoder में समझाए गए jsonable_encoder का उपयोग करेगा और उसे एक JSONResponse में रखेगा।

आप सीधे एक JSONResponse भी बना सकते हैं और उसे लौटा सकते हैं।

सुझाव

आम तौर पर सीधे JSONResponse लौटाने की तुलना में Response Model का उपयोग करने पर performance काफी बेहतर होगी, क्योंकि उस तरीके से यह Rust में Pydantic का उपयोग करके data serialize करता है।

एक Response लौटाएँ

आप एक Response या उसकी कोई भी sub-class लौटा सकते हैं।

नोट

JSONResponse खुद Response की एक sub-class है।

और जब आप एक Response लौटाते हैं, तो FastAPI उसे सीधे pass कर देगा।

यह Pydantic models के साथ कोई data conversion नहीं करेगा, contents को किसी भी type में convert नहीं करेगा, आदि।

यह आपको बहुत अधिक flexibility देता है। आप कोई भी data type लौटा सकते हैं, किसी भी data declaration या validation को override कर सकते हैं, आदि।

यह आपको बहुत अधिक responsibility भी देता है। आपको यह सुनिश्चित करना होगा कि आप जो data लौटा रहे हैं वह सही है, सही format में है, वह serialize किया जा सकता है, आदि।

Response में jsonable_encoder का उपयोग करना

क्योंकि FastAPI आपके लौटाए गए Response में कोई बदलाव नहीं करता, आपको सुनिश्चित करना होगा कि उसके contents इसके लिए तैयार हैं।

उदाहरण के लिए, आप किसी Pydantic model को पहले dict में convert किए बिना JSONResponse में नहीं रख सकते, जिसमें सभी data types (जैसे datetime, UUID, आदि) JSON-compatible types में convert किए गए हों।

ऐसे मामलों के लिए, response को pass करने से पहले आप अपने data को convert करने के लिए jsonable_encoder का उपयोग कर सकते हैं:

from datetime import datetime

from fastapi import FastAPI
from fastapi.encoders import jsonable_encoder
from fastapi.responses import JSONResponse
from pydantic import BaseModel


class Item(BaseModel):
    title: str
    timestamp: datetime
    description: str | None = None


app = FastAPI()


@app.put("/items/{id}")
def update_item(id: str, item: Item):
    json_compatible_item_data = jsonable_encoder(item)
    return JSONResponse(content=json_compatible_item_data)

तकनीकी विवरण

आप from starlette.responses import JSONResponse का भी उपयोग कर सकते हैं।

FastAPI आपकी सुविधा के लिए, developer के रूप में, वही starlette.responses fastapi.responses के रूप में उपलब्ध कराता है। लेकिन उपलब्ध अधिकांश responses सीधे Starlette से आते हैं।

custom Response लौटाना

ऊपर दिया गया उदाहरण वे सभी हिस्से दिखाता है जिनकी आपको जरूरत है, लेकिन यह अभी बहुत उपयोगी नहीं है, क्योंकि आप सीधे item लौटा सकते थे, और FastAPI उसे आपके लिए JSONResponse में रख देता, उसे dict में convert करता, आदि। यह सब default रूप से होता है।

अब, देखते हैं कि आप इसका उपयोग custom response लौटाने के लिए कैसे कर सकते हैं।

मान लें कि आप एक XML response लौटाना चाहते हैं।

आप अपना XML content एक string में रख सकते हैं, उसे Response में रख सकते हैं, और उसे लौटा सकते हैं:

from fastapi import FastAPI, Response

app = FastAPI()


@app.get("/legacy/")
def get_legacy_data():
    data = """<?xml version="1.0"?>
    <shampoo>
    <Header>
        Apply shampoo here.
    </Header>
    <Body>
        You'll have to use soap here.
    </Body>
    </shampoo>
    """
    return Response(content=data, media_type="application/xml")

Response Model कैसे काम करता है

जब आप किसी path operation में Response Model - Return Type declare करते हैं, तो FastAPI Pydantic का उपयोग करके data को JSON में serialize करने के लिए उसका उपयोग करेगा।

from fastapi import FastAPI
from pydantic import BaseModel

app = FastAPI()


class Item(BaseModel):
    name: str
    description: str | None = None
    price: float
    tax: float | None = None
    tags: list[str] = []


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


@app.get("/items/")
async def read_items() -> list[Item]:
    return [
        Item(name="Portal Gun", price=42.0),
        Item(name="Plumbus", price=32.0),
    ]

क्योंकि यह Rust side पर होगा, performance regular Python और JSONResponse class के साथ किए जाने की तुलना में काफी बेहतर होगी।

response_model या return type का उपयोग करते समय, FastAPI data को convert करने के लिए jsonable_encoder का उपयोग नहीं करेगा (जो धीमा होता), और न ही JSONResponse class का उपयोग करेगा।

इसके बजाय यह response model (या return type) का उपयोग करके Pydantic के साथ generate किए गए JSON bytes लेता है और JSON के लिए सही media type (application/json) के साथ सीधे एक Response लौटाता है।

नोट्स

जब आप सीधे एक Response लौटाते हैं, तो उसका data अपने-आप validate, convert (serialize), या document नहीं किया जाता।

लेकिन आप फिर भी उसे OpenAPI में अतिरिक्त Responses में बताए अनुसार document कर सकते हैं।

बाद के sections में आप देख सकते हैं कि automatic data conversion, documentation, आदि रखते हुए इन custom Responses का उपयोग/declare कैसे करें।