from fastapi import FastAPI, HTTPException, Depends, Query, status
from pydantic import BaseModel, EmailStr, Field
from datetime import datetime

app = FastAPI(title="User Service", version="1.0.0")

# Request/Response models (validation + documentation)
class UserCreate(BaseModel):
    name: str = Field(..., min_length=1, max_length=100)
    email: EmailStr
    role: str = "user"

class UserResponse(BaseModel):
    id: int
    name: str
    email: str
    role: str
    created_at: datetime

    model_config = {"from_attributes": True}

class PaginatedResponse(BaseModel):
    items: list[UserResponse]
    total: int
    page: int
    page_size: int

# Endpoints
@app.get("/api/v1/users", response_model=PaginatedResponse)
async def list_users(
    page: int = Query(1, ge=1),
    page_size: int = Query(20, ge=1, le=100),
    role: str | None = None,
):
    """List users with pagination and optional filtering."""
    users, total = await user_service.list_users(
        page=page, page_size=page_size, role=role
    )
    return PaginatedResponse(
        items=users, total=total, page=page, page_size=page_size
    )

@app.post("/api/v1/users", response_model=UserResponse, status_code=status.HTTP_201_CREATED)
async def create_user(user_data: UserCreate):
    """Create a new user."""
    user = await user_service.create_user(user_data)
    return user

@app.get("/api/v1/users/{user_id}", response_model=UserResponse)
async def get_user(user_id: int):
    """Get a single user by ID."""
    user = await user_service.get_by_id(user_id)
    if not user:
        raise HTTPException(status_code=404, detail="User not found")
    return user

# gunicorn.conf.py — Production server configuration
import multiprocessing

# Workers = 2-4 × CPU cores (for I/O-bound workloads)
workers = multiprocessing.cpu_count() * 2 + 1
worker_class = "uvicorn.workers.UvicornWorker"  # Async workers
bind = "0.0.0.0:8000"
keepalive = 120
timeout = 30
graceful_timeout = 30
max_requests = 1000        # Restart worker after N requests (prevent memory leaks)
max_requests_jitter = 50   # Randomize restarts to avoid thundering herd

from contextlib import asynccontextmanager
import asyncpg
import redis.asyncio as aioredis

# Application lifespan — create pools once at startup
@asynccontextmanager
async def lifespan(app: FastAPI):
    # Startup: create connection pools
    app.state.db_pool = await asyncpg.create_pool(
        dsn=settings.database_url,
        min_size=5,          # Keep 5 connections ready
        max_size=20,         # Max 20 concurrent DB connections per worker
        max_inactive_connection_lifetime=300,
    )
    app.state.redis = aioredis.from_url(
        settings.redis_url,
        max_connections=20,
    )
    yield
    # Shutdown: close pools
    await app.state.db_pool.close()
    await app.state.redis.close()

app = FastAPI(lifespan=lifespan)

# Usage in endpoints
async def get_db(request: Request) -> asyncpg.Pool:
    return request.app.state.db_pool

@app.get("/api/v1/users/{user_id}")
async def get_user(user_id: int, db: asyncpg.Pool = Depends(get_db)):
    row = await db.fetchrow("SELECT * FROM users WHERE id = $1", user_id)
    if not row:
        raise HTTPException(status_code=404)
    return dict(row)

import asyncio
from concurrent.futures import ProcessPoolExecutor

executor = ProcessPoolExecutor(max_workers=4)

def cpu_intensive_task(data: bytes) -> dict:
    """Runs in a separate process — doesn't block event loop."""
    # Heavy computation here (image processing, ML inference, etc.)
    return {"result": process(data)}

@app.post("/api/v1/process")
async def process_data(data: bytes):
    loop = asyncio.get_event_loop()
    result = await loop.run_in_executor(executor, cpu_intensive_task, data)
    return result

import time
from fastapi import Request, HTTPException
from redis.asyncio import Redis

class RateLimiter:
    """Sliding window rate limiter using Redis sorted sets."""

    def __init__(self, redis: Redis, requests_per_minute: int = 60):
        self.redis = redis
        self.limit = requests_per_minute
        self.window = 60  # seconds

    async def is_allowed(self, key: str) -> tuple[bool, dict]:
        now = time.time()
        window_start = now - self.window
        pipe = self.redis.pipeline()

        # Remove expired entries
        pipe.zremrangebyscore(key, 0, window_start)
        # Add current request
        pipe.zadd(key, {str(now): now})
        # Count requests in window
        pipe.zcard(key)
        # Set expiry on the key
        pipe.expire(key, self.window)

        _, _, count, _ = await pipe.execute()

        remaining = max(0, self.limit - count)
        headers = {
            "X-RateLimit-Limit": str(self.limit),
            "X-RateLimit-Remaining": str(remaining),
            "X-RateLimit-Reset": str(int(now + self.window)),
        }

        return count <= self.limit, headers

# FastAPI middleware / dependency
async def rate_limit_dependency(request: Request):
    client_ip = request.client.host
    key = f"rate_limit:{client_ip}"
    limiter = RateLimiter(request.app.state.redis)
    allowed, headers = await limiter.is_allowed(key)

    if not allowed:
        raise HTTPException(
            status_code=429,
            detail="Too many requests",
            headers={"Retry-After": "60", **headers},
        )
    # Attach headers to response
    request.state.rate_limit_headers = headers

import hashlib
import json
from functools import wraps
from redis.asyncio import Redis

# Layer 1: In-memory cache (per-worker, fastest)
from cachetools import TTLCache
local_cache = TTLCache(maxsize=1000, ttl=30)  # 30-second TTL

# Layer 2: Redis cache (shared across workers)
async def cache_response(redis: Redis, key: str, ttl: int = 300):
    """Decorator for caching endpoint responses in Redis."""
    def decorator(func):
        @wraps(func)
        async def wrapper(*args, **kwargs):
            # Check cache
            cached = await redis.get(key)
            if cached:
                return json.loads(cached)

            # Compute result
            result = await func(*args, **kwargs)

            # Store in cache
            await redis.set(key, json.dumps(result), ex=ttl)
            return result
        return wrapper
    return decorator

# Layer 3: HTTP cache headers
from fastapi.responses import JSONResponse

@app.get("/api/v1/products/{product_id}")
async def get_product(product_id: int):
    product = await product_service.get(product_id)
    response = JSONResponse(content=product.dict())
    response.headers["Cache-Control"] = "public, max-age=60"
    response.headers["ETag"] = hashlib.md5(
        json.dumps(product.dict()).encode()
    ).hexdigest()
    return response

# SLOW: N+1 query problem
async def get_users_with_orders_slow():
    users = await db.fetch("SELECT * FROM users LIMIT 100")
    for user in users:
        # 100 separate queries!
        orders = await db.fetch(
            "SELECT * FROM orders WHERE user_id = $1", user["id"]
        )
        user["orders"] = orders

# FAST: Single query with JOIN or batch
async def get_users_with_orders_fast():
    return await db.fetch("""
        SELECT u.*, json_agg(o.*) as orders
        FROM users u
        LEFT JOIN orders o ON o.user_id = u.id
        GROUP BY u.id
        LIMIT 100
    """)

# FAST: Batch loading with IN clause
async def get_users_with_orders_batch():
    users = await db.fetch("SELECT * FROM users LIMIT 100")
    user_ids = [u["id"] for u in users]
    orders = await db.fetch(
        "SELECT * FROM orders WHERE user_id = ANY($1)", user_ids
    )
    # Group orders by user_id in Python
    orders_by_user = defaultdict(list)
    for order in orders:
        orders_by_user[order["user_id"]].append(order)
    for user in users:
        user["orders"] = orders_by_user[user["id"]]

from datetime import datetime, timedelta, timezone
from fastapi import Depends, HTTPException, status
from fastapi.security import OAuth2PasswordBearer
from jose import JWTError, jwt
from passlib.context import CryptContext
from pydantic import BaseModel

# Configuration
SECRET_KEY = settings.secret_key  # From environment, never hardcoded!
ALGORITHM = "HS256"
ACCESS_TOKEN_EXPIRE_MINUTES = 30

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

class TokenPayload(BaseModel):
    sub: str          # Subject (user ID)
    exp: datetime     # Expiration
    role: str         # User role

def create_access_token(user_id: int, role: str) -> str:
    expire = datetime.now(timezone.utc) + timedelta(minutes=ACCESS_TOKEN_EXPIRE_MINUTES)
    payload = {"sub": str(user_id), "exp": expire, "role": role}
    return jwt.encode(payload, SECRET_KEY, algorithm=ALGORITHM)

def verify_password(plain_password: str, hashed_password: str) -> bool:
    return pwd_context.verify(plain_password, hashed_password)

def hash_password(password: str) -> str:
    return pwd_context.hash(password)

# Dependency: extract and verify current user from JWT
async def get_current_user(token: str = Depends(oauth2_scheme)) -> User:
    credentials_exception = HTTPException(
        status_code=status.HTTP_401_UNAUTHORIZED,
        detail="Invalid authentication credentials",
        headers={"WWW-Authenticate": "Bearer"},
    )
    try:
        payload = jwt.decode(token, SECRET_KEY, algorithms=[ALGORITHM])
        user_id = payload.get("sub")
        if user_id is None:
            raise credentials_exception
    except JWTError:
        raise credentials_exception

    user = await user_service.get_by_id(int(user_id))
    if user is None:
        raise credentials_exception
    return user

from enum import Enum
from functools import wraps

class Role(str, Enum):
    USER = "user"
    ADMIN = "admin"
    MODERATOR = "moderator"

def require_role(*allowed_roles: Role):
    """Dependency that checks user role."""
    async def role_checker(current_user: User = Depends(get_current_user)):
        if current_user.role not in allowed_roles:
            raise HTTPException(
                status_code=status.HTTP_403_FORBIDDEN,
                detail="Insufficient permissions",
            )
        return current_user
    return role_checker

# Usage
@app.delete("/api/v1/users/{user_id}")
async def delete_user(
    user_id: int,
    admin: User = Depends(require_role(Role.ADMIN)),
):
    """Only admins can delete users."""
    await user_service.delete(user_id)
    return {"status": "deleted"}

@app.get("/api/v1/admin/stats")
async def admin_stats(
    user: User = Depends(require_role(Role.ADMIN, Role.MODERATOR)),
):
    """Admins and moderators can view stats."""
    return await stats_service.get_dashboard()

# VULNERABLE: String formatting in SQL
async def get_user_unsafe(username: str):
    # NEVER DO THIS — SQL injection!
    query = f"SELECT * FROM users WHERE username = '{username}'"
    return await db.fetch(query)
    # Attack: username = "'; DROP TABLE users; --"

# SAFE: Parameterized queries (always use these)
async def get_user_safe(username: str):
    query = "SELECT * FROM users WHERE username = $1"
    return await db.fetchrow(query, username)
    # Parameters are escaped automatically

# SAFE: ORM (SQLAlchemy, Tortoise)
async def get_user_orm(username: str):
    return await User.filter(username=username).first()

from pydantic import BaseModel, Field, field_validator
import re

class UserCreate(BaseModel):
    """Only these fields are accepted — everything else is ignored."""
    name: str = Field(..., min_length=1, max_length=100)
    email: EmailStr
    password: str = Field(..., min_length=8, max_length=128)

    @field_validator("name")
    @classmethod
    def validate_name(cls, v: str) -> str:
        if not re.match(r"^[a-zA-Z\s\-']+$", v):
            raise ValueError("Name contains invalid characters")
        return v.strip()

    @field_validator("password")
    @classmethod
    def validate_password(cls, v: str) -> str:
        if not re.search(r"[A-Z]", v):
            raise ValueError("Password must contain an uppercase letter")
        if not re.search(r"[0-9]", v):
            raise ValueError("Password must contain a digit")
        return v

# Mass assignment protection: UserCreate does NOT have 'role' or 'is_admin'
# Even if client sends {"name": "Alice", "role": "admin"}, role is ignored
@app.post("/api/v1/users")
async def create_user(data: UserCreate):  # Only name, email, password accepted
    user = await user_service.create(data)
    return UserResponse.model_validate(user)  # Only safe fields in response

from fastapi.middleware.cors import CORSMiddleware
from fastapi.middleware.trustedhost import TrustedHostMiddleware

# CORS: restrict which origins can call your API
app.add_middleware(
    CORSMiddleware,
    allow_origins=["https://myapp.com", "https://admin.myapp.com"],
    allow_credentials=True,
    allow_methods=["GET", "POST", "PUT", "DELETE"],
    allow_headers=["Authorization", "Content-Type"],
)

# Trusted hosts: prevent Host header attacks
app.add_middleware(TrustedHostMiddleware, allowed_hosts=["api.myapp.com"])

# Security headers middleware
@app.middleware("http")
async def add_security_headers(request, call_next):
    response = await call_next(request)
    response.headers["X-Content-Type-Options"] = "nosniff"
    response.headers["X-Frame-Options"] = "DENY"
    response.headers["Strict-Transport-Security"] = "max-age=31536000; includeSubDomains"
    response.headers["X-XSS-Protection"] = "1; mode=block"
    return response

from fastapi import BackgroundTasks

async def send_welcome_email(email: str, name: str):
    """Runs after response is sent — doesn't block the client."""
    await email_service.send(
        to=email,
        subject="Welcome!",
        body=f"Hi {name}, welcome to our platform!"
    )

async def log_signup(user_id: int):
    await analytics.track("user_signup", user_id=user_id)

@app.post("/api/v1/users", status_code=201)
async def create_user(data: UserCreate, background_tasks: BackgroundTasks):
    user = await user_service.create(data)

    # These run AFTER the response is returned to the client
    background_tasks.add_task(send_welcome_email, user.email, user.name)
    background_tasks.add_task(log_signup, user.id)

    return UserResponse.model_validate(user)
    # Client gets 201 immediately — doesn't wait for email

# tasks.py — define tasks
from arq import create_pool
from arq.connections import RedisSettings

async def generate_report(ctx, user_id: int, report_type: str):
    """Heavy task — runs in a separate worker process."""
    data = await fetch_report_data(user_id, report_type)
    pdf = render_pdf(data)  # CPU-intensive
    url = await upload_to_s3(pdf)
    await notify_user(user_id, f"Report ready: {url}")
    return {"url": url}

async def process_image(ctx, image_id: int):
    """Image processing — CPU-bound, offloaded to worker."""
    image = await download_image(image_id)
    thumbnails = create_thumbnails(image, sizes=[128, 256, 512])
    await save_thumbnails(image_id, thumbnails)

# Worker configuration
class WorkerSettings:
    functions = [generate_report, process_image]
    redis_settings = RedisSettings(host="redis")
    max_jobs = 10

# API endpoint — enqueue task
@app.post("/api/v1/reports")
async def request_report(user_id: int, report_type: str):
    redis = await create_pool(RedisSettings(host="redis"))
    job = await redis.enqueue_job("generate_report", user_id, report_type)
    return {"job_id": job.job_id, "status": "queued"}

from fastapi import APIRouter

# Version 1
v1_router = APIRouter(prefix="/api/v1")

@v1_router.get("/users/{user_id}")
async def get_user_v1(user_id: int):
    user = await user_service.get(user_id)
    return {"id": user.id, "name": user.name, "email": user.email}

# Version 2 — adds new fields, changes format
v2_router = APIRouter(prefix="/api/v2")

@v2_router.get("/users/{user_id}")
async def get_user_v2(user_id: int):
    user = await user_service.get(user_id)
    return {
        "id": user.id,
        "name": {"first": user.first_name, "last": user.last_name},
        "email": user.email,
        "created_at": user.created_at.isoformat(),
        "links": {"self": f"/api/v2/users/{user.id}"},
    }

app.include_router(v1_router)
app.include_router(v2_router)

import warnings
from fastapi import Header

@v1_router.get("/users/{user_id}", deprecated=True)  # Shows in OpenAPI docs
async def get_user_v1(user_id: int):
    """Deprecated: Use /api/v2/users/{user_id} instead."""
    # Add sunset header
    response.headers["Sunset"] = "Sat, 01 Jan 2027 00:00:00 GMT"
    response.headers["Deprecation"] = "true"
    response.headers["Link"] = '</api/v2/users>; rel="successor-version"'
    return await get_user_legacy(user_id)

from fastapi import FastAPI, status
from pydantic import BaseModel

class HealthResponse(BaseModel):
    status: str
    checks: dict[str, str]

@app.get("/health/live", status_code=200)
async def liveness():
    """Is the process alive? (Kubernetes liveness probe)"""
    return {"status": "alive"}

@app.get("/health/ready", response_model=HealthResponse)
async def readiness():
    """Can the service handle traffic? Check dependencies."""
    checks = {}

    # Check database
    try:
        await app.state.db_pool.fetchval("SELECT 1")
        checks["database"] = "healthy"
    except Exception:
        checks["database"] = "unhealthy"

    # Check Redis
    try:
        await app.state.redis.ping()
        checks["redis"] = "healthy"
    except Exception:
        checks["redis"] = "unhealthy"

    all_healthy = all(v == "healthy" for v in checks.values())

    if not all_healthy:
        raise HTTPException(
            status_code=status.HTTP_503_SERVICE_UNAVAILABLE,
            detail={"status": "unhealthy", "checks": checks},
        )
    return HealthResponse(status="healthy", checks=checks)

import time
from prometheus_client import Counter, Histogram, generate_latest
from starlette.middleware.base import BaseHTTPMiddleware

REQUEST_COUNT = Counter(
    "http_requests_total",
    "Total HTTP requests",
    ["method", "endpoint", "status_code"],
)
REQUEST_LATENCY = Histogram(
    "http_request_duration_seconds",
    "HTTP request latency",
    ["method", "endpoint"],
    buckets=[0.01, 0.05, 0.1, 0.25, 0.5, 1.0, 2.5, 5.0],
)

class MetricsMiddleware(BaseHTTPMiddleware):
    async def dispatch(self, request, call_next):
        start = time.perf_counter()
        response = await call_next(request)
        duration = time.perf_counter() - start

        endpoint = request.url.path
        REQUEST_COUNT.labels(request.method, endpoint, response.status_code).inc()
        REQUEST_LATENCY.labels(request.method, endpoint).observe(duration)

        return response

app.add_middleware(MetricsMiddleware)

@app.get("/metrics")
async def metrics():
    """Prometheus scrape endpoint."""
    return Response(content=generate_latest(), media_type="text/plain")

import signal
import asyncio
from contextlib import asynccontextmanager

@asynccontextmanager
async def lifespan(app: FastAPI):
    # STARTUP
    app.state.db_pool = await create_db_pool()
    app.state.redis = await create_redis_pool()
    app.state.task_queue = TaskQueue()

    yield  # Application runs here

    # SHUTDOWN (triggered by SIGTERM)
    # 1. Stop accepting new background tasks
    await app.state.task_queue.stop()

    # 2. Wait for in-flight background tasks to complete (with timeout)
    await asyncio.wait_for(
        app.state.task_queue.drain(),
        timeout=30,  # Force exit after 30s
    )

    # 3. Close external connections
    await app.state.db_pool.close()
    await app.state.redis.close()

app = FastAPI(lifespan=lifespan)

# gunicorn.conf.py
graceful_timeout = 30  # Seconds to wait for workers to finish requests
timeout = 60           # Max time for a single request

# Pre-fork hook: setup signal handling
def worker_exit(server, worker):
    """Called when a worker is shutting down."""
    # Cleanup worker-specific resources
    pass

# Deployment with graceful shutdown support
apiVersion: apps/v1
kind: Deployment
spec:
  replicas: 3
  strategy:
    type: RollingUpdate
    rollingUpdate:
      maxUnavailable: 1
      maxSurge: 1
  template:
    spec:
      terminationGracePeriodSeconds: 45  # Time for graceful shutdown
      containers:
        - name: api
          livenessProbe:
            httpGet:
              path: /health/live
              port: 8000
            initialDelaySeconds: 5
            periodSeconds: 10
          readinessProbe:
            httpGet:
              path: /health/ready
              port: 8000
            initialDelaySeconds: 10
            periodSeconds: 5
          lifecycle:
            preStop:
              exec:
                command: ["sleep", "5"]  # Allow LB to deregister

# Immutable: str
s = "hello"
s_id = id(s)
s += " world"       # Creates a NEW string object
print(id(s) == s_id)  # False — different object!

# Mutable: list
lst = [1, 2, 3]
lst_id = id(lst)
lst.append(4)        # Modifies SAME object
print(id(lst) == lst_id)  # True — same object!

# DANGEROUS: mutable default argument
def append_item(item, items=[]):
    items.append(item)
    return items

print(append_item(1))  # [1]
print(append_item(2))  # [1, 2] — BUG! Expected [2]

# SAFE: use None as default
def append_item_safe(item, items=None):
    if items is None:
        items = []
    items.append(item)
    return items

# ✗ Threading — limited by GIL for CPU work
import threading

# ✓ Multiprocessing — separate processes, separate GILs
from multiprocessing import Pool

def cpu_heavy(n):
    return sum(i * i for i in range(n))

with Pool(4) as p:
    results = p.map(cpu_heavy, [10**7] * 4)

# ✓ asyncio — for I/O-bound concurrency
import asyncio

async def fetch_data(url):
    async with aiohttp.ClientSession() as session:
        async with session.get(url) as resp:
            return await resp.json()

# This decorator syntax:
@my_decorator
def say_hello():
    print("Hello!")

# Is exactly equivalent to:
def say_hello():
    print("Hello!")
say_hello = my_decorator(say_hello)

import functools
import time

def timer(func):
    """Decorator that measures execution time."""
    @functools.wraps(func)  # Preserves original function metadata
    def wrapper(*args, **kwargs):
        start = time.perf_counter()
        result = func(*args, **kwargs)
        elapsed = time.perf_counter() - start
        print(f"{func.__name__} took {elapsed:.4f}s")
        return result
    return wrapper

@timer
def process_data(n):
    """Process n items."""
    return sum(range(n))

process_data(1_000_000)
# Output: process_data took 0.0312s
print(process_data.__name__)  # "process_data" (preserved by @wraps)

def retry(max_attempts=3, delay=1):
    """Decorator that retries on failure."""
    def decorator(func):
        @functools.wraps(func)
        def wrapper(*args, **kwargs):
            for attempt in range(max_attempts):
                try:
                    return func(*args, **kwargs)
                except Exception as e:
                    if attempt == max_attempts - 1:
                        raise
                    time.sleep(delay)
        return wrapper
    return decorator

@retry(max_attempts=5, delay=2)
def call_api(url):
    ...

# Regular function: stores ALL values in memory
def get_squares_list(n):
    result = []
    for i in range(n):
        result.append(i ** 2)
    return result  # 1 billion items = ~8 GB RAM!

# Generator: produces ONE value at a time
def get_squares_gen(n):
    for i in range(n):
        yield i ** 2  # Pauses here, resumes on next()

# Memory comparison
squares_list = get_squares_list(1_000_000_000)  # MemoryError!
squares_gen = get_squares_gen(1_000_000_000)     # Instant, ~0 bytes
next(squares_gen)  # 0
next(squares_gen)  # 1

# List comprehension: creates full list in memory
squares_list = [x**2 for x in range(10_000_000)]  # ~80 MB

# Generator expression: lazy evaluation
squares_gen = (x**2 for x in range(10_000_000))   # ~0 bytes

def flatten(nested_list):
    for item in nested_list:
        if isinstance(item, list):
            yield from flatten(item)  # Delegate to recursive generator
        else:
            yield item

list(flatten([1, [2, [3, 4]], 5]))  # [1, 2, 3, 4, 5]

from functools import total_ordering

@total_ordering  # Generates __le__, __gt__, __ge__ from __eq__ and __lt__
class Money:
    def __init__(self, amount, currency="USD"):
        self.amount = amount
        self.currency = currency

    def __repr__(self):
        """For developers: unambiguous, ideally eval()-able."""
        return f"Money({self.amount!r}, {self.currency!r})"

    def __str__(self):
        """For users: readable."""
        return f"${self.amount:.2f} {self.currency}"

    def __eq__(self, other):
        if not isinstance(other, Money):
            return NotImplemented
        return self.amount == other.amount and self.currency == other.currency

    def __lt__(self, other):
        if not isinstance(other, Money):
            return NotImplemented
        if self.currency != other.currency:
            raise ValueError("Cannot compare different currencies")
        return self.amount < other.amount

    def __hash__(self):
        return hash((self.amount, self.currency))

    def __add__(self, other):
        if not isinstance(other, Money):
            return NotImplemented
        if self.currency != other.currency:
            raise ValueError("Cannot add different currencies")
        return Money(self.amount + other.amount, self.currency)

    def __bool__(self):
        return self.amount != 0

wallet = Money(50.00)
tip = Money(10.00)

print(repr(wallet))     # Money(50.0, 'USD')
print(str(wallet))      # $50.00 USD
print(wallet + tip)     # $60.00 USD
print(wallet > tip)     # True
print(wallet == Money(50.0))  # True

# Works as dict key (hashable)
prices = {Money(9.99): "coffee", Money(24.99): "book"}

import copy

original = [[1, 2, 3], [4, 5, 6]]

# Assignment: same object
assigned = original
assigned[0][0] = 99
print(original[0][0])  # 99 — both point to same object!

# Shallow copy: new outer, shared inner
original = [[1, 2, 3], [4, 5, 6]]
shallow = copy.copy(original)
shallow.append([7, 8])        # Only affects shallow (new outer)
shallow[0][0] = 99            # Affects BOTH (shared inner)
print(original[0][0])         # 99 — inner list is shared!
print(len(original))          # 2 — outer list is independent

# Deep copy: fully independent
original = [[1, 2, 3], [4, 5, 6]]
deep = copy.deepcopy(original)
deep[0][0] = 99               # Only affects deep
print(original[0][0])         # 1 — completely independent

# All of these create shallow copies:
lst_copy = lst[:]              # Slice
lst_copy = lst.copy()          # .copy() method
lst_copy = list(lst)           # Constructor
dict_copy = {**original_dict}  # Dict unpacking
dict_copy = dict.copy()        # .copy() method

def func(pos_only, /, normal, *args, kw_only, **kwargs):
    """Complete parameter order (Python 3.8+)"""
    pass

# Order: positional-only / normal / *args / keyword-only / **kwargs

# Flexible logging function
def log(message, *args, level="INFO", **kwargs):
    formatted = message.format(*args) if args else message
    print(f"[{level}] {formatted}", kwargs if kwargs else "")

log("User {} logged in from {}", "Alice", "NYC", level="DEBUG")
# [DEBUG] User Alice logged in from NYC

# Forwarding arguments (decorator pattern)
def decorator(func):
    @functools.wraps(func)
    def wrapper(*args, **kwargs):
        print(f"Calling {func.__name__}")
        return func(*args, **kwargs)  # Forward everything
    return wrapper

# Unpacking in function calls
def greet(first, last, greeting="Hello"):
    return f"{greeting}, {first} {last}!"

args = ("Alice", "Smith")
kwargs = {"greeting": "Hi"}
greet(*args, **kwargs)  # "Hi, Alice Smith!"

# WITHOUT context manager — resource leak if exception occurs!
f = open("data.txt")
try:
    data = f.read()
    process(data)     # If this raises, file stays open!
finally:
    f.close()

# WITH context manager — always cleaned up
with open("data.txt") as f:
    data = f.read()
    process(data)     # File closed even if exception raised

# Method 1: Class-based
class DatabaseConnection:
    def __init__(self, connection_string):
        self.connection_string = connection_string
        self.conn = None

    def __enter__(self):
        self.conn = connect(self.connection_string)
        return self.conn

    def __exit__(self, exc_type, exc_val, exc_tb):
        self.conn.close()
        return False  # Don't suppress exceptions

# Method 2: contextlib (simpler for most cases)
from contextlib import contextmanager

@contextmanager
def timer(label):
    start = time.perf_counter()
    try:
        yield  # Code inside 'with' block runs here
    finally:
        elapsed = time.perf_counter() - start
        print(f"{label}: {elapsed:.4f}s")

with timer("data processing"):
    process_large_dataset()

import sys

a = [1, 2, 3]         # refcount = 1
b = a                  # refcount = 2
print(sys.getrefcount(a))  # 3 (includes temporary ref from getrefcount)

del b                  # refcount drops to 1
del a                  # refcount drops to 0 → immediately freed

# Reference counting alone can't handle this:
class Node:
    def __init__(self):
        self.ref = None

a = Node()
b = Node()
a.ref = b    # a → b
b.ref = a    # b → a (cycle!)

del a, b     # refcount never reaches 0!
# Cyclic GC detects and collects these

import gc

# Force garbage collection (rarely needed)
gc.collect()

# Disable GC for performance-critical sections
gc.disable()
# ... time-critical code ...
gc.enable()

# Avoid reference cycles with weak references
import weakref
cache = weakref.WeakValueDictionary()

# Basic: [expression for item in iterable]
squares = [x**2 for x in range(10)]

# With condition: [expression for item in iterable if condition]
evens = [x for x in range(20) if x % 2 == 0]

# Nested: [expression for item1 in iter1 for item2 in iter2]
pairs = [(x, y) for x in range(3) for y in range(3) if x != y]

# List comprehension
squares = [x**2 for x in range(10)]           # → list

# Dict comprehension
word_len = {w: len(w) for w in words}          # → dict

# Set comprehension
unique_lower = {s.lower() for s in names}      # → set

# Generator expression (lazy!)
sum_squares = sum(x**2 for x in range(10**9))  # → generator (no memory!)

import timeit

# List comprehension: ~30% faster than loop
timeit.timeit('[x**2 for x in range(1000)]', number=10000)

# Equivalent for loop
timeit.timeit('''
result = []
for x in range(1000):
    result.append(x**2)
''', number=10000)

# TOO COMPLEX — use a regular loop instead
result = [
    transform(x)
    for group in data
    for x in group.items
    if x.is_valid()
    if x.score > threshold
]

# BETTER — readable for loop
result = []
for group in data:
    for x in group.items:
        if x.is_valid() and x.score > threshold:
            result.append(transform(x))

import asyncio
import aiohttp

async def fetch_url(session, url):
    """Fetch a single URL — suspends at await, frees event loop."""
    async with session.get(url) as response:
        return await response.text()

async def fetch_all(urls):
    """Fetch all URLs concurrently — not sequentially!"""
    async with aiohttp.ClientSession() as session:
        tasks = [asyncio.create_task(fetch_url(session, url)) for url in urls]
        return await asyncio.gather(*tasks)

# Sequential: 10 URLs × 200ms = ~2000ms
# Concurrent: 10 URLs overlapped = ~200ms
urls = [f"https://api.example.com/data/{i}" for i in range(10)]
results = asyncio.run(fetch_all(urls))

# WRONG: Calling coroutine without await
result = fetch_url(session, url)  # Returns coroutine object, not result!

# WRONG: Sequential awaits when concurrency is possible
for url in urls:
    result = await fetch_url(session, url)  # One at a time!

# RIGHT: Concurrent execution
results = await asyncio.gather(*[fetch_url(session, url) for url in urls])

# WRONG: Blocking call inside async function
async def bad():
    time.sleep(5)  # Blocks entire event loop!

# RIGHT: Use async sleep
async def good():
    await asyncio.sleep(5)  # Yields control to event loop

# Basic types
name: str = "Alice"
age: int = 30
scores: list[float] = [98.5, 87.3, 92.1]

# Union types (Python 3.10+: use |)
def find_user(user_id: int) -> dict | None:
    ...

# Function signatures
def process_items(
    items: list[str],
    *,
    batch_size: int = 32,
    callback: Callable[[str, int], bool] | None = None,
) -> dict[str, int]:
    ...

# Generics
from typing import TypeVar, Generic

T = TypeVar("T")

class Stack(Generic[T]):
    def __init__(self) -> None:
        self._items: list[T] = []

    def push(self, item: T) -> None:
        self._items.append(item)

    def pop(self) -> T:
        return self._items.pop()

# Usage
int_stack: Stack[int] = Stack()
int_stack.push(42)

from typing import Protocol, TypedDict, Literal, TypeGuard

# Protocol: structural subtyping (duck typing with types)
class Drawable(Protocol):
    def draw(self) -> None: ...

def render(obj: Drawable) -> None:
    obj.draw()  # Any object with draw() method works

# TypedDict: typed dictionaries
class UserDict(TypedDict):
    name: str
    age: int
    email: str | None

# Literal: restrict to specific values
def set_mode(mode: Literal["read", "write", "append"]) -> None: ...

# TypeGuard: narrow types in conditionals
def is_string_list(val: list[object]) -> TypeGuard[list[str]]:
    return all(isinstance(x, str) for x in val)

# WITHOUT dataclass: ~25 lines of boilerplate
class PointManual:
    def __init__(self, x: float, y: float, label: str = ""):
        self.x = x
        self.y = y
        self.label = label

    def __repr__(self):
        return f"PointManual(x={self.x!r}, y={self.y!r}, label={self.label!r})"

    def __eq__(self, other):
        if not isinstance(other, PointManual):
            return NotImplemented
        return (self.x, self.y, self.label) == (other.x, other.y, other.label)

    def __hash__(self):
        return hash((self.x, self.y, self.label))

# WITH dataclass: 5 lines, same functionality
from dataclasses import dataclass, field

@dataclass(frozen=True)  # frozen=True makes it immutable + hashable
class Point:
    x: float
    y: float
    label: str = ""

from dataclasses import dataclass, field, asdict, astuple
from typing import ClassVar

@dataclass(order=True, slots=True)  # slots=True for memory efficiency (3.10+)
class Employee:
    # ClassVar excluded from __init__ and __repr__
    company: ClassVar[str] = "Acme Corp"

    # Sort key (used for ordering)
    sort_index: int = field(init=False, repr=False)

    name: str
    salary: float
    skills: list[str] = field(default_factory=list)  # Mutable default!

    def __post_init__(self):
        self.sort_index = self.salary  # Sort by salary

# Usage
emp = Employee("Alice", 95000, ["Python", "SQL"])
emp_dict = asdict(emp)   # Convert to dict
emp_tuple = astuple(emp) # Convert to tuple

# These are EQUIVALENT:
class Dog:
    def speak(self):
        return "Woof"

# is the same as:
Dog = type("Dog", (), {"speak": lambda self: "Woof"})
# type(name, bases, namespace) → creates a new class

class ValidatedMeta(type):
    """Metaclass that enforces all methods have docstrings."""

    def __new__(mcs, name, bases, namespace):
        for key, value in namespace.items():
            if callable(value) and not key.startswith("_"):
                if not value.__doc__:
                    raise TypeError(
                        f"Method '{key}' in class '{name}' must have a docstring"
                    )
        return super().__new__(mcs, name, bases, namespace)

class APIEndpoint(metaclass=ValidatedMeta):
    def get(self):
        """Handle GET request."""  # OK: has docstring
        ...

    def post(self):  # ERROR at class creation time!
        ...          # TypeError: Method 'post' must have a docstring

class SingletonMeta(type):
    _instances = {}

    def __call__(cls, *args, **kwargs):
        if cls not in cls._instances:
            cls._instances[cls] = super().__call__(*args, **kwargs)
        return cls._instances[cls]

class Database(metaclass=SingletonMeta):
    def __init__(self):
        self.connection = "connected"

db1 = Database()
db2 = Database()
assert db1 is db2  # Same instance!

def divide(a, b):
    try:
        result = a / b
    except ZeroDivisionError:
        print("Cannot divide by zero")
        return None
    except TypeError as e:
        print(f"Type error: {e}")
        raise  # Re-raise the original exception
    else:
        # Only runs if NO exception occurred
        print(f"Division successful: {result}")
        return result
    finally:
        # ALWAYS runs — even if return/raise happened above
        print("Cleanup complete")

class AppError(Exception):
    """Base exception for application."""
    def __init__(self, message: str, code: str, details: dict | None = None):
        super().__init__(message)
        self.code = code
        self.details = details or {}

class ValidationError(AppError):
    """Raised when input validation fails."""
    pass

class NotFoundError(AppError):
    """Raised when a resource is not found."""
    pass

# Usage
def get_user(user_id: int) -> dict:
    if user_id < 0:
        raise ValidationError(
            "User ID must be positive",
            code="INVALID_USER_ID",
            details={"user_id": user_id}
        )
    user = db.find(user_id)
    if not user:
        raise NotFoundError(
            f"User {user_id} not found",
            code="USER_NOT_FOUND"
        )
    return user

try:
    data = json.loads(raw_input)
except json.JSONDecodeError as e:
    raise ValidationError("Invalid JSON input") from e
    # Original exception preserved in __cause__

# Python 3.11+: Exception Groups
async def fetch_all(urls):
    async with asyncio.TaskGroup() as tg:
        tasks = [tg.create_task(fetch(url)) for url in urls]
    # If multiple tasks fail, raises ExceptionGroup

class Pizza:
    # Class variable
    base_price = 10.0

    def __init__(self, toppings: list[str], size: str = "medium"):
        self.toppings = toppings
        self.size = size

    # INSTANCE METHOD: accesses self (instance data)
    def get_price(self) -> float:
        """Calculate price based on instance data."""
        topping_cost = len(self.toppings) * 1.50
        size_multiplier = {"small": 0.8, "medium": 1.0, "large": 1.3}
        return (self.base_price + topping_cost) * size_multiplier[self.size]

    # CLASS METHOD: accesses cls (class data), alternative constructor
    @classmethod
    def margherita(cls) -> "Pizza":
        """Factory method: create a standard Margherita."""
        return cls(["mozzarella", "tomato", "basil"])

    @classmethod
    def set_base_price(cls, price: float) -> None:
        """Modify class-level data."""
        cls.base_price = price

    # STATIC METHOD: no access to cls or self, utility function
    @staticmethod
    def validate_topping(topping: str) -> bool:
        """Pure utility — doesn't need class or instance data."""
        valid = {"mozzarella", "pepperoni", "mushrooms", "olives", "basil", "tomato"}
        return topping.lower() in valid

# Usage
p = Pizza.margherita()           # classmethod as factory
print(p.get_price())             # instance method
Pizza.validate_topping("olives") # staticmethod — no instance needed

class Serializer:
    def __init__(self, data: dict):
        self.data = data

    @classmethod
    def from_json(cls, json_string: str) -> "Serializer":
        return cls(json.loads(json_string))

    @classmethod
    def from_csv(cls, csv_path: str) -> "Serializer":
        with open(csv_path) as f:
            reader = csv.DictReader(f)
            return cls(next(reader))

    @classmethod
    def from_yaml(cls, yaml_string: str) -> "Serializer":
        return cls(yaml.safe_load(yaml_string))

class PointRegular:
    def __init__(self, x, y):
        self.x = x
        self.y = y

class PointSlots:
    __slots__ = ("x", "y")

    def __init__(self, x, y):
        self.x = x
        self.y = y

# Memory comparison (1 million instances)
import sys

regular = PointRegular(1.0, 2.0)
slotted = PointSlots(1.0, 2.0)

print(sys.getsizeof(regular.__dict__))  # 104 bytes (just the dict!)
# PointSlots has no __dict__ — memory is inline

# Dynamic attribute behavior
regular.z = 3.0       # Works — __dict__ allows anything
# slotted.z = 3.0    # AttributeError! Not in __slots__

# For 1 million instances:
# Regular class: ~170 bytes/instance × 1M = ~170 MB
# Slotted class: ~56 bytes/instance × 1M = ~56 MB
# Savings: ~67%!

# Python 3.10+ dataclass with slots
from dataclasses import dataclass

@dataclass(slots=True)
class Coordinate:
    x: float
    y: float
    z: float = 0.0

# test_calculator.py
import pytest
from calculator import Calculator

class TestCalculator:
    """Group related tests in a class."""

    def test_add_positive_numbers(self):
        calc = Calculator()
        assert calc.add(2, 3) == 5

    def test_add_negative_numbers(self):
        calc = Calculator()
        assert calc.add(-1, -1) == -2

    def test_divide_by_zero_raises(self):
        calc = Calculator()
        with pytest.raises(ZeroDivisionError):
            calc.divide(10, 0)

import pytest

@pytest.fixture
def db_connection():
    """Setup: create connection. Teardown: close it."""
    conn = Database.connect("test_db")
    yield conn  # Test runs here
    conn.close()  # Cleanup after test

@pytest.fixture
def sample_user(db_connection):
    """Fixtures can depend on other fixtures."""
    user = db_connection.create_user("Alice", "alice@test.com")
    yield user
    db_connection.delete_user(user.id)

def test_user_email(sample_user):
    assert sample_user.email == "alice@test.com"

@pytest.mark.parametrize("input_val,expected", [
    ("hello", "HELLO"),
    ("world", "WORLD"),
    ("Python", "PYTHON"),
    ("", ""),
])
def test_uppercase(input_val, expected):
    assert input_val.upper() == expected

@pytest.mark.parametrize("a,b,expected", [
    (1, 2, 3),
    (-1, 1, 0),
    (0, 0, 0),
    (100, -50, 50),
])
def test_add(a, b, expected):
    assert add(a, b) == expected

from unittest.mock import patch, MagicMock

def test_api_call():
    """Mock external HTTP calls."""
    mock_response = MagicMock()
    mock_response.status_code = 200
    mock_response.json.return_value = {"name": "Alice"}

    with patch("requests.get", return_value=mock_response):
        result = get_user_from_api(user_id=1)
        assert result["name"] == "Alice"

# Or as a decorator
@patch("myapp.services.send_email")
def test_registration(mock_send_email):
    register_user("alice@test.com")
    mock_send_email.assert_called_once_with("alice@test.com", subject="Welcome!")

from collections import defaultdict

# WITHOUT defaultdict
word_groups = {}
for word in words:
    first_letter = word[0]
    if first_letter not in word_groups:
        word_groups[first_letter] = []
    word_groups[first_letter].append(word)

# WITH defaultdict — cleaner!
word_groups = defaultdict(list)
for word in words:
    word_groups[word[0]].append(word)

# Common factory functions
counts = defaultdict(int)      # Missing keys default to 0
groups = defaultdict(list)     # Missing keys default to []
nested = defaultdict(dict)     # Missing keys default to {}
sets = defaultdict(set)        # Missing keys default to set()

from collections import Counter

# Count elements
words = ["apple", "banana", "apple", "cherry", "banana", "apple"]
word_counts = Counter(words)
# Counter({'apple': 3, 'banana': 2, 'cherry': 1})

# Most common
word_counts.most_common(2)  # [('apple', 3), ('banana', 2)]

# Arithmetic
c1 = Counter(a=3, b=1)
c2 = Counter(a=1, b=2)
c1 + c2   # Counter({'a': 4, 'b': 3})
c1 - c2   # Counter({'a': 2})  — drops zero/negative

# Count characters in string
Counter("mississippi")
# Counter({'s': 4, 'i': 4, 'p': 2, 'm': 1})

from collections import deque

# O(1) operations on both ends (list.pop(0) is O(n)!)
dq = deque([1, 2, 3])
dq.appendleft(0)   # [0, 1, 2, 3]
dq.popleft()       # 0, deque is [1, 2, 3]

# Fixed-size sliding window
recent_logs = deque(maxlen=100)
recent_logs.append("event1")  # Auto-removes oldest when full

# BFS implementation
def bfs(graph, start):
    visited = set()
    queue = deque([start])
    while queue:
        node = queue.popleft()  # O(1) vs list.pop(0) O(n)
        if node not in visited:
            visited.add(node)
            queue.extend(graph[node])
    return visited

from collections import namedtuple

# Create a type
Point = namedtuple("Point", ["x", "y"])
Color = namedtuple("Color", "red green blue")

p = Point(3, 4)
print(p.x, p.y)    # Named access
print(p[0], p[1])  # Index access
x, y = p           # Unpacking

# With defaults (Python 3.6.1+)
Server = namedtuple("Server", ["host", "port", "protocol"], defaults=["https"])
s = Server("example.com", 443)  # protocol defaults to "https"

# property() is actually a descriptor!
class property:
    def __init__(self, fget=None, fset=None, fdel=None):
        self.fget = fget
        self.fset = fset
        self.fdel = fdel

    def __get__(self, obj, objtype=None):
        if obj is None:
            return self
        return self.fget(obj)

    def __set__(self, obj, value):
        self.fset(obj, value)

    def __delete__(self, obj):
        self.fdel(obj)

class Validated:
    """Descriptor that validates values on assignment."""

    def __init__(self, min_value=None, max_value=None):
        self.min_value = min_value
        self.max_value = max_value

    def __set_name__(self, owner, name):
        """Called automatically when descriptor is assigned to a class attribute."""
        self.name = name
        self.private_name = f"_{name}"

    def __get__(self, obj, objtype=None):
        if obj is None:
            return self
        return getattr(obj, self.private_name, None)

    def __set__(self, obj, value):
        if self.min_value is not None and value < self.min_value:
            raise ValueError(f"{self.name} must be >= {self.min_value}, got {value}")
        if self.max_value is not None and value > self.max_value:
            raise ValueError(f"{self.name} must be <= {self.max_value}, got {value}")
        setattr(obj, self.private_name, value)

# Usage — validation happens automatically on assignment
class Product:
    price = Validated(min_value=0)
    quantity = Validated(min_value=0, max_value=10000)
    rating = Validated(min_value=0, max_value=5)

    def __init__(self, name, price, quantity):
        self.name = name
        self.price = price        # Triggers Validated.__set__
        self.quantity = quantity   # Triggers Validated.__set__

p = Product("Widget", 9.99, 100)
# p.price = -5  # ValueError: price must be >= 0, got -5

# These are ALL descriptors:
class MyClass:
    @property          # Data descriptor
    def value(self): ...

    @classmethod       # Non-data descriptor
    def create(cls): ...

    @staticmethod      # Non-data descriptor
    def utility(): ...

    __slots__ = ("x",) # Creates data descriptors for each slot

# VIOLATION: One class does too many things
class UserManager:
    def create_user(self, data): ...
    def send_welcome_email(self, user): ...
    def generate_report(self, users): ...
    def export_to_csv(self, users): ...

# FIXED: Each class has one responsibility
class UserService:
    def create_user(self, data): ...

class EmailService:
    def send_welcome_email(self, user): ...

class UserReporter:
    def generate_report(self, users): ...
    def export_to_csv(self, users): ...

from abc import ABC, abstractmethod

# VIOLATION: Adding a new payment method requires modifying existing code
def process_payment(method, amount):
    if method == "credit_card":
        ...
    elif method == "paypal":
        ...
    elif method == "crypto":  # Must modify this function!
        ...

# FIXED: Open for extension (new classes), closed for modification
class PaymentProcessor(ABC):
    @abstractmethod
    def process(self, amount: float) -> bool: ...

class CreditCardProcessor(PaymentProcessor):
    def process(self, amount: float) -> bool: ...

class PayPalProcessor(PaymentProcessor):
    def process(self, amount: float) -> bool: ...

class CryptoProcessor(PaymentProcessor):  # Just add new class!
    def process(self, amount: float) -> bool: ...

from typing import Protocol

# Abstraction (Protocol = duck-typed interface)
class UserRepository(Protocol):
    def get_by_id(self, user_id: int) -> dict: ...
    def save(self, user: dict) -> None: ...

# High-level module depends on abstraction, not concrete DB
class UserService:
    def __init__(self, repo: UserRepository):
        self.repo = repo  # Injected — can be any implementation

    def get_user(self, user_id: int) -> dict:
        return self.repo.get_by_id(user_id)

# Concrete implementations
class PostgresUserRepo:
    def get_by_id(self, user_id: int) -> dict: ...
    def save(self, user: dict) -> None: ...

class InMemoryUserRepo:  # For testing!
    def __init__(self):
        self._store = {}
    def get_by_id(self, user_id: int) -> dict:
        return self._store[user_id]
    def save(self, user: dict) -> None:
        self._store[user["id"]] = user

# Production
service = UserService(PostgresUserRepo())
# Testing
service = UserService(InMemoryUserRepo())

from typing import Protocol

class EmailSender(Protocol):
    def send(self, to: str, subject: str, body: str) -> None: ...

# 1. CONSTRUCTOR INJECTION (most common, recommended)
class NotificationService:
    def __init__(self, email_sender: EmailSender):
        self._sender = email_sender

    def notify_user(self, user_email: str, message: str):
        self._sender.send(user_email, "Notification", message)

# 2. METHOD INJECTION (for one-off dependencies)
class ReportGenerator:
    def generate(self, data: list, formatter: Formatter) -> str:
        return formatter.format(data)

# 3. MODULE-LEVEL INJECTION (simple cases)
# config.py
def get_database():
    if os.environ.get("TESTING"):
        return InMemoryDB()
    return PostgresDB(os.environ["DATABASE_URL"])

# app.py — the "composition root" wires everything together
def create_app():
    """Build the dependency graph at application startup."""
    # Infrastructure
    db = PostgresDatabase(settings.DATABASE_URL)
    cache = RedisCache(settings.REDIS_URL)
    email = SMTPEmailSender(settings.SMTP_HOST)

    # Repositories
    user_repo = PostgresUserRepo(db)
    order_repo = PostgresOrderRepo(db)

    # Services (injected with repos)
    user_service = UserService(user_repo, cache)
    order_service = OrderService(order_repo, user_service)
    notification_service = NotificationService(email)

    # API layer (injected with services)
    app = FastAPI()
    app.include_router(create_user_router(user_service))
    app.include_router(create_order_router(order_service))

    return app

# Tests inject fakes/mocks — no real DB or email!
def test_notify_user():
    fake_sender = FakeEmailSender()
    service = NotificationService(fake_sender)

    service.notify_user("alice@test.com", "Hello!")

    assert fake_sender.sent_emails == [
        ("alice@test.com", "Notification", "Hello!")
    ]

from dataclasses import dataclass
from typing import Literal

@dataclass
class Notification:
    message: str
    recipient: str

class EmailNotification(Notification):
    def send(self): print(f"Email to {self.recipient}: {self.message}")

class SMSNotification(Notification):
    def send(self): print(f"SMS to {self.recipient}: {self.message}")

class SlackNotification(Notification):
    def send(self): print(f"Slack to {self.recipient}: {self.message}")

# Factory function (Pythonic — no need for a class!)
def create_notification(
    channel: Literal["email", "sms", "slack"],
    message: str,
    recipient: str,
) -> Notification:
    factories = {
        "email": EmailNotification,
        "sms": SMSNotification,
        "slack": SlackNotification,
    }
    if channel not in factories:
        raise ValueError(f"Unknown channel: {channel}")
    return factories[channel](message=message, recipient=recipient)

from typing import Callable

# In Java you'd create a Strategy interface + concrete classes
# In Python: just pass a function!

def process_data(
    data: list[float],
    strategy: Callable[[list[float]], float],
) -> float:
    return strategy(data)

# Strategies are just functions
def mean_strategy(data: list[float]) -> float:
    return sum(data) / len(data)

def median_strategy(data: list[float]) -> float:
    sorted_data = sorted(data)
    n = len(sorted_data)
    mid = n // 2
    return sorted_data[mid] if n % 2 else (sorted_data[mid-1] + sorted_data[mid]) / 2

# Usage
result = process_data([1, 2, 3, 4, 5], strategy=mean_strategy)
result = process_data([1, 2, 3, 4, 5], strategy=median_strategy)

from typing import Callable

class EventBus:
    """Simple publish-subscribe event system."""

    def __init__(self):
        self._subscribers: dict[str, list[Callable]] = {}

    def subscribe(self, event: str, callback: Callable) -> None:
        self._subscribers.setdefault(event, []).append(callback)

    def publish(self, event: str, **data) -> None:
        for callback in self._subscribers.get(event, []):
            callback(**data)

# Usage
bus = EventBus()
bus.subscribe("user_created", lambda **d: send_welcome_email(d["email"]))
bus.subscribe("user_created", lambda **d: log_event("signup", d))
bus.publish("user_created", email="alice@example.com", name="Alice")

# DON'T use metaclass singleton in Python. Use module-level instance:

# database.py
class _Database:
    def __init__(self):
        self._connection = None

    def connect(self, url: str):
        self._connection = create_connection(url)

    def query(self, sql: str):
        return self._connection.execute(sql)

# Module-level singleton — imported by other modules
db = _Database()

# Other files:
# from mypackage.database import db
# db.query("SELECT * FROM users")

# config.py
from pydantic_settings import BaseSettings
from pydantic import Field

class Settings(BaseSettings):
    """Application settings — loaded from environment variables."""

    # Required (no default = must be in env)
    database_url: str
    secret_key: str

    # Optional with defaults
    debug: bool = False
    log_level: str = "INFO"
    max_connections: int = Field(default=10, ge=1, le=100)
    allowed_hosts: list[str] = ["localhost"]

    # Nested prefix
    redis_host: str = "localhost"
    redis_port: int = 6379

    model_config = {
        "env_file": ".env",           # Load from .env in development
        "env_file_encoding": "utf-8",
        "case_sensitive": False,
    }

# Instantiate once at startup — validates all values
settings = Settings()

# Usage elsewhere:
# from mypackage.config import settings
# db = connect(settings.database_url)

# .env (local development — NEVER commit this!)
DATABASE_URL=postgresql://user:pass@localhost/mydb
SECRET_KEY=dev-secret-key-change-in-prod
DEBUG=true
LOG_LEVEL=DEBUG

# .env.example (committed — template for developers)
DATABASE_URL=postgresql://user:password@localhost/dbname
SECRET_KEY=change-me
DEBUG=false
LOG_LEVEL=INFO