FastAPI कोणते उन्नत dependency पॅटर्न सपोर्ट करते?

Question

Accepted Answer

मूलभूत `Depends` च्या पलीकडे, FastAPI चे dependency injection उन्नत पॅटर्न सपोर्ट करते: **sub-dependencies**, **dependencies with parameters** (class-based किंवा factories द्वारे), **scoped resources** (yield), **global/router dependencies**, आणि **dependency overrides** testing साठी — ज्यामुळे ते वास्तविक अनुप्रयोग संरचित करण्यासाठी एक बहुमुखी साधन बनते.

## 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 स्वयंचलितपणे सोडवते (आणि shared ones प्रति 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 आहे — तुम्ही त्याला use time वर parameterize करता (उदा. विविध routes साठी भिन्न rate limits).

## Dependencies as side-effects (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
```

Dependencies app-wide किंवा per-router साठी cross-cutting requirements साठी लागू करा (auth, rate limiting).

## Testing साठी Overrides

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

## हे का महत्वाचे आहे

FastAPI चे dependency injection त्याच्या सर्वात शक्तिशाली वैशिष्ट्यांपैकी एक आहे, आणि हे उन्नत पॅटर्न हेच आहेत जे तुम्हाला वास्तविक, जटिल applications सुंदरपणे संरचित करू देतात.

त्यांना समजून घेणे हे मूल्यवान senior-level ज्ञान आहे: **sub-dependencies** reusable layers तयार करतात (token → user → admin) स्वयंचलित resolution आणि per-request caching सह (अनावश्यक काम टाळून); **parameterized/class-based dependencies** configurable, reusable components तयार करतात (rate limiters, permission checks विविध settings सह per route); **dependencies as side-effects** requirements स्वच्छपणे लागू करतात (auth) function signatures गोंधळून न देता; आणि **global/router-level dependencies** cross-cutting concerns (authentication, rate limiting) संपूर्ण route गटांना एका जागी लागू करतात.

अत्यंत महत्वाचे, **dependency overrides** अगदी जटिल dependency graphs तक्षणार्हता testable बनवतात.

हे पॅटर्न आयत्त करणे — dependencies compose करणे, त्यांना parameterize करणे, त्यांना globally किंवा per-router scope करणे, आणि tests मध्ये त्यांना override करणे — हेच non-trivial FastAPI applications मध्ये clean, DRY, testable architecture सक्षम करते, ज्या developers हे framework चे DI system पूर्णपणे leverage करू शकतात त्यांना फक्त मूलभूत `Depends` वापरणाऱ्यांपासून वेगळे करते.

ही मुख्य-structured, maintainable, large-scale FastAPI apps बांधण्यासाठी एक महत्वाचा विषय आहे.