ਤੁਸੀਂ routes (path operations) ਨੂੰ ਕਿਵੇਂ ਪਰਿਭਾਸ਼ਿਤ ਕਰਦੇ ਹੋ?

Question

Accepted Answer

FastAPI ਵਿੱਚ, ਇੱਕ **path operation** ਇੱਕ route ਹੈ — ਇੱਕ HTTP method decorator (`@app.get`, `@app.post`, ਆਦਿ) ਨਾਲ ਸਜਾਇਆ ਗਿਆ ਫੰਕਸ਼ਨ ਜੋ ਕਿਸੇ path ਨੂੰ requests ਨੂੰ ਸੰਭਾਲਦਾ ਹੈ। ਫੰਕਸ਼ਨ ਦਾ return value ਸਵਾਹਜ ਨਾਲ JSON ਵਿੱਚ serialize ਹੁੰਦਾ ਹੈ।

## ਹਰੇਕ HTTP method ਲਈ 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 ਨਾਲ map ਕਰਦਾ ਹੈ। ਫੰਕਸ਼ਨ ਦਾ ਨਾਮ ਤੁਹਾਡਾ ਹੈ; decorator route ਨੂੰ ਪਰਿਭਾਸ਼ਿਤ ਕਰਦਾ ਹੈ। Returned dicts/lists/Pydantic models ਸਵਾਹਜ ਨਾਲ JSON ਵਿੱਚ serialize ਹੁੰਦੇ ਹਨ — ਕੋਈ manual `json.dumps` ਨਹੀਂ।

## Overlapping paths ਲਈ ਕ੍ਰਮ ਮਹੱਤਵਪੂਰਨ ਹੈ

```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 order ਵਿੱਚ routes ਨਾਲ match ਕਰਦਾ ਹੈ, ਇਸ ਲਈ static paths ਨੂੰ dynamic ਨਾਲ ਪਹਿਲਾਂ ਰੱਖੋ।

## Operation 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`) ਵਰਤਾਅ ਨੂੰ configure ਕਰਦੇ ਹਨ ਅਤੇ auto-generated documentation ਨੂੰ enrich ਕਰਦੇ ਹਨ।

## ਇਹ ਕਿਉਂ ਮਹੱਤਵਪੂਰਨ ਹੈ

Path operations ਹਰੇਕ FastAPI application ਦੀ ਬੁਨਿਆਦ ਹਨ — ਉਹ ਤੁਹਾਡੇ API ਦੇ endpoints ਅਤੇ ਕਿਵੇਂ requests ਨੂੰ ਸੰਭਾਲਿਆ ਜਾਂਦਾ ਹੈ ਇਹ ਪਰਿਭਾਸ਼ਿਤ ਕਰਦੇ ਹਨ।

Decorator-per-HTTP-method pattern ਨੂੰ ਸਮਝਣਾ, ਕਿ return values ਸਵਾਹਜ ਨਾਲ JSON ਵਿੱਚ serialize ਹੁੰਦੇ ਹਨ (ਕੋਈ boilerplate ਨਹੀਂ), ਕਿ parameters ਉੱਪਰ type hints conversion ਅਤੇ validation ਨੂੰ ਚਲਾਉਂਦੇ ਹਨ, ਅਤੇ overlapping paths ਲਈ route order ਮਹੱਤਵਪੂਰਨ ਹੈ, ਕਿਸੇ ਵੀ endpoint ਨਿਰਮਾਣ ਲਈ ਜ਼ਰੂਰੀ ਰੋਜ਼ਾਨਾ ਬੋਲ ਹਨ।

Decorator metadata ਵੀ FastAPI ਦੇ automatic documentation ਨੂੰ ਖਵਾਉਂਦਾ ਹੈ, routes ਨੂੰ ਸਿੱਧੇ docs ਨਾਲ ਜੋੜਦੇ ਹੋਏ।

ਇਹ FastAPI ਵਿੱਚ ਸਿੱਖਣ ਵਾਲੀ ਪਹਿਲੀ ਅਤੇ ਸਭ ਤੋਂ ਬਨਿਆਦੀ ਚੀਜ਼ ਹੈ।