Implementing Context Managers

Python
from contextlib import contextmanager

@contextmanager
def managed_resource(name):
    resource = acquire(name)
    try:
        yield resource
    finally:
        release(resource)

with managed_resource("db") as r:
    use(r)

For simple cases, prefer @contextmanager over hand-written __enter__/__exit__ classes. Reach for a class-based implementation only when you need state across multiple with uses, reentrancy, or subclassing.

Progress:

• Determine sync vs async (with vs async with)
• Choose implementation style: generator-based (@contextmanager) vs class-based (__enter__/__exit__)
• Implement setup logic in __enter__ (or before yield)
• Implement teardown logic in __exit__ (or after yield, in finally)
• Decide exception handling: propagate (return falsy) or suppress (return truthy)
• Handle reentrancy/reusability requirements if any
• Test normal exit, exceptional exit, and (if relevant) suppressed-exception paths

Class-based protocol

Python
class Resource:
    def __enter__(self):
        # setup; return value bound to `as` target
        return self

    def __exit__(self, exc_type, exc_value, traceback):
        # cleanup; return True to suppress exception
        return False

• __exit__ receives (None, None, None) on normal exit.
• Returning a truthy value from __exit__ suppresses the exception — do this deliberately, never by accident (e.g., don't let a bare except: inside __exit__ swallow the return value implicitly).
• If cleanup itself raises, that new exception replaces the original unless you explicitly chain/reraise the original.

Generator-based protocol (contextlib.contextmanager)

Python
@contextmanager
def cm():
    setup()
    try:
        yield value
    except SomeError:
        handle_and_suppress()   # swallowing: don't re-raise
    finally:
        teardown()

• Code before yield = __enter__; code after (in finally) = __exit__.
• To suppress an exception, catch it and do not re-raise.
• To propagate, either don't catch it, or catch/log/raise.

Async variant

Python
class AsyncResource:
    async def __aenter__(self):
        await self.connect()
        return self

    async def __aexit__(self, exc_type, exc_value, traceback):
        await self.disconnect()
        return False

Or with contextlib.asynccontextmanager:

Python
from contextlib import asynccontextmanager

@asynccontextmanager
async def acm():
    await setup()
    try:
        yield
    finally:
        await teardown()

Example 1: Input: Need a context manager that times a code block and prints duration, never suppressing exceptions. Output:

Python
import time
from contextlib import contextmanager

@contextmanager
def timer(label):
    start = time.perf_counter()
    try:
        yield
    finally:
        print(f"{label}: {time.perf_counter() - start:.4f}s")

Example 2: Input: Need a reusable, reentrant lock-like context manager as a class. Output:

Python
class ReentrantFlag:
    def __init__(self):
        self._depth = 0

    def __enter__(self):
        self._depth += 1
        return self

    def __exit__(self, exc_type, exc_value, traceback):
        self._depth -= 1
        return False

Example 3: Input: Suppress a specific exception type using stdlib instead of custom code. Output:

Python
from contextlib import suppress

with suppress(FileNotFoundError):
    os.remove("maybe_missing.txt")