તમે રૂટ્સ (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 માં આ શીખવા માટે પ્રથમ અને સૌથી મૌલિક વસ્તુ છે.