FastAPI ఎటువంటి అధ్యున్నత ఆధారపడటం నమూనాలను సపోర్ట్ చేస్తుంది?

Question

Accepted Answer

ప్రాథమిక `Depends` కంటే ఆगળానికి, FastAPI యొక్క ఆధారపడటం ఇంజెక్షన్ అధ్యున్నత నమూనాలను సపోర్ట్ చేస్తుంది: **ఉప-ఆధారపడటాలు**, **పారామితులతో ఆధారపడటాలు** (తరగతి-ఆధారిత లేదా కర్మాగారాల ద్వారా), **స్కోప్ చేసిన వనరులు** (yield), **ప్రపంచ/రూటర్ ఆధారపడటాలు**, మరియు **పరీక్ష కోసం ఆధారపడటం ఓవర్‌రైడ్‌లు** — దీనిని నిజమైన అనువర్తనాలను నిర్మించడానికి బహుముఖ సాధనంగా చేస్తుంది.

## ఉప-ఆధారపడటాలు (ఆధారపడటం చెట్టులు)

```python
def get_token(authorization: str = Header()):
    return parse(authorization)

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

def get_admin(user: User = Depends(get_current_user)):    # depends on that, in turn
    if not user.is_admin: raise HTTPException(403)
    return user
# FastAPI resolves the whole chain, caching shared dependencies within a request
```

ఆధారపడటాలు ఇతర ఆధారపడటాలపై ఆధారపడవచ్చు, చెట్టును ఏర్పరుస్తాయి FastAPI స్వయంచాలకంగా సమర్థవంతం చేస్తుంది (మరియు **కాష్** చేస్తుంది ఇచ్చిన అభ్యర్థనకు భాగస్వామీ వాటిని, కాబట్టి `get_token` ఒకసారి చేస్తుంది అయినా అనేక ఆధారపడటాలచే ఉపయోగించినట్లయితే).

## పారామిటర్‌గా ఉండేవి (తరగతి-ఆధారిత) ఆధారపడటాలు

```python
class RateLimiter:
    def __init__(self, calls: int):        # configure the dependency
        self.calls = calls
    def __call__(self, request: Request):  # callable → acts as a dependency
        check_rate_limit(request, self.calls)

@app.get("/items", dependencies=[Depends(RateLimiter(calls=100))])  # configured per route
def items(): ...
```

`__call__` ఉన్న తరగతి ఒక **కాన్ఫిగర్ చేయదగిన** ఆధారపడటం — మీరు దానిని ఉపయోగ సమయంలో పారామిటర్‌గా చేస్తారు (ఉ.దా. రూట్‌కు భిన్న రేట్ పరిమితులు).

## ఆధారపడటాలు ఎడ్జెక్టులుగా (తిరిగి ఇవ్వాల్సిన అవసరం లేదు)

```python
@app.get("/admin", dependencies=[Depends(verify_admin)])   # run for the effect (auth check)
def admin(): ...                                            # don't need its return value
```

## ప్రపంచ మరియు రూటర్-స్థాయి ఆధారపడటాలు

```python
app = FastAPI(dependencies=[Depends(verify_api_key)])      # applies to EVERY route
router = APIRouter(dependencies=[Depends(get_current_user)])  # to all routes in a router
```

ప్రతిచ్ఛాయ-విస్తృత అవసరాల కోసం పూర్తి యాప్‌లో లేదా ప్రతి-రూటర్‌లో ఆధారపడటాలను వర్తించండి (ప్రామాణీకరణ, రేట్ పరిమితి).

## పరీక్ష కోసం ఓవర్‌రైడ్‌లు

```python
app.dependency_overrides[get_db] = get_test_db    # swap any dependency in tests
```

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

FastAPI యొక్క ఆధారపడటం ఇంజెక్షన్ దాని అత్యంత శక్తిశాలీ లక్షణాలలో ఒకటి, మరియు ఈ అధ్యున్నత నమూనాలు మీకు నిజమైన, సంక్లిష్ట అనువర్తనాలను సందర్భానికి సరిగ్గా నిర్మించడానికి అనుమతించేవి.

వాటిని అర్థం చేసుకోవడం విలువైన సీనియర్-స్థాయి జ్ఞానం: **ఉప-ఆధారపడటాలు** పునర్ఉపయోగ చేయదగిన పొరలను నిర్మిస్తాయి (టోకెన్ → వినియోగదారు → నిర్వాహకుడు) స్వయంచాలక సంకల్పం మరియు అభ్యర్థన-ప్రతి కాష్‌తో (అనవసరమైన పని నివారణ); **పారామిటర్‌గా/తరగతి-ఆధారిత ఆధారపడటాలు** కాన్ఫిగర్ చేయదగిన, పునర్ఉపయోగ చేయదగిన భాగాలను సృష్టిస్తాయి (రేట్ పరిమితులు, వివిధ సెట్టింగ్‌లతో రూట్‌కు ఆనుమతి తనిఖీలు); **ఆధారపడటాలు ఎడ్జెక్టులుగా** స청్ఛిద్రమైన అవసరాలను (ప్రామాణీకరణ) క్లీన్‌గా అమలు చేస్తాయి ఫంక్షన్ సిగ్నేచర్‌లను గందరగోళానికి గురిచేయకుండా; మరియు **ప్రపంచ/రూటర్-స్థాయి ఆధారపడటాలు** క్రాస్-కటింగ్ సమస్యలను (ప్రామాణీకరణ, రేట్ పరిమితి) ఒక స్థానంలో మార్గాల సమూహానికి వర్తించాయి.

ముఖ్యంగా, **ఆధారపడటం ఓవర్‌రైడ్‌లు** సంక్లిష్ట ఆధారపడటం గ్రాఫ్‌లను సరళంగా పరీక్షించదగిన చేస్తాయి.

ఈ నమూనాలను ప్రావీణ్యం చేయడం — ఆధారపడటాలను కూపర్ చేయడం, వాటిని పారామిటర్ చేయడం, వాటిని ప్రపంచ-విస్తృత లేదా ప్రతి-రూటర్‌గా స్కోప్ చేయడం, మరియు పరీక్షలలో వాటిని ఓవర్‌రైడ్ చేయడం — నిరీక్షక-ఆధారిత, పునర్బరువు చేయలేనిది, నిరీక్ష చేయదగిన ఆర్కిటెక్చర్ సక్షమం చేస్తుంది అతुచ్ఛ FastAPI అనువర్తనాలలో, డెవలపర్‌లను వేరుచేస్తుంది ఎవరు ఫ్రేమ్‌వర్క్ DI సిస్టమ్‌ను సంపూర్ణంగా ఉపయోగించవచ్చు వారి నుండి ఎవరు ప్రాథమిక `Depends` మాత్రమే ఉపయోగించారు.

ఇది బాగా-నిర్మిత, నిర్ధారణీయమైన, పెద్ద-స్థాయి FastAPI అనువర్తనాలను నిర్మించడానికి ఒక ముఖ్యమైన విషయం.