Source

contextlib2 / docs / index.rst

Full commit

contextlib2 --- Updated utilities for context management

This module provides backports of features in the latest version of the standard library's :mod:`contextlib` module to earlier Python versions. It also serves as a real world proving ground for potential future enhancements to that module.

Like :mod:`contextlib`, this module provides utilities for common tasks involving the with statement.

Additions Relative to the Standard Library

This module is primarily a backport of the Python 3.2 version of :mod:`contextlib` to earlier releases. However, it is also a proving ground for new features not yet part of the standard library. Those new features are currently:

API Reference

A base class that enables a context manager to also be used as a decorator.

Context managers inheriting from ContextDecorator have to implement :meth:`__enter__` and :meth:`__exit__` as normal. :meth:`__exit__` retains its optional exception handling even when used as a decorator.

ContextDecorator is used by :func:`contextmanager`, so you get this functionality automatically.

Example of ContextDecorator:

from contextlib import ContextDecorator

class mycontext(ContextDecorator):
    def __enter__(self):
        print('Starting')
        return self

    def __exit__(self, *exc):
        print('Finishing')
        return False

>>> @mycontext()
... def function():
...     print('The bit in the middle')
...
>>> function()
Starting
The bit in the middle
Finishing

>>> with mycontext():
...     print('The bit in the middle')
...
Starting
The bit in the middle
Finishing

This change is just syntactic sugar for any construct of the following form:

def f():
    with cm():
        # Do stuff

ContextDecorator lets you instead write:

@cm()
def f():
    # Do stuff

It makes it clear that the cm applies to the whole function, rather than just a piece of it (and saving an indentation level is nice, too).

Existing context managers that already have a base class can be extended by using ContextDecorator as a mixin class:

from contextlib import ContextDecorator

class mycontext(ContextBaseClass, ContextDecorator):
    def __enter__(self):
        return self

    def __exit__(self, *exc):
        return False

A context manager that is designed to make it easy to programmatically combine other context managers and cleanup functions, especially those that are optional or otherwise driven by input data.

For example, a set of files may easily be handled in a single with statement as follows:

with ContextStack() as stack:
    files = [stack.enter_context(open(fname)) for fname in filenames]
    # All opened files will automatically be closed at the end of
    # the with statement, even if attempts to open files later
    # in the list throw an exception

Each instance maintains a stack of registered callbacks that are called in reverse order when the instance is closed (either explicitly or implicitly at the end of a with statement). Note that callbacks are not invoked implicitly when the context stack instance is garbage collected.

Since registered callbacks are invoked in the reverse order of registration, this ends up behaving as if multiple nested with statements had been used with the registered set of callbacks. This even extends to exception handling - if an inner callback suppresses or replaces an exception, then outer callbacks will be passed arguments based on that updated state.

Examples and Recipes

This section describes some examples and recipes for making effective use of the tools provided by :mod:`contextlib2`. Some of them may also work with :mod:`contextlib` in sufficiently recent versions of Python. When this is the case, it is noted at the end of the example.

Using a context manager as a function decorator

:class:`ContextDecorator` makes it possible to use a context manager in both an ordinary with statement and also as a function decorator. The :meth:`ContextDecorator.refresh_cm` method even makes it possible to use otherwise single use context managers (such as those created by :func:`contextmanager`) that way.

For example, it is sometimes useful to wrap functions or groups of statements with a logger that can track the time of entry and time of exit. Rather than writing both a function decorator and a context manager for the task, :func:`contextmanager` provides both capabilities in a single definition:

from contextlib2 import contextmanager
import logging

logging.basicConfig(level=logging.INFO)

@contextmanager
def track_entry_and_exit(name):
    logging.info('Entering: {}'.format(name))
    yield
    logging.info('Exiting: {}'.format(name))

This can be used as both a context manager:

with track_entry_and_exit('widget loader'):
    print('Some time consuming activity goes here')
    load_widget()

And also as a function decorator:

@track_entry_and_exit('widget loader')
def activity():
    print('Some time consuming activity goes here')
    load_widget()

Note that there is one additional limitation when using context managers as function decorators: there's no way to access the return value of :meth:`__enter__`. If that value is needed, then it is still necessary to use an explicit with statement.

This example should also work with :mod:`contextlib` in Python 3.2.1 or later.

Cleaning up in an __enter__ implementation

As noted in the documentation of :meth:`ContextStack.register_exit`, this method can be useful in cleaning up an already allocated resource if later steps in the :meth:`__enter__` implementation fail.

Here's an example of doing this for a context manager that accepts resource acquisition and release functions, along with an optional validation function, and maps them to the context management protocol:

from contextlib2 import ContextStack

class ResourceManager(object):

    def __init__(self, acquire_resource, release_resource, check_resource_ok=None):
        self.acquire_resource = acquire_resource
        self.release_resource = release_resource
        self.check_resource_ok = check_resource_ok

    def __enter__(self):
        resource = self.acquire_resource()
        if self.check_resource_ok is not None:
            with ContextStack() as stack:
                stack.register_exit(self)
                if not self.check_resource_ok(resource):
                    msg = "Failed validation for {!r}"
                    raise RuntimeError(msg.format(resource))
                # The validation check passed and didn't raise an exception
                # Accordingly, we want to keep the resource, and pass it
                # back to our caller
                stack.preserve()
        return resource

    def __exit__(self, *exc_details):
        # We don't need to duplicate any of our resource release logic
        self.release_resource()

Replacing any use of try-finally and flag variables

A pattern you will sometimes see is a try-finally statement with a flag variable to indicate whether or not the body of the finally clause should be executed. In its simplest form (that can't already be handled just by using an except clause instead), it looks something like this:

cleanup_needed = True
try:
    result = perform_operation()
    if result:
        cleanup_needed = False
finally:
    if cleanup_needed:
        cleanup_resources()

As with any try statement based code, this can cause problems for development and review, because the setup code and the cleanup code can end up being separated by arbitrarily long sections of code.

:class:`ContextStack` makes it possible to instead register a callback for execution at the end of a with statement, and then later decide to skip executing that callback:

from contextlib2 import ContextStack

with ContextStack() as stack:
    stack.register(cleanup_resources)
    result = perform_operation()
    if result:
        stack.preserve()

This allows the intended cleanup up behaviour to be made explicit up front, rather than requiring a separate flag variable.

If you find yourself using this pattern a lot, it can be simplified even further by means of a small helper class:

from contextlib2 import ContextStack

class Callback(ContextStack):
    def __init__(self, callback, *args, **kwds):
        super(Callback, self).__init__()
        self.register(callback, *args, **kwds)

    def cancel(self):
        self.preserve()

with Callback(cleanup_resources) as cb:
    result = perform_operation()
    if result:
        cb.cancel()

If the resource cleanup isn't already neatly bundled into a standalone function, then it is still possible to use the decorator form of :meth:`ContextStack.register_exit` to declare the resource cleanup in advance:

from contextlib2 import ContextStack

with ContextStack() as stack:
    @stack.register_exit
    def cleanup_resources(*exc_details):
        ...
    result = perform_operation()
    if result:
        stack.preserve()

Obtaining the Module

This module can be installed directly from the Python Package Index with pip:

pip install contextlib2

Alternatively, you can download and unpack it manually from the contextlib2 PyPI page.

There are no operating system or distribution specific versions of this module - it is a pure Python module that should work on all platforms.

Supported Python versions are currently 2.7 and 3.2+.

Development and Support

contextlib2 is developed and maintained on BitBucket. Problems and suggested improvements can be posted to the issue tracker.

Indices and tables