अवलंबित्व इंजेक्शन (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 च्या सर्वाधिक शक्तिशाली आणि महत्वाच्या वैशिष्ट्यांपैकी एक आहे — हा असा मार्ग आहे जेथे आप शेअर आणि पुन्हा वापरला तर्क एंडपॉइंटवर स्वच्छपणे ठेवता (डेटाबेस सेशन, प्रमाणीकरण, सामान्य प्रश्न मापदंड, परवानगी तपास) पुनरावृत्तीशिवाय.

हे समजून घेणे आवश्यक आहे कारण ते मूल नमुन्यांचा आधार बनवते: **`yield` अवलंबित्व** डेटाबेस सेशन व्यवस्थापित करण्याचा मानक मार्ग आहे (प्रत्येक विनंतीनंतर गारंटीकृत सफाई सह), आणि **`get_current_user` अवलंबित्व** हा प्रमाणीकरण लागू करण्याचा रीतिरिवाज आहे.

DI कोडला अत्यंत **चाचणीयोग्य** बनवते — आप चाचणीमध्ये मॉकसह अवलंबित्व ओव्हरराइड करू शकता.

प्रणालीचा अनन्यता (अवलंबित्व विनंतीपासून स्वतःचे मापदंड सोडवते, इतर अवलंबित्वांवर अवलंबून असू शकते, वृक्ष तयार करते, आणि दस्तऐवजांशी समन्वित) हे वास्तविक अनुप्रयोग संरचित करण्यासाठी बहुमुखी साधन आहे, म्हणून `Depends` मास्टर करणे हे सुसंगत, राखणीय, चाचणीयोग्य FastAPI अनुप्रयोग तयार करण्याचा मुख्य आहे.