Master FastAPI from scratch

Compare the server gateway interfaces: ASGI used by FastAPI vs. WSGI used by Django.

Contrast FastAPI's async-first programming model with Django's synchronous request-response cycle.

Write Python coroutines using `async` and `await` and run them concurrently using `asyncio.gather`.

Distinguish when to use `async def` vs. `def` for route handlers and explain how FastAPI handles blocking I/O.

Define and run a minimal FastAPI application using uvicorn, comparing the workflow to Django's `runserver`.

Use Python type hints to annotate function parameters and return types as the basis for FastAPI's auto-validation.

Implement application startup and shutdown logic using lifespan events.

Extract and validate path parameters and query parameters using type annotations and default values.

Receive and process JSON request bodies using Pydantic models.

Organize routes into modules using `APIRouter`, analogous to Django's app-based `include()`.

Customize auto-generated OpenAPI docs (Swagger UI/ReDoc) with metadata, tags, and response status codes.

Define Pydantic `BaseModel` schemas for request validation, comparing them to DRF serializers.

Apply fine-grained validation using Pydantic field types, constraints, and the `Field()` function.

Create nested Pydantic models to represent complex, hierarchical JSON structures.

Implement custom validation logic with `@field_validator` and `@model_validator`, comparing them to DRF's `validate_<field>` and `validate` methods.

Use separate Pydantic schemas for create, update, and response representations of a single resource.

Configure Pydantic model behavior, such as ORM integration, using `model_config`.

Use the `response_model` parameter to filter and validate response data, comparing it to DRF serializer-based responses.

Raise and customize `HTTPException` for standard error responses, analogous to DRF's exception classes.

Create custom exception handlers to standardize error formats across the entire API.

Declare different status codes and multiple possible responses for a single endpoint in the OpenAPI documentation.

Define database tables using SQLAlchemy declarative models and compare the approach to Django's `models.py`.

Implement Create and Read (single and list) operations using async SQLAlchemy sessions and queries.

Set up and use Alembic for database migrations, comparing the workflow to Django's `makemigrations` and `migrate`.

Explain FastAPI's dependency injection (DI) system and contrast it with Django's middleware and DRF's permission/mixin patterns.

Create and use simple function-based dependencies with `Depends()`.

Build reusable, parameterized dependencies using callable classes.

Chain nested dependencies to compose complex, reusable logic.

Create dependencies with `yield` for setup and teardown logic, such as managing database sessions.

Apply dependencies at different scopes: globally (app), on a router, or for a specific path operation.

Implement password hashing and verification using `passlib`, compared to Django's built-in auth hashers.

Create and decode JWT access tokens for stateless authentication.

Build a login endpoint that returns JWT tokens upon valid credentials using an `OAuth2PasswordRequestForm` dependency.

Implement a dependency using `OAuth2PasswordBearer` that extracts and validates a JWT from request headers.

Protect routes by injecting the current authenticated user via a dependency, compared to DRF's `permission_classes`.

Implement role-based access control (RBAC) using dependencies that check user permissions.

Organize a FastAPI project into a scalable folder structure with routers, schemas, models, and configuration.

Manage environment variables and application settings using Pydantic's `BaseSettings`.

Implement the repository pattern to decouple database logic from business logic.

Implement a service layer to encapsulate business logic, orchestrating calls between route handlers and repositories.

Implement API versioning by prefixing routers.

Explain the use cases for `BackgroundTasks` versus a dedicated task queue like Celery.

Return non-JSON responses, such as `FileResponse` for file downloads or `StreamingResponse` for large data.

Write synchronous and asynchronous tests for API endpoints using `TestClient` and `httpx.AsyncClient`.

Use dependency overrides in tests to inject mocks for external services or database sessions.

Write tests for authenticated endpoints by managing test tokens and authorization headers.

Containerize the FastAPI application using a multi-stage `Dockerfile` for a lean production image.

Create a `docker-compose.yml` file to orchestrate the application and its database for local development.

Configure and run the application in production using Gunicorn as a process manager for Uvicorn workers.

Explain the role of a reverse proxy like Nginx in a production deployment for handling SSL and load balancing.

Design the complete API specification, including endpoints, Pydantic schemas, and SQLAlchemy database models for a new application.

Implement the project structure from scratch using the service and repository patterns.

Implement user registration, JWT-based login, and role-based access control.

Implement all CRUD endpoints for the application's primary resources, secured by authentication.

Write a comprehensive test suite covering business logic, authentication, error handling, and service/repository layers.