Más allá de Depends básico, la inyección de dependencias de FastAPI soporta patrones avanzados: sub-dependencias, dependencias con parámetros (basadas en clases o mediante factories), recursos con scope (yield), , y para testing — lo que la convierte en una herramienta versátil para estructurar aplicaciones reales.
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
Las dependencias pueden depender de otras dependencias, formando un árbol que FastAPI resuelve automáticamente (y cachea las compartidas por solicitud, por lo que get_token se ejecuta una sola vez incluso si varias dependencias la usan).
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(): ...
Una clase con __call__ es una dependencia configurable — la parametrizas en tiempo de uso (p. ej. diferentes límites de rate por ruta).
@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
Aplica dependencias a toda la app o por router para requisitos transversales (auth, rate limiting).
app.dependency_overrides[get_db] = get_test_db # swap any dependency in tests
La inyección de dependencias de FastAPI es una de sus características más poderosas, y estos patrones avanzados son los que te permiten estructurar aplicaciones reales y complejas de forma elegante.
Entenderlos es conocimiento valioso de nivel senior: las sub-dependencias construyen capas reutilizables (token → usuario → admin) con resolución automática y cacheo por solicitud (evitando trabajo redundante); las dependencias parametrizadas/basadas en clases crean componentes reutilizables y configurables (limitadores de rate, validaciones de permisos con diferentes configuraciones por ruta); las dependencias como efectos secundarios aplican requisitos limpiamente (auth) sin saturar firmas de funciones; y las dependencias globales/a nivel de router aplican concernimientos transversales (autenticación, rate limiting) a grupos completos de rutas en un solo lugar.
Crucialmente, los dependency overrides hacen que incluso grafos de dependencias complejos sean trivialmente testables.
Dominar estos patrones — componiendo dependencias, parametrizándolas, definiéndoles scope global o por router, e haciéndoles overrides en tests — es lo que permite una arquitectura limpia, DRY y testeable en aplicaciones FastAPI no triviales, diferenciando a desarrolladores que pueden aprovechar completamente el sistema de DI del framework de aquellos que usan solo Depends básico.
Es un tema importante para construir apps FastAPI bien estructuradas, mantenibles y a gran escala.