మీరు routes (path operations) ను ఎలా నిర్వచిస్తారు?

Question

Accepted Answer

FastAPI లో, **path operation** ఒక route — HTTP method decorator (`@app.get`, `@app.post`, మొదలైనవి) తో అలంకరించిన ఒక ఫంక్షన్, ఇది ఒక మార్గానికి అభ్యర్థనలను నిర్వహిస్తుంది. ఫంక్షన్ యొక్క రిటర్న్ విలువ స్వయంచాలకంగా JSON కు క్రమబద్ధీకరించబడుతుంది.

## ప్రతి HTTP పద్ధతి కోసం routes నిర్వచించడం

```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}
```

ప్రతి decorator ఒక HTTP method + path ను handler కు మ్యాప్ చేస్తుంది. ఫంక్షన్ పేరు మీది; decorator route నిర్వచిస్తుంది. తిరిగి వచ్చిన dicts/lists/Pydantic models స్వయంచాలకంగా 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 declaration ఆర్డర్ లో routes ను సరిపోల్చుకుంటుంది, కాబట్టి స్టాటిక్ paths ను డైనమిక్ వాటికి ముందు ఉంచండి.

## ఆపరేషన్ metadata (docs ను నడుపుతుంది)

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

Decorator parameters (`tags`, `summary`, `status_code`, `response_model`) ప్రవర్తనను కాన్ఫిగర్ చేస్తాయి మరియు స్వయంచాలకంగా ఉత్పన్న డాక్యుమెంటేషన్ ను సমృద్ధిపరుస్తాయి.

## ఇది ఎందుకు ముఖ్యమైనది

Path operations ప్రతి FastAPI అప్లికేషన్ యొక్క ఆధారం — అవి మీ API యొక్క endpoints ను నిర్వచిస్తాయి మరియు అభ్యర్థనలను ఎలా నిర్వహిస్తారో నిర్వచిస్తాయి.

decorator-per-HTTP-method pattern, తిరిగి వచ్చిన విలువలు స్వయంచాలకంగా JSON కు క్రమబద్ధీకరించబడతాయి (boilerplate లేదు), type hints on parameters conversion మరియు validation ను నడుపుతుంది, మరియు route order అతిపెట్టిన paths కోసం ముఖ్యమైనది, ఏదైనా endpoint నిర్మించటానికి అవసరమైన రోజువారీ జ్ఞానం.

Decorator metadata కూడా FastAPI యొక్క స్వయంచాలక డాక్యుమెంటేషన్ ను పోషిస్తుంది, routes ను నేరుగా docs కు సంధానించుకుంటుంది.

ఇది FastAPI లో నిర్వహించటానికి మొదటి మరియు చాలా ప్రాథమికమైన విషయం.