ਡੀਪੈਂਡੈਂਸੀ ਇਨਜੈਕਸ਼ਨ (Depends) ਕਿਵੇਂ ਕਾਮ ਕਰਦਾ ਹੈ?

Question

Accepted Answer

FastAPI ਦਾ **ਡੀਪੈਂਡੈਂਸੀ ਇਨਜੈਕਸ਼ਨ** ਸਿਸਟਮ ਤੁਹਾਨੂੰ ਰੀਯੂਜ਼ਯੋਗ ਡੀਪੈਂਡੈਂਸੀਜ਼ (ਫੰਕਸ਼ਨ/ਕਲਾਸਿਜ਼) ਨੂੰ ਘੋਸ਼ਣਾ ਕਰਨ ਦਿੰਦਾ ਹੈ ਜਿਨ੍ਹਾਂ ਨੂੰ FastAPI ਕਾਲ ਕਰਦਾ ਹੈ ਅਤੇ `Depends()` ਰਾਹੀਂ ਤੁਹਾਡੀ ਪਾਥ ਓਪਰੇਸ਼ਨ ਵਿੱਚ **ਇਨਜੈਕਟ** ਕਰਦਾ ਹੈ। ਇਹ ਡੇਟਾਬੇਸ ਸੈਸ਼ਨ, ਆਥਨਟਿਕੇਸ਼ਨ, ਅਤੇ ਆਮ ਪੈਰਾਮੀਟਰ ਜਿਵੇਂ ਸ਼ੇਅਰ ਕੀਤੀ ਲਾਜਿਕ ਲਈ ਵਰਤਿਆ ਜਾਂਦਾ ਹੈ — ਜਿਸ ਨਾਲ ਕੋਡ 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
```

## ਇਹ ਮਾਇਨੇ ਕਿਉਂ ਰੱਖਦਾ ਹੈ

ਡੀਪੈਂਡੈਂਸੀ ਇਨਜੈਕਸ਼ਨ FastAPI ਦੀ ਸਭ ਤੋਂ ਸ਼ਕਤੀਸ਼ਾਲੀ ਅਤੇ ਮਹੱਤਵਪੂਰਨ ਫੀਚਰ ਹੈ — ਇਹ ਉਹ ਹੈ ਕਿ ਤੁਸੀਂ ਲਾਜਿਕ ਨੂੰ ਐਂਡਪੁਆਇੰਟ ਦੇ ਪਾਰ ਕਿਵੇਂ ਸ਼ੇਅਰ ਕਰਦੇ ਹੋ ਅਤੇ ਰੀਯੂਸ ਕਰਦੇ ਹੋ (ਡੇਟਾਬੇਸ ਸੈਸ਼ਨ, ਆਥਨਟਿਕੇਸ਼ਨ, ਆਮ ਕਵੇਰੀ ਪੈਰਾਮੀਟਰ, ਪਰਮਿਸ਼ਨ ਚੈਕ) ਡੁਪਲੀਕੇਸ਼ਨ ਦੇ ਬਿਨਾਂ।
avੀ ਨੂੰ ਸਮਝਣਾ ਜ਼ਰੂਰੀ ਹੈ ਕਿਉਂਕਿ ਇਹ ਮੂਲ ਪੈਟਰਨ ਨੂੰ ਵਿਸ਼ਰਮ ਕਰਦਾ ਹੈ: **`yield` ਡੀਪੈਂਡੈਂਸੀ** ਡੇਟਾਬੇਸ ਸੈਸ਼ਨ ਨੂੰ ਸੰਭਾਲਣ ਦਾ ਸਟੈਂਡਰਡ ਤਰੀਕਾ ਹੈ (ਹਰੇਕ ਰੀਕਵੈਸਟ ਤੋਂ ਬਾਅਦ ਗਾਰੰਟੀਸ਼ੁਦਾ ਸਫਾਈ ਦੇ ਨਾਲ), ਅਤੇ **`get_current_user` ਡੀਪੈਂਡੈਂਸੀ** ਆਥਨਟਿਕੇਸ਼ਨ ਨੂੰ ਲਾਗੂ ਕਰਨ ਦਾ ਆਦੀਮੀ ਤਰੀਕਾ ਹੈ।

DI ਕੋਡ ਨੂੰ ਬਹੁਤ ਜ਼ਿਆਦਾ **ਟੈਸਟਯੋਗ** ਬਣਾਉਂਦਾ ਹੈ — ਤੁਸੀਂ ਪਰਖ ਵਿੱਚ ਡੀਪੈਂਡੈਂਸੀਜ਼ ਨੂੰ ਮਾਕ ਨਾਲ ਓਵਰਰਾਈਡ ਕਰ ਸਕਦੇ ਹੋ।

ਸਿਸਟਮ ਦੀ ਖੂਬਸੂਰਤੀ (ਡੀਪੈਂਡੈਂਸੀਜ਼ ਆਪਣੇ ਆਪ ਰੀਕਵੈਸਟ ਤੋਂ ਪੈਰਾਮੀਟਰ ਨੂੰ ਰਿਜ਼ੋਲਵ ਕਰਦੀ ਹੈ, ਦੂਜੀ ਡੀਪੈਂਡੈਂਸੀ 'ਤੇ ਨਿਰਭਰ ਹੋ ਸਕਦੀ ਹੈ ਇੱਕ ਦਰਖ਼ਤ ਬਣਾਉਂਦੇ ਹੋਏ, ਅਤੇ ਡਾਕਸ ਨਾਲ ਰਲ ਜਾਂਦੀ ਹੈ) ਇਸ ਨੂੰ ਅਸਲੀ ਐਪਲੀਕੇਸ਼ਨ ਨੂੰ ਢਾਂਚਾਬੱਧ ਕਰਨ ਲਈ ਇੱਕ ਬਹੁਮੁਖੀ ਸਾਧਨ ਬਣਾਉਂਦਾ ਹੈ, ਇਸ ਲਈ `Depends` ਨੂੰ ਸਮਭਾਲਣਾ ਸੁਸੰਗਤ, ਰੱਖ-ਭਾਲ ਯੋਗ, ਪਰਖਯੋਗ FastAPI ਐਪ ਬਿਲਡ ਕਰਨ ਲਈ ਕੁੰਜੀ ਹੈ।