Recap — Building Reusable, Composable Abstractions

# Building Reusable, Composable Abstractions Decorators and context managers are Python's main mechanisms for cross-cutting concerns: logging, timing, caching, resource management. Learn the templates. ## Context managers — `with` statements ```python with open("data.txt") as f: data = f.read() # File is automatically closed, even if exception raised ``` The `with` block guarantees cleanup. Critical for: - File handles. - Database connections. - Network sockets. - Locks. - Anything that needs cleanup. ### Writing a context manager — class-based ```python class Timer: def __enter__(self): self.start = time.time() return self def __exit__(self, exc_type, exc_val, exc_tb): elapsed = time.time() - self.start print(f"Elapsed: {elapsed:.3f}s") # Return False/None to propagate exception; True to suppress return False with Timer(): do_work() ``` ### Writing one — `@contextmanager` decorator Easier for simple cases: ```python from contextlib import contextmanager @contextmanager def timer(): start = time.time() try: yield finally: elapsed = time.time() - start print(f"Elapsed: {elapsed:.3f}s") with timer(): do_work() ``` `yield` is where the `with` block executes. Setup before yield; cleanup after. ### Nesting context managers ```python with open("in.txt") as fin, open("out.txt", "w") as fout: fout.write(fin.read()) ``` Multiple resources, single statement. ### ExitStack — dynamic context managers ```python from contextlib import ExitStack with ExitStack() as stack: files = [stack.enter_context(open(f)) for f in filenames] # all files closed when stack exits ``` Useful when number of context managers is dynamic. ### Async context managers ```python async def main(): async with httpx.AsyncClient() as client: response = await client.get("https://api.com") ``` Define with `__aenter__` / `__aexit__` or `@asynccontextmanager`. ## Decorators A decorator wraps a function to add behavior. ### Simple decorator ```python def log_calls(func): def wrapper(*args, **kwargs): print(f"Calling {func.__name__}") result = func(*args, **kwargs) print(f"Returned {result}") return result return wrapper @log_calls def add(a, b): return a + b add(1, 2) # Calling add # Returned 3 ``` `@log_calls` is equivalent to `add = log_calls(add)`. ### Preserve metadata with @wraps ```python from functools import wraps def log_calls(func): @wraps(func) # preserves __name__, __doc__, signature def wrapper(*args, **kwargs): ... return wrapper ``` Without `@wraps`, the wrapped function loses its identity (name becomes "wrapper", docstring lost). Always use `@wraps`. ### Decorator with arguments ```python def retry(times: int): def decorator(func): @wraps(func) def wrapper(*args, **kwargs): for attempt in range(times): try: return func(*args, **kwargs) except Exception as e: if attempt == times - 1: raise time.sleep(2 ** attempt) return wrapper return decorator @retry(times=3) def flaky_api_call(): ... ``` Three layers: outer takes args; middle takes the function; inner is the wrapped behavior. ### Common useful decorators ```python @functools.cache # cache call results (replaces lru_cache(None)) @functools.lru_cache(maxsize=100) # cache with LRU eviction @property # method becomes attribute access @staticmethod # class method without self/cls @classmethod # class method receiving cls @dataclass # auto __init__, __repr__, __eq__ @pytest.fixture # pytest test fixture @contextmanager # turn generator into context manager ``` ### Class-based decorator For stateful decorators: ```python class CountCalls: def __init__(self, func): self.func = func self.count = 0 def __call__(self, *args, **kwargs): self.count += 1 return self.func(*args, **kwargs) @CountCalls def hello(): print("hi") hello() print(hello.count) # 1 ``` ## Production patterns ### Pattern 1: Resource management ```python @contextmanager def transaction(db): db.begin() try: yield db db.commit() except Exception: db.rollback() raise with transaction(db) as tx: tx.execute("INSERT ...") ``` Auto-commit-or-rollback. Standard pattern in many DB libraries. ### Pattern 2: Timing ```python @contextmanager def timed(label): start = time.perf_counter() try: yield finally: print(f"{label}: {(time.perf_counter() - start)*1000:.1f}ms") with timed("compute"): heavy_compute() ``` ### Pattern 3: Retry ```python from functools import wraps def retry(time