Lil hinn minn Depends bażiku, l-injection ta' dipendenzi ta' FastAPI jassorti mudelli avvanzati: sub-dipendenzi, dipendenzi b'parametri (ibbażati fuq klassit jew permezz ta' factories), riżorsi skopjati (yield), , u għat-test — li jagħmluha ferħa versatili għal strutturazzjoni ta' applikazzjonijiet reali.
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
Id-dipendenzi jistgħu jiddipendenza fuq dipendenzi oħra, u jiffurmaw siġar li FastAPI jirrisolvi awtomatikament (u cache dawk li huma shared għal kull request, allura get_token jaħdem darba biss anki jekk jintuża minn diversi dipendenzi).
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(): ...
Klassa b'__call__ hija dipendenza konfigurabbli — inti tikkonfiġurahha fil-ħin tal-użu (per eż. limitazzjonijiet ta' rata differenti għal kull rotta).
@app.get("/admin", dependencies=[Depends(verify_admin)]) # run for the effect (auth check)
def admin(): ... # don't need its return value
app = FastAPI(dependencies=[Depends(verify_api_key)]) # applies to EVERY route
router = APIRouter(dependencies=[Depends(get_current_user)]) # to all routes in a router
Applikazzjoni ta' dipendenzi app-wide jew għal kull router għal rekwiżiti cross-cutting (auth, rate limiting).
app.dependency_overrides[get_db] = get_test_db # swap any dependency in tests
L-injection ta' dipendenzi ta' FastAPI hija waħda mill-aktar karatteristiki qawwija, u mudelli avvanzati dawn huma dawk li jippermettulok li strutturizz applikazzjonijiet reali u kumplessi b'eleganza.
L-għarfien tagħhom hu ħjiel ta' livell għoli: sub-dipendenzi jibnu saffi li jistgħu jerġgħu jintuża (token → user → admin) b'risoluzzjoni awtomatika u caching kull request (u jevo xogħol ridundanti); dipendenzi parametrizzati/ibbażati fuq klassit jirrivoluzzjonaw komponenti konfigurabbli, li jistgħu jerġgħu jintuża (rate limiters, permissjoni checks b'settings differenti għal kull rotta); dipendenzi bħala side-effects japplikaw rekwiżiti b'mod ħielsa (auth) mingħajr ma jixtriqu signatures ta' funzjoni; u dipendenzi globali/a livell ta' router japplikaw cross-cutting concerns (authentication, rate limiting) għal gruppi sħaħ ta' rotot fil-post wieħed.
\
nb'mod kritikali, dependency overrides agħmlu anki graffi ta' dipendenza kumplessi trivjalment testabbli.
Imparar dawn il-mudelli — kumposizzjoni ta' dipendenzi, parameterizzazzjoni tagħhom, scoping globali jew għal kull router, u override tagħhom fit-tests — hu dak li jippermetti arkitettura nadifa, DRY, testabbli f'applikazzjonijiet FastAPI mhux trivjali, li jiddistingwi developers li jistgħu japprofittaw kompletament mis-sistema ta' DI tal-framework minn dawk li jużaw biss Depends bażiku.
Hija suġġett importanti għall-kostruzzjoni ta' applikazzjonijiet FastAPI strutturati tajjeb, mantenut tajjeb, u skala kbira.