Python FastApi Syllabus

How do you declare a request body in FastAPI, and what status code is returned on invalid body data?

Declare a Pydantic BaseModel and use it as a function parameter type. Invalid data yields a 422 response with detailed errors.

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

If the name is in the path it's a path param; if it's a singular type (int, str) it defaults to a query param; if it's a Pydantic model it's read from the request body.

Which Pydantic class do request-body models inherit from in FastAPI?

pydantic.BaseModel.

How do you force a singular value (like an int) to be read from the request body instead of as a query parameter?

Annotate it with Body(), e.g. importance: int = Body().

What is Dependency Injection in FastAPI and which function declares a dependency?

It is a mechanism to declare and reuse shared logic/resources that FastAPI resolves automatically. Dependencies are declared with Depends(), e.g. commons: dict = Depends(get_common_params).

Name three benefits of using FastAPI's dependency injection system.

Code reuse (shared logic), separation of concerns, and easy testing via dependency overrides; it also handles authentication, DB sessions, and validation.

How can a dependency provide a resource and guarantee cleanup (e.g., closing a DB session)?

Use a generator dependency with yield: code before yield sets up the resource, the yielded value is injected, and code after yield runs as teardown.

What can be used as a dependency in FastAPI besides functions?

Any callable, including classes (the class is called to create an instance), and dependencies can themselves have sub-dependencies.

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

Add it to the decorator's dependencies list, e.g. @app.get("/items/", dependencies=[Depends(verify_token)]).

Which OpenAPI/standards-based scheme does FastAPI provide for token-based authentication, and from which module?

OAuth2 with Password flow and Bearer tokens via OAuth2PasswordBearer in fastapi.security.

What does OAuth2PasswordBearer(tokenUrl="token") do in a FastAPI security setup?

It declares the URL where clients send username/password to obtain a token and creates a dependency that extracts the Bearer token from the Authorization header.

Which HTTP status code and header should a FastAPI endpoint return when authentication fails?

401 Unauthorized with the header WWW-Authenticate: Bearer.

What is the recommended library and algorithm approach for password hashing in FastAPI security tutorials?

Use passlib (commonly with bcrypt) to hash and verify passwords; never store plaintext passwords.

In FastAPI's OAuth2 JWT flow, what does the server return after successful login and what does the client send afterward?

The server returns a JWT access token (with token_type 'bearer'); the client then sends it in the Authorization: Bearer <token> header on subsequent requests.

What is the purpose of BackgroundTasks in FastAPI?

To run operations after returning the response, so the client isn't kept waiting — e.g. sending email notifications or writing logs.

How do you add a background task in a FastAPI path operation?

Declare a BackgroundTasks parameter and call background_tasks.add_task(func, *args, **kwargs); the task runs after the response is sent.

When should you use Celery instead of FastAPI's built-in BackgroundTasks?

For heavy, long-running, or CPU-intensive jobs needing a distributed task queue, retries, scheduling, or a separate worker process. BackgroundTasks suits light operations within the same process.

What is middleware in FastAPI and when does its code run?

Middleware is a function/class that processes every request before it reaches the path operation and every response before it's returned, enabling cross-cutting concerns like logging, timing, or headers.

Write the signature pattern for a custom HTTP middleware function in FastAPI.

@app.middleware("http") async def add_process_time(request: Request, call_next): response = await call_next(request) return response # call_next runs the rest of the app

Which middleware do you add in FastAPI to allow requests from other origins (browsers)?

CORSMiddleware (from fastapi.middleware.cors / starlette), configured with allow_origins, allow_methods, and allow_headers.

Which ORM is traditionally used with FastAPI for relational databases, and which library does FastAPI's creator recommend that combines it with Pydantic?

SQLAlchemy is traditional; SQLModel (by FastAPI's creator) combines SQLAlchemy and Pydantic in one model.

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

Through a dependency (get_db) that uses yield to create a SessionLocal, inject it, and close it afterward.

What three core objects must you configure for SQLAlchemy in a FastAPI app?

An engine (create_engine with the DB URL), a session factory (sessionmaker -> SessionLocal), and a declarative Base class for models.

For SQLite specifically with FastAPI, what connect argument is required and why?

connect_args={"check_same_thread": False}, because SQLite by default allows only the creating thread to use the connection, while FastAPI may use multiple threads.

What is a NoSQL (non-relational) database, and name two types?

A database that stores data without fixed relational tables/schemas. Types include document stores (MongoDB), key-value stores (Redis), wide-column (Cassandra), and graph databases (Neo4j).

Give one key advantage and one trade-off of NoSQL vs SQL databases.

Advantage: flexible schema and horizontal scalability for large/unstructured data. Trade-off: weaker ACID guarantees and limited multi-table JOINs/complex relational queries compared to SQL.

Which async driver is commonly used to connect FastAPI to MongoDB?

Motor (the async MongoDB driver), often paired with Beanie or ODMantic as a Pydantic-based ODM.

Which HTTP client class does FastAPI use for writing tests, and from which library?

TestClient from fastapi.testing (backed by Starlette/httpx) — instantiated as client = TestClient(app).

Write a minimal FastAPI test using TestClient that checks the root endpoint.

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() == {"Hello": "World"}

How do you replace a real dependency (like a DB) with a fake one during FastAPI tests?

Use app.dependency_overrides[original_dependency] = fake_dependency; this swaps the dependency only for tests without changing app code.

Why is dependency override preferred over patching/monkeypatching for mocking dependencies in FastAPI?

Because FastAPI's DI system is designed for it: overrides are explicit, scoped, and reset easily (clear the dict), keeping production code untouched and tests isolated/repeatable.

List three common options for deploying a FastAPI application.

(1) A container image (Docker) run on Kubernetes/cloud; (2) a managed/PaaS host (e.g., a cloud run service or platform); (3) a VM/server running Uvicorn behind a reverse proxy like Nginx, often managed by Gunicorn with Uvicorn workers.

What is the recommended way to run FastAPI in production for multiple worker processes?

Run Uvicorn with multiple workers (e.g. fastapi run --workers N or Gunicorn managing uvicorn.workers.UvicornWorker), typically behind a reverse proxy/load balancer.

What is CI/CD and what does each part stand for?

CI is Continuous Integration (automatically building and testing code on each change/merge); CD is Continuous Delivery/Deployment (automatically releasing/deploying validated code).

What are the typical stages of a CI/CD pipeline for a FastAPI project?

Lint/format check, install dependencies, run automated tests (pytest), build the artifact/Docker image, and deploy to the target environment.

Why is a reverse proxy (e.g., Nginx) commonly placed in front of a deployed FastAPI/Uvicorn server?

To handle TLS/HTTPS termination, serve static files, load-balance across workers, and add buffering/security — letting Uvicorn focus on the ASGI app.