ਤੁਸ਼ ਇੱਕ ਵੱਡੀ ਐਪ ਨੂੰ APIRouter ਨਾਲ ਕਿਵੇਂ ਸੰਰਚਿਤ ਕਰਦੇ ਹੋ?

Question

Accepted Answer

**`APIRouter`** ਤੁਹਾਨੂੰ ਇੱਕ ਵੱਡੀ FastAPI ਐਪ ਨੂੰ ਕਈ ਮਾਡਿਊਲਾਂ ਵਿੱਚ ਵੰਡਣ ਦਿੰਦਾ ਹੈ — ਹਰ ਰਾਊਟਰ ਸੰਬੰਧਿਤ endpoints ਨੂੰ ਗਰੁੱਪ ਕਰਦਾ ਹੈ (ਜਿਵੇਂ ਸਾਰੇ `/users` ਰੂਟ), ਅਤੇ ਮੁੱਖ ਐਪ ਉਨ੍ਹਾਂ ਨੂੰ ਸ਼ਾਮਲ ਕਰਦੀ ਹੈ। ਇਹ ਵਧ ਰਹੇ codebase ਨੂੰ ਸੰਗਠਿਤ ਅਤੇ ਬਰਾਬਰ ਰੱਖਦਾ ਹੈ।

## ਆਪਣੇ ਮਾਡਿਊਲ ਵਿੱਚ ਰਾਊਟਰ ਨੂੰ ਪਰਿਭਾਸ਼ਿਤ ਕਰਨਾ

```python
# routers/users.py
from fastapi import APIRouter

router = APIRouter(
    prefix="/users",          # all routes here start with /users
    tags=["users"],           # grouped under "users" in the docs
)

@router.get("/")              # GET /users/
def list_users(): ...

@router.get("/{user_id}")     # GET /users/{user_id}
def get_user(user_id: int): ...
```

ਇੱਕ `APIRouter` ਇੱਕ ਮਿਨੀ-ਐਪ ਵਾਂਗ ਕੰਮ ਕਰਦਾ ਹੈ — ਤੁਸ਼ ਉਸ ਉੱਤੇ path operations ਨੂੰ ਉਸੇ decorators ਨਾਲ ਪਰਿਭਾਸ਼ਿਤ ਕਰਦੇ ਹੋ, ਅਤੇ ਇੱਕ `prefix` ਉਨ੍ਹਾਂ ਸਾਰਿਆਂ ਉੱਤੇ ਲਾਗੂ ਹੁੰਦਾ ਹੈ।

## ਰਾਊਟਰਾਂ ਨੂੰ ਮੁੱਖ ਐਪ ਵਿੱਚ ਸ਼ਾਮਲ ਕਰਨਾ

```python
# main.py
from fastapi import FastAPI
from routers import users, items, auth

app = FastAPI()
app.include_router(users.router)     # mounts /users/* endpoints
app.include_router(items.router)
app.include_router(auth.router)
```

`app.include_router()` ਹਰ ਰਾਊਟਰ ਦੇ endpoints ਨੂੰ ਮੁੱਖ ਐਪ ਵਿੱਚ mount ਕਰਦਾ ਹੈ — ਮਾਡਿਊਲਰ ਟੁਕੜਿਆਂ ਤੋਂ ਪੂਰੀ API ਨੂੰ ਜੋੜਦਾ ਹੈ।

## ਇੱਕ ਖੰਡੀ ਪ੍ਰੋਜੈਕਟ ਸੰਰਚਨਾ

```text
app/
  main.py              # creates the app, includes routers
  routers/
    users.py           # APIRouter for /users
    items.py           # APIRouter for /items
    auth.py            # APIRouter for /auth
  models.py            # Pydantic models
  database.py          # DB setup
  dependencies.py      # shared dependencies
```

ਹਰ ਫੀਚਰ/ਡੋਮੇਨ ਨੂੰ ਆਪਣਾ ਰਾਊਟਰ ਮਾਡਿਊਲ ਮਿਲਦਾ ਹੈ — ਸੰਬੰਧਿਤ routes ਨੂੰ ਰੱਖਦਾ ਹੈ, ਅਤੇ codebase ਨੂੰ ਵਧੀਆ ਸੰਗਠਿਤ ਰੱਖਦਾ ਹੈ।

## ਰਾਊਟਰ-ਪੱਧਰ ਦੇ ਦੇਪਤਾਲੀ ਅਤੇ ਕੌਂਫਿਗਰੇਸ਼ਨ

```python
router = APIRouter(
    prefix="/admin",
    dependencies=[Depends(verify_admin)],   # apply a dependency to ALL routes in the router
)
# you can also nest routers via include_router on a router
```

Raraਵਟਰਸ ਸਾਂਝੀ ਦੇਪਤਾਲੀ ਲੈ ਸਕਦੇ ਹਨ (ਜਿਵੇਂ routes ਦੇ ਪੂਰੇ ਗਰੁੱਪ ਲਈ admin auth ਦੀ ਲੋੜ ਹੋਵੇ) — ਇਕਾਈ ਵਿੱਚ ਸਾਰੇ endpoints ਉੱਤੇ ਲਾਗੂ ਹੁੰਦੀ ਹੈ।

## ਇਹ ਕਿਉਂ ਮਾਇਨੇ ਰੱਖਦਾ ਹੈ

`APIRouter` ਕਿਸੇ ਵੀ ਕਸ਼ਮੀਰੀ FastAPI ਐਪ ਤੋਂ ਵਧ ਕੇ ਬਣਾਉਣ ਲਈ ਜ਼ਰੂਰੀ ਹੈ — ਇਸ ਤੋਂ ਬਿਨਾਂ, ਸਾਰੇ endpoints ਇੱਕ ਫਾਈਲ ਵਿੱਚ ਰਹਿੰਦੇ ਹਨ, ਜਿਹੜੀ ਐਪੀਐਈ ਵੱਧ ਜਾਣ ਨਾਲ ਅਸੰਭਵ ਹੋ ਜਾਂਦੀ ਹੈ।
eਇਸ ਨੂੰ ਸਮਝਣਾ **code organization ਅਤੇ maintainability** ਲਈ ਮਹੱਤਵਪੂਰਨ ਹੈ: endpoints ਨੂੰ feature-based router modules ਵਿੱਚ ਵੰਡਨਾ (users, items, auth) ਸੰਬੰਧਿਤ code ਨੂੰ ਇਕੱਠਾ ਰੱਖਦਾ ਹੈ, ਪ੍ਰੋਜੈਕਟ ਨੂੰ ਖੋਜਯੋਗ ਬਣਾਉਂਦਾ ਹੈ, ਅਤੇ ਟੀਮਾਂ ਨੂੰ ਵੱਖ-ਵੱਖ ਖੇਤਰਾਂ ਉੱਤੇ ਸੁਤੰਤਰ ਕੰਮ ਕਰਨ ਦਿੰਦਾ ਹੈ।

`prefix` ਅਤੇ `tags` routes ਅਤੇ documentation ਨੂੰ ਸੰਗਠਿਤ ਰੱਖਦੇ ਹਨ, ਅਤੇ **router-level dependencies** (ਜਿਵੇਂ ਪੂਰੇ ਗਰੁੱਪ ਲਈ admin auth ਦੀ ਲੋੜ ਹੋਵੇ) ਸਾਫ਼, ਗਰੁੱਪ-ਵਿਆਪੀ ਵਿਵਹਾਰ ਪ੍ਰਦਾਨ ਕਰਦੇ ਹਨ।

ਇਹ modular structure FastAPI ਐਪਲੀਕੇਸ਼ਨਾਂ ਲਈ ਮਿਆਰੀ ਅਭਿਆਸ ਹੈ, `APIRouter` ਅਤੇ ਇਸ ਦੇ ਆਲੇ-ਦੁਆਲੇ project-organization ਪੈਟਰਨਾਂ ਨੂੰ ਮਾਪਕ, maintainable APIs ਬਣਾਉਣ ਲਈ ਮਹੱਤਵਪੂਰਨ, ਵਿਹਾਰਕ-ਜ਼ਰੂਰੀ ਗਿਆਨ ਬਣਾਉਂਦਾ ਹੈ।