FastAPI Cheat Sheet

# Create the virtual environment
python -m venv venv

# Activate on Windows (CMD)
venv\Scripts\activate

# Activate on Windows (PowerShell)
venv\Scripts\Activate.ps1

# Activate on macOS / Linux
source venv/bin/activate

# Install FastAPI with uvicorn
pip install fastapi uvicorn

# Verify the installation
pip list | grep -i fastapi

# Run the server with auto-reload
uvicorn main:app --reload

from fastapi import FastAPI
app = FastAPI()

@app.get("/")
def read_root():
    return {"msg": "Hello FastAPI!"}

@app.get("/items/{item_id}")
def read_item(item_id: int, q: str | None = None):
    return {"item_id": item_id, "q": q}

@app.post("/items/")
def create_item(item: dict):
    return {"item": item}

@app.put("/items/{item_id}")
def update_item(item_id: int, item: dict):
    return {"item_id": item_id, "updated": item}

@app.patch("/items/{item_id}")
def partial_update_item(item_id: int, item: dict):
    return {"item_id": item_id, "patched": item}

@app.delete("/items/{item_id}")
def delete_item(item_id: int):
    return {"item_id": item_id, "deleted": True}

@app.get("/users/{user_id}")
def get_user(user_id: int, active: bool = True):
    return {"user_id": user_id, "active": active}

from fastapi import FastAPI, APIRouter

app = FastAPI(title="My API", version="1.0")

router = APIRouter(prefix="/v1", tags=["items"])   # group related routes
app.include_router(router)                            # mount them on the app

from pydantic import BaseModel

class Item(BaseModel):
    name: str
    price: float
    in_stock: bool = True

@app.post("/items/")
def create_item(item: Item):
    return item

from pydantic import BaseModel, Field

class ItemIn(BaseModel):
    name: str
    price: float = Field(gt=0)     # validated: price must be > 0
    tags: list[str] = []

class ItemOut(BaseModel):
    id: int
    name: str
    price: float

@app.post("/items", response_model=ItemOut, status_code=201)
def create_item(item: ItemIn):
    # "secret" is stripped by response_model
    return {"id": 1, "name": item.name, "price": item.price, "secret": "hidden"}

from fastapi import Query, Path
from typing import Annotated

@app.get("/search/")
def search(
    q: Annotated[str, Query(min_length=3, max_length=50)],
    page: Annotated[int, Query(ge=1)] = 1,
):
    return {"q": q, "page": page}

@app.get("/users/{user_id}")
def get_user(user_id: Annotated[int, Path(ge=1)]):
    return {"user_id": user_id}

# GET /search/?q=ab         -> 422 (min_length=3)
# GET /users/0              -> 422 (fails ge=1)
# GET /users/3?page=5       -> 200

from fastapi import FastAPI, Depends, HTTPException, Query
from typing import Annotated

app = FastAPI()

def common_params(q: str = "", skip: int = 0, limit: int = 10):
    return {"q": q, "skip": skip, "limit": limit}

@app.get("/items/")
def read_items(commons: Annotated[dict, Depends(common_params)]):
    return commons

# Setup & teardown with yield
def get_db():
    db = connect()
    try:
        yield db          # injected into the handler
    finally:
        db.close()        # teardown, always runs

# Route-level guard (no value passed)
def verify_token(x_token: Annotated[str | None, Query()] = None):
    if x_token != "secret":
        raise HTTPException(status_code=401, detail="bad token")

@app.get("/admin", dependencies=[Depends(verify_token)])
def admin():
    return {"ok": True}

from fastapi import Depends, HTTPException
from fastapi.security import OAuth2PasswordBearer

oauth2_scheme = OAuth2PasswordBearer(tokenUrl="token")

@app.get("/users/me")
def read_users_me(token: str = Depends(oauth2_scheme)):
    return {"token": token}

from fastapi.security.api_key import APIKeyHeader

api_key_header = APIKeyHeader(name="X-API-Key")

@app.get("/secure-data/")
def secure_data(api_key: str = Depends(api_key_header)):
    if api_key != "secret123":
        raise HTTPException(403, "Unauthorized")
    return {"data": "Top secret!"}

from fastapi import FastAPI, HTTPException, status
from fastapi.responses import JSONResponse

app = FastAPI()

@app.post("/items", status_code=status.HTTP_201_CREATED)
def make_item():
    return {"ok": True}

@app.get("/items/{item_id}")
def read_item(item_id: int):
    if item_id == 0:
        raise HTTPException(
            status_code=status.HTTP_404_NOT_FOUND,
            detail="not found",
            headers={"WWW-Authenticate": "Bearer"},
        )
    return {"item_id": item_id}

@app.exception_handler(ValueError)
def handle(request, exc):
    return JSONResponse(status_code=400, content={"detail": str(exc)})

from fastapi import Cookie, Header

@app.get("/cookies/")
def get_cookie(session_id: str = Cookie(None)):
    return {"session_id": session_id}

@app.get("/headers/")
def get_header(user_agent: str = Header(None)):
    return {"user_agent": user_agent}

from fastapi import BackgroundTasks

def write_log(msg: str):
    with open("log.txt", "a") as f:
        f.write(msg + "\n")

@app.post("/log/")
def log_message(msg: str, bg: BackgroundTasks):
    bg.add_task(write_log, msg)
    return {"status": "scheduled"}

from sqlalchemy import create_engine, Column, Integer, String
from sqlalchemy.orm import declarative_base, sessionmaker

# PostgreSQL database connection
DATABASE_URL = (
    "postgresql+psycopg://"
    "almacen_user:tu_contraseña@localhost:5432/almacen"
)

# Create database engine
engine = create_engine(
    DATABASE_URL,
    echo=True
)

# Create session factory
SessionLocal = sessionmaker(
    bind=engine,
    autoflush=False,
    autocommit=False
)

# Create declarative base
Base = declarative_base()


# Define User model
class User(Base):
    __tablename__ = "users"

    id = Column(
        Integer,
        primary_key=True,
        index=True
    )

    name = Column(
        String,
        index=True,
        nullable=False
    )


# Create database tables
Base.metadata.create_all(bind=engine)

from fastapi.middleware.cors import CORSMiddleware

app.add_middleware(
    CORSMiddleware,
    allow_origins=["*"],
    allow_methods=["*"],
    allow_headers=["*"],
)

from fastapi import FastAPI
from pydantic import BaseModel, Field

app = FastAPI(docs_url="/api-docs", redoc_url=None)   # relocate Swagger, drop ReDoc

class Item(BaseModel):
    name: str = Field(examples=["Ada"], description="The item name")

@app.get("/items", tags=["items"], summary="List items")
def list_items(): ...

from fastapi.testclient import TestClient

client = TestClient(app)

def test_root():
    response = client.get("/")
    assert response.status_code == 200
    assert response.json() == {"msg": "Hello FastAPI!"}

# Development: auto-reload
fastapi dev main.py

# Production: no reload, binds 0.0.0.0:8000
fastapi run main.py

# Direct uvicorn invocation
uvicorn main:app --reload --port 8000

# Scale with worker processes
uvicorn main:app --workers 4

import uvicorn

if __name__ == "__main__":
    uvicorn.run("main:app", host="127.0.0.1", port=8000, reload=True)