# Approach 1: Module-level instance (Pythonic — recommended)
# config.py
class _AppConfig:
    """Private class — consumers use the module-level instance."""

    def __init__(self):
        self._settings: dict = {}
        self._loaded = False

    def load(self, path: str) -> None:
        import json
        with open(path) as f:
            self._settings = json.load(f)
        self._loaded = True

    def get(self, key: str, default=None):
        return self._settings.get(key, default)

# Module-level singleton — Python imports are cached
config = _AppConfig()

# Usage:
# from myapp.config import config
# config.load("settings.json")
# db_url = config.get("database_url")

# Approach 2: __new__ override (when you need class-based control)
class DatabasePool:
    _instance = None

    def __new__(cls, *args, **kwargs):
        if cls._instance is None:
            cls._instance = super().__new__(cls)
            cls._instance._initialized = False
        return cls._instance

    def __init__(self, connection_string: str = ""):
        if self._initialized:
            return
        self.connection_string = connection_string
        self._pool = []
        self._initialized = True

    def get_connection(self):
        # Return connection from pool
        ...

# Both variables point to the same object
pool1 = DatabasePool("postgres://localhost/db")
pool2 = DatabasePool("ignored — already initialized")
assert pool1 is pool2  # True

# Approach 3: Thread-safe Singleton (for multi-threaded apps)
import threading

class ThreadSafeSingleton:
    _instance = None
    _lock = threading.Lock()

    def __new__(cls, *args, **kwargs):
        if cls._instance is None:
            with cls._lock:  # Double-checked locking
                if cls._instance is None:
                    cls._instance = super().__new__(cls)
        return cls._instance

from abc import ABC, abstractmethod
from dataclasses import dataclass

# Product interface
class Notification(ABC):
    @abstractmethod
    def send(self, recipient: str, message: str) -> bool: ...

# Concrete products
@dataclass
class EmailNotification(Notification):
    smtp_host: str = "smtp.example.com"

    def send(self, recipient: str, message: str) -> bool:
        print(f"Email to {recipient}: {message}")
        return True

@dataclass
class SMSNotification(Notification):
    api_key: str = ""

    def send(self, recipient: str, message: str) -> bool:
        print(f"SMS to {recipient}: {message}")
        return True

@dataclass
class PushNotification(Notification):
    def send(self, recipient: str, message: str) -> bool:
        print(f"Push to {recipient}: {message}")
        return True

# Factory (Pythonic: use a registry dict, not class hierarchy)
class NotificationFactory:
    _registry: dict[str, type[Notification]] = {
        "email": EmailNotification,
        "sms": SMSNotification,
        "push": PushNotification,
    }

    @classmethod
    def register(cls, name: str, notification_cls: type[Notification]):
        """Open for extension — register new types at runtime."""
        cls._registry[name] = notification_cls

    @classmethod
    def create(cls, channel: str, **kwargs) -> Notification:
        if channel not in cls._registry:
            raise ValueError(f"Unknown channel: {channel}")
        return cls._registry[channel](**kwargs)

# Usage
notif = NotificationFactory.create("email", smtp_host="mail.company.com")
notif.send("alice@example.com", "Hello!")

# Extend without modifying factory:
NotificationFactory.register("slack", SlackNotification)

from abc import ABC, abstractmethod

# Abstract products
class Button(ABC):
    @abstractmethod
    def render(self) -> str: ...

class Input(ABC):
    @abstractmethod
    def render(self) -> str: ...

# Concrete products — Light theme
class LightButton(Button):
    def render(self) -> str:
        return "<button class='btn-light'>Click</button>"

class LightInput(Input):
    def render(self) -> str:
        return "<input class='input-light'/>"

# Concrete products — Dark theme
class DarkButton(Button):
    def render(self) -> str:
        return "<button class='btn-dark'>Click</button>"

class DarkInput(Input):
    def render(self) -> str:
        return "<input class='input-dark'/>"

# Abstract Factory
class UIFactory(ABC):
    @abstractmethod
    def create_button(self) -> Button: ...
    @abstractmethod
    def create_input(self) -> Input: ...

class LightThemeFactory(UIFactory):
    def create_button(self) -> Button:
        return LightButton()
    def create_input(self) -> Input:
        return LightInput()

class DarkThemeFactory(UIFactory):
    def create_button(self) -> Button:
        return DarkButton()
    def create_input(self) -> Input:
        return DarkInput()

# Client code — works with ANY factory
def build_form(factory: UIFactory) -> str:
    button = factory.create_button()
    input_field = factory.create_input()
    return f"{input_field.render()}\n{button.render()}"

# Swap themes without changing client code
print(build_form(DarkThemeFactory()))

from typing import Protocol, Any
from dataclasses import dataclass, field

# Observer protocol (structural typing — no inheritance required)
class EventHandler(Protocol):
    def handle(self, event: str, data: dict[str, Any]) -> None: ...

# Subject (Publisher)
class EventBus:
    """Publish-subscribe event system."""

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

    def subscribe(self, event: str, handler: EventHandler) -> None:
        if event not in self._subscribers:
            self._subscribers[event] = []
        self._subscribers[event].append(handler)

    def unsubscribe(self, event: str, handler: EventHandler) -> None:
        if event in self._subscribers:
            self._subscribers[event].remove(handler)

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

# Concrete observers
class EmailNotifier:
    def handle(self, event: str, data: dict[str, Any]) -> None:
        email = data.get("email", "")
        print(f"[Email] Sending notification to {email} for event: {event}")

class AnalyticsTracker:
    def handle(self, event: str, data: dict[str, Any]) -> None:
        print(f"[Analytics] Tracking event: {event}, data: {data}")

class AuditLogger:
    def handle(self, event: str, data: dict[str, Any]) -> None:
        print(f"[Audit] {event}: {data}")

# Usage
bus = EventBus()
bus.subscribe("user_registered", EmailNotifier())
bus.subscribe("user_registered", AnalyticsTracker())
bus.subscribe("user_registered", AuditLogger())
bus.subscribe("order_placed", AnalyticsTracker())

# Publishing an event notifies all relevant observers
bus.publish("user_registered", email="alice@example.com", user_id=42)
# Output:
# [Email] Sending notification to alice@example.com for event: user_registered
# [Analytics] Tracking event: user_registered, data: {...}
# [Audit] user_registered: {...}

import asyncio
from typing import Callable, Awaitable

class AsyncEventBus:
    """Async event bus for I/O-bound handlers."""

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

    def on(self, event: str, handler: Callable[..., Awaitable]) -> None:
        self._handlers.setdefault(event, []).append(handler)

    async def emit(self, event: str, **data) -> None:
        handlers = self._handlers.get(event, [])
        # Run all handlers concurrently
        await asyncio.gather(*(h(**data) for h in handlers))

# Usage
bus = AsyncEventBus()

async def send_email(email: str, **_):
    await asyncio.sleep(0.1)  # Simulate I/O
    print(f"Email sent to {email}")

async def track_event(user_id: int, **_):
    await asyncio.sleep(0.05)
    print(f"Tracked signup for user {user_id}")

bus.on("signup", send_email)
bus.on("signup", track_event)
await bus.emit("signup", email="bob@test.com", user_id=7)

from abc import ABC, abstractmethod
from dataclasses import dataclass

# Strategy interface
class CompressionStrategy(ABC):
    @abstractmethod
    def compress(self, data: bytes) -> bytes: ...

    @abstractmethod
    def decompress(self, data: bytes) -> bytes: ...

# Concrete strategies
class GzipStrategy(CompressionStrategy):
    def compress(self, data: bytes) -> bytes:
        import gzip
        return gzip.compress(data)

    def decompress(self, data: bytes) -> bytes:
        import gzip
        return gzip.decompress(data)

class LZ4Strategy(CompressionStrategy):
    def compress(self, data: bytes) -> bytes:
        import lz4.frame
        return lz4.frame.compress(data)

    def decompress(self, data: bytes) -> bytes:
        import lz4.frame
        return lz4.frame.decompress(data)

class NoCompression(CompressionStrategy):
    def compress(self, data: bytes) -> bytes:
        return data

    def decompress(self, data: bytes) -> bytes:
        return data

# Context
class FileStorage:
    def __init__(self, strategy: CompressionStrategy):
        self._strategy = strategy

    def set_strategy(self, strategy: CompressionStrategy) -> None:
        """Switch strategy at runtime."""
        self._strategy = strategy

    def save(self, filename: str, data: bytes) -> None:
        compressed = self._strategy.compress(data)
        with open(filename, "wb") as f:
            f.write(compressed)

    def load(self, filename: str) -> bytes:
        with open(filename, "rb") as f:
            compressed = f.read()
        return self._strategy.decompress(compressed)

# Usage — switch compression at runtime
storage = FileStorage(GzipStrategy())
storage.save("data.gz", b"Hello, world!")

storage.set_strategy(LZ4Strategy())  # Switch strategy
storage.save("data.lz4", b"Hello, world!")

from typing import Callable

# Strategies are just functions — no classes needed!
def sort_by_price(products: list[dict]) -> list[dict]:
    return sorted(products, key=lambda p: p["price"])

def sort_by_rating(products: list[dict]) -> list[dict]:
    return sorted(products, key=lambda p: p["rating"], reverse=True)

def sort_by_name(products: list[dict]) -> list[dict]:
    return sorted(products, key=lambda p: p["name"])

# Context accepts any callable matching the signature
SortStrategy = Callable[[list[dict]], list[dict]]

def display_products(products: list[dict], strategy: SortStrategy) -> None:
    sorted_products = strategy(products)
    for p in sorted_products:
        print(f"  {p['name']}: ${p['price']} ({p['rating']}★)")

# Usage
products = [
    {"name": "Widget", "price": 25.99, "rating": 4.5},
    {"name": "Gadget", "price": 49.99, "rating": 4.8},
    {"name": "Doohickey", "price": 9.99, "rating": 3.9},
]

display_products(products, sort_by_price)
display_products(products, sort_by_rating)

# Lambda as strategy
display_products(products, lambda ps: sorted(ps, key=lambda p: -p["price"]))

from abc import ABC, abstractmethod

# Component interface
class DataSource(ABC):
    @abstractmethod
    def write(self, data: str) -> None: ...

    @abstractmethod
    def read(self) -> str: ...

# Concrete component
class FileDataSource(DataSource):
    def __init__(self, filename: str):
        self._filename = filename

    def write(self, data: str) -> None:
        with open(self._filename, "w") as f:
            f.write(data)

    def read(self) -> str:
        with open(self._filename, "r") as f:
            return f.read()

# Base decorator (wraps a DataSource)
class DataSourceDecorator(DataSource):
    def __init__(self, source: DataSource):
        self._wrapped = source

    def write(self, data: str) -> None:
        self._wrapped.write(data)

    def read(self) -> str:
        return self._wrapped.read()

# Concrete decorators — each adds one behavior
class EncryptionDecorator(DataSourceDecorator):
    def write(self, data: str) -> None:
        encrypted = self._encrypt(data)
        super().write(encrypted)

    def read(self) -> str:
        data = super().read()
        return self._decrypt(data)

    def _encrypt(self, data: str) -> str:
        # Simple Caesar cipher for illustration
        return "".join(chr(ord(c) + 3) for c in data)

    def _decrypt(self, data: str) -> str:
        return "".join(chr(ord(c) - 3) for c in data)

class CompressionDecorator(DataSourceDecorator):
    def write(self, data: str) -> None:
        compressed = self._compress(data)
        super().write(compressed)

    def read(self) -> str:
        data = super().read()
        return self._decompress(data)

    def _compress(self, data: str) -> str:
        import zlib, base64
        return base64.b64encode(zlib.compress(data.encode())).decode()

    def _decompress(self, data: str) -> str:
        import zlib, base64
        return zlib.decompress(base64.b64decode(data.encode())).decode()

# Stack decorators: File → Compress → Encrypt
source = EncryptionDecorator(
    CompressionDecorator(
        FileDataSource("secret.dat")
    )
)
source.write("Sensitive data here")
print(source.read())  # "Sensitive data here" — decrypted & decompressed

import functools
import time
import logging

logger = logging.getLogger(__name__)

# Python's @ syntax IS the decorator pattern for functions!
def retry(max_attempts: int = 3, delay: float = 1.0):
    """Decorator that retries a function on failure."""
    def decorator(func):
        @functools.wraps(func)
        def wrapper(*args, **kwargs):
            for attempt in range(1, max_attempts + 1):
                try:
                    return func(*args, **kwargs)
                except Exception as e:
                    if attempt == max_attempts:
                        raise
                    logger.warning(f"Attempt {attempt} failed: {e}. Retrying...")
                    time.sleep(delay)
        return wrapper
    return decorator

def cache(ttl_seconds: int = 300):
    """Decorator that caches results with a TTL."""
    def decorator(func):
        _cache: dict = {}

        @functools.wraps(func)
        def wrapper(*args, **kwargs):
            key = (args, tuple(sorted(kwargs.items())))
            if key in _cache:
                value, timestamp = _cache[key]
                if time.time() - timestamp < ttl_seconds:
                    return value
            result = func(*args, **kwargs)
            _cache[key] = (result, time.time())
            return result
        return wrapper
    return decorator

# Stack multiple decorators (like wrapping layers)
@retry(max_attempts=3)
@cache(ttl_seconds=60)
def fetch_user(user_id: int) -> dict:
    """First call fetches, subsequent calls use cache, failures retry."""
    return api_client.get(f"/users/{user_id}")

from typing import Protocol
from dataclasses import dataclass

# Target interface — what your application expects
class PaymentGateway(Protocol):
    def charge(self, amount_cents: int, currency: str, token: str) -> str:
        """Returns transaction ID."""
        ...

    def refund(self, transaction_id: str) -> bool: ...

# Adaptee 1: Stripe (uses dollars, different method names)
class StripeAPI:
    """Third-party Stripe SDK — incompatible interface."""
    def create_charge(self, amount: float, cur: str, source: str) -> dict:
        print(f"Stripe: charging ${amount} {cur}")
        return {"id": "ch_stripe_123", "status": "succeeded"}

    def create_refund(self, charge_id: str) -> dict:
        return {"id": "re_456", "status": "succeeded"}

# Adaptee 2: PayPal (completely different API)
class PayPalSDK:
    """Third-party PayPal SDK — incompatible interface."""
    def execute_payment(self, payment_data: dict) -> dict:
        print(f"PayPal: executing payment")
        return {"paymentId": "PAY-789", "state": "approved"}

    def void_payment(self, payment_id: str) -> dict:
        return {"state": "voided"}

# Adapters — translate between your interface and third-party SDKs
class StripeAdapter:
    """Adapts Stripe SDK to PaymentGateway interface."""

    def __init__(self, stripe: StripeAPI):
        self._stripe = stripe

    def charge(self, amount_cents: int, currency: str, token: str) -> str:
        # Convert cents to dollars (Stripe uses dollars)
        result = self._stripe.create_charge(
            amount=amount_cents / 100,
            cur=currency,
            source=token,
        )
        return result["id"]

    def refund(self, transaction_id: str) -> bool:
        result = self._stripe.create_refund(transaction_id)
        return result["status"] == "succeeded"

class PayPalAdapter:
    """Adapts PayPal SDK to PaymentGateway interface."""

    def __init__(self, paypal: PayPalSDK):
        self._paypal = paypal

    def charge(self, amount_cents: int, currency: str, token: str) -> str:
        result = self._paypal.execute_payment({
            "amount": {"total": amount_cents / 100, "currency": currency},
            "token": token,
        })
        return result["paymentId"]

    def refund(self, transaction_id: str) -> bool:
        result = self._paypal.void_payment(transaction_id)
        return result["state"] == "voided"

# Client code — works with any adapter uniformly
def process_order(gateway: PaymentGateway, amount: int, token: str) -> str:
    tx_id = gateway.charge(amount, "USD", token)
    print(f"Order processed. Transaction: {tx_id}")
    return tx_id

# Swap payment providers without changing business logic
stripe_gateway = StripeAdapter(StripeAPI())
paypal_gateway = PayPalAdapter(PayPalSDK())

process_order(stripe_gateway, 4999, "tok_visa")
process_order(paypal_gateway, 4999, "tok_paypal")

from dataclasses import dataclass, field
from typing import Self

@dataclass
class HttpRequest:
    """Complex object with many optional components."""
    method: str
    url: str
    headers: dict[str, str] = field(default_factory=dict)
    query_params: dict[str, str] = field(default_factory=dict)
    body: str | bytes | None = None
    timeout: float = 30.0
    retries: int = 0
    auth_token: str | None = None

class HttpRequestBuilder:
    """Fluent builder for constructing HttpRequest objects step by step."""

    def __init__(self, method: str, url: str):
        self._method = method
        self._url = url
        self._headers: dict[str, str] = {}
        self._query_params: dict[str, str] = {}
        self._body: str | bytes | None = None
        self._timeout: float = 30.0
        self._retries: int = 0
        self._auth_token: str | None = None

    def header(self, key: str, value: str) -> Self:
        self._headers[key] = value
        return self

    def query(self, key: str, value: str) -> Self:
        self._query_params[key] = value
        return self

    def body(self, content: str | bytes) -> Self:
        self._body = content
        return self

    def timeout(self, seconds: float) -> Self:
        self._timeout = seconds
        return self

    def retries(self, count: int) -> Self:
        self._retries = count
        return self

    def auth(self, token: str) -> Self:
        self._auth_token = token
        self._headers["Authorization"] = f"Bearer {token}"
        return self

    def build(self) -> HttpRequest:
        """Construct the final immutable object."""
        return HttpRequest(
            method=self._method,
            url=self._url,
            headers=self._headers,
            query_params=self._query_params,
            body=self._body,
            timeout=self._timeout,
            retries=self._retries,
            auth_token=self._auth_token,
        )

# Fluent usage — reads like natural language
request = (
    HttpRequestBuilder("POST", "https://api.example.com/users")
    .header("Content-Type", "application/json")
    .header("X-Request-ID", "abc-123")
    .auth("my-secret-token")
    .body('{"name": "Alice", "email": "alice@example.com"}')
    .timeout(10.0)
    .retries(3)
    .build()
)

from dataclasses import dataclass

@dataclass
class QueryConfig:
    """For simpler cases, dataclass + defaults = lightweight builder."""
    table: str
    select: list[str] = field(default_factory=lambda: ["*"])
    where: dict[str, str] = field(default_factory=dict)
    order_by: str | None = None
    limit: int = 100
    offset: int = 0

    def to_sql(self) -> str:
        cols = ", ".join(self.select)
        sql = f"SELECT {cols} FROM {self.table}"
        if self.where:
            conditions = " AND ".join(f"{k} = '{v}'" for k, v in self.where.items())
            sql += f" WHERE {conditions}"
        if self.order_by:
            sql += f" ORDER BY {self.order_by}"
        sql += f" LIMIT {self.limit} OFFSET {self.offset}"
        return sql

# Simple construction with keyword args
q = QueryConfig(
    table="users",
    select=["id", "name", "email"],
    where={"role": "admin"},
    order_by="created_at DESC",
    limit=50,
)
print(q.to_sql())

from abc import ABC, abstractmethod
from dataclasses import dataclass, field

# Command interface
class Command(ABC):
    @abstractmethod
    def execute(self) -> None: ...

    @abstractmethod
    def undo(self) -> None: ...

# Receiver
class TextDocument:
    def __init__(self):
        self.content: str = ""

    def insert(self, position: int, text: str) -> None:
        self.content = self.content[:position] + text + self.content[position:]

    def delete(self, position: int, length: int) -> str:
        deleted = self.content[position:position + length]
        self.content = self.content[:position] + self.content[position + length:]
        return deleted

# Concrete commands
@dataclass
class InsertCommand(Command):
    document: TextDocument
    position: int
    text: str

    def execute(self) -> None:
        self.document.insert(self.position, self.text)

    def undo(self) -> None:
        self.document.delete(self.position, len(self.text))

@dataclass
class DeleteCommand(Command):
    document: TextDocument
    position: int
    length: int
    _deleted_text: str = field(default="", init=False)

    def execute(self) -> None:
        self._deleted_text = self.document.delete(self.position, self.length)

    def undo(self) -> None:
        self.document.insert(self.position, self._deleted_text)

# Invoker with history
class CommandInvoker:
    def __init__(self):
        self._history: list[Command] = []
        self._redo_stack: list[Command] = []

    def execute(self, command: Command) -> None:
        command.execute()
        self._history.append(command)
        self._redo_stack.clear()  # New command invalidates redo

    def undo(self) -> None:
        if not self._history:
            return
        command = self._history.pop()
        command.undo()
        self._redo_stack.append(command)

    def redo(self) -> None:
        if not self._redo_stack:
            return
        command = self._redo_stack.pop()
        command.execute()
        self._history.append(command)

# Usage
doc = TextDocument()
invoker = CommandInvoker()

invoker.execute(InsertCommand(doc, 0, "Hello, "))
invoker.execute(InsertCommand(doc, 7, "World!"))
print(doc.content)  # "Hello, World!"

invoker.undo()
print(doc.content)  # "Hello, "

invoker.redo()
print(doc.content)  # "Hello, World!"

invoker.execute(DeleteCommand(doc, 5, 7))
print(doc.content)  # "Hello"

invoker.undo()
print(doc.content)  # "Hello, World!"

from abc import ABC, abstractmethod
from dataclasses import dataclass
from typing import Any

@dataclass
class Request:
    path: str
    method: str
    headers: dict[str, str]
    body: dict[str, Any] | None = None
    user: str | None = None

@dataclass
class Response:
    status_code: int
    body: dict[str, Any]

# Abstract handler
class Middleware(ABC):
    def __init__(self):
        self._next: Middleware | None = None

    def set_next(self, handler: "Middleware") -> "Middleware":
        self._next = handler
        return handler  # Enable chaining: a.set_next(b).set_next(c)

    def handle(self, request: Request) -> Response:
        if self._next:
            return self._next.handle(request)
        return Response(200, {"message": "OK"})

# Concrete handlers
class AuthenticationMiddleware(Middleware):
    def handle(self, request: Request) -> Response:
        token = request.headers.get("Authorization", "")
        if not token.startswith("Bearer "):
            return Response(401, {"error": "Missing or invalid token"})
        # Extract user from token
        request.user = token.split(" ")[1]  # Simplified
        return super().handle(request)

class RateLimitMiddleware(Middleware):
    def __init__(self, max_requests: int = 100):
        super().__init__()
        self._counts: dict[str, int] = {}
        self._max = max_requests

    def handle(self, request: Request) -> Response:
        user = request.user or "anonymous"
        self._counts[user] = self._counts.get(user, 0) + 1
        if self._counts[user] > self._max:
            return Response(429, {"error": "Rate limit exceeded"})
        return super().handle(request)

class ValidationMiddleware(Middleware):
    def handle(self, request: Request) -> Response:
        if request.method == "POST" and not request.body:
            return Response(400, {"error": "Request body required"})
        return super().handle(request)

class BusinessLogicHandler(Middleware):
    def handle(self, request: Request) -> Response:
        # Final handler — process the request
        return Response(200, {
            "message": f"Processed {request.method} {request.path}",
            "user": request.user,
        })

# Build the chain
auth = AuthenticationMiddleware()
rate_limit = RateLimitMiddleware(max_requests=10)
validation = ValidationMiddleware()
logic = BusinessLogicHandler()

auth.set_next(rate_limit).set_next(validation).set_next(logic)

# Process requests through the chain
request = Request(
    path="/api/users",
    method="POST",
    headers={"Authorization": "Bearer user123"},
    body={"name": "Alice"},
)

response = auth.handle(request)
print(f"{response.status_code}: {response.body}")
# 200: {'message': 'Processed POST /api/users', 'user': 'user123'}

# Failing request — stopped at authentication
bad_request = Request(path="/api/users", method="GET", headers={})
response = auth.handle(bad_request)
print(f"{response.status_code}: {response.body}")
# 401: {'error': 'Missing or invalid token'}

from typing import Protocol
import time

# Subject interface
class DatabaseService(Protocol):
    def query(self, sql: str) -> list[dict]: ...
    def execute(self, sql: str) -> int: ...

# Real subject (expensive to create, sensitive operations)
class PostgresDatabase:
    def __init__(self, connection_string: str):
        print(f"[DB] Connecting to database...")
        time.sleep(0.5)  # Expensive connection
        self._conn = connection_string

    def query(self, sql: str) -> list[dict]:
        print(f"[DB] Executing query: {sql}")
        return [{"id": 1, "name": "Alice"}]  # Simulated

    def execute(self, sql: str) -> int:
        print(f"[DB] Executing: {sql}")
        return 1  # Rows affected

# Virtual Proxy — lazy initialization
class LazyDatabaseProxy:
    """Defers expensive database connection until first use."""

    def __init__(self, connection_string: str):
        self._connection_string = connection_string
        self._db: PostgresDatabase | None = None

    def _get_db(self) -> PostgresDatabase:
        if self._db is None:
            self._db = PostgresDatabase(self._connection_string)
        return self._db

    def query(self, sql: str) -> list[dict]:
        return self._get_db().query(sql)

    def execute(self, sql: str) -> int:
        return self._get_db().execute(sql)

# Caching Proxy — avoids repeated expensive queries
class CachingDatabaseProxy:
    """Caches query results to reduce database load."""

    def __init__(self, db: DatabaseService, ttl: float = 60.0):
        self._db = db
        self._cache: dict[str, tuple[list[dict], float]] = {}
        self._ttl = ttl

    def query(self, sql: str) -> list[dict]:
        now = time.time()
        if sql in self._cache:
            result, timestamp = self._cache[sql]
            if now - timestamp < self._ttl:
                print(f"[Cache] HIT: {sql}")
                return result

        print(f"[Cache] MISS: {sql}")
        result = self._db.query(sql)
        self._cache[sql] = (result, now)
        return result

    def execute(self, sql: str) -> int:
        # Writes invalidate cache
        self._cache.clear()
        return self._db.execute(sql)

# Protection Proxy — access control
class ProtectedDatabaseProxy:
    """Restricts dangerous operations based on user role."""

    def __init__(self, db: DatabaseService, user_role: str):
        self._db = db
        self._role = user_role

    def query(self, sql: str) -> list[dict]:
        # All roles can read
        return self._db.query(sql)

    def execute(self, sql: str) -> int:
        # Only admins can write
        if self._role != "admin":
            raise PermissionError(
                f"Role '{self._role}' cannot execute write operations"
            )
        return self._db.execute(sql)

# Compose proxies: Lazy → Caching → Protected
db = ProtectedDatabaseProxy(
    CachingDatabaseProxy(
        LazyDatabaseProxy("postgres://localhost/mydb"),
        ttl=30,
    ),
    user_role="viewer",
)

# First query: lazy init + cache miss + actual query
result = db.query("SELECT * FROM users")

# Second query: cache hit (no DB call)
result = db.query("SELECT * FROM users")

# Write attempt: blocked by protection proxy
try:
    db.execute("DELETE FROM users")
except PermissionError as e:
    print(f"Blocked: {e}")

// 1. CONSTRUCTOR INJECTION (recommended by Spring team)
@Service
public class OrderService {

    private final OrderRepository orderRepo;
    private final EmailService emailService;

    // Spring auto-injects matching beans
    @Autowired // Optional in Spring 4.3+ with single constructor
    public OrderService(OrderRepository orderRepo, EmailService emailService) {
        this.orderRepo = orderRepo;
        this.emailService = emailService;
    }

    public Order createOrder(OrderRequest request) {
        Order order = orderRepo.save(new Order(request));
        emailService.sendConfirmation(order);
        return order;
    }
}

// 2. SETTER INJECTION (for optional dependencies)
@Service
public class ReportService {

    private ReportFormatter formatter;

    @Autowired(required = false) // Optional dependency
    public void setFormatter(ReportFormatter formatter) {
        this.formatter = formatter;
    }

    public String generate(List<Data> data) {
        if (formatter != null) {
            return formatter.format(data);
        }
        return data.toString(); // Fallback
    }
}

// 3. FIELD INJECTION (discouraged — hard to test)
@Service
public class UserService {

    @Autowired // Injected directly — no constructor or setter
    private UserRepository userRepo;

    // Hard to test: can't easily provide a mock
}

// Define beans with different scopes
@Component
@Scope("singleton") // Default — one instance per container
public class AppConfig { }

@Component
@Scope("prototype") // New instance every time it's injected
public class RequestHandler { }

@Component
@Scope("request") // One instance per HTTP request (web apps)
public class RequestContext { }

// Bean lifecycle hooks
@Component
public class DatabasePool {

    @PostConstruct // Called after dependency injection
    public void init() {
        System.out.println("Initializing connection pool...");
    }

    @PreDestroy // Called before bean is destroyed
    public void cleanup() {
        System.out.println("Closing connections...");
    }
}

// Approach 1: Annotation-based (most common in Spring Boot)
@Configuration
public class AppConfig {

    @Bean
    public DataSource dataSource() {
        return new HikariDataSource(hikariConfig());
    }

    @Bean
    public OrderRepository orderRepository(DataSource ds) {
        return new JdbcOrderRepository(ds); // Spring injects DataSource
    }
}

// Approach 2: Component scanning
@SpringBootApplication // Enables @ComponentScan
public class Application {
    public static void main(String[] args) {
        SpringApplication.run(Application.class, args);
    }
}

// Approach 3: Profiles for environment-specific beans
@Configuration
@Profile("production")
public class ProdConfig {
    @Bean
    public EmailService emailService() {
        return new SmtpEmailService(); // Real email in production
    }
}

@Configuration
@Profile("test")
public class TestConfig {
    @Bean
    public EmailService emailService() {
        return new MockEmailService(); // Fake email in tests
    }
}

// Unit test — inject mocks manually (no Spring container)
class OrderServiceTest {

    @Test
    void shouldCreateOrder() {
        // Arrange — construct with mocks
        OrderRepository mockRepo = mock(OrderRepository.class);
        EmailService mockEmail = mock(EmailService.class);
        OrderService service = new OrderService(mockRepo, mockEmail);

        when(mockRepo.save(any())).thenReturn(new Order(1L));

        // Act
        Order order = service.createOrder(new OrderRequest("Widget"));

        // Assert
        verify(mockRepo).save(any());
        verify(mockEmail).sendConfirmation(order);
    }
}

// Integration test — Spring wires everything
@SpringBootTest
class OrderServiceIntegrationTest {

    @Autowired
    private OrderService orderService; // Spring injects real beans

    @MockBean
    private EmailService emailService; // Replace with mock

    @Test
    void shouldCreateOrderWithRealDB() {
        Order order = orderService.createOrder(new OrderRequest("Gadget"));
        assertNotNull(order.getId());
    }
}

// The Spring ApplicationContext IS the IoC container
// It manages the full lifecycle:

// 1. BEAN DEFINITION: Read configuration (annotations, XML, Java config)
// 2. INSTANTIATION: Create bean instances
// 3. DEPENDENCY RESOLUTION: Wire dependencies (DI)
// 4. INITIALIZATION: Call @PostConstruct, InitializingBean
// 5. READY: Beans available for use
// 6. DESTRUCTION: Call @PreDestroy on shutdown

// Two main container types:
// BeanFactory — basic DI, lazy initialization
// ApplicationContext — extends BeanFactory with:
//   - Event publishing
//   - Internationalization (i18n)
//   - Resource loading
//   - AOP integration

@SpringBootApplication
public class MyApp {
    public static void main(String[] args) {
        // Creates the IoC container
        ApplicationContext ctx = SpringApplication.run(MyApp.class, args);

        // Container manages all beans
        OrderService service = ctx.getBean(OrderService.class);
        service.createOrder(new OrderRequest("Widget"));
    }
}

from fastapi import FastAPI, Depends
from typing import Annotated

app = FastAPI()

# Dependencies are functions — FastAPI's IoC container calls them
def get_db():
    db = Database("postgres://localhost/mydb")
    try:
        yield db  # Injected into endpoint
    finally:
        db.close()  # Cleanup (like @PreDestroy)

def get_user_service(db: Database = Depends(get_db)):
    return UserService(db)  # Composed dependency

# FastAPI resolves the entire dependency tree (IoC)
@app.get("/users/{user_id}")
async def get_user(
    user_id: int,
    service: Annotated[UserService, Depends(get_user_service)],
):
    return service.get_by_id(user_id)

// Template method in an abstract class
public abstract class DataExporter {

    // TEMPLATE METHOD — defines the algorithm skeleton
    // Marked final so subclasses can't change the overall flow
    public final void export(String query) {
        List<Map<String, Object>> data = fetchData(query);   // Step 1
        List<Map<String, Object>> transformed = transform(data); // Step 2
        String formatted = format(transformed);               // Step 3
        write(formatted);                                     // Step 4
        cleanup();                                            // Step 5 (hook)
    }

    // Concrete step — same for all subclasses
    private List<Map<String, Object>> fetchData(String query) {
        return database.query(query);
    }

    // Abstract steps — subclasses MUST implement
    protected abstract List<Map<String, Object>> transform(
        List<Map<String, Object>> data
    );
    protected abstract String format(List<Map<String, Object>> data);
    protected abstract void write(String content);

    // Hook method — optional override (default does nothing)
    protected void cleanup() { }
}

// Concrete implementation: CSV exporter
public class CsvExporter extends DataExporter {

    @Override
    protected List<Map<String, Object>> transform(List<Map<String, Object>> data) {
        // Remove sensitive columns
        data.forEach(row -> row.remove("password"));
        return data;
    }

    @Override
    protected String format(List<Map<String, Object>> data) {
        StringBuilder sb = new StringBuilder();
        // Header
        sb.append(String.join(",", data.get(0).keySet())).append("\n");
        // Rows
        data.forEach(row ->
            sb.append(String.join(",",
                row.values().stream().map(Object::toString).toList()
            )).append("\n")
        );
        return sb.toString();
    }

    @Override
    protected void write(String content) {
        Files.writeString(Path.of("export.csv"), content);
    }
}

// Concrete implementation: JSON exporter
public class JsonExporter extends DataExporter {

    @Override
    protected List<Map<String, Object>> transform(List<Map<String, Object>> data) {
        return data; // No transformation needed for JSON
    }

    @Override
    protected String format(List<Map<String, Object>> data) {
        return new ObjectMapper().writeValueAsString(data);
    }

    @Override
    protected void write(String content) {
        Files.writeString(Path.of("export.json"), content);
    }
}

// Usage — algorithm structure is fixed, details vary
DataExporter csvExporter = new CsvExporter();
csvExporter.export("SELECT * FROM users");

DataExporter jsonExporter = new JsonExporter();
jsonExporter.export("SELECT * FROM users");

from abc import ABC, abstractmethod

class DataPipeline(ABC):
    """Template method: extract → validate → transform → load."""

    def run(self, source: str) -> int:
        """Template method — defines the pipeline skeleton."""
        raw = self.extract(source)
        valid = self.validate(raw)
        transformed = self.transform(valid)
        count = self.load(transformed)
        self.on_complete(count)  # Hook
        return count

    @abstractmethod
    def extract(self, source: str) -> list[dict]: ...

    def validate(self, data: list[dict]) -> list[dict]:
        """Default validation — subclasses can override."""
        return [row for row in data if row]  # Remove empty rows

    @abstractmethod
    def transform(self, data: list[dict]) -> list[dict]: ...

    @abstractmethod
    def load(self, data: list[dict]) -> int: ...

    def on_complete(self, count: int) -> None:
        """Hook — optional override."""
        pass

class CsvToPostgresPipeline(DataPipeline):

    def extract(self, source: str) -> list[dict]:
        import csv
        with open(source) as f:
            return list(csv.DictReader(f))

    def transform(self, data: list[dict]) -> list[dict]:
        for row in data:
            row["email"] = row["email"].lower().strip()
        return data

    def load(self, data: list[dict]) -> int:
        db.bulk_insert("users", data)
        return len(data)

    def on_complete(self, count: int) -> None:
        print(f"Loaded {count} records into PostgreSQL")

# Run the pipeline
pipeline = CsvToPostgresPipeline()
pipeline.run("users.csv")

from abc import ABC, abstractmethod
from typing import TYPE_CHECKING

if TYPE_CHECKING:
    from order import Order

# State interface
class OrderState(ABC):
    @abstractmethod
    def pay(self, order: "Order") -> None: ...

    @abstractmethod
    def ship(self, order: "Order") -> None: ...

    @abstractmethod
    def deliver(self, order: "Order") -> None: ...

    @abstractmethod
    def cancel(self, order: "Order") -> None: ...

# Concrete states
class PendingState(OrderState):
    def pay(self, order: "Order") -> None:
        print("Payment processed. Order is now paid.")
        order.set_state(PaidState())

    def ship(self, order: "Order") -> None:
        raise InvalidOperationError("Cannot ship — order not yet paid")

    def deliver(self, order: "Order") -> None:
        raise InvalidOperationError("Cannot deliver — order not yet shipped")

    def cancel(self, order: "Order") -> None:
        print("Order cancelled.")
        order.set_state(CancelledState())

class PaidState(OrderState):
    def pay(self, order: "Order") -> None:
        raise InvalidOperationError("Order already paid")

    def ship(self, order: "Order") -> None:
        print("Order shipped.")
        order.set_state(ShippedState())

    def deliver(self, order: "Order") -> None:
        raise InvalidOperationError("Cannot deliver — order not yet shipped")

    def cancel(self, order: "Order") -> None:
        print("Refund issued. Order cancelled.")
        order.set_state(CancelledState())

class ShippedState(OrderState):
    def pay(self, order: "Order") -> None:
        raise InvalidOperationError("Order already paid")

    def ship(self, order: "Order") -> None:
        raise InvalidOperationError("Order already shipped")

    def deliver(self, order: "Order") -> None:
        print("Order delivered!")
        order.set_state(DeliveredState())

    def cancel(self, order: "Order") -> None:
        raise InvalidOperationError("Cannot cancel — order already shipped")

class DeliveredState(OrderState):
    def pay(self, order): raise InvalidOperationError("Order completed")
    def ship(self, order): raise InvalidOperationError("Order completed")
    def deliver(self, order): raise InvalidOperationError("Already delivered")
    def cancel(self, order): raise InvalidOperationError("Cannot cancel delivered order")

class CancelledState(OrderState):
    def pay(self, order): raise InvalidOperationError("Order cancelled")
    def ship(self, order): raise InvalidOperationError("Order cancelled")
    def deliver(self, order): raise InvalidOperationError("Order cancelled")
    def cancel(self, order): raise InvalidOperationError("Already cancelled")

class InvalidOperationError(Exception):
    pass

# Context
class Order:
    def __init__(self, order_id: str):
        self.order_id = order_id
        self._state: OrderState = PendingState()

    def set_state(self, state: OrderState) -> None:
        self._state = state

    @property
    def status(self) -> str:
        return type(self._state).__name__.replace("State", "")

    def pay(self) -> None:
        self._state.pay(self)

    def ship(self) -> None:
        self._state.ship(self)

    def deliver(self) -> None:
        self._state.deliver(self)

    def cancel(self) -> None:
        self._state.cancel(self)

# Usage
order = Order("ORD-001")
print(order.status)  # "Pending"

order.pay()
print(order.status)  # "Paid"

order.ship()
print(order.status)  # "Shipped"

order.deliver()
print(order.status)  # "Delivered"

# Invalid transition raises error
try:
    order.cancel()  # InvalidOperationError: Cannot cancel delivered order
except InvalidOperationError as e:
    print(f"Error: {e}")

# Complex subsystem classes
class VideoCodec:
    def decode(self, file: str) -> bytes:
        print(f"Decoding video from {file}")
        return b"video_data"

    def encode(self, data: bytes, format: str) -> bytes:
        print(f"Encoding video to {format}")
        return b"encoded_video"

class AudioCodec:
    def extract(self, file: str) -> bytes:
        print(f"Extracting audio from {file}")
        return b"audio_data"

    def encode(self, data: bytes, bitrate: int) -> bytes:
        print(f"Encoding audio at {bitrate}kbps")
        return b"encoded_audio"

class Muxer:
    def mux(self, video: bytes, audio: bytes) -> bytes:
        print("Multiplexing audio and video streams")
        return b"muxed_data"

class FileWriter:
    def write(self, data: bytes, output: str) -> None:
        print(f"Writing to {output}")

# FACADE — simple interface to the complex subsystem
class VideoConverter:
    """Facade that hides the complexity of video conversion."""

    def __init__(self):
        self._video = VideoCodec()
        self._audio = AudioCodec()
        self._muxer = Muxer()
        self._writer = FileWriter()

    def convert(self, input_file: str, output_file: str, format: str = "mp4") -> None:
        """One method does everything — clients don't need to know the steps."""
        video_data = self._video.decode(input_file)
        audio_data = self._audio.extract(input_file)

        encoded_video = self._video.encode(video_data, format)
        encoded_audio = self._audio.encode(audio_data, bitrate=192)

        muxed = self._muxer.mux(encoded_video, encoded_audio)
        self._writer.write(muxed, output_file)
        print(f"Conversion complete: {output_file}")

# Client uses the simple facade
converter = VideoConverter()
converter.convert("input.avi", "output.mp4")
# vs manually orchestrating 5 subsystem objects

// Spring Boot itself is a FACADE over the Spring ecosystem!
// Instead of manually configuring:
//   - DispatcherServlet
//   - ViewResolver
//   - DataSource + JPA EntityManager
//   - Transaction manager
//   - Embedded server (Tomcat)

// You just write:
@SpringBootApplication  // Facade annotation — auto-configures everything
public class Application {
    public static void main(String[] args) {
        SpringApplication.run(Application.class, args);
    }
}

// Service facade example:
@Service
public class CheckoutFacade {

    private final InventoryService inventory;
    private final PaymentService payment;
    private final ShippingService shipping;
    private final NotificationService notifications;

    public CheckoutFacade(InventoryService inventory, PaymentService payment,
                          ShippingService shipping, NotificationService notifications) {
        this.inventory = inventory;
        this.payment = payment;
        this.shipping = shipping;
        this.notifications = notifications;
    }

    // One method hides the complexity of checkout
    public OrderResult checkout(Cart cart, PaymentInfo paymentInfo) {
        inventory.reserve(cart.getItems());
        PaymentResult payResult = payment.charge(paymentInfo, cart.getTotal());
        ShipmentTracking tracking = shipping.createShipment(cart);
        notifications.sendConfirmation(cart.getUserEmail(), tracking);
        return new OrderResult(payResult.getTransactionId(), tracking.getId());
    }
}

from dataclasses import dataclass

# Flyweight — stores intrinsic (shared) state
@dataclass(frozen=True)  # Immutable — safe to share
class CharacterStyle:
    """Shared state: font properties that many characters share."""
    font_family: str
    font_size: int
    is_bold: bool
    is_italic: bool
    color: str

# Flyweight Factory — caches and reuses styles
class StyleFactory:
    _cache: dict[tuple, CharacterStyle] = {}

    @classmethod
    def get_style(
        cls,
        font_family: str = "Arial",
        font_size: int = 12,
        is_bold: bool = False,
        is_italic: bool = False,
        color: str = "black",
    ) -> CharacterStyle:
        key = (font_family, font_size, is_bold, is_italic, color)
        if key not in cls._cache:
            cls._cache[key] = CharacterStyle(*key)
        return cls._cache[key]

    @classmethod
    def cache_size(cls) -> int:
        return len(cls._cache)

# Context — stores extrinsic (unique) state
@dataclass
class Character:
    """Each character has unique position but shares style."""
    char: str
    row: int
    col: int
    style: CharacterStyle  # Reference to shared flyweight

# Usage: 10,000 characters but only a few style objects
document: list[Character] = []

normal = StyleFactory.get_style()  # Cached
bold = StyleFactory.get_style(is_bold=True)  # Cached
heading = StyleFactory.get_style(font_size=24, is_bold=True)  # Cached

# All 'normal' characters share the SAME style object
for i, char in enumerate("This is a long document with many characters..."):
    document.append(Character(char, row=0, col=i, style=normal))

# Bold words share the bold style object
for i, char in enumerate("IMPORTANT"):
    document.append(Character(char, row=1, col=i, style=bold))

print(f"Characters: {len(document)}")  # 56
print(f"Unique styles: {StyleFactory.cache_size()}")  # 3 (not 56!)

# Memory saved: 53 fewer CharacterStyle objects

// Java's String pool IS the Flyweight pattern!
String a = "hello";  // From string pool
String b = "hello";  // Same object from pool
System.out.println(a == b);  // true — same reference

// Integer cache is also Flyweight
Integer x = Integer.valueOf(127);  // Cached (-128 to 127)
Integer y = Integer.valueOf(127);
System.out.println(x == y);  // true — same object from cache

// Boolean.TRUE, Boolean.FALSE — only 2 instances ever

from abc import ABC, abstractmethod
from dataclasses import dataclass, field
from datetime import datetime

# Mediator interface
class ChatMediator(ABC):
    @abstractmethod
    def send_message(self, message: str, sender: "User") -> None: ...

    @abstractmethod
    def add_user(self, user: "User") -> None: ...

# Concrete mediator
class ChatRoom(ChatMediator):
    def __init__(self, name: str):
        self.name = name
        self._users: list["User"] = []

    def add_user(self, user: "User") -> None:
        self._users.append(user)
        user.chat_room = self
        self.send_message(f"{user.name} joined the room", user)

    def send_message(self, message: str, sender: "User") -> None:
        timestamp = datetime.now().strftime("%H:%M")
        for user in self._users:
            if user != sender:  # Don't echo to sender
                user.receive(f"[{timestamp}] {sender.name}: {message}")

# Colleague
@dataclass
class User:
    name: str
    chat_room: ChatMediator | None = None
    messages: list[str] = field(default_factory=list)

    def send(self, message: str) -> None:
        if self.chat_room:
            self.chat_room.send_message(message, self)

    def receive(self, message: str) -> None:
        self.messages.append(message)
        print(f"  {self.name} received: {message}")

# Usage — users don't know about each other, only the mediator
room = ChatRoom("Engineering")

alice = User("Alice")
bob = User("Bob")
charlie = User("Charlie")

room.add_user(alice)
room.add_user(bob)
room.add_user(charlie)

alice.send("Hey team, standup in 5 minutes!")
# Bob received: [10:00] Alice: Hey team, standup in 5 minutes!
# Charlie received: [10:00] Alice: Hey team, standup in 5 minutes!

bob.send("On my way!")
# Alice received: [10:00] Bob: On my way!
# Charlie received: [10:00] Bob: On my way!

// Spring's ApplicationEventPublisher is a Mediator!
@Service
public class OrderService {

    @Autowired
    private ApplicationEventPublisher eventPublisher; // Mediator

    public Order createOrder(OrderRequest request) {
        Order order = orderRepo.save(new Order(request));
        // Publish event — OrderService doesn't know who handles it
        eventPublisher.publishEvent(new OrderCreatedEvent(order));
        return order;
    }
}

// Listeners are decoupled — they don't know about each other
@Component
public class InventoryListener {
    @EventListener
    public void onOrderCreated(OrderCreatedEvent event) {
        inventoryService.reserve(event.getOrder().getItems());
    }
}

@Component
public class NotificationListener {
    @EventListener
    public void onOrderCreated(OrderCreatedEvent event) {
        emailService.sendConfirmation(event.getOrder());
    }
}

// Spring Data auto-generates the implementation!
@Repository
public interface UserRepository extends JpaRepository<User, Long> {

    // Method name IS the query — Spring generates SQL
    List<User> findByEmail(String email);

    List<User> findByRoleAndActiveTrue(String role);

    @Query("SELECT u FROM User u WHERE u.createdAt > :since")
    List<User> findRecentUsers(@Param("since") LocalDateTime since);

    // Pagination built in
    Page<User> findByRole(String role, Pageable pageable);
}

// Entity
@Entity
@Table(name = "users")
public class User {
    @Id
    @GeneratedValue(strategy = GenerationType.IDENTITY)
    private Long id;

    @Column(nullable = false, unique = true)
    private String email;

    @Column(nullable = false)
    private String name;

    private String role;
    private boolean active;
    private LocalDateTime createdAt;

    // Getters, setters, constructors...
}

// Service uses repository — doesn't know about JPA/SQL
@Service
public class UserService {

    private final UserRepository userRepo;

    public UserService(UserRepository userRepo) {
        this.userRepo = userRepo;
    }

    public User createUser(CreateUserRequest request) {
        if (!userRepo.findByEmail(request.getEmail()).isEmpty()) {
            throw new DuplicateEmailException(request.getEmail());
        }
        User user = new User(request.getName(), request.getEmail());
        return userRepo.save(user);
    }

    public Page<User> listAdmins(int page, int size) {
        return userRepo.findByRole("admin", PageRequest.of(page, size));
    }
}

from typing import Protocol, TypeVar, Generic
from dataclasses import dataclass

T = TypeVar("T")

# Generic repository interface
class Repository(Protocol[T]):
    def get_by_id(self, id: int) -> T | None: ...
    def list_all(self) -> list[T]: ...
    def save(self, entity: T) -> T: ...
    def delete(self, id: int) -> bool: ...

# Domain entity
@dataclass
class User:
    id: int | None
    name: str
    email: str
    role: str = "user"

# PostgreSQL implementation
class PostgresUserRepository:
    def __init__(self, db_pool):
        self._pool = db_pool

    async def get_by_id(self, id: int) -> User | None:
        row = await self._pool.fetchrow(
            "SELECT * FROM users WHERE id = $1", id
        )
        return User(**dict(row)) if row else None

    async def list_all(self) -> list[User]:
        rows = await self._pool.fetch("SELECT * FROM users")
        return [User(**dict(r)) for r in rows]

    async def save(self, user: User) -> User:
        if user.id is None:
            row = await self._pool.fetchrow(
                "INSERT INTO users (name, email, role) VALUES ($1, $2, $3) RETURNING id",
                user.name, user.email, user.role,
            )
            user.id = row["id"]
        else:
            await self._pool.execute(
                "UPDATE users SET name=$1, email=$2, role=$3 WHERE id=$4",
                user.name, user.email, user.role, user.id,
            )
        return user

    async def delete(self, id: int) -> bool:
        result = await self._pool.execute(
            "DELETE FROM users WHERE id = $1", id
        )
        return result == "DELETE 1"

# In-memory implementation (for testing)
class InMemoryUserRepository:
    def __init__(self):
        self._store: dict[int, User] = {}
        self._next_id = 1

    async def get_by_id(self, id: int) -> User | None:
        return self._store.get(id)

    async def list_all(self) -> list[User]:
        return list(self._store.values())

    async def save(self, user: User) -> User:
        if user.id is None:
            user.id = self._next_id
            self._next_id += 1
        self._store[user.id] = user
        return user

    async def delete(self, id: int) -> bool:
        return self._store.pop(id, None) is not None

# Service works with either implementation
class UserService:
    def __init__(self, repo: Repository[User]):
        self._repo = repo

// MODEL — Entity + Service
@Entity
public class Product {
    @Id @GeneratedValue
    private Long id;
    private String name;
    private BigDecimal price;
    private int stock;
    // Getters, setters...
}

@Service
public class ProductService {
    private final ProductRepository repo;

    public ProductService(ProductRepository repo) {
        this.repo = repo;
    }

    public List<Product> listAll() { return repo.findAll(); }
    public Product getById(Long id) {
        return repo.findById(id)
            .orElseThrow(() -> new ProductNotFoundException(id));
    }
    public Product create(Product product) { return repo.save(product); }
}

// CONTROLLER — handles HTTP requests
@RestController  // Returns JSON (no view resolution)
@RequestMapping("/api/v1/products")
public class ProductController {

    private final ProductService productService;

    public ProductController(ProductService productService) {
        this.productService = productService;
    }

    @GetMapping
    public List<Product> listProducts() {
        return productService.listAll();
    }

    @GetMapping("/{id}")
    public Product getProduct(@PathVariable Long id) {
        return productService.getById(id);
    }

    @PostMapping
    @ResponseStatus(HttpStatus.CREATED)
    public Product createProduct(@Valid @RequestBody Product product) {
        return productService.create(product);
    }

    // Exception handling
    @ExceptionHandler(ProductNotFoundException.class)
    @ResponseStatus(HttpStatus.NOT_FOUND)
    public Map<String, String> handleNotFound(ProductNotFoundException ex) {
        return Map.of("error", ex.getMessage());
    }
}

// VIEW — for server-side rendering (Thymeleaf)
@Controller  // Returns view names (not @RestController)
@RequestMapping("/products")
public class ProductViewController {

    @GetMapping
    public String listProducts(Model model) {
        model.addAttribute("products", productService.listAll());
        return "products/list";  // → templates/products/list.html
    }

    @GetMapping("/{id}")
    public String showProduct(@PathVariable Long id, Model model) {
        model.addAttribute("product", productService.getById(id));
        return "products/detail";
    }
}

from dataclasses import dataclass, field
from datetime import datetime
from abc import ABC, abstractmethod

# COMMANDS (writes)
@dataclass(frozen=True)
class CreateOrderCommand:
    user_id: int
    items: list[dict]
    shipping_address: str

@dataclass(frozen=True)
class CancelOrderCommand:
    order_id: int
    reason: str

# Command handler — enforces business rules
class OrderCommandHandler:
    def __init__(self, write_repo, event_bus):
        self._repo = write_repo
        self._events = event_bus

    def handle_create(self, cmd: CreateOrderCommand) -> int:
        # Validate business rules
        if not cmd.items:
            raise ValueError("Order must have at least one item")

        # Create in write model (normalized)
        order = Order(
            user_id=cmd.user_id,
            items=cmd.items,
            address=cmd.shipping_address,
            status="pending",
            created_at=datetime.now(),
        )
        self._repo.save(order)

        # Publish event to sync read model
        self._events.publish("order_created", order_id=order.id, data=order.to_dict())
        return order.id

    def handle_cancel(self, cmd: CancelOrderCommand) -> None:
        order = self._repo.get(cmd.order_id)
        if order.status == "shipped":
            raise ValueError("Cannot cancel shipped order")
        order.status = "cancelled"
        order.cancel_reason = cmd.reason
        self._repo.save(order)
        self._events.publish("order_cancelled", order_id=order.id)

# QUERIES (reads)
@dataclass(frozen=True)
class GetOrderQuery:
    order_id: int

@dataclass(frozen=True)
class ListUserOrdersQuery:
    user_id: int
    page: int = 1
    page_size: int = 20

# Query handler — optimized for read performance
class OrderQueryHandler:
    def __init__(self, read_repo):
        self._repo = read_repo  # Denormalized read model

    def handle_get(self, query: GetOrderQuery) -> dict:
        # Read from denormalized view (fast, no JOINs)
        return self._repo.get_order_view(query.order_id)

    def handle_list(self, query: ListUserOrdersQuery) -> dict:
        orders, total = self._repo.list_user_orders(
            query.user_id, query.page, query.page_size
        )
        return {"items": orders, "total": total, "page": query.page}

# Read model sync (event listener)
class OrderReadModelUpdater:
    """Listens to write events and updates the denormalized read model."""

    def __init__(self, read_repo):
        self._repo = read_repo

    def on_order_created(self, event: dict) -> None:
        # Denormalize: pre-join user name, item details, totals
        self._repo.upsert_order_view({
            "order_id": event["order_id"],
            "user_name": user_service.get_name(event["data"]["user_id"]),
            "items_summary": summarize_items(event["data"]["items"]),
            "total": calculate_total(event["data"]["items"]),
            "status": "pending",
            "created_at": event["data"]["created_at"],
        })

# API layer
@app.post("/api/v1/orders", status_code=201)
async def create_order(cmd: CreateOrderCommand):
    order_id = command_handler.handle_create(cmd)
    return {"order_id": order_id}

@app.get("/api/v1/orders/{order_id}")
async def get_order(order_id: int):
    return query_handler.handle_get(GetOrderQuery(order_id))

// Write model — normalized, validated
@Entity
@Table(name = "orders")
public class Order {
    @Id @GeneratedValue
    private Long id;
    private Long userId;
    @OneToMany(cascade = CascadeType.ALL)
    private List<OrderItem> items;
    private String status;
    private LocalDateTime createdAt;
}

// Read model — denormalized for fast queries
@Entity
@Table(name = "order_views")
public class OrderView {
    @Id
    private Long orderId;
    private String userName;       // Pre-joined
    private String itemsSummary;   // Pre-computed
    private BigDecimal total;      // Pre-calculated
    private String status;
    private LocalDateTime createdAt;
}

// Separate repositories
@Repository
public interface OrderRepository extends JpaRepository<Order, Long> { }

@Repository
public interface OrderViewRepository extends JpaRepository<OrderView, Long> {
    Page<OrderView> findByUserNameContaining(String name, Pageable pageable);
}