Waɗannan ƙimantattun tsarin dogondiya da FastAPI ke goyo?

Question

Accepted Answer

Bayan `Depends` na asali, jijiyar dogondiya na FastAPI tana goyo ƙimantattun tsarin: **sub-dependencies**, **dependencies tare da sifofi** (tushen aji ko ta hanyar masana'antu), **allunan dabaɓɓu** (yield), **dogondiya na jiki/router**, da **sakewa na dogondiya** don gwaji — wanda ya sanya shi kayan aiki masu ban abu don tsara aikace-aikace na gaida.

## Sub-dependencies (bishiyoyin dogondiya)

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

Dogondiya na iya dogon dogondiya na ɗan ƙara, da ke samar da bishiya FastAPI ɗin kwankwaso ta atomatik (da **jera** waɗanda ke tattare dasu a baje ƴi, don haka `get_token` yana gudu sau ɗaya duni ko da aka yi amfani ta tare da dogondiya da dama).

## Dogondiya da aka shimfiɗa (tushen aji)

```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(): ...
```

Aji tare da `__call__` shi ne **dogondiya da za a iya daidaita** — kuna shimfiɗa shi a lokacin amfani (misali rate limits daban-daban a hanyoyi daban-daban).

## Dogondiya a matsayin tasirin gida (ba a buƙata maɓuginu)

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

## Dogondiya na jiki da router-level

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

Daukar dogondiya kawo-kawo ko kuma a kowane router don bukatuwan shingizawa (authentication, rate limiting).

## Sakewa don gwaji

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

## Me ya sa ya maɗi

Jijiyar dogondiya na FastAPI ita ce ɗaya daga cikin abubuwan masu karfi sosai, da ƙimantattun tsarin nan ne suka bar ku hayin daidaita aikace-aikace masu rikitarwa da haɗaka. Fahimta waɗannan tana da muhimmanci babbar mataki: **sub-dependencies** suna gina maɓuginu masu amfani (token → mai amfani → admin) tare da atomatik na warwarewa da jera a baje ƴi (gaje mula aikiyi na waje); **parameterized/class-based dependencies** suna aiki ƙomai-ƙomai, abubuwan da za a iya daidaita (masu ajiye ma'auratar daji, bincikan izini tare da saitin daban-daban a kowane hanya); **dogondiya a matsayin tasirin gida** suna aiwatar da bukatuwa cikakke (authentication) ba tare da ɓigon sa ilma kaɗan ba; da **global/router-level dependencies** suna daukar matakan shingizawa (authentication, rate limiting) ga rukuni na auzare a wuri ɗaya.
"]}}{