Beyond basic Depends, FastAPI's dependency injection supports advanced patterns: sub-dependencies, dependencies with parameters (class-based or via factories), scoped resources (yield), global/router dependencies, and for testing — making it a versatile tool for structuring real 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
Dependencies can depend on other dependencies, forming a tree FastAPI resolves automatically (and caches shared ones per request, so get_token runs once even if used by several dependencies).
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(): ...
A class with __call__ is a configurable dependency — you parameterize it at use time (e.g. different rate limits per 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
Apply dependencies app-wide or per-router for cross-cutting requirements (auth, rate limiting).
app.dependency_overrides[get_db] = get_test_db # swap any dependency in tests
FastAPI's dependency injection is one of its most powerful features, and these advanced patterns are what let you structure real, complex applications elegantly.
Understanding them is valuable senior-level knowledge: sub-dependencies build reusable layers (token → user → admin) with automatic resolution and per-request caching (avoiding redundant work); parameterized/class-based dependencies create configurable, reusable components (rate limiters, permission checks with different settings per route); dependencies as side-effects cleanly enforce requirements (auth) without cluttering function signatures; and global/router-level dependencies apply cross-cutting concerns (authentication, rate limiting) to whole groups of routes in one place.
Crucially, dependency overrides make even complex dependency graphs trivially testable.
Mastering these patterns — composing dependencies, parameterizing them, scoping them globally or per-router, and overriding them in tests — is what enables clean, DRY, testable architecture in non-trivial FastAPI applications, distinguishing developers who can leverage the framework's DI system fully from those who use only basic Depends.
It's an important topic for building well-structured, maintainable, large-scale FastAPI apps.