Custom Exception Hierarchies

class CommerceError(Exception):
    """Root exception for all commerce subsystem failures."""
    pass

class InventoryError(CommerceError):
    """Raised when inventory operations fail."""
    pass

class InsufficientStockError(InventoryError):
    """Raised when an item does not have enough quantity."""
    pass

class PaymentError(CommerceError):
    """Raised when payment processing fails."""
    pass

def checkout(sku, quantity_requested, stock_on_hand):
    if quantity_requested > stock_on_hand:
        raise InsufficientStockError(f"SKU {sku} needs {quantity_requested}, but only {stock_on_hand} available")
    print("Stock reserved successfully")

try:
    checkout("BOOK-404", 5, 2)
except InsufficientStockError as err:
    print(f"Specific handler: {err}")
except CommerceError as err:
    print(f"Broad commerce handler: {err}")

class APIError(Exception):
    def __init__(self, message, status_code=400, error_code="BAD_REQUEST", details=None):
        super().__init__(message)
        self.status_code = status_code
        self.error_code = error_code
        self.details = details or {}

    def to_dict(self):
        return {
            "error": self.error_code,
            "message": str(self),
            "status": self.status_code,
            "details": self.details
        }

def validate_user_payload(data):
    if "email" not in data:
        raise APIError(
            "Validation failed for payload",
            status_code=422,
            error_code="VALIDATION_FAILED",
            details={"missing_fields": ["email"]}
        )

try:
    validate_user_payload({"username": "ada"})
except APIError as err:
    print("HTTP Status:", err.status_code)
    print("JSON Response:", err.to_dict())

class NetworkError(Exception): pass
class TransientError(NetworkError): pass
class PermanentError(NetworkError): pass
class TimeoutError(TransientError): pass
class RateLimitExceededError(TransientError): pass
class BadCredentialsError(PermanentError): pass

# 1. Class hierarchy introspection with issubclass
print("Timeout is transient:", issubclass(TimeoutError, TransientError))
print("Timeout is network error:", issubclass(TimeoutError, NetworkError))
print("Transient is timeout:", issubclass(TransientError, TimeoutError))

def handle_dispatch(err):
    # 2. Instance classification with isinstance
    if isinstance(err, TransientError):
        return "SCHEDULE_RETRY"
    elif isinstance(err, PermanentError):
        return "ALERT_OPERATOR"
    return "ABORT"

print("Dispatch RateLimit:", handle_dispatch(RateLimitExceededError("Backoff 5s")))
print("Dispatch BadCredentials:", handle_dispatch(BadCredentialsError("Invalid secret")))

class InsufficientFundsError(Exception):
    pass

def withdraw(balance, amount):
    if amount > balance:
        raise InsufficientFundsError("Withdrawal exceeds balance!")
    return balance - amount

# Service integration layer
def handle_request(payload: dict) -> dict:
    return {"status": "success", "processed": True}

# High-resilience production pattern
import time

def process_stream(events: list) -> int:
    processed = 0
    for event in events:
        if event:
            processed += 1
    return processed