Au-delà du simple Depends, l'injection de dépendances de FastAPI supporte des motifs avancés : sous-dépendances, dépendances avec paramètres (basées sur des classes ou via des factories), ressources scoped (yield), , et pour les tests — ce qui en fait un outil polyvalent pour structurer de véritables applications.
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
Les dépendances peuvent dépendre d'autres dépendances, formant un arbre que FastAPI résout automatiquement (et met en cache les dépendances partagées par requête, donc get_token s'exécute une seule fois même s'il est utilisé par plusieurs dépendances).
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(): ...
Une classe avec __call__ est une dépendance configurable — vous la paramétrisiez au moment de l'utilisation (par ex. des limites de débit différentes par route).
@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
Appliquez des dépendances à l'échelle de l'application ou par routeur pour les exigences transversales (authentification, limitation de débit).
app.dependency_overrides[get_db] = get_test_db # swap any dependency in tests
L'injection de dépendances de FastAPI est l'une de ses caractéristiques les plus puissantes, et ces motifs avancés sont ce qui vous permet de structurer des applications réelles et complexes élégamment.
Les comprendre est une connaissance précieuse de niveau senior : les sous-dépendances construisent des couches réutilisables (token → utilisateur → admin) avec résolution automatique et mise en cache par requête (évitant les travaux redondants) ; les dépendances paramétrées/basées sur des classes créent des composants configurables et réutilisables (limiteurs de débit, vérifications de permissions avec des paramètres différents par route) ; les dépendances comme effets secondaires appliquent proprement les exigences (authentification) sans encombrer les signatures de fonction ; et les dépendances globales/routeur appliquent les préoccupations transversales (authentification, limitation de débit) à des groupes entiers de routes en un seul endroit.
Crucifixalement, les surcharges de dépendances rendent même les graphes de dépendances complexes trivialement testables.
Maîtriser ces motifs — composer les dépendances, les paramétrer, les scoper globalement ou par routeur, et les surcharger dans les tests — est ce qui permet une architecture propre, DRY et testable dans les applications FastAPI non triviales, distinguant les développeurs qui peuvent exploiter pleinement le système DI du framework de ceux qui n'utilisent que le simple Depends.
C'est un sujet important pour construire des applications FastAPI bien structurées, maintenables et à grande échelle.