Implement a context manager class for a sequence generator using __enter__ and __exit__

A context manager class, implemented with __enter__ and __exit__, provides a robust way to manage resources by ensuring setup and teardown operations are executed reliably, even in the presence of errors. For a sequence generator, this means guaranteeing proper initialization of the generator's state and finalization of any associated resources.

Mechanics and Why

The __enter__ method is invoked upon entering the with block. It should perform any necessary setup, such as initializing the sequence's starting point, opening a file handle, or establishing a database connection. This method must return the resource to be used within the block (often self for class-based context managers). The __exit__ method is called upon exiting the with block, regardless of whether the exit was normal or due to an exception. It receives the exception type, value, and traceback as arguments. Returning True from __exit__ suppresses the exception, while False (or None) allows it to propagate.

This pattern guarantees resource cleanup, preventing leaks and improving system stability. In data engineering, this is critical for managing connections to data warehouses (e.g., Snowflake, BigQuery), file systems (e.g., S3, HDFS), or stream processors (e.g., Kafka consumers), ensuring connections are closed, buffers flushed, or temporary files deleted. This reliability is paramount in production data pipelines where resource contention and stability are key concerns.

Example: Stateful Sequence Generator

For a sequence generator, __enter__ might initialize the starting point and potentially log the start of generation, while __exit__ could log statistics, reset state, or close an underlying data source.

class SequenceGenerator:
    def __init__(self, start, stop):
        self.current = start
        self.stop = stop
    def __enter__(self):
        print(f"Entering sequence generator context: {self.current} to {self.stop}")
        return self # The object itself is the iterable resource
    def __iter__(self):
        return self
    def __next__(self):
        if self.current < self.stop:
            value = self.current
            self.current += 1
            return value
        raise StopIteration
    def __exit__(self, exc_type, exc_val, exc_tb):
        print(f"Exiting sequence generator context. Last value generated: {self.current - 1}")
        if exc_type:
            print(f"An exception occurred during generation: {exc_val}")
            # Production note: Log the exception here, don't just print.
        return False # Propagate exceptions by default

In the interview, also mention…

Discuss the contextlib.contextmanager decorator as a more concise, function-based alternative for simpler context managers, especially when wrapping existing generators or functions that yield a single resource. This can reduce boilerplate for less complex use cases.