Python Exceptions & Error Handling

# Inspecting the Exception Class Hierarchy at runtime:
print("Is ZeroDivisionError an ArithmeticError?", issubclass(ZeroDivisionError, ArithmeticError))
print("Is KeyError a LookupError?", issubclass(KeyError, LookupError))
print("Is FileNotFoundError an OSError?", issubclass(FileNotFoundError, OSError))
print("Is ArithmeticError an Exception?", issubclass(ArithmeticError, Exception))

def safe_divide_engine(a, b):
    print(f"\n--- Attempting: {a} / {b} ---")
    try:
        # Step 1: Risky calculation
        result = a / b
    except ZeroDivisionError as err:
        # Step 2: Handles zero division error
        print(f"❌ Handled Error: Cannot divide by zero! ({err})")
        return None
    except TypeError as err:
        # Step 2: Handles invalid data types
        print(f"❌ Handled Error: Both operands must be numbers! ({err})")
        return None
    else:
        # Step 3: Runs ONLY if division was successful
        print(f"✅ Calculation Successful! Result = {result}")
        return result
    finally:
        # Step 4: Runs ALWAYS for resource cleanup / logging
        print("🔒 [Cleanup] safe_divide_engine execution cycle finished.")

# Test all branches:
safe_divide_engine(100, 4)   # Success (try -> else -> finally)
safe_divide_engine(50, 0)    # Zero Division (try -> except -> finally)
safe_divide_engine(10, "2")  # Type Error (try -> except -> finally)

def process_user_record(data_dict, key, divisor):
    try:
        raw_val = data_dict[key]          # May raise KeyError
        parsed_num = float(raw_val)       # May raise ValueError
        computed = 1000 / parsed_num      # May raise ZeroDivisionError
        return computed
    except KeyError:
        print(f"❌ Error: Required key '{key}' is missing from user record!")
    except (ValueError, TypeError) as err:
        print(f"❌ Data Parsing Error: Invalid numeric input ({err})")
    except ZeroDivisionError:
        print("❌ Math Error: Value cannot be zero!")

# Testing different failure scenarios:
user_data = {"score": "50", "bonus": "zero", "zero_val": "0"}

print("1. Valid score:    ", process_user_record(user_data, "score", 2))
print("2. Missing key:    ", process_user_record(user_data, "missing_key", 2))
print("3. Bad number string:", process_user_record(user_data, "bonus", 2))
print("4. Division by zero:", process_user_record(user_data, "zero_val", 2))

def validate_account_age(age):
    if not isinstance(age, int):
        raise TypeError(f"Age must be an integer, received {type(age).__name__}")
    if age < 0:
        raise ValueError(f"Age cannot be negative! Received: {age}")
    if age < 18:
        raise PermissionError(f"User is {age} years old. Minimum required age is 18.")
    return "✅ Age verified successfully!"

# Test exception raising:
try:
    print(validate_account_age(22))  # Valid
    validate_account_age(-5)         # Triggers ValueError
except (TypeError, ValueError, PermissionError) as err:
    print(f"🚫 Validation Failed: {err}")

# Define Custom Application Exceptions
class BankingAppError(Exception):
    """Base exception for all banking domain errors."""
    pass

class InsufficientFundsError(BankingAppError):
    """Raised when a withdrawal exceeds available balance."""
    def __init__(self, balance, amount_requested):
        self.balance = balance
        self.amount_requested = amount_requested
        self.shortage = amount_requested - balance
        super().__init__(
            f"Withdrawal of Rs.{amount_requested:.2f} failed! "
            f"Current Balance: Rs.{balance:.2f} (Short by Rs.{self.shortage:.2f})"
        )

class AccountLockedError(BankingAppError):
    """Raised when operating on a frozen account."""
    pass

def withdraw_money(account_balance, amount, is_locked=False):
    if is_locked:
        raise AccountLockedError("Account is temporarily locked. Please contact support.")
    if amount > account_balance:
        raise InsufficientFundsError(account_balance, amount)
    return account_balance - amount

# Test Custom Exception handling:
try:
    new_bal = withdraw_money(500.0, 750.0)
except InsufficientFundsError as err:
    print("💳 Transaction Blocked:", err)
    print(f"👉 Customer needs to deposit at least Rs.{err.shortage:.2f} more.")
except BankingAppError as err:
    print("🏦 General Banking Error:", err)