Exceptions & Defensive Code¶

def parse_age(raw: str) -> int:
    """
    Full try/except/else/finally anatomy:
    - try:     code that might fail
    - except:  runs ONLY if the try block raised that exception
    - else:    runs ONLY if the try block did NOT raise
    - finally: ALWAYS runs — even with return or re-raise
    """
    try:
        age = int(raw)
    except ValueError as exc:
        # Catch ONLY what you can handle
        # raise ... from exc preserves the original exception as __cause__
        raise ValueError(f"age must be an integer, got {raw!r}") from exc
    else:
        # Only reached if int(raw) succeeded
        if age < 0 or age > 150:
            raise ValueError(f"age {age} is outside valid range [0, 150]")
        return age
    finally:
        # Always runs — cleanup, logging, metrics
        print(f"parse_age({raw!r}) attempt completed")

# Multiple except clauses — most specific first
def fetch_record(record_id: int) -> dict:
    try:
        return database.get(record_id)
    except KeyError:
        raise LookupError(f"Record {record_id} not found") from None
    except ConnectionError as exc:
        raise RuntimeError("Database unreachable") from exc
    except Exception as exc:
        # Catch-all for truly unexpected errors — log, then re-raise
        logger.error("Unexpected error in fetch_record: %s", exc)
        raise

# Catching multiple types in one clause
try:
    result = risky_io_operation()
except (TimeoutError, ConnectionRefusedError) as exc:
    log.warning("Transient network error: %s", exc)
    result = fallback_value

# Define a domain exception hierarchy
class AppError(Exception):
    """Base for all application errors — callers can catch this broadly."""
    pass

class ValidationError(AppError):
    """Input data failed validation."""
    def __init__(self, field: str, value, message: str):
        super().__init__(f"{field}={value!r}: {message}")
        self.field   = field
        self.value   = value
        self.message = message

class NotFoundError(AppError):
    """Requested resource does not exist."""
    def __init__(self, resource: str, identifier):
        super().__init__(f"{resource} {identifier!r} not found")
        self.resource   = resource
        self.identifier = identifier

class ServiceError(AppError):
    """Downstream service call failed."""
    def __init__(self, service: str, cause: Exception):
        super().__init__(f"{service} failed: {cause}")
        self.service = service

# Usage: precise exception types let callers handle each case
def create_order(data: dict) -> dict:
    if not data.get("customer_id"):
        raise ValidationError("customer_id", data.get("customer_id"),
                               "is required")

    try:
        customer = customer_service.get(data["customer_id"])
    except RequestException as exc:
        raise ServiceError("CustomerService", exc) from exc

    if not customer:
        raise NotFoundError("Customer", data["customer_id"])

    return order_service.create(data)

# Callers can handle each case precisely
try:
    order = create_order(payload)
except ValidationError as e:
    return {"error": "invalid_input", "field": e.field}
except NotFoundError as e:
    return {"error": "not_found", "resource": e.resource}
except ServiceError as e:
    log.error("Dependency failure: %s", e)
    return {"error": "service_unavailable"}

# LBYL: check before every operation
def get_user_email_lbyl(data: dict, user_id: str) -> str | None:
    if not isinstance(data, dict):
        return None
    if user_id not in data:
        return None
    user = data[user_id]
    if not isinstance(user, dict):
        return None
    if "email" not in user:
        return None
    return user["email"]

# EAFP: just try it, handle failures
def get_user_email_eafp(data: dict, user_id: str) -> str | None:
    try:
        return data[user_id]["email"]
    except (KeyError, TypeError):
        return None

# EAFP is also race-condition safe:
# LBYL: file could be deleted between os.path.exists() check and open()
import os
# BAD:
if os.path.exists("config.json"):         # check
    with open("config.json") as f:        # open — race condition window!
        data = f.read()

# GOOD: EAFP handles the same case without the race
try:
    with open("config.json") as f:
        data = f.read()
except FileNotFoundError:
    data = "{}"    # default config