Building A Custom Context Manager In Python: A Closer Look

Prerequisites

To follow this tutorial, you should understand

Key Libraries & Tools

• python 3
  : A built-in Python library for interacting with SQL databases.
• context managers
  : A standard library module providing utilities for creating and working with context managers.
• context managers
  : An asynchronous wrapper for sqlite3 used for non-blocking database operations.

Code Walkthrough: The Class-Based Approach

The "hard way" to build a context manager involves creating a class with __enter__ and __exit__ methods. This provides the most control over the object's lifecycle.

import sqlite3

class SQLite:
    def __init__(self, file_name: str):
        self.file_name = file_name
        self.connection = sqlite3.connect(self.file_name)

    def __enter__(self):
        return self.connection.cursor()

    def __exit__(self, exc_type, exc_val, exc_tb):
        self.connection.commit()
        self.connection.close()

When you use with SQLite('app.db') as cursor:, Python calls __enter__ to provide the cursor. Once the block ends (or fails), __exit__ runs to commit changes and close the connection.

The Decorator Approach

For simpler use cases, the contextlib.contextmanager decorator is much cleaner. It uses a generator function to define the boundary between setup and teardown.

from contextlib import contextmanager

@contextmanager
def open_db(file_name: str):
    conn = sqlite3.connect(file_name)
    try:
        yield conn.cursor()
    finally:
        conn.commit()
        conn.close()

The code before yield is your setup. The yield itself provides the resource to the with statement. The finally block ensures cleanup happens regardless of errors.

Syntax Notes

Python 3.10 introduced parenthesized context managers, which allow you to group multiple managers across several lines without using backslashes. This keeps your code readable when handling complex resource chains.

Tips & Gotchas

Only use context managers when resource cleanup is required. If there is no state to tear down, avoid them; they add an unnecessary level of indentation and create a new scope that can make debugging more complex. Always use finally within your generator-based managers to guarantee the teardown executes.