Writing context managers, and chaining exceptions

Lesson 5 used with on files. Any object can take part, through two methods:

• __enter__(self) runs when the block starts; whatever it returns is bound to the name after as.
• __exit__(self, exc_type, exc, tb) runs when the block ends, however it ends. After a normal finish all three arguments are None. After an exception they describe it, and the return value decides what happens next: a truthy return suppresses the exception, anything else (including the implicit None) lets it continue outwards.

with a, b: enters a then b, and exits in reverse: b first. That is the order you want — what was acquired last is released first.

1log = []2 3 4class Step:5    def __init__(self, name, swallow=False):6        self.name = name7        self.swallow = swallow8 9    def __enter__(self):10        log.append(f"enter {self.name}")11        return self12 13    def __exit__(self, exc_type, exc, tb):14        seen = exc_type.__name__ if exc_type else None15        log.append(f"exit {self.name} saw {seen}")16        return self.swallow17 18 19def run():20    log.clear()21    with Step("a"), Step("b"):22        log.append("body")23 24    try:25        with Step("plain"):26            raise KeyError("k")27    except KeyError:28        log.append("KeyError reached the caller")29 30    with Step("swallowing", swallow=True):31        raise KeyError("k")32    log.append("after swallowing: no exception")33    return log

Suppressing is rarely right. Return True only for an exception you have genuinely handled, and check its type first; the standard library's contextlib.suppress(FileNotFoundError) is the explicit way to say "ignore exactly this".

@contextmanager

contextlib.contextmanager turns a generator into a context manager: the code before yield is the enter step, the yielded value is what as receives, and the code after it is the exit step. If the block raises, the exception is thrown into the generator at the yield. Without a try/finally around the yield, the cleanup line after it never runs.

from contextlib import contextmanager

@contextmanager
def opened(resource):
    resource.open()
    try:
        yield resource
    finally:
        resource.close()   # runs on success and on error

1from contextlib import contextmanager2 3log = []4 5 6@contextmanager7def careless(name):8    log.append(f"open {name}")9    yield name10    log.append(f"close {name}")  # skipped if the block raises11 12 13@contextmanager14def careful(name):15    log.append(f"open {name}")16    try:17        yield name18    finally:19        log.append(f"close {name}")20 21 22def run():23    log.clear()24    for manager in (careless, careful):25        try:26            with manager(manager.__name__):27                raise RuntimeError("boom")28        except RuntimeError:29            log.append("caught boom")30    return log

Chaining exceptions

When you translate a low-level error into one that fits your API, keep the original. raise ConfigError("bad port") from err stores err as the new exception's __cause__, and the traceback shows both, joined by "The above exception was the direct cause of the following exception". Raising inside an except block without from still records the original, as __context__ ("During handling of the above exception, another exception occurred"), which reads like a second bug. raise ... from None hides the original deliberately.

1class ConfigError(Exception):2    pass3 4 5def parse_port(text, explicit):6    try:7        return int(text)8    except ValueError as err:9        if explicit:10            raise ConfigError(f"bad port {text!r}") from err11        raise ConfigError(f"bad port {text!r}")12 13 14def describe(explicit):15    try:16        parse_port("80a", explicit)17    except ConfigError as e:18        return {19            "error": str(e),20            "cause": repr(e.__cause__),21            "context": repr(e.__context__),22            "suppress_context": e.__suppress_context__,23        }24 25 26def run():27    return {"with_from": describe(True), "without_from": describe(False)}

Common mistakes

• A @contextmanager generator with no try/finally: the cleanup after yield is skipped exactly when an error makes it matter.
• __exit__ that returns True unconditionally, so every exception in the block, including real bugs, disappears.
• Re-raising a new exception without from, so the log shows two unrelated-looking errors instead of a cause and its effect.

What interviewers ask

• What does __exit__ receive, and how can it suppress an exception? The exception's type, value and traceback (all None on success); returning a truthy value suppresses it.
• How would you write a context manager without a class? A generator with @contextmanager, the setup before yield, the teardown in a finally after it.
• What is the difference between __cause__ and __context__? __cause__ is set explicitly by raise ... from; __context__ is recorded automatically when an exception is raised while another is being handled.