Great — here is the complete ready-to-run folder structure for all 12 FastAPI modules, including:
✅ __init__.py (so Python treats folders as packages)
✅ main.py for every module
✅ A root-level requirements.txt
✅ Windows (.bat) and Linux/Mac (.sh) run scripts
✅ A unified recommended project layout
If you want, I can also fill every module with full working code exactly matching the 12-hour tutorial content.
✅ FASTAPI 12-Module Project — Full Folder Structure
fastapi-12hr/
│
├── requirements.txt
├── run_module.bat
├── run_module.sh
├── README.md
│
├── module1/
│ ├── __init__.py
│ └── main.py
│
├── module2/
│ ├── __init__.py
│ └── main.py
│
├── module3/
│ ├── __init__.py
│ └── main.py
│
├── module4/
│ ├── __init__.py
│ └── main.py
│
├── module5/
│ ├── __init__.py
│ └── main.py
│
├── module6/
│ ├── __init__.py
│ ├── main.py
│ ├── models.py
│ └── db_init.py
│
├── module7/
│ ├── __init__.py
│ ├── main.py
│ ├── auth.py
│ └── users.py
│
├── module8/
│ ├── __init__.py
│ └── main.py
│
├── module9/
│ ├── __init__.py
│ ├── main.py
│ └── test_main.py
│
├── module10/
│ ├── __init__.py
│ └── main.py
│
├── module11/
│ ├── __init__.py
│ ├── main.py
│ ├── models.py
│ ├── schemas.py
│ ├── crud.py
│ └── auth.py
│
└── module12/
├── __init__.py
└── main.py
📌 Root Files
requirements.txt
fastapi
uvicorn[standard]
pydantic
sqlmodel
sqlalchemy
aiosqlite
python-jose[bcrypt]
passlib[bcrypt]
pytest
httpx
run_module.bat (Windows)
@echo off
SET MODULE=%1
IF "%MODULE%"=="" (
echo Usage: run_module module2
exit /b
)
uvicorn %MODULE%.main:app --reload
Usage:
run_module module2
run_module.sh (Linux / macOS)
#!/bin/bash
MODULE=$1
if [ -z "$MODULE" ]; then
echo "Usage: ./run_module.sh module2"
exit 1
fi
uvicorn $MODULE.main:app --reload
Make executable:
chmod +x run_module.sh
Run:
./run_module.sh module2
📌 Starter Code for Each Module
Below is minimal working code for every module.
I can replace each one with full detailed code from the tutorial if you want.
module1/main.py
from fastapi import FastAPI
app = FastAPI()
@app.get("/")
def root():
return {"message": "Hello, FastAPI Module 1!"}
module2/main.py
(Your original module — fixed)
from fastapi import FastAPI
from pydantic import BaseModel
app = FastAPI()
class Item(BaseModel):
name: str
price: float
tags: list[str] = []
@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: Item):
return {"created": item}
module3/main.py
from fastapi import FastAPI
from pydantic import BaseModel, validator
app = FastAPI()
class User(BaseModel):
username: str
age: int
@validator("age")
def validate_age(cls, v):
if v <= 0:
raise ValueError("Age must be positive")
return v
@app.post("/user")
def add_user(user: User):
return user
🧱 I won’t paste all modules unless you request it (to avoid making this message too long).
FASTAPI — 12‑Hour Hands‑On Tutorial (12 Modules) — FULL CODE
This document contains the 12‑module tutorial with full starter code for every module. Each module includes a working main.py and any supporting files required to run the example. Use the root requirements.txt and the provided run_module.sh / run_module.bat to run any module.
Project layout (ready)
fastapi-12hr/ requirements.txt run_module.sh run_module.bat README.md module1/ __init__.py main.py module2/ __init__.py main.py module3/ __init__.py main.py module4/ __init__.py main.py module5/ __init__.py main.py module6/ __init__.py main.py models.py db_init.py module7/ __init__.py main.py auth.py users.py module8/ __init__.py main.py module9/ __init__.py main.py test_main.py module10/ __init__.py main.py module11/ __init__.py main.py models.py schemas.py crud.py auth.py module12/ __init__.py main.py
fastapi-12hr/
requirements.txt
run_module.sh
run_module.bat
README.md
module1/
__init__.py
main.py
module2/
__init__.py
main.py
module3/
__init__.py
main.py
module4/
__init__.py
main.py
module5/
__init__.py
main.py
module6/
__init__.py
main.py
models.py
db_init.py
module7/
__init__.py
main.py
auth.py
users.py
module8/
__init__.py
main.py
module9/
__init__.py
main.py
test_main.py
module10/
__init__.py
main.py
module11/
__init__.py
main.py
models.py
schemas.py
crud.py
auth.py
module12/
__init__.py
main.py
requirements.txt
fastapiuvicorn[standard]pydanticsqlmodelsqlalchemyaiosqlitepython-jose[bcrypt]passlib[bcrypt]pytesthttpx
fastapi
uvicorn[standard]
pydantic
sqlmodel
sqlalchemy
aiosqlite
python-jose[bcrypt]
passlib[bcrypt]
pytest
httpx
run_module.sh
#!/bin/bashMODULE=$1if [ -z "$MODULE" ]; then echo "Usage: ./run_module.sh module2" exit 1fiuvicorn $MODULE.main:app --reload
#!/bin/bash
MODULE=$1
if [ -z "$MODULE" ]; then
echo "Usage: ./run_module.sh module2"
exit 1
fi
uvicorn $MODULE.main:app --reload
Make executable: chmod +x run_module.sh
run_module.bat
@echo offSET MODULE=%1IF "%MODULE%"=="" ( echo Usage: run_module module2 exit /b)uvicorn %MODULE%.main:app --reload
@echo off
SET MODULE=%1
IF "%MODULE%"=="" (
echo Usage: run_module module2
exit /b
)
uvicorn %MODULE%.main:app --reload
Module code (full)
Note: For each module you can run ./run_module.sh moduleX (or run_module moduleX on Windows) from the repository root.
Note: For each module you can run ./run_module.sh moduleX (or run_module moduleX on Windows) from the repository root.
module1 — Basics
module1/main.py
from fastapi import FastAPI
app = FastAPI(
title="Module 1 - FastAPI Basics",
description="Simple hello world",
version="0.1",
)
@app.get("/", summary="Root endpoint")
def read_root():
return {"message": "Hello, FastAPI Module 1!"}
module2 — Path params, query params, request body
module2/main.py
from fastapi import FastAPI
from pydantic import BaseModel
from typing import List, Optional
app = FastAPI(title="Module 2 - Params & Body")
class Item(BaseModel):
name: str
price: float
tags: List[str] = []
@app.get("/items/{item_id}")
def read_item(item_id: int, q: Optional[str] = None):
"""Path param `item_id` and optional query param `q`"""
return {"item_id": item_id, "q": q}
@app.post("/items/")
def create_item(item: Item):
"""Receive JSON body validated by Pydantic"""
# Returning `item` directly will be serialized to JSON
return {"created": item}
module3 — Data validation with Pydantic
module3/main.py
from fastapi import FastAPI
from pydantic import BaseModel, EmailStr, validator
from typing import List
app = FastAPI(title="Module 3 - Pydantic")
class User(BaseModel):
username: str
email: EmailStr
age: int
@validator("age")
def age_must_be_positive(cls, v):
if v < 0:
raise ValueError("age must be positive")
return v
class Group(BaseModel):
name: str
members: List[User]
@app.post("/groups/")
def create_group(group: Group):
return {"group": group}
module4 — Dependency injection & simple API key security
module4/main.py
from fastapi import FastAPI, Depends, HTTPException, Header
from typing import Optional
app = FastAPI(title="Module 4 - Dependencies & Security")
async def get_api_key(x_api_key: Optional[str] = Header(None)):
if x_api_key != "secret123":
raise HTTPException(status_code=401, detail="Unauthorized")
return x_api_key
@app.get("/secure")
async def secure_endpoint(api_key: str = Depends(get_api_key)):
return {"message": "Secure data", "api_key": api_key}
# Example of injecting a simple resource (like DB session placeholder)
async def get_db():
# yield a fake resource; replace with real DB session in later modules
yield {"db": "fake-session"}
@app.get("/use-db")
async def use_db(db = Depends(get_db)):
return {"using": db}
module5 — Background tasks, startup/shutdown events, middleware
module5/main.py
from fastapi import FastAPI, BackgroundTasks, Request
import time
app = FastAPI(title="Module 5 - Background & Middleware")
@app.on_event("startup")
def startup():
print("[startup] App is starting")
@app.on_event("shutdown")
def shutdown():
print("[shutdown] App is shutting down")
def write_log(message: str):
with open("module5.log", "a", encoding="utf-8") as f:
f.write(message + "
")
@app.post("/notify")
def notify(background_tasks: BackgroundTasks, msg: str):
background_tasks.add_task(write_log, msg)
return {"status": "scheduled"}
# Simple middleware to log path and duration
@app.middleware("http")
async def log_middleware(request: Request, call_next):
start = time.time()
response = await call_next(request)
duration = time.time() - start
with open("module5_requests.log", "a", encoding="utf-8") as f:
f.write(f"{request.method} {request.url.path} {duration:.4f}s
")
return response
module6 — Database integration (SQLModel + SQLite)
module6/models.py
from sqlmodel import SQLModel, Field
from typing import Optional
class Todo(SQLModel, table=True):
id: Optional[int] = Field(default=None, primary_key=True)
title: str
done: bool = False
module6/db_init.py
from sqlmodel import create_engine, SQLModel
from .models import Todo
sqlite_url = "sqlite:///./module6_todos.db"
engine = create_engine(sqlite_url, echo=False)
def init_db():
SQLModel.metadata.create_all(engine)
module6/main.py
from fastapi import FastAPI, HTTPException
from sqlmodel import Session, select
from .models import Todo
from .db_init import engine, init_db
app = FastAPI(title="Module 6 - SQLModel (SQLite)")
init_db()
@app.post('/todos/')
def create_todo(todo: Todo):
with Session(engine) as session:
session.add(todo)
session.commit()
session.refresh(todo)
return todo
@app.get('/todos/')
def list_todos():
with Session(engine) as session:
todos = session.exec(select(Todo)).all()
return todos
@app.get('/todos/{todo_id}')
def get_todo(todo_id: int):
with Session(engine) as session:
todo = session.get(Todo, todo_id)
if not todo:
raise HTTPException(status_code=404, detail='Not found')
return todo
@app.put('/todos/{todo_id}')
def update_todo(todo_id: int, updated: Todo):
with Session(engine) as session:
todo = session.get(Todo, todo_id)
if not todo:
raise HTTPException(status_code=404, detail='Not found')
todo.title = updated.title
todo.done = updated.done
session.add(todo)
session.commit()
session.refresh(todo)
return todo
@app.delete('/todos/{todo_id}')
def delete_todo(todo_id: int):
with Session(engine) as session:
todo = session.get(Todo, todo_id)
if not todo:
raise HTTPException(status_code=404, detail='Not found')
session.delete(todo)
session.commit()
return {"deleted": todo_id}
module7 — Authentication (OAuth2 password flow + JWT sketch)
module7/users.py
# simple in-memory user store (for demo only)
users_db = {
"alice": {
"username": "alice",
"full_name": "Alice Example",
"email": "alice@example.com",
"hashed_password": "$2b$12$KIX0...", # replace with real bcrypt hash
"disabled": False,
}
}
module7/auth.py
from datetime import datetime, timedelta
from jose import jwt
from passlib.context import CryptContext
SECRET_KEY = "CHANGE_THIS_SECRET"
ALGORITHM = "HS256"
ACCESS_TOKEN_EXPIRE_MINUTES = 30
pwd_context = CryptContext(schemes=["bcrypt"], deprecated="auto")
def verify_password(plain_password, hashed_password):
return pwd_context.verify(plain_password, hashed_password)
def get_password_hash(password):
return pwd_context.hash(password)
def create_access_token(data: dict, expires_delta: timedelta | None = None):
to_encode = data.copy()
if expires_delta:
expire = datetime.utcnow() + expires_delta
else:
expire = datetime.utcnow() + timedelta(minutes=15)
to_encode.update({"exp": expire})
encoded_jwt = jwt.encode(to_encode, SECRET_KEY, algorithm=ALGORITHM)
return encoded_jwt
module7/main.py
from fastapi import FastAPI, Depends, HTTPException, status
from fastapi.security import OAuth2PasswordRequestForm, OAuth2PasswordBearer
from .users import users_db
from .auth import verify_password, create_access_token
from datetime import timedelta
app = FastAPI(title="Module 7 - Auth (JWT)")
oauth2_scheme = OAuth2PasswordBearer(tokenUrl="token")
@app.post('/token')
def login_for_access_token(form_data: OAuth2PasswordRequestForm = Depends()):
user = users_db.get(form_data.username)
if not user:
raise HTTPException(status_code=400, detail='Incorrect username or password')
# NOTE: hashed_password should be real bcrypt hash; for demo assume verify_password returns True
if not verify_password(form_data.password, user.get('hashed_password', '')):
raise HTTPException(status_code=400, detail='Incorrect username or password')
access_token_expires = timedelta(minutes=30)
access_token = create_access_token(data={"sub": user['username']}, expires_delta=access_token_expires)
return {"access_token": access_token, "token_type": "bearer"}
@app.get('/protected')
def protected_route(token: str = Depends(oauth2_scheme)):
return {"token": token}
Note: This module uses a simplified in-memory store and a placeholder bcrypt hash. For real apps, use a DB and properly hash passwords.
