Python Exceptions -- Find the Bug¶

import sys

def shutdown_server():
    """Gracefully shut down the server."""
    try:
        print("Shutting down...")
        sys.exit(0)
    except Exception:  # FIX: only catch Exception, not BaseException
        print("Caught an error, continuing...")

# shutdown_server()  # Would actually exit now

# Demonstration without actually exiting:
try:
    sys.exit(0)
except SystemExit:
    print("SystemExit was raised (caught for demo)")

print("Bare except would have swallowed SystemExit!")

def get_user_data(user_id: int) -> dict:
    """Fetch user data from the database."""
    users = {1: {"name": "Alice", "age": 30}}
    try:
        user = users[user_id]
    except KeyError:  # FIX: only catch the specific exception
        return {"error": "User not found"}

    # Access fields outside try/except so typos are NOT caught
    return {"name": user["name"], "age": user["age"]}  # FIX: "agee" -> "age"


# Tests
assert get_user_data(1) == {"name": "Alice", "age": 30}
assert get_user_data(999) == {"error": "User not found"}
print("All tests passed!")

def parse_config(config_str: str) -> dict:
    """Parse a 'key=value' config string."""
    result = {}
    for line in config_str.strip().split("\n"):
        line = line.strip()
        if not line:
            continue
        try:
            key, value = line.split("=", 1)  # FIX: maxsplit=1 for values containing =
            result[key.strip()] = value.strip()
        except ValueError:  # FIX: correct exception type
            print(f"Skipping invalid line: {line}")
    return result


config = """
host=localhost
port=8080
invalid_line_without_equals
debug=true
"""

result = parse_config(config)
assert result == {"host": "localhost", "port": "8080", "debug": "true"}
print("All tests passed!")

def read_number(text: str) -> int | str:
    """Parse a number from text, with cleanup."""
    try:
        result = int(text)
    except ValueError:
        result = "invalid"
    finally:
        print("Cleanup done")  # FIX: use finally for cleanup only, not return
    return result  # FIX: return outside finally


# Tests
assert read_number("42") == 42
assert read_number("hello") == "invalid"
print("All tests passed!")

import logging

def process_file(path: str) -> str:
    """Process a file with error logging."""
    try:
        with open(path) as f:
            return f.read()
    except FileNotFoundError as e:
        # FIX: use a safe logging mechanism, handle logging errors too
        try:
            logging.error(f"File not found: {path} -- {e}")
        except Exception:
            pass  # Logging failure should not mask the original error
        return f"Error: file '{path}' not found"


# Tests
result = process_file("missing.txt")
assert "not found" in result
print("All tests passed!")

def fetch_from_api(url: str) -> dict:
    """Fetch data from an API."""
    raise ConnectionError(f"Cannot connect to {url}")

def get_user_profile(user_id: int) -> dict:
    """Get user profile from API."""
    try:
        return fetch_from_api(f"https://api.example.com/users/{user_id}")
    except ConnectionError as e:
        raise RuntimeError("Failed to load user profile") from e  # FIX: explicit chain


try:
    get_user_profile(1)
except RuntimeError as e:
    assert e.__cause__ is not None  # Now has an explicit cause
    assert isinstance(e.__cause__, ConnectionError)
    print(f"Error: {e}")
    print(f"Cause: {e.__cause__}")

print("All tests passed!")

def tricky_generator():
    """Generator that properly handles iterator exhaustion."""
    values = iter([1, 2, 3])
    while True:
        try:
            value = next(values)
        except StopIteration:  # FIX: explicitly catch StopIteration
            return  # Properly end the generator
        yield value

# Alternative fix using sentinel:
def tricky_generator_v2():
    """Generator using sentinel pattern."""
    values = iter([1, 2, 3])
    sentinel = object()
    while (value := next(values, sentinel)) is not sentinel:
        yield value


result1 = list(tricky_generator())
result2 = list(tricky_generator_v2())
assert result1 == [1, 2, 3]
assert result2 == [1, 2, 3]
print("All tests passed!")

import atexit
import os
import weakref


class ResourceHolder:
    """Holds a resource with safe cleanup using weakref finalizer."""
    _instances: list = []

    def __init__(self, name: str):
        self.name = name
        self._path = f"/tmp/resource_{name}.tmp"
        self.file = open(self._path, "w")
        ResourceHolder._instances.append(self)

        # FIX: Use weakref.finalize for guaranteed cleanup
        self._finalizer = weakref.finalize(
            self, ResourceHolder._cleanup, self.file, self._path, name
        )

    @staticmethod
    def _cleanup(file, path, name):
        """Static cleanup function that doesn't depend on the object."""
        try:
            if not file.closed:
                file.close()
            if os.path.exists(path):
                os.unlink(path)
        except Exception:
            pass  # Best-effort cleanup during shutdown


# Test
r1 = ResourceHolder("test1")
r2 = ResourceHolder("test2")
r1.file.write("data")
assert not r1.file.closed
del r1  # Triggers weakref finalizer safely
# Temp file is cleaned up
assert not os.path.exists("/tmp/resource_test1.tmp")

r2._finalizer()  # Can also call explicitly
assert r2.file.closed
print("All tests passed!")

class DatabaseConnection:
    """Context manager with safe exception handling in __exit__."""
    def __init__(self, url: str, fail_on_close: bool = False):
        self.url = url
        self.fail_on_close = fail_on_close

    def __enter__(self):
        print(f"Connected to {self.url}")
        return self

    def __exit__(self, exc_type, exc_val, exc_tb):
        try:
            if self.fail_on_close:
                raise ConnectionError("Failed to close connection!")
            print("Connection closed")
        except ConnectionError as close_error:
            if exc_val is not None:
                # FIX: Chain the cleanup error to the original exception
                # so neither is lost
                exc_val.add_note(f"Additionally, cleanup failed: {close_error}")
                # Or for Python < 3.11, use __context__:
                # close_error.__context__ = exc_val
            else:
                raise  # No original exception, so the close error IS the problem
        return False  # Do not suppress the original exception

    def query(self, sql: str):
        raise RuntimeError(f"Query failed: {sql}")


# Test
try:
    with DatabaseConnection("localhost", fail_on_close=True) as db:
        db.query("SELECT * FROM users")
except RuntimeError as e:
    # FIX: Now we see the ORIGINAL RuntimeError
    print(f"Caught original: {e}")
    assert "Query failed" in str(e)
    notes = getattr(e, "__notes__", [])
    assert any("cleanup failed" in n for n in notes)

print("All tests passed!")

def database_cursor(query: str):
    """Generator that simulates a database cursor with proper cleanup."""
    print(f"Opening cursor for: {query}")
    connection = {"status": "open"}
    try:
        for i in range(1000):
            if i == 5:
                raise ValueError(f"Bad data at row {i}")
            yield {"row": i, "data": f"value_{i}"}
    except GeneratorExit:
        # FIX: Do cleanup but NEVER yield here
        connection["status"] = "closed"
        print(f"GeneratorExit: cursor cleaned up. Connection: {connection['status']}")
        return  # Must return, not yield
    finally:
        # finally also runs on GeneratorExit -- safe for cleanup
        if connection["status"] != "closed":
            connection["status"] = "closed"
        print(f"Finally: Connection {connection['status']}")


# Test 1: Break early (triggers GeneratorExit)
gen = database_cursor("SELECT *")
rows = []
for row in gen:
    rows.append(row)
    if row["row"] >= 2:
        break

assert len(rows) == 3  # rows 0, 1, 2
assert rows[-1]["row"] == 2

# Test 2: Exhaust until ValueError
gen2 = database_cursor("SELECT *")
collected = []
try:
    for row in gen2:
        collected.append(row)
except ValueError as e:
    assert "Bad data at row 5" in str(e)

assert len(collected) == 5  # rows 0-4

print("All tests passed!")