Dependency Injection

• A param = Depends(fn) is resolved before the handler runs
• The callable's return value is passed in as the argument
• Any callable works: def, async def, or a class
• Its own params are parsed like path function params: path, query, header, body

def common(q: str | None = None, limit: int = 10):
    return {'q': q, 'limit': limit}

@app.get('/items')
def items(p: dict = Depends(common)):
    return p

q and limit are read as query params of /items

• Depends(get_db()) calls it at import time
• It injects one fixed value, not a fresh one per request
• Correct: Depends(get_db), the function uncalled

• A dependency can declare its own Depends(...) params, which forms a tree
• FastAPI resolves the tree bottom-up: leaves first, then the parents
• The endpoint declares only require_admin; the rest is pulled in

fresh: int = Depends(counter, use_cache=False)

forces a new call at this declaration

• Code before yield is setup
• The yielded value is injected into the handler
• Code after yield is teardown, run once the response is sent
• finally guarantees cleanup even when the handler raises

def get_db():
    db = Session()  # setup
    try:
        yield db  # injected
    finally:
        db.close()  # teardown

standard pattern

• Handler exceptions are re-raised at the yield
• except there to rollback, then raise
• Cannot change the response from teardown: it already started streaming

• A class is callable: Depends(Pagination) calls Pagination(...)
• __init__ params are read as query/path params
• Depends() with no argument uses the type annotation as the callable
• Wins over a dict for typed attributes (p.skip) and editor autocomplete

class Pagination:
    def __init__(self, skip: int = 0, limit: int = 10):
        self.skip, self.limit = skip, limit

@app.get('/items')
def items(p: Pagination = Depends()):
    return p.skip, p.limit

Depends() reads the annotation: Pagination

• app.dependency_overrides[orig] = fake replaces it for every request
• Key is the original function object, not a string
• Fake's own params resolve as usual: lambda: User(id=1) skips auth

app.dependency_overrides[get_db] = lambda: test_session
client = TestClient(app)
client.get('/items')  # handler gets test_session

override first, then call

def items(
    db: Annotated[Session, Depends(get_db)],
    p: Annotated[Pagination, Depends()],
):
    return db.query(Item).offset(p.skip)

function and class dependencies

• Pass fn uncalled: Depends(get_db)
• use_cache=False disables per-request reuse
• Class dep: Depends(Cls) or bare Depends(); read p.skip