ડિપેન્ડેન્સી ઇન્જેક્શન (Depends) કેવી રીતે કામ કરે છે?

Question

Accepted Answer

FastAPI નું **ડિપેન્ડેન્સી ઇન્જેક્શન** સિસ્ટમ તમને પુનઃઉપયોગી ડિપેન્ડેન્સી (ફંક્શન્સ/ક્લાસ) ઘોષણા કરવાની સુવિધા આપે છે જેને FastAPI કૉલ કરે છે અને `Depends()` દ્વારા તમારા પાથ ઓપરેશનમાં **ઇન્જેક્ટ** કરે છે. તેનો ઉપયોગ શેર્ડ લૉજિક માટે થાય છે જેમ કે ડેટાબેસ સેશન્સ, પ્રમાણીકરણ અને સામાન્ય પરિમાણો — કોડ DRY અને ટેસ્ટેબલ રાખે છે.

## એક મૂળભૂત ડિપેન્ડેન્સી

```python
from fastapi import Depends

# a dependency is just a callable that returns something
def pagination(skip: int = 0, limit: int = 10):
    return {"skip": skip, "limit": limit}

@app.get("/items")
def list_items(params: dict = Depends(pagination)):   # FastAPI calls pagination() and injects the result
    return params
# the skip/limit query params are now handled by the reusable dependency
```

`params = Depends(pagination)` ઘોષણા FastAPI ને કહે છે કે `pagination` કોલ કરો (તેના પરિમાણોને રિક્વેસ્ટ પણથી રિઝોલ્વ કરો) અને પરિણામ તમારા ફંક્શનમાં પાસ કરો. ડિપેન્ડેન્સી ઘણા એન્ડપોઈન્ટ્સ પર પુનઃઉપયોગી છે.

## ક્લીનআપ સાથેની ડિપેન્ડેન્સી (yield) — દા.ત. ડેટાબેસ સેશન્સ

```python
def get_db():
    db = SessionLocal()
    try:
        yield db                  # provide the session to the endpoint
    finally:
        db.close()                # cleanup runs AFTER the response — guaranteed

@app.get("/users")
def list_users(db = Depends(get_db)):
    return db.query(User).all()    # uses the injected, auto-closed session
```

એક `yield` ડિપેન્ડેન્સી રિસોર્સ પ્રદાન કરે છે અને રિક્વેસ્ટ પછી ટીયરડાઉન ચલાવે છે — ડેટાબેસ સેશન્સ માટે પ્રમાણભૂત પેટર્ન (પહેલા ખોલો, પછી બંધ કરો, આપમેળે).

## ડિપેન્ડેન્સીઝ ડિપેન્ડેન્સીઝ પર આધાર રાખી શકે છે

```python
def get_current_user(token: str = Depends(get_token)):   # depends on another dependency
    return decode(token)

@app.get("/me")
def me(user: User = Depends(get_current_user)):           # auth via injection
    return user
```

ડિપેન્ડેન્સીઝ એક ટ્રી બનાવે છે — FastAPI સમગ્ર ચેઇન રિઝોલ્વ કરે છે. આ સામાન્ય રીતે પ્રમાણીકરણ માટે કેવી રીતે થાય છે (`get_current_user` ડિપેન્ડેન્સી).

## ક્લાસ ડિપેન્ડેન્સીઝ અને પુનઃઉપયોગ

```python
@app.get("/items", dependencies=[Depends(verify_api_key)])   # run a dependency without using its return
def items(): ...                                              # e.g. enforce auth as a side effect
```

## તેનું મહત્વ

ડિપેન્ડેન્સી ઇન્જેક્શન FastAPI ની સૌથી શક્તિશાળી અને મહત્વપૂર્ણ સુવિધાઓમાંથી એક છે — તે કેવી રીતે તમે એન્ડપોઈન્ટ્સ પર લૉજિક કલીનલી શેર કરો અને પુનઃઉપયોગ કરો તે છે (ડેટાબેસ સેશન્સ, પ્રમાણીકરણ, સામાન્ય ક્વેરી પરિમાણો, પરમિશન ચેક્સ) ડુપ્લિકેશન વગર.
ace તેને સમજવું જરૂરી છે કારણ કે તે મૂળ પેટર્નને અન્તર્ભૂત કરે છે: **`yield` ડિપેન્ડેન્સી** એ ડેટાબેસ સેશન્સ સંચાલન કરવાનું પ્રમાણભૂત ટ્રિકસ છે (પ્રત્યેક રિક્વેસ્ટ પછી ખાતરીપૂર્વક ક્લીનআપ સાથે), અને એક **`get_current_user` ડિપેન્ડેન્સી** એ પ્રમાણીકરણ અમલમાં આણવાનો મુહાવરાશીલ રીત છે.

DI પણ કોડ ખૂબજ **ટેસ્ટેબલ** બનાવે છે — તમે ટેસ્ટમાં મોક્સ સાથે ડિપેન્ડેન્સીઝ ઓવરાઈડ કરી શકો છો.

સિસ્ટમની સુંદરતા (ડિપેન્ડેન્સીઝ તેમના પોતાના પરિમાણોને રિક્વેસ્ટ પણથી રિઝોલ્વ કરે છે, અન્ય ડિપેન્ડેન્સીઝ પર આધાર રાખી શકે છે ટ્રી બનાવીને, અને ડોક્સ સાથે એકીકૃત થાય છે) તેને વास્તવિક એપ્લિકેશન્સ સ્ટ્રક્ચર કરવા માટે સર્વશક્તિમાન સાધન બનાવે છે, તેથી `Depends` માસ્ટર કરવું સુસંગઠિત, રક્ષણીય, ટેસ્ટેબલ FastAPI એપ્સ બનાવવાની કી છે.