Unit 11: Exception Handling

# Case A: Crashing without Exception Handling (Anti-Pattern)
# num = 10 / 0  # CRASH! Program terminates immediately with ZeroDivisionError

# Case B: Graceful recovery using try-except
print("System starting...")

try:
    numerator = 50
    denominator = 0  # Will cause division error
    result = numerator / denominator
    print(f"Result: {result}")  # This line is skipped!
except ZeroDivisionError:
    print("⚠️ HANDLED: Cannot divide a number by zero! Defaulting to 0.")
    result = 0

print(f"Final safe value: {result}")
print("System continues running smoothly without crashing! 🎉")

def process_student_marks(scores_list, index_str):
    try:
        idx = int(index_str)                    # May raise ValueError
        val = scores_list[idx]                  # May raise IndexError
        percentage = 100 / val                  # May raise ZeroDivisionError
        print(f"Success: Index [{idx}] -> Score: {val} | Factor: {percentage:.2f}")

    except ValueError:
        print(f"❌ Input Error: '{index_str}' is not a valid integer!")

    except IndexError:
        print(f"❌ Range Error: Index {index_str} is out of bounds (List size: {len(scores_list)})!")

    except ZeroDivisionError:
        print("❌ Arithmetic Error: Score at this position is 0, cannot divide by zero!")

    except Exception as err:
        print(f"❌ Unexpected Error: {type(err).__name__} -> {err}")

marks = [85, 0, 92]

# Test Scenario 1: Valid Execution
process_student_marks(marks, "0")

# Test Scenario 2: ValueError
process_student_marks(marks, "two")

# Test Scenario 3: IndexError
process_student_marks(marks, "9")

# Test Scenario 4: ZeroDivisionError
process_student_marks(marks, "1")

def safe_file_reader(filename):
    print(f"\n--- Attempting to open '{filename}' ---")
    file = None
    try:
        file = open(filename, "r", encoding="utf-8")
        content = file.read()
    except FileNotFoundError:
        print(f"EXCEPT: File '{filename}' does not exist on disk!")
    else:
        print(f"ELSE: File successfully read! Size: {len(content)} characters.")
    finally:
        if file and not file.closed:
            file.close()
            print("FINALLY: File handle safely closed in RAM.")
        else:
            print("FINALLY: Cleanup routine completed.")

# Case 1: Missing file (triggers try -> except -> finally)
safe_file_reader("non_existent_doc.txt")

# Case 2: Existing file (triggers try -> else -> finally)
with open("test_doc.txt", "w") as f:
    f.write("DevAscent Academy")

safe_file_reader("test_doc.txt")

def verify_driving_license_eligibility(applicant_name, age):
    """Enforces biological and legal constraints using raise."""
    if not isinstance(age, int):
        raise TypeError(f"Age must be an integer number, received: {type(age).__name__}")
    
    if age < 0 or age > 120:
        raise ValueError(f"Invalid biological age: {age}. Must be between 0 and 120.")
    
    if age < 18:
        raise PermissionError(f"Underage applicant: {applicant_name} ({age} yrs). Minimum age is 18.")
    
    return f"✅ APPROVED: {applicant_name} is eligible to take the driving test!"

# Testing defensive validation
test_cases = [
    ("Suresh Kumar", 22),
    ("Aman Gupta", 16),
    ("Pooja Roy", -5)
]

for name, age_val in test_cases:
    try:
        verdict = verify_driving_license_eligibility(name, age_val)
        print(verdict)
    except (ValueError, PermissionError, TypeError) as err:
        print(f"🛑 REJECTED: {err}")

# Step 1: Define custom exception classes inheriting from Exception
class BankingException(Exception):
    """Base exception for all banking errors."""
    pass

class InsufficientFundsError(BankingException):
    """Raised when withdrawal exceeds available account balance."""
    def __init__(self, balance, requested):
        self.balance = balance
        self.requested = requested
        super().__init__(f"Deficit: Balance is ₹{balance}, cannot withdraw ₹{requested}!")

class DailyLimitExceededError(BankingException):
    """Raised when withdrawal exceeds ₹50,000 daily ATM cap."""
    pass

# Step 2: Use custom exceptions inside business logic
def withdraw_atm_cash(account_balance, amount):
    if amount > 50000:
        raise DailyLimitExceededError(f"₹{amount} exceeds daily ATM withdrawal limit of ₹50,000!")
    
    if amount > account_balance:
        raise InsufficientFundsError(account_balance, amount)
    
    new_balance = account_balance - amount
    return new_balance

# Step 3: Handling custom exceptions
account_balance = 15000

# Test Scenario 1: Attempting to withdraw ₹25,000 (Insufficient Funds)
try:
    account_balance = withdraw_atm_cash(account_balance, 25000)
except InsufficientFundsError as ife:
    print("ATM Alert:", ife)

# Test Scenario 2: Attempting to withdraw ₹80,000 (Exceeds daily cap)
try:
    account_balance = withdraw_atm_cash(account_balance, 80000)
except DailyLimitExceededError as dfe:
    print("ATM Alert:", dfe)

class OutOfStockError(Exception): pass
class PaymentDeclinedError(Exception): pass

INVENTORY = {"Laptop": 3, "Mouse": 0, "Headphones": 5}

def process_customer_order(item_name, quantity, wallet_balance, item_price):
    print(f"\n==============================================")
    print(f"🛒 PROCESSING ORDER: {quantity}x {item_name}")
    print(f"==============================================")
    
    order_success = False
    total_cost = quantity * item_price
    
    try:
        # Check 1: Item existence
        if item_name not in INVENTORY:
            raise KeyError(f"Product '{item_name}' does not exist in store catalog.")
        
        # Check 2: Stock availability
        if INVENTORY[item_name] < quantity:
            raise OutOfStockError(f"Only {INVENTORY[item_name]} units available in stock!")
        
        # Check 3: Payment balance
        if wallet_balance < total_cost:
            raise PaymentDeclinedError(f"Order cost ₹{total_cost} exceeds balance ₹{wallet_balance}!")
        
        # Deduct inventory
        INVENTORY[item_name] -= quantity
        order_success = True

    except KeyError as ke:
        print("Catalog Error:", ke)
    except OutOfStockError as ose:
        print("Inventory Error:", ose)
    except PaymentDeclinedError as pde:
        print("Payment Error:", pde)
    else:
        print(f"✅ ORDER CONFIRMED! Charged ₹{total_cost}. Remaining stock: {INVENTORY[item_name]}")
    finally:
        status_label = "SUCCESS" if order_success else "FAILED"
        print(f"[AUDIT LOG] Session finalized with status: {status_label}")

# Run simulated transactions
process_customer_order("Laptop", quantity=1, wallet_balance=65000, item_price=52000)
process_customer_order("Mouse", quantity=1, wallet_balance=5000, item_price=800)
process_customer_order("Headphones", quantity=2, wallet_balance=2000, item_price=2500)