{"id":31802945,"url":"https://github.com/anshsinghsonkhia/masters-in-fastapi","last_synced_at":"2026-05-19T07:31:05.860Z","repository":{"id":305959374,"uuid":"1024517498","full_name":"AnshSinghSonkhia/Masters-in-FastAPI","owner":"AnshSinghSonkhia","description":"A comprehensive guide to master FastAPI for interviews and production applications","archived":false,"fork":false,"pushed_at":"2025-07-23T07:01:02.000Z","size":20,"stargazers_count":0,"open_issues_count":0,"forks_count":0,"subscribers_count":0,"default_branch":"main","last_synced_at":"2025-10-11T00:59:56.868Z","etag":null,"topics":["fastapi","python"],"latest_commit_sha":null,"homepage":"","language":"Python","has_issues":true,"has_wiki":null,"has_pages":null,"mirror_url":null,"source_name":null,"license":"mit","status":null,"scm":"git","pull_requests_enabled":true,"icon_url":"https://github.com/AnshSinghSonkhia.png","metadata":{"files":{"readme":"README.md","changelog":null,"contributing":null,"funding":null,"license":"LICENSE","code_of_conduct":null,"threat_model":null,"audit":null,"citation":null,"codeowners":null,"security":null,"support":null,"governance":null,"roadmap":null,"authors":null,"dei":null,"publiccode":null,"codemeta":null,"zenodo":null}},"created_at":"2025-07-22T20:34:10.000Z","updated_at":"2025-07-23T07:01:45.000Z","dependencies_parsed_at":"2025-07-22T22:37:30.398Z","dependency_job_id":null,"html_url":"https://github.com/AnshSinghSonkhia/Masters-in-FastAPI","commit_stats":null,"previous_names":["anshsinghsonkhia/masters-in-fastapi"],"tags_count":0,"template":false,"template_full_name":null,"purl":"pkg:github/AnshSinghSonkhia/Masters-in-FastAPI","repository_url":"https://repos.ecosyste.ms/api/v1/hosts/GitHub/repositories/AnshSinghSonkhia%2FMasters-in-FastAPI","tags_url":"https://repos.ecosyste.ms/api/v1/hosts/GitHub/repositories/AnshSinghSonkhia%2FMasters-in-FastAPI/tags","releases_url":"https://repos.ecosyste.ms/api/v1/hosts/GitHub/repositories/AnshSinghSonkhia%2FMasters-in-FastAPI/releases","manifests_url":"https://repos.ecosyste.ms/api/v1/hosts/GitHub/repositories/AnshSinghSonkhia%2FMasters-in-FastAPI/manifests","owner_url":"https://repos.ecosyste.ms/api/v1/hosts/GitHub/owners/AnshSinghSonkhia","download_url":"https://codeload.github.com/AnshSinghSonkhia/Masters-in-FastAPI/tar.gz/refs/heads/main","sbom_url":"https://repos.ecosyste.ms/api/v1/hosts/GitHub/repositories/AnshSinghSonkhia%2FMasters-in-FastAPI/sbom","scorecard":null,"host":{"name":"GitHub","url":"https://github.com","kind":"github","repositories_count":286080680,"owners_count":33206276,"icon_url":"https://github.com/github.png","version":null,"created_at":"2022-05-30T11:31:42.601Z","updated_at":"2026-05-19T07:16:55.748Z","status":"ssl_error","status_checked_at":"2026-05-19T07:16:54.366Z","response_time":58,"last_error":"SSL_read: unexpected eof while reading","robots_txt_status":"success","robots_txt_updated_at":"2025-07-24T06:49:26.215Z","robots_txt_url":"https://github.com/robots.txt","online":false,"can_crawl_api":true,"host_url":"https://repos.ecosyste.ms/api/v1/hosts/GitHub","repositories_url":"https://repos.ecosyste.ms/api/v1/hosts/GitHub/repositories","repository_names_url":"https://repos.ecosyste.ms/api/v1/hosts/GitHub/repository_names","owners_url":"https://repos.ecosyste.ms/api/v1/hosts/GitHub/owners"}},"keywords":["fastapi","python"],"created_at":"2025-10-11T00:59:45.278Z","updated_at":"2026-05-19T07:31:05.853Z","avatar_url":"https://github.com/AnshSinghSonkhia.png","language":"Python","funding_links":[],"categories":[],"sub_categories":[],"readme":"# 🚀 Masters in FastAPI\n\n\u003e A comprehensive guide to master FastAPI for interviews and production applications\n\n[![FastAPI](https://img.shields.io/badge/FastAPI-005571?style=for-the-badge\u0026logo=fastapi)](https://fastapi.tiangolo.com/) [![Python](https://img.shields.io/badge/python-3670A0?style=for-the-badge\u0026logo=python\u0026logoColor=ffdd54)](https://www.python.org/)\n---\n\n## 📚 Table of Contents\n\n- [Introduction](#-introduction)\n- [Core Concepts](#-core-concepts)\n- [Request Handling](#-request-handling)\n- [Response Models](#-response-models)\n- [Dependency Injection](#-dependency-injection)\n- [Database Integration](#-database-integration)\n- [Authentication \u0026 Security](#-authentication--security)\n- [Background Tasks \u0026 WebSockets](#-background-tasks--websockets)\n- [Testing](#-testing)\n- [Performance \u0026 Optimization](#-performance--optimization)\n- [Deployment](#-deployment)\n- [Advanced Features](#-advanced-features)\n- [Common Interview Questions](#-common-interview-questions)\n- [Best Practices](#-best-practices)\n- [Troubleshooting](#-troubleshooting)\n\n---\n\n## 🌟 Introduction\n\n### What is FastAPI?\n- **Modern Python Web Framework** - Built on Starlette and Pydantic\n- **High Performance** - On par with NodeJS and Go\n- **Easy to Use** - Intuitive and pythonic\n- **Standards-based** - OpenAPI, JSON Schema, OAuth2\n- **Type Hints** - Full editor support with autocompletion\n\n### Why FastAPI?\n- ✅ **Fast Development** - Less code, fewer bugs\n- ✅ **Fast Performance** - Starlette + Pydantic + Python 3.7+\n- ✅ **Auto Documentation** - Swagger UI \u0026 ReDoc\n- ✅ **Type Safety** - Python type hints validation\n- ✅ **Async Support** - Built-in asynchronous capabilities\n- ✅ **Production Ready** - Used by Microsoft, Uber, Netflix\n- ✅ **Great DX** - Editor support, debugging, less time reading docs\n\n### FastAPI vs Others\n```python\n# FastAPI vs Flask\n- FastAPI: Async, automatic validation, auto docs\n- Flask: Mature, simple, large ecosystem\n\n# FastAPI vs Django\n- FastAPI: API-focused, modern, fast\n- Django: Full-stack, batteries included, admin panel\n\n# FastAPI vs Express.js\n- FastAPI: Type safety, auto validation, Python\n- Express: JavaScript, minimal, flexible\n```\n\n---\n\n## 🎯 Core Concepts\n\n### Basic Application Structure\n\n#### Minimal App\n```python\nfrom fastapi import FastAPI\n\napp = FastAPI()\n\n@app.get(\"/\")\ndef read_root():\n    return {\"Hello\": \"World\"}\n\n# Run with: uvicorn main:app --reload\n```\n\n#### With Async\n```python\nfrom fastapi import FastAPI\n\napp = FastAPI()\n\n@app.get(\"/\")\nasync def read_root():\n    return {\"Hello\": \"Async World\"}\n```\n\n### Path Operations\n\n#### HTTP Methods\n```python\n@app.get(\"/items/\")         # GET - Retrieve data\n@app.post(\"/items/\")        # POST - Create data\n@app.put(\"/items/{id}\")     # PUT - Update data\n@app.patch(\"/items/{id}\")   # PATCH - Partial update\n@app.delete(\"/items/{id}\")  # DELETE - Remove data\n```\n\n#### Path Parameters\n```python\n@app.get(\"/users/{user_id}\")\nasync def read_user(user_id: int):\n    return {\"user_id\": user_id}\n\n# Enum path parameters\nfrom enum import Enum\n\nclass ModelName(str, Enum):\n    alexnet = \"alexnet\"\n    resnet = \"resnet\"\n    lenet = \"lenet\"\n\n@app.get(\"/models/{model_name}\")\nasync def get_model(model_name: ModelName):\n    return {\"model\": model_name}\n```\n\n#### Query Parameters\n```python\n# Optional parameters with defaults\n@app.get(\"/items/\")\nasync def read_items(skip: int = 0, limit: int = 10):\n    return {\"skip\": skip, \"limit\": limit}\n\n# Required query parameters\n@app.get(\"/items/search\")\nasync def search_items(q: str):\n    return {\"query\": q}\n\n# Optional with None\nfrom typing import Optional\n\n@app.get(\"/items/{item_id}\")\nasync def read_item(item_id: int, q: Optional[str] = None):\n    return {\"item_id\": item_id, \"q\": q}\n```\n\n### Request Body\n\n#### Pydantic Models\n```python\nfrom pydantic import BaseModel\nfrom typing import Optional\nfrom datetime import datetime\n\nclass Item(BaseModel):\n    name: str\n    price: float\n    description: Optional[str] = None\n    tax: Optional[float] = None\n    tags: list[str] = []\n    created_at: datetime = datetime.now()\n\n@app.post(\"/items/\")\nasync def create_item(item: Item):\n    return {\"item\": item}\n```\n\n#### Nested Models\n```python\nclass Image(BaseModel):\n    url: str\n    name: str\n\nclass Product(BaseModel):\n    name: str\n    price: float\n    images: list[Image] = []\n\n@app.post(\"/products/\")\nasync def create_product(product: Product):\n    return product\n```\n\n---\n\n## 📥 Request Handling\n\n### Multiple Parameters\n\n#### Combined Parameters\n```python\n@app.put(\"/items/{item_id}\")\nasync def update_item(\n    item_id: int,                    # Path parameter\n    item: Item,                      # Request body\n    q: Optional[str] = None         # Query parameter\n):\n    result = {\"item_id\": item_id, **item.dict()}\n    if q:\n        result.update({\"q\": q})\n    return result\n```\n\n### Form Data\n```python\nfrom fastapi import Form\n\n@app.post(\"/login/\")\nasync def login(\n    username: str = Form(...), \n    password: str = Form(...)\n):\n    return {\"username\": username}\n```\n\n### File Uploads\n```python\nfrom fastapi import File, UploadFile\n\n# Single file\n@app.post(\"/uploadfile/\")\nasync def create_upload_file(file: UploadFile = File(...)):\n    contents = await file.read()\n    return {\n        \"filename\": file.filename,\n        \"content_type\": file.content_type,\n        \"size\": len(contents)\n    }\n\n# Multiple files\n@app.post(\"/uploadfiles/\")\nasync def create_upload_files(\n    files: list[UploadFile] = File(...)\n):\n    return {\"filenames\": [file.filename for file in files]}\n```\n\n### Request Headers\n```python\nfrom fastapi import Header\nfrom typing import Optional\n\n@app.get(\"/items/\")\nasync def read_items(\n    user_agent: Optional[str] = Header(None),\n    x_token: Optional[str] = Header(None)\n):\n    return {\n        \"User-Agent\": user_agent,\n        \"X-Token\": x_token\n    }\n```\n\n### Cookies\n```python\nfrom fastapi import Cookie\nfrom typing import Optional\n\n@app.get(\"/items/\")\nasync def read_items(\n    session_id: Optional[str] = Cookie(None)\n):\n    return {\"session_id\": session_id}\n```\n\n---\n\n## 📤 Response Models\n\n### Response Model\n```python\nclass UserIn(BaseModel):\n    username: str\n    password: str\n    email: str\n    full_name: Optional[str] = None\n\nclass UserOut(BaseModel):\n    username: str\n    email: str\n    full_name: Optional[str] = None\n\n@app.post(\"/users/\", response_model=UserOut)\nasync def create_user(user: UserIn):\n    # Password not included in response\n    return user\n```\n\n### Response Status Codes\n```python\nfrom fastapi import status\n\n@app.post(\"/items/\", status_code=status.HTTP_201_CREATED)\nasync def create_item(item: Item):\n    return item\n\n# Custom status code\n@app.delete(\"/items/{item_id}\", status_code=204)\nasync def delete_item(item_id: int):\n    return None\n```\n\n### Multiple Response Models\n```python\nfrom typing import Union\n\nclass ItemBasic(BaseModel):\n    name: str\n    price: float\n\nclass ItemDetailed(BaseModel):\n    name: str\n    price: float\n    description: str\n    tax: float\n\n@app.get(\"/items/{item_id}\", response_model=Union[ItemBasic, ItemDetailed])\nasync def read_item(item_id: int, detailed: bool = False):\n    if detailed:\n        return ItemDetailed(...)\n    return ItemBasic(...)\n```\n\n### Response Headers\n```python\nfrom fastapi import Response\n\n@app.get(\"/legacy/\")\nasync def get_legacy_data(response: Response):\n    response.headers[\"X-Cat-Dog\"] = \"alone in the world\"\n    return {\"message\": \"Hello World\"}\n```\n\n---\n\n## 💉 Dependency Injection\n\n### Basic Dependencies\n```python\nfrom fastapi import Depends\n\nasync def common_parameters(\n    q: Optional[str] = None, \n    skip: int = 0, \n    limit: int = 100\n):\n    return {\"q\": q, \"skip\": skip, \"limit\": limit}\n\n@app.get(\"/items/\")\nasync def read_items(commons: dict = Depends(common_parameters)):\n    return commons\n```\n\n### Class Dependencies\n```python\nclass CommonQueryParams:\n    def __init__(self, q: Optional[str] = None, skip: int = 0, limit: int = 100):\n        self.q = q\n        self.skip = skip\n        self.limit = limit\n\n@app.get(\"/items/\")\nasync def read_items(commons: CommonQueryParams = Depends()):\n    return commons\n```\n\n### Sub-dependencies\n```python\ndef query_extractor(q: Optional[str] = None):\n    return q\n\ndef query_or_default(q: str = Depends(query_extractor)):\n    if not q:\n        return \"default\"\n    return q\n\n@app.get(\"/items/\")\nasync def read_items(query: str = Depends(query_or_default)):\n    return {\"query\": query}\n```\n\n### Dependency with Yield\n```python\nasync def get_db():\n    db = DBSession()\n    try:\n        yield db\n    finally:\n        db.close()\n\n@app.get(\"/users/\")\nasync def read_users(db: Session = Depends(get_db)):\n    return db.query(User).all()\n```\n\n### Global Dependencies\n```python\nasync def verify_token(x_token: str = Header(...)):\n    if x_token != \"fake-super-secret-token\":\n        raise HTTPException(status_code=400, detail=\"X-Token header invalid\")\n\n# Apply to entire app\napp = FastAPI(dependencies=[Depends(verify_token)])\n\n# Or to a router\nfrom fastapi import APIRouter\n\nrouter = APIRouter(dependencies=[Depends(verify_token)])\n```\n\n---\n\n## 🗄️ Database Integration\n\n### SQLAlchemy Setup\n\n#### Database Configuration\n```python\nfrom sqlalchemy import create_engine\nfrom sqlalchemy.ext.declarative import declarative_base\nfrom sqlalchemy.orm import sessionmaker\n\nSQLALCHEMY_DATABASE_URL = \"postgresql://user:password@localhost/dbname\"\n# For SQLite: \"sqlite:///./test.db\"\n\nengine = create_engine(SQLALCHEMY_DATABASE_URL)\nSessionLocal = sessionmaker(autocommit=False, autoflush=False, bind=engine)\n\nBase = declarative_base()\n```\n\n#### Models\n```python\nfrom sqlalchemy import Column, Integer, String, Float, Boolean, ForeignKey\nfrom sqlalchemy.orm import relationship\n\nclass User(Base):\n    __tablename__ = \"users\"\n\n    id = Column(Integer, primary_key=True, index=True)\n    email = Column(String, unique=True, index=True)\n    hashed_password = Column(String)\n    is_active = Column(Boolean, default=True)\n    \n    items = relationship(\"Item\", back_populates=\"owner\")\n\nclass Item(Base):\n    __tablename__ = \"items\"\n\n    id = Column(Integer, primary_key=True, index=True)\n    title = Column(String, index=True)\n    description = Column(String, index=True)\n    price = Column(Float)\n    owner_id = Column(Integer, ForeignKey(\"users.id\"))\n    \n    owner = relationship(\"User\", back_populates=\"items\")\n```\n\n#### Pydantic Schemas\n```python\nfrom pydantic import BaseModel\nfrom typing import Optional\n\n# User schemas\nclass UserBase(BaseModel):\n    email: str\n\nclass UserCreate(UserBase):\n    password: str\n\nclass User(UserBase):\n    id: int\n    is_active: bool\n    items: list[Item] = []\n\n    class Config:\n        orm_mode = True\n\n# Item schemas\nclass ItemBase(BaseModel):\n    title: str\n    description: Optional[str] = None\n    price: float\n\nclass ItemCreate(ItemBase):\n    pass\n\nclass Item(ItemBase):\n    id: int\n    owner_id: int\n\n    class Config:\n        orm_mode = True\n```\n\n#### CRUD Operations\n```python\nfrom sqlalchemy.orm import Session\n\n# User CRUD\ndef get_user(db: Session, user_id: int):\n    return db.query(User).filter(User.id == user_id).first()\n\ndef get_user_by_email(db: Session, email: str):\n    return db.query(User).filter(User.email == email).first()\n\ndef create_user(db: Session, user: UserCreate):\n    fake_hashed_password = user.password + \"notreallyhashed\"\n    db_user = User(email=user.email, hashed_password=fake_hashed_password)\n    db.add(db_user)\n    db.commit()\n    db.refresh(db_user)\n    return db_user\n\n# Item CRUD\ndef create_user_item(db: Session, item: ItemCreate, user_id: int):\n    db_item = Item(**item.dict(), owner_id=user_id)\n    db.add(db_item)\n    db.commit()\n    db.refresh(db_item)\n    return db_item\n```\n\n### Async Database (SQLAlchemy 2.0)\n```python\nfrom sqlalchemy.ext.asyncio import create_async_engine, AsyncSession\nfrom sqlalchemy.orm import sessionmaker\n\n# Async engine\nengine = create_async_engine(\"postgresql+asyncpg://user:pass@localhost/db\")\nasync_session = sessionmaker(engine, class_=AsyncSession, expire_on_commit=False)\n\n# Async dependency\nasync def get_async_db():\n    async with async_session() as session:\n        yield session\n\n# Async query\n@app.get(\"/users/{user_id}\")\nasync def read_user(user_id: int, db: AsyncSession = Depends(get_async_db)):\n    result = await db.execute(select(User).where(User.id == user_id))\n    user = result.scalar_one_or_none()\n    if not user:\n        raise HTTPException(status_code=404, detail=\"User not found\")\n    return user\n```\n\n### MongoDB Integration\n```python\nfrom motor.motor_asyncio import AsyncIOMotorClient\nfrom beanie import Document, init_beanie\n\n# MongoDB client\nclient = AsyncIOMotorClient(\"mongodb://localhost:27017\")\ndatabase = client.mydatabase\n\n# Beanie Document\nclass User(Document):\n    email: str\n    name: str\n    is_active: bool = True\n\n    class Settings:\n        collection = \"users\"\n\n# Initialize Beanie\n@app.on_event(\"startup\")\nasync def startup_event():\n    await init_beanie(database=database, document_models=[User])\n\n# CRUD with Beanie\n@app.post(\"/users/\")\nasync def create_user(user: User):\n    await user.insert()\n    return user\n\n@app.get(\"/users/{user_id}\")\nasync def read_user(user_id: str):\n    user = await User.get(user_id)\n    if not user:\n        raise HTTPException(status_code=404)\n    return user\n```\n\n---\n\n## 🔐 Authentication \u0026 Security\n\n### Password Hashing\n```python\nfrom passlib.context import CryptContext\n\npwd_context = CryptContext(schemes=[\"bcrypt\"], deprecated=\"auto\")\n\ndef verify_password(plain_password, hashed_password):\n    return pwd_context.verify(plain_password, hashed_password)\n\ndef get_password_hash(password):\n    return pwd_context.hash(password)\n```\n\n### JWT Token Authentication\n```python\nfrom datetime import datetime, timedelta\nfrom typing import Optional\nfrom jose import JWTError, jwt\nfrom fastapi import HTTPException, status, Depends\nfrom fastapi.security import OAuth2PasswordBearer, OAuth2PasswordRequestForm\n\nSECRET_KEY = \"your-secret-key-here\"\nALGORITHM = \"HS256\"\nACCESS_TOKEN_EXPIRE_MINUTES = 30\n\noauth2_scheme = OAuth2PasswordBearer(tokenUrl=\"token\")\n\ndef create_access_token(data: dict, expires_delta: Optional[timedelta] = None):\n    to_encode = data.copy()\n    if expires_delta:\n        expire = datetime.utcnow() + expires_delta\n    else:\n        expire = datetime.utcnow() + timedelta(minutes=15)\n    to_encode.update({\"exp\": expire})\n    encoded_jwt = jwt.encode(to_encode, SECRET_KEY, algorithm=ALGORITHM)\n    return encoded_jwt\n\nasync def get_current_user(token: str = Depends(oauth2_scheme)):\n    credentials_exception = HTTPException(\n        status_code=status.HTTP_401_UNAUTHORIZED,\n        detail=\"Could not validate credentials\",\n        headers={\"WWW-Authenticate\": \"Bearer\"},\n    )\n    try:\n        payload = jwt.decode(token, SECRET_KEY, algorithms=[ALGORITHM])\n        username: str = payload.get(\"sub\")\n        if username is None:\n            raise credentials_exception\n    except JWTError:\n        raise credentials_exception\n    user = get_user(username=username)\n    if user is None:\n        raise credentials_exception\n    return user\n\n@app.post(\"/token\")\nasync def login(form_data: OAuth2PasswordRequestForm = Depends()):\n    user = authenticate_user(form_data.username, form_data.password)\n    if not user:\n        raise HTTPException(\n            status_code=status.HTTP_401_UNAUTHORIZED,\n            detail=\"Incorrect username or password\",\n            headers={\"WWW-Authenticate\": \"Bearer\"},\n        )\n    access_token_expires = timedelta(minutes=ACCESS_TOKEN_EXPIRE_MINUTES)\n    access_token = create_access_token(\n        data={\"sub\": user.username}, expires_delta=access_token_expires\n    )\n    return {\"access_token\": access_token, \"token_type\": \"bearer\"}\n\n@app.get(\"/users/me\")\nasync def read_users_me(current_user: User = Depends(get_current_user)):\n    return current_user\n```\n\n### OAuth2 with Scopes\n```python\nfrom fastapi.security import OAuth2PasswordBearer, SecurityScopes\n\noauth2_scheme = OAuth2PasswordBearer(\n    tokenUrl=\"token\",\n    scopes={\"read\": \"Read access\", \"write\": \"Write access\"}\n)\n\nasync def get_current_user(\n    security_scopes: SecurityScopes, \n    token: str = Depends(oauth2_scheme)\n):\n    # Verify token and check scopes\n    authenticate_value = f'Bearer scope=\"{security_scopes.scope_str}\"'\n    # ... token validation logic\n    \n    for scope in security_scopes.scopes:\n        if scope not in token_scopes:\n            raise HTTPException(\n                status_code=status.HTTP_401_UNAUTHORIZED,\n                detail=\"Not enough permissions\",\n                headers={\"WWW-Authenticate\": authenticate_value},\n            )\n    return user\n\n@app.get(\"/items/\", dependencies=[Security(get_current_user, scopes=[\"read\"])])\nasync def read_items():\n    return [{\"item\": \"Foo\"}, {\"item\": \"Bar\"}]\n```\n\n### API Key Authentication\n```python\nfrom fastapi.security import APIKeyHeader, APIKeyQuery, HTTPBearer\nfrom fastapi import Security\n\n# Header-based API Key\napi_key_header = APIKeyHeader(name=\"X-API-Key\")\n\n@app.get(\"/protected\")\nasync def protected_route(api_key: str = Security(api_key_header)):\n    if api_key != \"secret-api-key\":\n        raise HTTPException(status_code=403, detail=\"Invalid API Key\")\n    return {\"message\": \"Access granted\"}\n\n# Query-based API Key\napi_key_query = APIKeyQuery(name=\"api_key\")\n\n@app.get(\"/query-protected\")\nasync def query_protected(api_key: str = Security(api_key_query)):\n    # Validate API key\n    return {\"message\": \"Access granted\"}\n```\n\n### CORS Configuration\n```python\nfrom fastapi.middleware.cors import CORSMiddleware\n\norigins = [\n    \"http://localhost:3000\",\n    \"https://mydomain.com\",\n]\n\napp.add_middleware(\n    CORSMiddleware,\n    allow_origins=origins,\n    allow_credentials=True,\n    allow_methods=[\"*\"],\n    allow_headers=[\"*\"],\n)\n```\n\n---\n\n## 🔄 Background Tasks \u0026 WebSockets\n\n### Background Tasks\n```python\nfrom fastapi import BackgroundTasks\nimport time\n\ndef write_notification(email: str, message=\"\"):\n    time.sleep(10)  # Simulate slow operation\n    with open(\"log.txt\", mode=\"a\") as file:\n        file.write(f\"notification sent to {email}: {message}\\n\")\n\n@app.post(\"/send-notification/{email}\")\nasync def send_notification(\n    email: str, \n    background_tasks: BackgroundTasks\n):\n    background_tasks.add_task(write_notification, email, message=\"some notification\")\n    return {\"message\": \"Notification sent in the background\"}\n```\n\n### Celery Integration\n```python\nfrom celery import Celery\n\ncelery_app = Celery(\n    \"worker\",\n    broker=\"redis://localhost:6379/0\",\n    backend=\"redis://localhost:6379/0\"\n)\n\n@celery_app.task\ndef process_data(data: dict):\n    # Long running task\n    time.sleep(60)\n    return {\"status\": \"completed\", \"data\": data}\n\n@app.post(\"/process/\")\nasync def process_endpoint(data: dict):\n    task = process_data.delay(data)\n    return {\"task_id\": task.id}\n\n@app.get(\"/task/{task_id}\")\nasync def get_task_status(task_id: str):\n    task = process_data.AsyncResult(task_id)\n    return {\n        \"task_id\": task_id,\n        \"status\": task.status,\n        \"result\": task.result\n    }\n```\n\n### WebSockets\n```python\nfrom fastapi import WebSocket, WebSocketDisconnect\n\nclass ConnectionManager:\n    def __init__(self):\n        self.active_connections: list[WebSocket] = []\n\n    async def connect(self, websocket: WebSocket):\n        await websocket.accept()\n        self.active_connections.append(websocket)\n\n    def disconnect(self, websocket: WebSocket):\n        self.active_connections.remove(websocket)\n\n    async def send_personal_message(self, message: str, websocket: WebSocket):\n        await websocket.send_text(message)\n\n    async def broadcast(self, message: str):\n        for connection in self.active_connections:\n            await connection.send_text(message)\n\nmanager = ConnectionManager()\n\n@app.websocket(\"/ws/{client_id}\")\nasync def websocket_endpoint(websocket: WebSocket, client_id: int):\n    await manager.connect(websocket)\n    try:\n        while True:\n            data = await websocket.receive_text()\n            await manager.send_personal_message(f\"You wrote: {data}\", websocket)\n            await manager.broadcast(f\"Client #{client_id} says: {data}\")\n    except WebSocketDisconnect:\n        manager.disconnect(websocket)\n        await manager.broadcast(f\"Client #{client_id} left the chat\")\n```\n\n---\n\n## 🧪 Testing\n\n### Basic Testing\n```python\nfrom fastapi.testclient import TestClient\n\nclient = TestClient(app)\n\ndef test_read_main():\n    response = client.get(\"/\")\n    assert response.status_code == 200\n    assert response.json() == {\"Hello\": \"World\"}\n\ndef test_create_item():\n    response = client.post(\n        \"/items/\",\n        json={\"name\": \"Test Item\", \"price\": 10.5}\n    )\n    assert response.status_code == 200\n    assert response.json()[\"name\"] == \"Test Item\"\n```\n\n### Async Testing\n```python\nimport pytest\nfrom httpx import AsyncClient\n\n@pytest.mark.anyio\nasync def test_async_endpoint():\n    async with AsyncClient(app=app, base_url=\"http://test\") as client:\n        response = await client.get(\"/\")\n        assert response.status_code == 200\n```\n\n### Database Testing\n```python\nfrom sqlalchemy import create_engine\nfrom sqlalchemy.orm import sessionmaker\n\n# Test database\nTEST_SQLALCHEMY_DATABASE_URL = \"sqlite:///./test.db\"\nengine = create_engine(TEST_SQLALCHEMY_DATABASE_URL, connect_args={\"check_same_thread\": False})\nTestingSessionLocal = sessionmaker(autocommit=False, autoflush=False, bind=engine)\n\ndef override_get_db():\n    try:\n        db = TestingSessionLocal()\n        yield db\n    finally:\n        db.close()\n\napp.dependency_overrides[get_db] = override_get_db\n\n# Run tests\ndef test_create_user():\n    response = client.post(\"/users/\", json={\"email\": \"test@example.com\", \"password\": \"secret\"})\n    assert response.status_code == 200\n    assert response.json()[\"email\"] == \"test@example.com\"\n```\n\n### Testing Authentication\n```python\ndef test_login():\n    response = client.post(\"/token\", data={\"username\": \"testuser\", \"password\": \"testpass\"})\n    assert response.status_code == 200\n    assert \"access_token\" in response.json()\n\ndef test_protected_route():\n    # Get token\n    login_response = client.post(\"/token\", data={\"username\": \"testuser\", \"password\": \"testpass\"})\n    token = login_response.json()[\"access_token\"]\n    \n    # Access protected route\n    response = client.get(\"/users/me\", headers={\"Authorization\": f\"Bearer {token}\"})\n    assert response.status_code == 200\n```\n\n---\n\n## ⚡ Performance \u0026 Optimization\n\n### Async Best Practices\n```python\nimport asyncio\nimport aiohttp\nfrom concurrent.futures import ThreadPoolExecutor\n\n# Don't block the event loop\nexecutor = ThreadPoolExecutor(max_workers=5)\n\n@app.get(\"/cpu-bound\")\nasync def cpu_bound_task():\n    loop = asyncio.get_event_loop()\n    # Run CPU-bound task in thread pool\n    result = await loop.run_in_executor(executor, cpu_intensive_function)\n    return {\"result\": result}\n\n# Use async libraries\n@app.get(\"/fetch-data\")\nasync def fetch_external_data():\n    async with aiohttp.ClientSession() as session:\n        async with session.get('https://api.example.com/data') as response:\n            return await response.json()\n\n# Concurrent requests\n@app.get(\"/aggregate\")\nasync def aggregate_data():\n    tasks = [\n        fetch_user_data(1),\n        fetch_order_data(1),\n        fetch_payment_data(1)\n    ]\n    results = await asyncio.gather(*tasks)\n    return {\"user\": results[0], \"orders\": results[1], \"payments\": results[2]}\n```\n\n### Caching\n```python\nfrom fastapi_cache import FastAPICache\nfrom fastapi_cache.decorator import cache\nfrom fastapi_cache.backends.redis import RedisBackend\n\n# Initialize cache\n@app.on_event(\"startup\")\nasync def startup():\n    redis = aioredis.from_url(\"redis://localhost\", encoding=\"utf8\", decode_responses=True)\n    FastAPICache.init(RedisBackend(redis), prefix=\"fastapi-cache\")\n\n# Cache endpoint results\n@app.get(\"/expensive-calculation\")\n@cache(expire=60)  # Cache for 60 seconds\nasync def expensive_calculation(param: int):\n    # Simulate expensive operation\n    await asyncio.sleep(5)\n    return {\"result\": param * 2}\n\n# Manual caching\nfrom functools import lru_cache\n\n@lru_cache(maxsize=128)\ndef get_settings():\n    return Settings()\n\n@app.get(\"/settings\")\nasync def read_settings(settings: Settings = Depends(get_settings)):\n    return settings\n```\n\n### Database Connection Pooling\n```python\n# SQLAlchemy connection pool\nengine = create_engine(\n    SQLALCHEMY_DATABASE_URL,\n    pool_size=20,           # Number of connections to maintain\n    max_overflow=0,         # Maximum overflow connections\n    pool_pre_ping=True,     # Test connections before using\n    pool_recycle=3600       # Recycle connections after 1 hour\n)\n\n# Async connection pool\nfrom databases import Database\n\ndatabase = Database(DATABASE_URL, min_size=10, max_size=20)\n\n@app.on_event(\"startup\")\nasync def startup():\n    await database.connect()\n\n@app.on_event(\"shutdown\")\nasync def shutdown():\n    await database.disconnect()\n```\n\n### Response Optimization\n```python\nfrom fastapi.responses import ORJSONResponse\nimport orjson\n\n# Use faster JSON serializer\napp = FastAPI(default_response_class=ORJSONResponse)\n\n# Streaming responses for large data\nfrom fastapi.responses import StreamingResponse\n\nasync def generate_large_csv():\n    for i in range(1000000):\n        yield f\"{i},data_{i}\\n\"\n\n@app.get(\"/download-csv\")\nasync def download_csv():\n    return StreamingResponse(\n        generate_large_csv(),\n        media_type=\"text/csv\",\n        headers={\"Content-Disposition\": \"attachment; filename=data.csv\"}\n    )\n\n# Compression middleware\nfrom fastapi.middleware.gzip import GZipMiddleware\n\napp.add_middleware(GZipMiddleware, minimum_size=1000)\n```\n\n### Pagination\n```python\nfrom fastapi import Query\n\nclass PaginationParams:\n    def __init__(\n        self,\n        page: int = Query(1, ge=1, description=\"Page number\"),\n        size: int = Query(50, ge=1, le=100, description=\"Page size\")\n    ):\n        self.page = page\n        self.size = size\n        self.skip = (page - 1) * size\n\n@app.get(\"/items/\")\nasync def read_items(\n    pagination: PaginationParams = Depends(),\n    db: Session = Depends(get_db)\n):\n    items = db.query(Item).offset(pagination.skip).limit(pagination.size).all()\n    total = db.query(Item).count()\n    \n    return {\n        \"items\": items,\n        \"total\": total,\n        \"page\": pagination.page,\n        \"size\": pagination.size,\n        \"pages\": (total + pagination.size - 1) // pagination.size\n    }\n```\n\n---\n\n## 🚀 Deployment\n\n### Production Server Setup\n\n#### Gunicorn with Uvicorn Workers\n```bash\n# Install\npip install gunicorn uvicorn[standard]\n\n# Run with Gunicorn\ngunicorn main:app -w 4 -k uvicorn.workers.UvicornWorker --bind 0.0.0.0:8000\n\n# With configuration file (gunicorn.conf.py)\nbind = \"0.0.0.0:8000\"\nworkers = 4\nworker_class = \"uvicorn.workers.UvicornWorker\"\nloglevel = \"info\"\naccesslog = \"/var/log/gunicorn/access.log\"\nerrorlog = \"/var/log/gunicorn/error.log\"\n```\n\n#### Systemd Service\n```ini\n# /etc/systemd/system/fastapi.service\n[Unit]\nDescription=FastAPI app\nAfter=network.target\n\n[Service]\nType=forking\nUser=www-data\nGroup=www-data\nWorkingDirectory=/var/www/app\nEnvironment=\"PATH=/var/www/app/venv/bin\"\nExecStart=/var/www/app/venv/bin/gunicorn main:app \\\n          --workers 4 \\\n          --worker-class uvicorn.workers.UvicornWorker \\\n          --bind unix:/var/www/app/fastapi.sock \\\n          --daemon\n\n[Install]\nWantedBy=multi-user.target\n```\n\n### Docker Deployment\n\n#### Dockerfile\n```dockerfile\nFROM python:3.11-slim\n\nWORKDIR /app\n\n# Install dependencies\nCOPY requirements.txt .\nRUN pip install --no-cache-dir -r requirements.txt\n\n# Copy app\nCOPY . .\n\n# Run with uvicorn\nCMD [\"uvicorn\", \"main:app\", \"--host\", \"0.0.0.0\", \"--port\", \"8000\"]\n```\n\n#### Multi-stage Build\n```dockerfile\n# Build stage\nFROM python:3.11-slim as builder\n\nWORKDIR /app\nCOPY requirements.txt .\nRUN pip install --user --no-cache-dir -r requirements.txt\n\n# Runtime stage\nFROM python:3.11-slim\n\nWORKDIR /app\n\n# Copy dependencies from builder\nCOPY --from=builder /root/.local /root/.local\nENV PATH=/root/.local/bin:$PATH\n\n# Copy application\nCOPY . .\n\n# Run with gunicorn\nCMD [\"gunicorn\", \"main:app\", \"-w\", \"4\", \"-k\", \"uvicorn.workers.UvicornWorker\", \"--bind\", \"0.0.0.0:8000\"]\n```\n\n#### Docker Compose\n```yaml\nversion: '3.8'\n\nservices:\n  web:\n    build: .\n    ports:\n      - \"8000:8000\"\n    environment:\n      - DATABASE_URL=postgresql://user:pass@db:5432/dbname\n      - REDIS_URL=redis://redis:6379\n    depends_on:\n      - db\n      - redis\n    volumes:\n      - ./app:/app\n    command: uvicorn main:app --host 0.0.0.0 --port 8000 --reload\n\n  db:\n    image: postgres:15\n    environment:\n      - POSTGRES_USER=user\n      - POSTGRES_PASSWORD=pass\n      - POSTGRES_DB=dbname\n    volumes:\n      - postgres_data:/var/lib/postgresql/data\n\n  redis:\n    image: redis:alpine\n\n  nginx:\n    image: nginx:alpine\n    ports:\n      - \"80:80\"\n    volumes:\n      - ./nginx.conf:/etc/nginx/nginx.conf\n    depends_on:\n      - web\n\nvolumes:\n  postgres_data:\n```\n\n### Nginx Configuration\n```nginx\nupstream app {\n    server web:8000;\n}\n\nserver {\n    listen 80;\n    server_name example.com;\n\n    location / {\n        proxy_pass http://app;\n        proxy_set_header Host $host;\n        proxy_set_header X-Real-IP $remote_addr;\n        proxy_set_header X-Forwarded-For $proxy_add_x_forwarded_for;\n        proxy_set_header X-Forwarded-Proto $scheme;\n    }\n\n    location /static {\n        alias /var/www/static;\n    }\n\n    # WebSocket support\n    location /ws {\n        proxy_pass http://app;\n        proxy_http_version 1.1;\n        proxy_set_header Upgrade $http_upgrade;\n        proxy_set_header Connection \"upgrade\";\n    }\n}\n```\n\n### Kubernetes Deployment\n```yaml\napiVersion: apps/v1\nkind: Deployment\nmetadata:\n  name: fastapi-app\nspec:\n  replicas: 3\n  selector:\n    matchLabels:\n      app: fastapi\n  template:\n    metadata:\n      labels:\n        app: fastapi\n    spec:\n      containers:\n      - name: fastapi\n        image: myregistry/fastapi-app:latest\n        ports:\n        - containerPort: 8000\n        env:\n        - name: DATABASE_URL\n          valueFrom:\n            secretKeyRef:\n              name: app-secrets\n              key: database-url\n        resources:\n          requests:\n            memory: \"256Mi\"\n            cpu: \"250m\"\n          limits:\n            memory: \"512Mi\"\n            cpu: \"500m\"\n---\napiVersion: v1\nkind: Service\nmetadata:\n  name: fastapi-service\nspec:\n  selector:\n    app: fastapi\n  ports:\n    - port: 80\n      targetPort: 8000\n  type: LoadBalancer\n```\n\n---\n\n## 🔧 Advanced Features\n\n### Custom Middleware\n```python\nimport time\nfrom fastapi import Request\n\n@app.middleware(\"http\")\nasync def add_process_time_header(request: Request, call_next):\n    start_time = time.time()\n    response = await call_next(request)\n    process_time = time.time() - start_time\n    response.headers[\"X-Process-Time\"] = str(process_time)\n    return response\n\n# Class-based middleware\nclass LoggingMiddleware:\n    def __init__(self, app):\n        self.app = app\n\n    async def __call__(self, scope, receive, send):\n        if scope[\"type\"] == \"http\":\n            path = scope[\"path\"]\n            print(f\"Request to {path}\")\n        await self.app(scope, receive, send)\n\napp.add_middleware(LoggingMiddleware)\n```\n\n### Event Handlers\n```python\n@app.on_event(\"startup\")\nasync def startup_event():\n    # Initialize database connections\n    await database.connect()\n    # Load ML models\n    app.state.model = load_model()\n    # Start background tasks\n    asyncio.create_task(periodic_task())\n\n@app.on_event(\"shutdown\")\nasync def shutdown_event():\n    # Close database connections\n    await database.disconnect()\n    # Clean up resources\n    await cleanup()\n\n# Lifespan context manager (newer approach)\nfrom contextlib import asynccontextmanager\n\n@asynccontextmanager\nasync def lifespan(app: FastAPI):\n    # Startup\n    await database.connect()\n    yield\n    # Shutdown\n    await database.disconnect()\n\napp = FastAPI(lifespan=lifespan)\n```\n\n### Custom Response Classes\n```python\nfrom fastapi.responses import Response\nimport orjson\n\nclass ORJSONResponse(Response):\n    media_type = \"application/json\"\n\n    def render(self, content: Any) -\u003e bytes:\n        return orjson.dumps(content)\n\n@app.get(\"/fast-json\", response_class=ORJSONResponse)\nasync def fast_json():\n    return {\"message\": \"Fast JSON response\"}\n\n# Custom HTML response\nfrom fastapi.responses import HTMLResponse\n\n@app.get(\"/html\", response_class=HTMLResponse)\nasync def get_html():\n    return \"\"\"\n    \u003chtml\u003e\n        \u003chead\u003e\u003ctitle\u003eFastAPI HTML\u003c/title\u003e\u003c/head\u003e\n        \u003cbody\u003e\u003ch1\u003eHello from FastAPI!\u003c/h1\u003e\u003c/body\u003e\n    \u003c/html\u003e\n    \"\"\"\n```\n\n### OpenAPI Customization\n```python\nfrom fastapi.openapi.utils import get_openapi\n\ndef custom_openapi():\n    if app.openapi_schema:\n        return app.openapi_schema\n    \n    openapi_schema = get_openapi(\n        title=\"My API\",\n        version=\"2.0.0\",\n        description=\"This is a custom OpenAPI schema\",\n        routes=app.routes,\n    )\n    \n    # Add custom x-logo\n    openapi_schema[\"info\"][\"x-logo\"] = {\n        \"url\": \"https://example.com/logo.png\"\n    }\n    \n    # Add security schemes\n    openapi_schema[\"components\"][\"securitySchemes\"] = {\n        \"Bearer\": {\n            \"type\": \"http\",\n            \"scheme\": \"bearer\",\n            \"bearerFormat\": \"JWT\",\n        }\n    }\n    \n    app.openapi_schema = openapi_schema\n    return app.openapi_schema\n\napp.openapi = custom_openapi\n```\n\n### GraphQL Integration\n```python\nfrom strawberry.fastapi import GraphQLRouter\nimport strawberry\n\n@strawberry.type\nclass User:\n    id: int\n    name: str\n    email: str\n\n@strawberry.type\nclass Query:\n    @strawberry.field\n    async def user(self, id: int) -\u003e User:\n        # Fetch user from database\n        return User(id=id, name=\"John Doe\", email=\"john@example.com\")\n\n@strawberry.type\nclass Mutation:\n    @strawberry.mutation\n    async def create_user(self, name: str, email: str) -\u003e User:\n        # Create user in database\n        return User(id=1, name=name, email=email)\n\nschema = strawberry.Schema(query=Query, mutation=Mutation)\ngraphql_app = GraphQLRouter(schema)\n\napp.include_router(graphql_app, prefix=\"/graphql\")\n```\n\n---\n\n## 💡 Common Interview Questions\n\n### Basic Level\n\n1. **What is FastAPI?**\n   - Modern Python web framework\n   - Based on Starlette and Pydantic\n   - Automatic validation and documentation\n   - High performance\n\n2. **FastAPI vs Flask/Django?**\n   ```python\n   # FastAPI: Type hints, async, auto-docs, fast\n   # Flask: Simple, mature, large ecosystem\n   # Django: Full-stack, ORM, admin panel\n   ```\n\n3. **What are Path Parameters?**\n   ```python\n   @app.get(\"/users/{user_id}\")\n   async def read_user(user_id: int):\n       return {\"user_id\": user_id}\n   ```\n\n4. **What are Query Parameters?**\n   ```python\n   @app.get(\"/items/\")\n   async def read_items(skip: int = 0, limit: int = 10):\n       return {\"skip\": skip, \"limit\": limit}\n   ```\n\n5. **How to handle Request Body?**\n   ```python\n   class Item(BaseModel):\n       name: str\n       price: float\n   \n   @app.post(\"/items/\")\n   async def create_item(item: Item):\n       return item\n   ```\n\n### Intermediate Level\n\n1. **Explain Dependency Injection in FastAPI**\n   ```python\n   # Reusable components\n   # Automatic resolution\n   # Testing friendly\n   # Reduces code duplication\n   ```\n\n2. **How does FastAPI validation work?**\n   ```python\n   # Uses Pydantic models\n   # Automatic type conversion\n   # Custom validators\n   # Error responses\n   ```\n\n3. **Async vs Sync endpoints?**\n   ```python\n   # Async: Non-blocking I/O operations\n   @app.get(\"/async\")\n   async def async_endpoint():\n       await some_async_operation()\n       return {\"status\": \"completed\"}\n   \n   # Sync: Blocking operations\n   @app.get(\"/sync\")\n   def sync_endpoint():\n       time.sleep(1)\n       return {\"status\": \"completed\"}\n   ```\n\n4. **How to handle file uploads?**\n   ```python\n   @app.post(\"/upload/\")\n   async def upload_file(file: UploadFile = File(...)):\n       contents = await file.read()\n       return {\"filename\": file.filename, \"size\": len(contents)}\n   ```\n\n5. **What is Response Model?**\n   ```python\n   # Controls response structure\n   # Excludes sensitive data\n   # Data validation\n   # Auto documentation\n   ```\n\n### Advanced Level\n\n1. **How does FastAPI handle concurrency?**\n   - Uses Starlette's async capabilities\n   - Event loop for async operations\n   - Thread pool for sync operations\n   - Non-blocking I/O\n\n2. **Explain Background Tasks vs Celery**\n   ```python\n   # Background Tasks: Simple, in-process\n   # Celery: Distributed, queue-based, scalable\n   ```\n\n3. **How to implement rate limiting?**\n   ```python\n   from slowapi import Limiter, _rate_limit_exceeded_handler\n   from slowapi.util import get_remote_address\n   \n   limiter = Limiter(key_func=get_remote_address)\n   app.state.limiter = limiter\n   app.add_exception_handler(RateLimitExceeded, _rate_limit_exceeded_handler)\n   \n   @app.get(\"/limited\")\n   @limiter.limit(\"5/minute\")\n   async def limited_endpoint(request: Request):\n       return {\"message\": \"This is limited\"}\n   ```\n\n4. **Custom Exception Handling?**\n   ```python\n   class CustomException(Exception):\n       def __init__(self, name: str):\n           self.name = name\n   \n   @app.exception_handler(CustomException)\n   async def custom_exception_handler(request: Request, exc: CustomException):\n       return JSONResponse(\n           status_code=418,\n           content={\"message\": f\"Error: {exc.name}\"}\n       )\n   ```\n\n5. **How to optimize FastAPI performance?**\n   - Use async operations\n   - Connection pooling\n   - Caching strategies\n   - Response compression\n   - Proper indexing\n   - Load balancing\n\n### Scenario-Based Questions\n\n1. **Design a REST API for a Blog System**\n   ```python\n   # Models\n   class Post(BaseModel):\n       title: str\n       content: str\n       author_id: int\n       tags: List[str] = []\n   \n   class Comment(BaseModel):\n       post_id: int\n       content: str\n       author_id: int\n   \n   # Endpoints\n   @app.post(\"/posts/\", response_model=Post)\n   @app.get(\"/posts/\", response_model=List[Post])\n   @app.get(\"/posts/{post_id}\", response_model=Post)\n   @app.put(\"/posts/{post_id}\", response_model=Post)\n   @app.delete(\"/posts/{post_id}\")\n   @app.post(\"/posts/{post_id}/comments/\", response_model=Comment)\n   ```\n\n2. **Implement User Authentication System**\n   ```python\n   # Registration, Login, JWT tokens\n   # Password hashing\n   # Protected routes\n   # Role-based access\n   # Token refresh\n   ```\n\n3. **Handle High Traffic Load**\n   - Use async endpoints\n   - Implement caching (Redis)\n   - Database connection pooling\n   - Horizontal scaling\n   - Load balancer (Nginx)\n   - CDN for static files\n\n4. **Implement Real-time Chat**\n   ```python\n   # WebSocket connections\n   # Message broadcasting\n   # Connection management\n   # Message persistence\n   # User presence\n   ```\n\n5. **Design Microservices Architecture**\n   - Service discovery\n   - API Gateway\n   - Inter-service communication\n   - Distributed tracing\n   - Circuit breakers\n\n---\n\n## ✅ Best Practices\n\n### Project Structure\n```\nproject/\n├── app/\n│   ├── __init__.py\n│   ├── main.py           # FastAPI app\n│   ├── config.py         # Configuration\n│   ├── models/           # SQLAlchemy models\n│   │   ├── __init__.py\n│   │   └── user.py\n│   ├── schemas/          # Pydantic schemas\n│   │   ├── __init__.py\n│   │   └── user.py\n│   ├── api/              # API routes\n│   │   ├── __init__.py\n│   │   ├── v1/\n│   │   │   ├── __init__.py\n│   │   │   └── endpoints/\n│   │   │       ├── __init__.py\n│   │   │       └── users.py\n│   ├── core/             # Core functionality\n│   │   ├── __init__.py\n│   │   ├── security.py\n│   │   └── config.py\n│   ├── db/               # Database\n│   │   ├── __init__.py\n│   │   ├── base.py\n│   │   └── session.py\n│   └── tests/           # Tests\n│       ├── __init__.py\n│       └── test_users.py\n├── alembic/              # Database migrations\n├── requirements.txt\n├── .env\n└── docker-compose.yml\n```\n\n### Code Organization\n```python\n# Separate concerns\n# routes/users.py\nfrom fastapi import APIRouter, Depends\nfrom sqlalchemy.orm import Session\n\nrouter = APIRouter(prefix=\"/users\", tags=[\"users\"])\n\n@router.get(\"/\")\nasync def get_users(db: Session = Depends(get_db)):\n    return get_all_users(db)\n\n# main.py\nfrom routes import users, posts, auth\n\napp = FastAPI()\napp.include_router(users.router)\napp.include_router(posts.router)\napp.include_router(auth.router)\n```\n\n### Configuration Management\n```python\n# config.py\nfrom pydantic import BaseSettings\nfrom functools import lru_cache\n\nclass Settings(BaseSettings):\n    app_name: str = \"My API\"\n    database_url: str\n    secret_key: str\n    algorithm: str = \"HS256\"\n    access_token_expire_minutes: int = 30\n    \n    class Config:\n        env_file = \".env\"\n\n@lru_cache()\ndef get_settings():\n    return Settings()\n\n# Usage\nsettings = get_settings()\n```\n\n### Error Handling\n```python\n# Custom error responses\nfrom fastapi import HTTPException, Request\nfrom fastapi.responses import JSONResponse\n\nclass DomainException(Exception):\n    \"\"\"Base domain exception\"\"\"\n    pass\n\nclass ItemNotFound(DomainException):\n    \"\"\"Item not found exception\"\"\"\n    pass\n\n@app.exception_handler(DomainException)\nasync def domain_exception_handler(request: Request, exc: DomainException):\n    return JSONResponse(\n        status_code=400,\n        content={\n            \"error\": exc.__class__.__name__,\n            \"message\": str(exc)\n        }\n    )\n\n# Validation error handling\nfrom fastapi.exceptions import RequestValidationError\n\n@app.exception_handler(RequestValidationError)\nasync def validation_exception_handler(request: Request, exc: RequestValidationError):\n    return JSONResponse(\n        status_code=422,\n        content={\n            \"error\": \"Validation Error\",\n            \"details\": exc.errors()\n        }\n    )\n```\n\n### Security Best Practices\n- 🔒 Always use HTTPS in production\n- 🔒 Implement rate limiting\n- 🔒 Use secure password hashing (bcrypt)\n- 🔒 Validate and sanitize inputs\n- 🔒 Use environment variables for secrets\n- 🔒 Implement CORS properly\n- 🔒 Use JWT with short expiration\n- 🔒 Implement request signing for APIs\n- 🔒 Log security events\n- 🔒 Regular security audits\n\n### Performance Best Practices\n- ⚡ Use async for I/O operations\n- ⚡ Implement caching strategically\n- ⚡ Use connection pooling\n- ⚡ Optimize database queries\n- ⚡ Use pagination for large datasets\n- ⚡ Implement request/response compression\n- ⚡ Use CDN for static assets\n- ⚡ Monitor and profile regularly\n- ⚡ Load test before production\n- ⚡ Use appropriate response models\n\n---\n\n## 🔧 Troubleshooting\n\n### Common Issues\n\n#### 1. **Circular Import Errors**\n```python\n# Problem: Circular dependencies between modules\n# Solution: Use TYPE_CHECKING and forward references\n\nfrom typing import TYPE_CHECKING\n\nif TYPE_CHECKING:\n    from .models import User\n\n# Or use string annotations\ndef get_user() -\u003e \"User\":\n    pass\n```\n\n#### 2. **Async Context Errors**\n```python\n# Problem: Using sync code in async function\n# Solution: Use async libraries or run_in_executor\n\n# Bad\n@app.get(\"/data\")\nasync def get_data():\n    time.sleep(1)  # Blocks event loop\n    return {\"data\": \"value\"}\n\n# Good\n@app.get(\"/data\")\nasync def get_data():\n    await asyncio.sleep(1)\n    return {\"data\": \"value\"}\n```\n\n#### 3. **Database Connection Issues**\n```python\n# Problem: Connection pool exhaustion\n# Solution: Proper session management\n\n# Always close sessions\n@app.get(\"/users/\")\nasync def get_users(db: Session = Depends(get_db)):\n    try:\n        return db.query(User).all()\n    finally:\n        db.close()  # Handled by dependency\n```\n\n#### 4. **Memory Leaks**\n```python\n# Problem: Large objects in memory\n# Solution: Stream large responses\n\nfrom fastapi.responses import StreamingResponse\n\nasync def generate_large_data():\n    for i in range(1000000):\n        yield f\"{i}\\n\".encode()\n\n@app.get(\"/large-data\")\nasync def large_data():\n    return StreamingResponse(generate_large_data(), media_type=\"text/plain\")\n```\n\n#### 5. **CORS Issues**\n```python\n# Problem: CORS blocking requests\n# Solution: Configure CORS properly\n\nfrom fastapi.middleware.cors import CORSMiddleware\n\napp.add_middleware(\n    CORSMiddleware,\n    allow_origins=[\"https://example.com\"],  # Don't use [\"*\"] in production\n    allow_credentials=True,\n    allow_methods=[\"GET\", \"POST\"],\n    allow_headers=[\"*\"],\n)\n```\n\n### Debugging Tips\n\n#### Enable Debug Mode\n```python\n# Development only\napp = FastAPI(debug=True)\n\n# Better logging\nimport logging\nlogging.basicConfig(level=logging.DEBUG)\nlogger = logging.getLogger(__name__)\n\n@app.get(\"/debug\")\nasync def debug_endpoint():\n    logger.debug(\"Debug message\")\n    return {\"status\": \"ok\"}\n```\n\n#### Request Profiling\n```python\nimport time\nfrom fastapi import Request\n\n@app.middleware(\"http\")\nasync def profile_request(request: Request, call_next):\n    start_time = time.time()\n    response = await call_next(request)\n    process_time = time.time() - start_time\n    logger.info(f\"{request.method} {request.url.path} took {process_time:.3f}s\")\n    return response\n```\n\n#### SQL Query Logging\n```python\n# SQLAlchemy query logging\nimport logging\nlogging.getLogger('sqlalchemy.engine').setLevel(logging.INFO)\n\n# Or in engine creation\nengine = create_engine(\n    DATABASE_URL,\n    echo=True  # Log all SQL\n)\n```\n\n---\n\n## 📚 Resources\n\n### Official Documentation\n- [FastAPI Documentation](https://fastapi.tiangolo.com/)\n- [FastAPI GitHub](https://github.com/tiangolo/fastapi)\n- [Starlette Documentation](https://www.starlette.io/)\n- [Pydantic Documentation](https://pydantic-docs.helpmanual.io/)\n\n### Learning Resources\n- **FastAPI Tutorial** - Official step-by-step guide\n- **Full Stack FastAPI PostgreSQL** - Project generator\n- **Awesome FastAPI** - Curated list of resources\n- **TestDriven.io FastAPI** - TDD with FastAPI\n\n### Books \u0026 Courses\n- \"Building Data Science Applications with FastAPI\" - François Voron\n- \"FastAPI Modern Python Web Development\" - Bill Lubanovic\n- \"Microservice APIs\" - José Haro Peralta\n\n### Tools \u0026 Extensions\n- **FastAPI-Users** - User authentication system\n- **FastAPI-SQLAlchemy** - SQLAlchemy integration\n- **FastAPI-Cache** - Caching support\n- **FastAPI-Limiter** - Rate limiting\n- **FastAPI-Mail** - Email support\n- **Tortoise-ORM** - Async ORM\n- **FastAPI-Admin** - Admin interface\n- **FastAPI-MQTT** - MQTT support\n\n### Community\n- [FastAPI Gitter](https://gitter.im/tiangolo/fastapi)\n- [FastAPI Discord](https://discord.gg/VQjSZaeJmf)\n- [Stack Overflow](https://stackoverflow.com/questions/tagged/fastapi)\n- [Reddit r/FastAPI](https://www.reddit.com/r/FastAPI/)\n\n---\n\n## 🎯 Quick Reference\n\n### Essential Imports\n```python\n# Core\nfrom fastapi import FastAPI, Request, Response, status\nfrom fastapi import HTTPException, Depends, Security\nfrom fastapi import Query, Path, Body, Form, File, UploadFile\nfrom fastapi import Header, Cookie\n\n# Responses\nfrom fastapi.responses import JSONResponse, HTMLResponse, StreamingResponse\nfrom fastapi.responses import FileResponse, RedirectResponse\n\n# Security\nfrom fastapi.security import OAuth2PasswordBearer, OAuth2PasswordRequestForm\nfrom fastapi.security import HTTPBearer, HTTPBasic, APIKeyHeader\n\n# Background \u0026 WebSocket\nfrom fastapi import BackgroundTasks, WebSocket\n\n# Routing\nfrom fastapi import APIRouter\n\n# Middleware \u0026 CORS\nfrom fastapi.middleware.cors import CORSMiddleware\nfrom fastapi.middleware.gzip import GZipMiddleware\n\n# Testing\nfrom fastapi.testclient import TestClient\n\n# Pydantic\nfrom pydantic import BaseModel, Field, validator\nfrom pydantic import EmailStr, HttpUrl, SecretStr\n\n# Typing\nfrom typing import Optional, List, Dict, Union, Any\n```\n\n### Common Patterns\n\n#### API Versioning\n```python\n# Version in path\napp = FastAPI()\n\nv1_router = APIRouter(prefix=\"/api/v1\")\nv2_router = APIRouter(prefix=\"/api/v2\")\n\napp.include_router(v1_router)\napp.include_router(v2_router)\n\n# Version in header\nfrom fastapi import Header\n\n@app.get(\"/users\")\nasync def get_users(api_version: str = Header(default=\"v1\")):\n    if api_version == \"v1\":\n        return {\"version\": \"1.0\", \"users\": [...]}\n    elif api_version == \"v2\":\n        return {\"version\": \"2.0\", \"data\": {\"users\": [...]}}\n```\n\n#### Health Checks\n```python\n@app.get(\"/health\", tags=[\"health\"])\nasync def health_check():\n    return {\n        \"status\": \"healthy\",\n        \"timestamp\": datetime.utcnow(),\n        \"service\": \"my-api\",\n        \"version\": \"1.0.0\"\n    }\n\n@app.get(\"/ready\", tags=[\"health\"])\nasync def readiness_check(db: Session = Depends(get_db)):\n    try:\n        # Check database connection\n        db.execute(\"SELECT 1\")\n        return {\"status\": \"ready\"}\n    except Exception as e:\n        raise HTTPException(status_code=503, detail=\"Service not ready\")\n```\n\n#### Request ID Tracking\n```python\nimport uuid\nfrom fastapi import Request\n\n@app.middleware(\"http\")\nasync def add_request_id(request: Request, call_next):\n    request_id = str(uuid.uuid4())\n    request.state.request_id = request_id\n    \n    response = await call_next(request)\n    response.headers[\"X-Request-ID\"] = request_id\n    \n    return response\n\n@app.get(\"/track\")\nasync def track_request(request: Request):\n    return {\"request_id\": request.state.request_id}\n```\n\n#### Graceful Shutdown\n```python\nimport signal\nimport sys\n\nshutdown_event = asyncio.Event()\n\ndef signal_handler(sig, frame):\n    print(\"Shutting down gracefully...\")\n    shutdown_event.set()\n\nsignal.signal(signal.SIGINT, signal_handler)\nsignal.signal(signal.SIGTERM, signal_handler)\n\n@app.on_event(\"startup\")\nasync def startup():\n    asyncio.create_task(monitor_shutdown())\n\nasync def monitor_shutdown():\n    await shutdown_event.wait()\n    # Cleanup tasks\n    await cleanup_resources()\n    sys.exit(0)\n```\n\n---\n\n## 🚦 Performance Monitoring\n\n### APM Integration\n```python\n# Datadog\nfrom ddtrace import patch_all\npatch_all()\n\n# New Relic\nimport newrelic.agent\nnewrelic.agent.initialize('newrelic.ini')\n\n# Sentry\nimport sentry_sdk\nfrom sentry_sdk.integrations.asgi import SentryAsgiMiddleware\n\nsentry_sdk.init(dsn=\"your-dsn-here\")\napp.add_middleware(SentryAsgiMiddleware)\n```\n\n### Custom Metrics\n```python\nfrom prometheus_client import Counter, Histogram, generate_latest\nimport time\n\n# Metrics\nREQUEST_COUNT = Counter('app_requests_total', 'Total requests', ['method', 'endpoint'])\nREQUEST_LATENCY = Histogram('app_request_latency_seconds', 'Request latency')\n\n@app.middleware(\"http\")\nasync def track_metrics(request: Request, call_next):\n    REQUEST_COUNT.labels(method=request.method, endpoint=request.url.path).inc()\n    \n    start_time = time.time()\n    response = await call_next(request)\n    REQUEST_LATENCY.observe(time.time() - start_time)\n    \n    return response\n\n@app.get(\"/metrics\")\nasync def metrics():\n    return Response(content=generate_latest(), media_type=\"text/plain\")\n```\n\n---\n\n## 🏁 Production Checklist\n\n### Pre-deployment\n- [ ] Remove debug mode\n- [ ] Set up proper logging\n- [ ] Configure CORS properly\n- [ ] Use environment variables\n- [ ] Set up database migrations\n- [ ] Implement health checks\n- [ ] Add rate limiting\n- [ ] Configure security headers\n- [ ] Set up monitoring\n- [ ] Load testing completed\n\n### Security\n- [ ] HTTPS enabled\n- [ ] Authentication implemented\n- [ ] Input validation active\n- [ ] SQL injection protected\n- [ ] XSS prevention\n- [ ] CSRF protection (if needed)\n- [ ] Secrets encrypted\n- [ ] Dependencies updated\n- [ ] Security headers configured\n- [ ] API versioning\n\n### Performance\n- [ ] Database indexed\n- [ ] Caching implemented\n- [ ] Connection pooling\n- [ ] Async operations used\n- [ ] Response compression\n- [ ] Static files on CDN\n- [ ] Query optimization\n- [ ] Pagination implemented\n- [ ] Rate limiting active\n- [ ] Auto-scaling configured\n\n### Monitoring\n- [ ] Error tracking (Sentry)\n- [ ] APM configured\n- [ ] Log aggregation\n- [ ] Uptime monitoring\n- [ ] Performance metrics\n- [ ] Custom dashboards\n- [ ] Alerting rules\n- [ ] Backup strategy\n- [ ] Disaster recovery plan\n- [ ] Documentation updated\n\n---\n\n## 📝 Code Snippets\n\n### Custom Validators\n```python\nfrom pydantic import validator, root_validator\n\nclass User(BaseModel):\n    username: str\n    email: EmailStr\n    age: int\n    \n    @validator('username')\n    def username_alphanumeric(cls, v):\n        assert v.isalnum(), 'must be alphanumeric'\n        return v\n    \n    @validator('age')\n    def age_must_be_positive(cls, v):\n        if v \u003c= 0:\n            raise ValueError('must be positive')\n        return v\n    \n    @root_validator\n    def check_consistency(cls, values):\n        # Cross-field validation\n        return values\n```\n\n### Dynamic Model Creation\n```python\nfrom pydantic import create_model\n\ndef create_item_model(fields: dict):\n    return create_model('DynamicItem', **fields)\n\n# Usage\nItemModel = create_item_model({\n    'name': (str, ...),\n    'price': (float, Field(gt=0)),\n    'quantity': (int, Field(default=1))\n})\n\n@app.post(\"/dynamic-item/\")\nasync def create_dynamic_item(item: ItemModel):\n    return item\n```\n\n### Custom Dependency Classes\n```python\nclass PaginationParams:\n    def __init__(\n        self,\n        page: int = Query(1, ge=1),\n        size: int = Query(50, ge=1, le=100)\n    ):\n        self.skip = (page - 1) * size\n        self.limit = size\n\nclass FilterParams:\n    def __init__(\n        self,\n        q: Optional[str] = None,\n        category: Optional[str] = None,\n        min_price: Optional[float] = None,\n        max_price: Optional[float] = None\n    ):\n        self.q = q\n        self.category = category\n        self.min_price = min_price\n        self.max_price = max_price\n\n@app.get(\"/products/\")\nasync def get_products(\n    pagination: PaginationParams = Depends(),\n    filters: FilterParams = Depends()\n):\n    # Apply pagination and filters\n    return {\"skip\": pagination.skip, \"limit\": pagination.limit, \"filters\": filters}\n```\n\n---\n\n## 🎉 Conclusion\n\nFastAPI is a powerful, modern web framework that combines the best of Python's type system with high performance and developer-friendly features. This guide covers everything from basic concepts to advanced production deployments.\n\n### Key Takeaways\n- 🚀 **Performance** - FastAPI is one of the fastest Python frameworks\n- 📝 **Type Safety** - Automatic validation and documentation\n- 🔧 **Developer Experience** - Excellent tooling and error messages\n- 🏭 **Production Ready** - Used by major companies worldwide\n- 🌟 **Active Community** - Regular updates and great support\n\n### Next Steps\n1. Build a real project\n2. Contribute to open source\n3. Share your knowledge\n4. Keep learning!\n\n---\n\n\u003cp align=\"center\"\u003e\n  \u003cb\u003eHappy Coding! 🚀\u003c/b\u003e\u003cbr\u003e\n  \u003ci\u003eRemember: The best API is one that's well-documented, fast, and secure!\u003c/i\u003e\n\u003c/p\u003e","project_url":"https://awesome.ecosyste.ms/api/v1/projects/github.com%2Fanshsinghsonkhia%2Fmasters-in-fastapi","html_url":"https://awesome.ecosyste.ms/projects/github.com%2Fanshsinghsonkhia%2Fmasters-in-fastapi","lists_url":"https://awesome.ecosyste.ms/api/v1/projects/github.com%2Fanshsinghsonkhia%2Fmasters-in-fastapi/lists"}