FastAPI किन advanced dependency patterns का समर्थन करता है?

Question

Accepted Answer

बुनियादी `Depends` से परे, FastAPI का dependency injection advanced patterns का समर्थन करता है: **sub-dependencies**, **parameters वाली dependencies** (class-based या factories के माध्यम से), **scoped resources** (yield), **global/router dependencies**, और testing के लिए **dependency overrides** — जो इसे वास्तविक applications को structure करने के लिए एक बहुमुखी tool बनाता है।

## Sub-dependencies (dependency trees)

```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
```

Dependencies अन्य dependencies पर निर्भर हो सकती हैं, एक tree बनाते हुए जिसे FastAPI स्वचालित रूप से resolve करता है (और साझा वालों को प्रति request **cache** करता है, इसलिए `get_token` एक बार चलता है भले ही कई dependencies द्वारा उपयोग किया जाए)।

## Parameterized (class-based) dependencies

```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__` वाली एक class एक **configurable** dependency है — आप इसे उपयोग के समय parameterize करते हैं (जैसे प्रति route अलग rate limits)।

## side-effects के रूप में dependencies (return की आवश्यकता नहीं)

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

## Global और router-level dependencies

```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
```

cross-cutting requirements (auth, rate limiting) के लिए dependencies को app-wide या per-router लागू करें।

## testing के लिए overrides

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

## यह क्यों महत्वपूर्ण है

FastAPI का dependency injection इसकी सबसे शक्तिशाली विशेषताओं में से एक है, और ये advanced patterns वही हैं जो आपको वास्तविक, जटिल applications को सुरुचिपूर्ण ढंग से structure करने देते हैं।

इन्हें समझना मूल्यवान senior-level ज्ञान है: **sub-dependencies** स्वचालित resolution और per-request caching के साथ पुन: उपयोग योग्य परतें बनाती हैं (token → user → admin) (अनावश्यक काम से बचते हुए); **parameterized/class-based dependencies** configurable, पुन: उपयोग योग्य components बनाती हैं (rate limiters, प्रति route अलग settings के साथ permission checks); **side-effects के रूप में dependencies** function signatures को अव्यवस्थित किए बिना requirements (auth) को साफ-सुथरे ढंग से लागू करती हैं; और **global/router-level dependencies** cross-cutting concerns (authentication, rate limiting) को एक स्थान पर routes के पूरे समूहों पर लागू करती हैं।

महत्वपूर्ण रूप से, **dependency overrides** जटिल dependency graphs को भी trivially testable बनाते हैं।

इन patterns में महारत हासिल करना — dependencies को composing करना, उन्हें parameterize करना, उन्हें globally या per-router scope करना, और tests में उन्हें override करना — वही है जो non-trivial FastAPI applications में साफ, DRY, testable architecture को सक्षम बनाता है, उन developers को अलग करते हुए जो framework के DI system का पूरा लाभ उठा सकते हैं उनसे जो केवल बुनियादी `Depends` का उपयोग करते हैं।

यह सुव्यवस्थित, maintainable, large-scale FastAPI apps बनाने के लिए एक महत्वपूर्ण विषय है।