आप रूट्स (path operations) को कैसे परिभाषित करते हैं?

Question

Accepted Answer

FastAPI में, एक **path operation** एक रूट है — एक फ़ंक्शन जिसे HTTP विधि डेकोरेटर (`@app.get`, `@app.post`, आदि) से सजाया गया है जो एक पथ के लिए अनुरोधों को संभालता है। फ़ंक्शन का रिटर्न वैल्यू स्वचालित रूप से JSON में क्रमबद्ध किया जाता है।

## प्रत्येक HTTP विधि के लिए रूट्स को परिभाषित करना

```python
from fastapi import FastAPI
app = FastAPI()

@app.get("/items")                # GET /items
def list_items():
    return [{"id": 1}, {"id": 2}]  # dict/list → automatically JSON-serialized

@app.get("/items/{item_id}")      # GET /items/5 — path parameter
def get_item(item_id: int):        # type hint converts "5" → int (and validates)
    return {"id": item_id}

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

@app.put("/items/{item_id}")      # PUT, PATCH, DELETE work the same way
@app.delete("/items/{item_id}")
def delete_item(item_id: int):
    return {"deleted": item_id}
```

प्रत्येक डेकोरेटर एक HTTP विधि + पथ को एक हैंडलर पर मैप करता है। फ़ंक्शन का नाम आपका है; डेकोरेटर रूट को परिभाषित करता है। लौटाए गए dicts/lists/Pydantic मॉडल स्वचालित रूप से JSON में क्रमबद्ध होते हैं — कोई मैनुअल `json.dumps` नहीं।

## ओवरलैपिंग पाथ्स के लिए क्रम मायने रखता है

```python
@app.get("/users/me")            # ✅ specific route FIRST
def read_me(): ...
@app.get("/users/{user_id}")     # dynamic AFTER — else "me" matches {user_id}
def read_user(user_id: int): ...
```

FastAPI घोषणा के क्रम में रूट्स का मिलान करता है, इसलिए स्थिर पाथ्स को गतिशील वाले से पहले रखें।

## ऑपरेशन मेटाडेटा (डॉक्स को शक्तिशाली बनाता है)

```python
@app.get("/items", tags=["items"], summary="List items", status_code=200)
def list_items(): ...
```

डेकोरेटर पैरामीटर्स (`tags`, `summary`, `status_code`, `response_model`) व्यवहार को कॉन्फ़िगर करते हैं और स्वचालित रूप से उत्पन्न दस्तावेज़ीकरण को समृद्ध करते हैं।

## यह क्यों महत्वपूर्ण है

Path operations हर FastAPI एप्लिकेशन की नींव हैं — वे आपके API के एंडपॉइंट्स को परिभाषित करते हैं और अनुरोधों को कैसे संभाला जाता है।

डेकोरेटर-प्रति-HTTP-विधि पैटर्न को समझना, कि रिटर्न वैल्यूज स्वचालित रूप से JSON में क्रमबद्ध होते हैं (कोई बॉयलरप्लेट नहीं), कि पैरामीटर्स पर टाइप हिंट्स रूपांतरण और सत्यापन को चलाते हैं, और कि रूट क्रम ओवरलैपिंग पाथ्स के लिए मायने रखता है, यह किसी भी एंडपॉइंट बनाने के लिए रोज़मर्रा का आवश्यक ज्ञान है।

डेकोरेटर मेटाडेटा FastAPI के स्वचालित दस्तावेज़ीकरण को भी शक्तिशाली बनाता है, रूट्स को सीधे डॉक्स से जोड़ता है।

यह FastAPI में सीखने वाली पहली और सबसे मौलिक चीज़ है।