What’s Changed & Migration

# Old way (still valid, but no longer the documented default)
uvicorn main:app --reload

# New way
uv add "fastapi[standard]"
fastapi dev            # auto-reload, development
fastapi run --workers 4   # production

import os
from datetime import datetime, timedelta

from jose import jwt
from passlib.context import CryptContext

SECRET_KEY = os.environ["SECRET_KEY"]          # never hardcode a key
pwd = CryptContext(schemes=["bcrypt"])
token = jwt.encode({"sub": "ana", "exp": datetime.utcnow() + timedelta(minutes=30)}, SECRET_KEY)

import os
import secrets
from datetime import datetime, timedelta, timezone
from typing import Annotated

import jwt
from fastapi import Depends, FastAPI
from fastapi.security import OAuth2PasswordBearer
from fastapi.testclient import TestClient
from pwdlib import PasswordHash

# In a real app this comes from settings (openssl rand -hex 32); a random value keeps the demo self-contained.
SECRET_KEY = os.environ.get("BOOKSHELF_SECRET_KEY") or secrets.token_hex(32)
ALGORITHM = "HS256"

password_hash = PasswordHash.recommended()          # Argon2
oauth2_scheme = OAuth2PasswordBearer(tokenUrl="token")
app = FastAPI()


def create_token(subject: str) -> str:
    expire = datetime.now(timezone.utc) + timedelta(minutes=30)
    return jwt.encode({"sub": subject, "exp": expire}, SECRET_KEY, algorithm=ALGORITHM)


@app.get("/me")
def me(token: Annotated[str, Depends(oauth2_scheme)]) -> dict[str, str]:
    payload = jwt.decode(token, SECRET_KEY, algorithms=[ALGORITHM])
    return {"user": payload["sub"]}


hashed = password_hash.hash("a-test-password")
print(password_hash.verify("a-test-password", hashed))

client = TestClient(app)
print(client.get("/me").status_code)
print(client.get("/me", headers={"Authorization": f"Bearer {create_token('ana')}"}).json())

True
401
{'user': 'ana'}

from collections.abc import Iterator
from functools import cache, partial
from typing import Annotated

from fastapi import Depends, FastAPI
from fastapi.testclient import TestClient
from pydantic_settings import BaseSettings, SettingsConfigDict


class Settings(BaseSettings):
    model_config = SettingsConfigDict(env_prefix="BOOKSHELF_")
    database_url: str = "sqlite:///./bookshelf.db"


@cache
def get_settings() -> Settings:
    return Settings()


events: list[str] = []


def get_session(settings: Annotated[Settings, Depends(get_settings)]) -> Iterator[str]:
    events.append("open " + settings.database_url)
    try:
        yield "session"
    finally:
        events.append("close")


def greeting(prefix: str) -> str:
    return prefix + "!"


app = FastAPI()


@app.get("/books")
def books(session: Annotated[str, Depends(get_session, scope="function")]) -> dict[str, str]:
    return {"using": session}


@app.get("/hello")
def hello(text: Annotated[str, Depends(partial(greeting, "hello"))]) -> str:
    return text


client = TestClient(app)
print(client.get("/books").json(), events)
print(client.get("/hello").json())

app.dependency_overrides[get_session] = lambda: "fake-session"
print(client.get("/books").json())

{'using': 'session'} ['open sqlite:///./bookshelf.db', 'close']
hello!
{'using': 'fake-session'}

import anyio
import httpx
from fastapi import FastAPI

app = FastAPI()


@app.get("/")
async def root() -> dict[str, str]:
    return {"message": "Tomato"}


async def main() -> None:
    async with httpx.AsyncClient(transport=httpx.ASGITransport(app=app), base_url="http://test") as client:
        response = await client.get("/")
    print(response.status_code, response.json())


anyio.run(main)

200 {'message': 'Tomato'}

return templates.TemplateResponse("books.html", {"request": request, "books": books})

import tempfile
from pathlib import Path

from fastapi import FastAPI, Request
from fastapi.responses import HTMLResponse
from fastapi.templating import Jinja2Templates
from fastapi.testclient import TestClient

directory = Path(tempfile.mkdtemp())
(directory / "books.html").write_text("<ul>{% for b in books %}<li>{{ b }}</li>{% endfor %}</ul>")

templates = Jinja2Templates(directory=directory)
app = FastAPI()


@app.get("/books", response_class=HTMLResponse)
def books(request: Request):
    return templates.TemplateResponse(request, "books.html", {"books": ["Dune", "Emma"]})


print(TestClient(app).get("/books").text)

<ul><li>Dune</li><li>Emma</li></ul>

from typing import Annotated, Literal

from fastapi import FastAPI, Form, Query
from fastapi.testclient import TestClient
from pydantic import BaseModel, Field

app = FastAPI()


class BookForm(BaseModel):
    model_config = {"extra": "forbid"}
    title: str
    year: int


class Filters(BaseModel):
    model_config = {"extra": "forbid"}
    limit: int = Field(100, gt=0, le=100)
    order_by: Literal["title", "year"] = "title"


@app.post("/books")
def create(form: Annotated[BookForm, Form()]) -> BookForm:
    return form


@app.get("/books")
def search(filters: Annotated[Filters, Query()]) -> Filters:
    return filters


client = TestClient(app)
print(client.post("/books", data={"title": "Dune", "year": "1965"}).json())
print(client.get("/books", params={"order_by": "year"}).json())
print(client.get("/books", params={"unknown": "x"}).status_code)

{'title': 'Dune', 'year': 1965}
{'limit': 100, 'order_by': 'year'}
422

from fastapi import FastAPI
from fastapi.responses import ORJSONResponse

app = FastAPI(default_response_class=ORJSONResponse)

from fastapi import FastAPI
from fastapi.testclient import TestClient
from pydantic import BaseModel

app = FastAPI()


class Book(BaseModel):
    title: str
    isbn: str | None = None


@app.get("/books/{book_id}")
def read_book(book_id: int) -> Book:                       # response model from the annotation
    return Book(title="Dune")


@app.delete("/books/{book_id}", status_code=204)
def delete_book(book_id: int) -> None:                     # no body
    return None


client = TestClient(app)
print(client.get("/books/1").json())
print(client.delete("/books/1").status_code, repr(client.delete("/books/1").content))
print(client.get("/openapi.json").json()["openapi"])

{'title': 'Dune', 'isbn': None}
204 b''
3.1.0

from fastapi import FastAPI
from fastapi.testclient import TestClient
from pydantic import BaseModel


class Book(BaseModel):
    title: str


strict = FastAPI()
lenient = FastAPI(strict_content_type=False)    # opt out only for legacy clients


@strict.post("/books")
def create_strict(book: Book) -> Book:
    return book


@lenient.post("/books")
def create_lenient(book: Book) -> Book:
    return book


body = '{"title": "Dune"}'
print(TestClient(strict).post("/books", content=body).status_code)
print(TestClient(strict).post("/books", content=body, headers={"Content-Type": "application/json"}).status_code)
print(TestClient(lenient).post("/books", content=body).status_code)

422
200
200

from collections.abc import AsyncIterable

from fastapi import FastAPI
from fastapi.sse import EventSourceResponse
from fastapi.testclient import TestClient
from pydantic import BaseModel

app = FastAPI()


class Book(BaseModel):
    title: str


@app.get("/books/stream")
async def stream_books() -> AsyncIterable[Book]:
    yield Book(title="Dune")
    yield Book(title="Emma")


@app.get("/books/events", response_class=EventSourceResponse)
async def book_events() -> AsyncIterable[Book]:
    yield Book(title="Dune")


client = TestClient(app)
lines = client.get("/books/stream")
print(lines.headers["content-type"], lines.text.splitlines())
events = client.get("/books/events")
print(events.headers["content-type"], events.text.strip().splitlines())

application/jsonl ['{"title":"Dune"}', '{"title":"Emma"}']
text/event-stream; charset=utf-8 ['data: {"title":"Dune"}']

import tempfile
from pathlib import Path

from fastapi import FastAPI
from fastapi.testclient import TestClient

dist = Path(tempfile.mkdtemp())
(dist / "index.html").write_text("<html><body>SPA</body></html>")

app = FastAPI()


@app.get("/api/books")
def list_books() -> list[str]:
    return ["Dune"]


app.frontend("/", directory=str(dist))

client = TestClient(app)
print(client.get("/api/books").json())
print(client.get("/", headers={"Accept": "text/html"}).text)
print(client.get("/books/42", headers={"Accept": "text/html"}).text)

['Dune']
<html><body>SPA</body></html>
<html><body>SPA</body></html>