Dependency Injection

Key concept: Dependencies are functions that FastAPI calls before your route handler. Use yield for cleanup logic.

Pattern	Use Case
Simple function	Get config, compute values
Generator (yield)	Database sessions, connections
Class-based	Complex dependencies with state
Nested dependencies	Dependencies that depend on other dependencies

Dependency	Purpose
get_db	Database session (yield for cleanup)
get_current_user	Authentication + user retrieval
get_settings	Configuration singleton
rate_limiter	Request throttling

Key concept: Use Annotated[Type, Depends(func)] for cleaner type hints and reusability.

Pydantic Models

Pattern	Purpose
Base model	Shared fields
Create model	Input for POST (no id)
Update model	Partial updates (all Optional)
Response model	Output (includes id, timestamps)
DB model	Internal with `from_attributes = True`

Approach	Use Case
HTTPException	Simple errors with status code
Custom exception class	Structured error responses
@app.exception_handler	Global error handling
RequestValidationError	Customize validation errors

Key concept: Create custom exception classes for consistent error response format across your API.

Concept	Purpose
APIRouter	Group related endpoints
prefix	URL prefix for all routes
tags	OpenAPI documentation grouping
dependencies	Router-level dependencies

Directory	Contents
routers/	Route handlers by domain
models/	SQLAlchemy/database models
schemas/	Pydantic request/response models
services/	Business logic
dependencies.py	Shared dependencies
config.py	Settings and configuration

Method	Use Case
BackgroundTasks	Simple async tasks (email, logging)
Celery	Heavy tasks, retries, scheduling
ARQ	Async Redis queue

Key concept: BackgroundTasks run after response is sent—good for non-critical operations that shouldn't block the response.

Client	Use Case
TestClient	Sync tests (most common)
AsyncClient (httpx)	Async tests, lifespan events

Key concept: Override get_db for test database, get_current_user for auth bypass.

Practice	Why
Use response_model	Control output, hide internal fields
Use dependency injection	Testable, reusable code
Separate schemas from DB models	Decouple API from database
Use routers for organization	Maintainable as API grows
Add OpenAPI descriptions	Self-documenting API
Use async for I/O	Better concurrency