FastAPI ਕਿਹੜੇ ਉন्नत dependency patterns ਨੂੰ support ਕਰਦਾ ਹੈ?

Question

Accepted Answer

Basic `Depends` ਤੋਂ ਪਰੇ, FastAPI ਦੀ dependency injection ਇਹ ਉن्नत patterns ਨੂੰ support ਕਰਦੀ ਹੈ: **sub-dependencies**, **dependencies ਜਿਨ੍ਹਾਂ ਦੇ 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 ਆਪਣੇ ਆਪ ਹੱਲ ਕਰਦਾ ਹੈ (ਅਤੇ **caches** shared ਇਨਾਂ ਨੂੰ ਪ੍ਰਤੀ request, ਇਸ ਲਈ `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 ਕਰਦੇ ਹੋ (ਉਦਾਹਰਣ ਲਈ ਵੱਖ-ਵੱਖ rate limits ਪ੍ਰਤੀ route)।

## Dependencies ਜਿਵੇਂ 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 ਲਈ apply ਕਰੋ 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 ਇਸ ਦੀਆਂ ਸਭ ਤੋਂ ਸ਼ਕਤੀਸ਼ਾਲੀ ਵਿਸ਼ੇਸ਼ਤਾਵਾਂ ਵਿੱਚੋਂ ਇਕ ਹੈ, ਅਤੇ ਇਹ ਉन्नत patterns ਉਹ ਹਨ ਜੋ ਤੁਹਾਨੂੰ ਅਸਲ, ਗੁੰਝਲਦਾਰ ਐਪਲਿਕੇਸ਼ਨਾਂ ਨੂੰ ਮਜ਼ਬੂਤੀ ਨਾਲ ਸਰੂਪਬੱਧ ਕਰਨ ਦਿੰਦੇ ਹਨ।
eam ਨੂੰ ਸਮਝਣਾ senior-level ਦਾ ਮੁੱਲਵਾਨ ਗਿਆਨ ਹੈ: **sub-dependencies** ਆਪਣੇ ਆਪ ਨੂੰ ਦੁਬਾਰਾ ਵਰਤਣ ਲਈ ਲੇਅਰਾਂ ਬਣਾਉਂਦੇ ਹਨ (token → user → admin) ਆਪਣੇ ਆਪ ਨੂੰ ਹੱਲ ਕਰਨ ਅਤੇ per-request caching ਦੇ ਨਾਲ (ਬੇਲੋੜੇ ਕੰਮ ਤੋਂ ਬਚਨਾ); **parameterized/class-based dependencies** configurable, reusable ਭਾਗ ਬਣਾਉਂਦੇ ਹਨ (rate limiters, permission checks ਵੱਖ-ਵੱਖ settings ਦੇ ਨਾਲ per route); **dependencies as side-effects** cleanly enforce ਕਰਨ ਲਈ requirements (auth) ਬਿਨਾਂ function signatures ਨੂੰ cluttering ਕੀਤੇ; ਅਤੇ **global/router-level dependencies** cross-cutting concerns (authentication, rate limiting) ਨੂੰ apply ਕਰਦੇ ਹਨ routes ਦੇ ਸਮੂਹਾਂ ਤੱਕ ਇੱਕ ਥਾਂ ਵਿੱਚ।

ਬਹੁਤ ਮਹੱਤਵਪੂਰਨ ਗੱਲ, **dependency overrides** ਵੀ ਗੁੰਝਲਦਾਰ dependency graphs ਨੂੰ trivially testable ਬਣਾਉਂਦੇ ਹਨ।

ਇਹਨਾਂ patterns ਨੂੰ master ਕਰਨਾ — dependencies ਨੂੰ compose ਕਰਨਾ, ਉਨ੍ਹਾਂ ਨੂੰ parameterize ਕਰਨਾ, ਉਨ੍ਹਾਂ ਨੂੰ globally ਜਾਂ per-router scope ਕਰਨਾ, ਅਤੇ tests ਵਿੱਚ ਉਨ੍ਹਾਂ ਨੂੰ override ਕਰਨਾ — ਜੋ ਕਿ clean, DRY, testable architecture ਨੂੰ enable ਕਰਦਾ ਹੈ non-trivial FastAPI applications ਵਿੱਚ, developers ਨੂੰ distinguish ਕਰਦੇ ਹੋ ਜੋ framework ਦੇ DI system ਨੂੰ fully leverage ਕਰ ਸਕਦੇ ਹਨ ਉਨ੍ਹਾਂ ਤੋਂ ਜੋ ਸਿਰਫ basic `Depends` ਨੂੰ ਵਰਤਦੇ ਹਨ।

ਇਹ well-structured, maintainable, large-scale FastAPI apps ਬਣਾਉਣ ਲਈ ਇਕ ਮਹੱਤਵਪੂਰਨ topic ਹੈ।