dependency injection (Depends) ఎలా పని చేస్తుంది?

Question

Accepted Answer

FastAPI యొక్క **dependency injection** సిస్టమ్ మీకు పున: ఉపయోగించదగిన డిపెండెన్సీలను (ఫంక్షన్‌లు/క్లాస్‌లు) ప్రకటించడానికి అనుమతిస్తుంది, FastAPI వాటిని కాల్ చేస్తుంది మరియు `Depends()` ద్వారా మీ path operations లో **ఇంజెక్ట్** చేస్తుంది. ఇది డేటాబేస్ సెషన్‌లు, ప్రామాణీకరణ మరియు సాధారణ పారామితుల వంటి భాగస్వామ్య లాజిక్‌కు ఉపయోగించబడుతుంది — కోడ్‌ను 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
```

## ఎందుకు ఇది ముఖ్యమైనది

Dependency injection FastAPI యొక్క అత్యంత శక్తిశాలీ మరియు ముఖ్యమైన లక్షణాలలో ఒకటి — ఇది ఎలా ముఖ్యమైన, తిరిగి ఉపయోగించదగిన లాజిక్‌ను ఎండ్‌పాయింట్‌ల అంతటా స్వచ్ఛంగా భాగస్వామ్యం చేయాలి మరియు (డేటాబేస్ సెషన్‌లు, ప్రామాణీకరణ, సాధారణ ప్రశ్న పారామితులు, అనుమతి తనిఖీలు) నకుల లేకుండా పున: ఉపయోగించాలి.

ఇది అర్థం చేసుకోవడం చాలా ముఖ్యమైనది ఎందుకంటే ఇది ప్రధాన నమూనాలను సపోర్ట్ చేస్తుంది: **`yield` డిపెండెన్సీ** డేటాబేస్ సెషన్‌లను నిర్వహించడానికి ప్రామాణిక మార్గం (ప్రతి అభ్యర్థన తర్వాత హామీదారు క్లీనప్‌తో), మరియు **`get_current_user` డిపెండెన్సీ** ప్రామాణీకరణను అమలు చేయడానికి ఐడియోమాటిక్ మార్గం.

DI కూడా కోడ్‌ను చాలా **టెస్టేబుల్** చేస్తుంది — మీరు పরీక్షలలో డిపెండెన్సీలను మాక్‌లతో ఓవర్‌రైడ్ చేయవచ్చు.

సిస్టమ్ యొక్క కమనీయత (డిపెండెన్సీలు అభ్యర్థన నుండి వారి స్వంత పారామితులను పరిష్కరిస్తాయి, చెట్టు ఏర్పడటం ద్వారా ఇతర డిపెండెన్సీలపై ఆధారపడవచ్చు, మరియు డాక్‌లతో సమన్వయం చేస్తుంది) ఇది నిజమైన అనువర్తనాలను నిర్మాణం చేయడానికి ఎక్కువ బహుముఖ సాధనం చేస్తుంది, కాబట్టి `Depends` ను నైపుణ్యం చేయడం, బాగా-సంస్థాగత, నిర్వహణీయ, టెస్టేబుల్ FastAPI అనువర్తనాలను రూపొందించడానికి కీలకం.