FastAPI Tutorial

pip install fastapi
pip install uvicorn[standard]

from fastapi import FastAPI

app = FastAPI()

@app.get("/")
def read_root():
    return {"message": "Hello, World!"}

uvicorn main:app --reload

from fastapi import FastAPI

app = FastAPI()

@app.get("/items/{item_id}")
def read_item(item_id: int):
    return {"item_id": item_id}

from enum import Enum
from fastapi import FastAPI

class ModelName(str, Enum):
    alexnet = "alexnet"
    resnet = "resnet"
    lenet = "lenet"

app = FastAPI()

@app.get("/models/{model_name}")
def get_model(model_name: ModelName):
    return {"model": model_name.value}

from typing import Union
from fastapi import FastAPI

app = FastAPI()

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

from fastapi import FastAPI
from pydantic import BaseModel
from typing import Union

app = FastAPI()

class Item(BaseModel):
    name: str
    description: Union[str, None] = None
    price: float
    tax: Union[float, None] = None

@app.post("/items/")
def create_item(item: Item):
    item_dict = item.model_dump()
    if item.tax:
        price_with_tax = item.price + item.tax
        item_dict.update({"price_with_tax": price_with_tax})
    return item_dict

from pydantic import BaseModel, Field
from fastapi import FastAPI, Query, Path

app = FastAPI()

class Item(BaseModel):
    name: str = Field(..., min_length=1, max_length=100)
    price: float = Field(..., gt=0, description="Must be > zero")
    tax: float = Field(default=0.0, ge=0, le=100)

@app.get("/items/")
def read_items(
    q: str = Query(default=None, min_length=3, max_length=50),
    item_id: int = Path(..., ge=1, le=1000),
):
    return {"q": q, "item_id": item_id}

class UserIn(BaseModel):
    username: str
    password: str
    email: str

class UserOut(BaseModel):
    username: str
    email: str

@app.post("/users/", response_model=UserOut)
def create_user(user: UserIn):
    return user  # password is automatically filtered out!

from fastapi import FastAPI, status

app = FastAPI()

@app.post("/items/", status_code=status.HTTP_201_CREATED)
def create_item(name: str):
    return {"name": name}

from fastapi import FastAPI, File, UploadFile, Form

app = FastAPI()

@app.post("/login/")
def login(username: str = Form(...), password: str = Form(...)):
    return {"username": username}

@app.post("/upload/")
async def upload(file: UploadFile = File(...)):
    contents = await file.read()
    return {"filename": file.filename, "size": len(contents)}

from fastapi import FastAPI, HTTPException, status

app = FastAPI()

@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="Item not found",
            headers={"X-Error": "custom header"},
        )
    return {"item_id": item_id}

from fastapi import FastAPI, Depends

app = FastAPI()

def common_parameters(q: str = None, skip: int = 0, limit: int = 100):
    return {"q": q, "skip": skip, "limit": limit}

@app.get("/items/")
def read_items(commons: dict = Depends(common_parameters)):
    return commons

def get_db():
    db = SessionLocal()
    try:
        yield db        # Give session to endpoint
    finally:
        db.close()      # ALWAYS close, even on errors

@app.get("/items/")
def get_items(db: Session = Depends(get_db)):
    return db.query(Item).all()

from fastapi import Depends, HTTPException, status
from fastapi.security import OAuth2PasswordBearer, OAuth2PasswordRequestForm
from jose import JWTError, jwt
from passlib.context import CryptContext

pwd_context = CryptContext(schemes=["bcrypt"], deprecated="auto")
oauth2_scheme = OAuth2PasswordBearer(tokenUrl="token")

async def get_current_user(token: str = Depends(oauth2_scheme)):
    payload = jwt.decode(token, SECRET_KEY, algorithms=[ALGORITHM])
    # ... validate and return user

import time
from fastapi import FastAPI, Request
from fastapi.middleware.cors import CORSMiddleware

app = FastAPI()

app.add_middleware(
    CORSMiddleware,
    allow_origins=["http://localhost:3000"],
    allow_methods=["*"],
    allow_headers=["*"],
)

@app.middleware("http")
async def add_timing(request: Request, call_next):
    start = time.time()
    response = await call_next(request)
    response.headers["X-Time"] = str(time.time() - start)
    return response

from fastapi import FastAPI, BackgroundTasks

app = FastAPI()

def send_email(email: str, message: str):
    # Runs AFTER response is sent
    print(f"Sent to {email}: {message}")

@app.post("/notify/{email}")
async def notify(email: str, bg: BackgroundTasks):
    bg.add_task(send_email, email, "Welcome!")
    return {"message": "Notification queued"}

from fastapi import APIRouter

router = APIRouter(prefix="/items", tags=["items"])

@router.get("/")
def read_items():
    return [{"name": "Item1"}]

from fastapi import FastAPI
from routers import items

app = FastAPI()
app.include_router(items.router)

from sqlalchemy import create_engine, Column, Integer, String
from sqlalchemy.orm import sessionmaker, declarative_base, Session
from pydantic import BaseModel, ConfigDict
from fastapi import Depends

engine = create_engine("sqlite:///./app.db")
SessionLocal = sessionmaker(bind=engine)
Base = declarative_base()

# ORM Model (database table)
class ItemDB(Base):
    __tablename__ = "items"
    id = Column(Integer, primary_key=True)
    name = Column(String)

# Pydantic Schema (API validation)
class ItemResponse(BaseModel):
    id: int
    name: str
    model_config = ConfigDict(from_attributes=True)

# Async — use when calling await-compatible libraries
@app.get("/async")
async def async_endpoint():
    async with httpx.AsyncClient() as client:
        resp = await client.get("https://api.example.com")
    return resp.json()

# Sync — use with blocking I/O (runs in thread pool automatically)
@app.get("/sync")
def sync_endpoint():
    time.sleep(1)  # Won't freeze the server
    return {"done": True}

from fastapi import FastAPI, WebSocket, WebSocketDisconnect

app = FastAPI()

@app.websocket("/ws")
async def websocket_endpoint(ws: WebSocket):
    await ws.accept()
    try:
        while True:
            data = await ws.receive_text()
            await ws.send_text(f"Echo: {data}")
    except WebSocketDisconnect:
        print("Client disconnected")

# ═══ CORE ═══
from fastapi import FastAPI          # Main application class
from fastapi import APIRouter        # Sub-router for organizing routes
from fastapi import Depends          # Dependency injection
from fastapi import HTTPException    # Raise HTTP errors
from fastapi import Request          # Access raw request object
from fastapi import status           # HTTP status code constants

# ═══ PARAMETERS ═══
from fastapi import Query            # Query parameter validation
from fastapi import Path             # Path parameter validation
from fastapi import Body             # Request body validation
from fastapi import Header           # Header extraction
from fastapi import Cookie           # Cookie extraction
from fastapi import Form             # Form data extraction
from fastapi import File             # File upload (bytes)
from fastapi import UploadFile       # File upload (with metadata)

# ═══ RESPONSES ═══
from fastapi.responses import JSONResponse
from fastapi.responses import HTMLResponse
from fastapi.responses import RedirectResponse
from fastapi.responses import StreamingResponse
from fastapi.responses import FileResponse

# ═══ SECURITY ═══
from fastapi.security import OAuth2PasswordBearer
from fastapi.security import OAuth2PasswordRequestForm

# ═══ MIDDLEWARE ═══
from fastapi.middleware.cors import CORSMiddleware

# ═══ BACKGROUND & WEBSOCKET ═══
from fastapi import BackgroundTasks
from fastapi import WebSocket, WebSocketDisconnect

# ═══ TESTING ═══
from fastapi.testclient import TestClient

# ═══ PYDANTIC ═══
from pydantic import BaseModel       # Base for data models
from pydantic import Field           # Field-level validation
from pydantic import ConfigDict      # Model configuration
from pydantic import field_validator # Custom field validators
from pydantic import model_validator # Model-level validators

# ═══ PYTHON TYPING ═══
from typing import Union             # str | None
from typing import List, Dict, Optional
from typing import Annotated         # Modern Query/Path pattern