Exception Handling from Basics to Production

def safe_divide(a, b):
    try:
        return a / b
    except ZeroDivisionError:
        print("Error: Cannot divide by zero.")
        return None

# Test
print(safe_divide(10, 2))   # 5.0
print(safe_divide(10, 0))   # Error: Cannot divide by zero. → None

def get_element(lst, index):
    try:
        return lst[index]
    except IndexError:
        print(f"Index {index} is out of range. Returning None.")
        return None

numbers = [10, 20, 30]
print(get_element(numbers, 1))  # 20
print(get_element(numbers, 5))  # Error message + None

def get_config(key, config_dict):
    try:
        return config_dict[key]
    except KeyError:
        print(f"Key '{key}' not found. Using default.")
        return "default_value"

config = {"host": "localhost", "port": 8080}
print(get_config("host", config))   # localhost
print(get_config("timeout", config)) # Key 'timeout' not found. Using default. → default_value

import json

def parse_and_access(json_string, key):
    try:
        data = json.loads(json_string)
        return data[key]
    except json.JSONDecodeError:
        print("Invalid JSON format.")
    except KeyError:
        print(f"Key '{key}' missing in JSON.")
    return None

# Example
good_json = '{"name": "Alice", "age": 30}'
bad_json = 'invalid'
print(parse_and_access(good_json, "name"))   # Alice
print(parse_and_access(good_json, "city"))   # Key missing
print(parse_and_access(bad_json, "name"))    # Invalid JSON

class InsufficientFundsError(Exception):
    def __init__(self, balance, amount):
        super().__init__(f"Balance {balance} is insufficient for withdrawal of {amount}")
        self.balance = balance
        self.amount = amount

def withdraw(balance, amount):
    if amount > balance:
        raise InsufficientFundsError(balance, amount)
    return balance - amount

try:
    new_balance = withdraw(100, 200)
except InsufficientFundsError as e:
    print(e)  # Balance 100 is insufficient for withdrawal of 200

import time
from functools import wraps

def retry(max_attempts=3, delay=1):
    def decorator(func):
        @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
                    print(f"Attempt {attempt+1} failed: {e}. Retrying...")
                    time.sleep(delay)
        return wrapper
    return decorator

@retry(max_attempts=2, delay=0.5)
def unstable_call():
    # simulate failure
    raise ConnectionError("Network issue")

try:
    unstable_call()
except ConnectionError:
    print("All retries exhausted")

class Transaction:
    def __init__(self):
        self.committed = False

    def __enter__(self):
        print("BEGIN TRANSACTION")
        return self

    def __exit__(self, exc_type, exc_val, exc_tb):
        if exc_type is None:
            self.committed = True
            print("COMMIT")
        else:
            print(f"ROLLBACK due to {exc_type.__name__}: {exc_val}")
        return False  # don't suppress exception

def process_order():
    with Transaction() as t:
        # raise ValueError("Invalid order")  # uncomment to test rollback
        print("Order processed")

process_order()

class DataPipelineError(Exception):
    pass

def parse_int(value):
    try:
        return int(value)
    except ValueError as original:
        raise DataPipelineError("Failed to convert to integer") from original

try:
    parse_int("abc")
except DataPipelineError as e:
    print(f"Pipeline error: {e}")
    if e.__cause__:
        print(f"Caused by: {e.__cause__}")

import sys
import traceback
from datetime import datetime

def global_exception_handler(exc_type, exc_value, exc_tb):
    """Log unhandled exceptions to a file."""
    error_msg = ''.join(traceback.format_exception(exc_type, exc_value, exc_tb))
    with open('crash.log', 'a') as f:
        f.write(f"[{datetime.now()}] UNHANDLED EXCEPTION\n{error_msg}\n")
    print("A critical error occurred. Check crash.log", file=sys.stderr)

sys.excepthook = global_exception_handler

# Test – uncomment to see it in action (will crash but log)
# raise RuntimeError("Something went very wrong")