FastApi Syllabus

How do you declare an optional query parameter that may be omitted entirely in FastAPI?

Give it a default of None with an optional type, e.g. q: str | None = None.

How are boolean query parameters parsed in FastAPI?

FastAPI converts strings like 'true', 'True', '1', 'on', 'yes' to True and their negatives to False, coercing the value to bool.

What is the Query utility used for in FastAPI?

Query adds extra validation and metadata to query parameters, such as min_length, max_length, pattern (regex), default values, and description.

What is a request body in FastAPI and how do you declare one?

Data sent by the client in the body (typically JSON); you declare it by adding a parameter whose type is a Pydantic BaseModel.

How does FastAPI decide whether a function parameter comes from the path, query, or request body?

If the name matches a path parameter it's a path param; if it's a singular type (int, str, etc.) it's a query param; if it's a Pydantic model it's read from the request body.

What is a Pydantic BaseModel and its role in FastAPI request bodies?

A class defining data schema via typed attributes; FastAPI uses it to validate, parse, and document the JSON request body, returning 422 on invalid data.

How can you send multiple Pydantic models plus scalars in a single FastAPI request body?

Declare multiple body parameters (each becomes a JSON key), and use Body() for singular values to embed them as keys rather than treating them as query params.

What is dependency injection in FastAPI?

A system where a path operation declares dependencies (via Depends) that FastAPI resolves and injects automatically, sharing logic like DB sessions, auth, and common parameters.

How do you declare a dependency in a FastAPI path operation?

Add a parameter with Depends, e.g. commons: dict = Depends(common_parameters), where the dependency is a callable (function or class).

What kinds of callables can be used as FastAPI dependencies?

Any callable: plain functions, async functions, or classes (using the class itself as the dependency, which injects an instance).

How can a dependency in FastAPI perform setup and teardown (e.g. open/close a DB session)?

Use a generator dependency with 'yield'; code before yield runs as setup, the yielded value is injected, and code after yield runs as teardown after the response.

How do you apply a dependency that runs but whose return value you don't need (e.g. auth check)?

Use the dependencies=[Depends(...)] argument on the path operation decorator or router, so it executes without injecting a value.

What does 'sub-dependencies' mean in FastAPI's dependency system?

Dependencies can themselves declare dependencies via Depends, forming a tree that FastAPI resolves recursively (and caches shared ones within a request).

By default, if the same dependency is used multiple times in one request, how often is it called?

Once; FastAPI caches the dependency's result per request. Set use_cache=False in Depends to force re-evaluation.

Which security schemes does FastAPI provide utilities for out of the box?

OAuth2 (including password flow with Bearer tokens), API keys (header/query/cookie), HTTP Basic, and OpenID Connect via fastapi.security classes.

What class is commonly used to implement OAuth2 password flow with bearer tokens in FastAPI?

OAuth2PasswordBearer, instantiated with a tokenUrl, used as a dependency to extract and require the Bearer token.

What is the recommended algorithm/standard for tokens in FastAPI's OAuth2 tutorial, and how is the password stored?

JWT (JSON Web Tokens) signed with a secret; passwords are stored hashed (e.g. bcrypt via passlib), never in plaintext.

How do you enforce that a user is authenticated for an endpoint in FastAPI?

Declare a dependency (e.g. current_user = Depends(get_current_user)) that validates the token and raises HTTPException 401 with WWW-Authenticate header if invalid.

What are OAuth2 scopes used for in FastAPI security?

Scopes define fine-grained permissions attached to a token; dependencies can require specific scopes and reject tokens lacking them with a 403/401.

What are background tasks in FastAPI and when are they useful?

Operations run after returning the response (e.g. sending email, logging), letting the client get a fast response without waiting for the work to finish.

How do you add a background task to a FastAPI endpoint?

Add a BackgroundTasks parameter to the path function, then call background_tasks.add_task(func, *args, **kwargs).

For heavy or CPU-intensive work, why might FastAPI BackgroundTasks be insufficient, and what is the alternative?

BackgroundTasks run in the same process and are lost on restart with no retries; for heavy/distributed work use a task queue like Celery, RQ, or ARQ with a message broker.

What is middleware in FastAPI?

A function/class that processes every request before it reaches the path operation and every response before it is returned, wrapping the whole request-response cycle.

How do you write a custom HTTP middleware function in FastAPI?

Use the @app.middleware("http") decorator on an async function that takes (request, call_next), calls response = await call_next(request), and returns the response.

How do you add CORS support in FastAPI?

Add CORSMiddleware via app.add_middleware(CORSMiddleware, allow_origins=[...], allow_methods=[...], allow_headers=[...]).

What ORM is most commonly used with FastAPI for relational (SQL) databases, and what modern library combines it with Pydantic?

SQLAlchemy is the common ORM; SQLModel (by FastAPI's author) combines SQLAlchemy and Pydantic into unified models.

In a FastAPI + SQLAlchemy setup, how is a database session typically provided to path operations?

Through a dependency with 'yield' (e.g. get_db) that creates a Session, yields it, and closes it in a finally/teardown block.

Why should Pydantic response models be used when returning SQLAlchemy ORM objects in FastAPI?

They control/validate the output schema, hide sensitive fields (like hashed passwords), and serialize ORM objects; enabling from_attributes/orm_mode lets Pydantic read attributes.

What are NoSQL (non-relational) databases and a common example used with FastAPI?

Databases that store data without fixed relational schemas (document, key-value, graph, wide-column). MongoDB (a document store) is common with FastAPI, often via Motor (async) or Beanie.

Compare SQL and NoSQL databases on schema and scaling.

SQL: fixed/rigid schema, strong ACID transactions, typically scales vertically, uses JOINs. NoSQL: flexible/dynamic schema, often eventual consistency (BASE), scales horizontally, denormalized data.

Which async MongoDB drivers/ODMs are commonly paired with FastAPI?

Motor (async MongoDB driver) and Beanie (an async ODM built on Motor and Pydantic).

What tools are used to write tests for FastAPI applications?

pytest as the test runner and Starlette/FastAPI's TestClient (based on httpx/requests) or httpx AsyncClient to make requests against the app.

Write a minimal FastAPI test using TestClient.

from fastapi.testclient import TestClient from .main import app client = TestClient(app) def test_root(): response = client.get("/") assert response.status_code == 200 assert response.json() == {"message": "Hello World"}

How do you test asynchronous FastAPI endpoints that require an async client?

Use httpx.AsyncClient with an ASGITransport pointing to the app, inside async test functions, typically with the anyio/pytest-asyncio plugin.

What is dependency overriding in FastAPI testing, and how is it done?

Replacing a real dependency with a test double by setting app.dependency_overrides[original_dependency] = test_dependency, letting you inject test DBs/auth without changing app code.

Why is FastAPI's dependency_overrides mechanism preferred over monkeypatching for tests?

It's built into FastAPI, integrates cleanly with the DI system, is scoped to the app, and lets you swap dependencies (DB sessions, auth, configs) declaratively and reversibly.

What is mocking, and why mock dependencies in tests?

Replacing real objects/services with controllable fakes; it isolates the unit under test, avoids slow/external calls (DBs, APIs), and lets you assert interactions and simulate edge cases.

Which standard Python library is used for mocking, and what class simulates objects?

unittest.mock, providing Mock/MagicMock objects and the patch() function/decorator to replace targets during a test.

What is the difference between a stub and a mock in testing?

A stub returns canned responses to make the test run; a mock also records calls and lets you assert that expected interactions occurred (behavior verification).

Name common deployment options for a FastAPI application.

Containers (Docker) on Kubernetes/ECS, PaaS (Render, Railway, Fly.io, Heroku), serverless (AWS Lambda via Mangum), or a VM running Uvicorn behind a reverse proxy like Nginx.

How is a FastAPI app typically deployed with Docker in production?

Build an image installing dependencies and copying the app, then run it with an ASGI server, e.g. CMD ["fastapi", "run", "main.py", "--port", "80"] or via uvicorn/gunicorn.

What is the difference between 'fastapi dev' and 'fastapi run' commands?

'fastapi dev' runs with auto-reload for development; 'fastapi run' runs in production mode (no reload, optimized defaults).

Why run Uvicorn workers behind Gunicorn (or use multiple workers) in production FastAPI deployments?

To utilize multiple CPU cores and handle more concurrency; Gunicorn manages multiple Uvicorn worker processes (via the uvicorn.workers.UvicornWorker class) for parallelism and resilience.

Why is a reverse proxy like Nginx or Traefik commonly placed in front of a FastAPI/Uvicorn app?

To terminate TLS/HTTPS, serve static files, load balance, handle timeouts/buffering, and provide a hardened public-facing entry point.

What is CI/CD?

Continuous Integration (automatically building and testing code on each commit/merge) and Continuous Delivery/Deployment (automatically releasing or deploying validated changes to environments).

What is the difference between Continuous Delivery and Continuous Deployment?

Continuous Delivery automatically prepares/validates releases but requires a manual approval to deploy to production; Continuous Deployment deploys every passing change to production automatically with no manual gate.

What typically runs in the CI stage of a FastAPI project's pipeline?

Installing dependencies, linting/formatting checks (e.g. ruff), type checking (mypy), and running the pytest test suite on each push or pull request.

Name a common CI/CD platform used to automate FastAPI pipelines.

GitHub Actions (also GitLab CI, CircleCI, Jenkins); workflows are defined in YAML, e.g. .github/workflows/*.yml, triggered on push/PR.

In a typical FastAPI CI/CD flow, what are the ordered stages from commit to production?

Commit/PR triggers CI (lint, type-check, tests) then build (Docker image) then push to a registry then deploy to staging/production, often with automated smoke tests.