Popular recipes tagged "contextmanager"

Variable Abbreviations (Python)

2017-06-22T11:57:20-07:00

Python recipe 580807 by Alfe (abbreviations, contextmanager, variables, with).

One sometimes has nice long speaking names vor variables, maybe things like buildingList[foundIndex].height, but would like to address these in a shorter fashion to be used within a formula or similar where lots of longs names tend to confuse any reader trying to understand the formula. Physicists use one-letter names for a reason.

For this I wrote a small context provider which allows using short names instead of long ones:

with Abbr(h=buildingList[foundIndex].height, g=gravitationalConstant):
    fallTime = sqrt(2 * h / g)
    endSpeed = sqrt(2 * h * g)
print("Fall time:", fallTime)
print("End speed:", endSpeed)

For longer formulas this can reduce ugly multi-line expressions to clearly readable one-liners.

One could use this:

h = buildingList[foundIndex].height
g = gravitationalConstant
fallTime = sqrt(2 * h / g)
endSpeed = sqrt(2 * h * g)
del g, h
print("Fall time:", fallTime)
print("End speed:", endSpeed)

to achieve the same result, but

it would not look as clean and
the context provider solves the typical issues like cleanup on exception etc.

Just using local variables without cleanup (like above without the del statement) also is an option of course, but that would clutter the variable name space unnecessarily.

CAVEATS: The implementation of Abbr() is a hack. If used as intended and described here, it should work just fine, though. But the hackish nature forces me to mention some things: Since at compile time the compiler decides that the h and g in the example must be global variables (because they aren't assigned in the function), it produces byte code accessing global variables. The context provider changes the global variable structure to fill the needs. (Overridden already existing global variables of the same name get restored properly at context exit.) This means some things:

One cannot have a local variable of the same name in the frame surrounding the context manager.
Existing global variables are changed during the time of the context manager; so using names like sys or os for abbreviations might be a bad idea due to side-effects.

Context Manager for an Arbitrary Number of Files in Python (Python)

2017-03-13T13:27:50-07:00

Python recipe 580763 by Alfe (contextmanager, file, open). Revision 2.

The pattern using with together with open() to automatically close a file after leaving the context is well known. To open a fixed number you can simply nest these statements or use the comma notation. For having a context which represents an arbitrary number of open files you can use the ExitStack class, but only for Python 3.3+.

For other Python versions I'm using the following class which I named Files. The presented implementation is only for reading files (for keeping it clear). Extending it for having various file modes should not pose a problem.

Use PDFWriter with context manager support (Python)

2013-12-16T21:43:27-08:00

Python recipe 578790 by Vasudev Ram (contextmanager, context_manager, pdf, python, reportlab, with_statement, xtopdf).

PDFWriter - a core class of the xtopdf toolkit - can now be used with a Python context manager, a.k.a. the Python with statement.

Code example below. More details here:

http://jugad2.blogspot.in/2013/12/xtopdf-pdfwriter-now-has-context.html

Wrap any iterable context manager so it closes when consumed (Python)

2012-11-19T20:10:35-08:00

Python recipe 578342 by Andrew Barnert (contextmanager, context_manager, generator, iterable, iterator, with_statement).

There are a few types in Python—most notably, files—that are both iterators and context managers. For trivial cases, these features are easy to use together, but as soon as you need to use the iterator lazily or asynchronously, a with statement won't help. That's where this recipe comes in handy:

send_async(with_iter(open(path, 'r')))

This also allows you to "forward" closing for a wrapped iterator, so closing the outer iterator also closes the inner one:

sync_async(line.upper() for line in with_iter(open(path, 'r')))

Context manager to atomically replace a file (Python)

2012-06-17T12:09:49-07:00

Python recipe 578166 by Oren Tirosh (atomic, contextmanager, file, replace). Revision 3.

This context manager ensures that a file's content is either replaced atomically with new contents or left unchanged. An exception or other error will not leave it empty or with partial content.

Handle exit context manager (Python)

2014-08-01T08:28:07-07:00

Python recipe 577997 by Giampaolo Rodolà (atexit, contextlib, contextmanager, exit, python, python3, shutdown, sigint, signal, sigterm). Revision 23.

A context manager which properly handles SIGTERM (SystemExit) and SIGINT (KeyboardInterrupt) signals, registering a function which is always guaranteed to be called on interpreter exit. Also, it makes sure to execute previously registered functions as well (if any).

CleanupManager for with statements (Python)

2011-12-18T07:20:46-08:00

Python recipe 577981 by Nick Coghlan (contextmanager, context_manager). Revision 5.

Inspired by unittest.TestCase.addCleanup(), CleanupManager provides a means to programmatically add resources to be cleaned up when leaving a with statement. This makes it easy to use with optional resources, and those derived from sequences of inputs.

An more powerful version of this recipe with a few additional features is published under the name ContextStack as part of the contextlib2 module: http://contextlib2.readthedocs.org

This recipe is based on a suggestion originally posted by Nikolaus Rath at http://bugs.python.org/issue13585

Context manager for low-level redirection of stdout/stderr (Python)

2012-01-26T02:14:25-08:00

Python recipe 577564 by Greg Haskins (contextmanager, context_manager, f2py, fortran, python, redirect, stdout). Revision 3.

This context manager provides a convenient, Pythonic way to temporarily replace the file descriptors of stdout and stderr, redirecting to either os.devnull or files of your choosing. Swapping the C-level file descriptors is required when suppressing output from compiled extension modules, such as those built using F2PY. It functions equally well for pure-Python code. UPDATE: (see below).

Decorator and context manager from a single API (Python)

2010-06-27T15:15:01-07:00

Python recipe 577273 by Michael Foord (contextmanager, context_manager, decorator, decorators, with, with_statement). Revision 12.

Create objects that act as both context managers and as decorators, and behave the same in both cases.

Works with Python 2.4 - 2.7 and Python 3. The tests require unittest2 or Python 3.2 to run. (And because the tests use the with statement they won't work with Python 2.4.)

Example:

from contextdecorator import ContextDecorator

class mycontext(ContextDecorator):

    def __init__(self, *args):
        """Normal initialiser"""

    def before(self):
        """
        Called on entering the with block or starting the decorated function.

        If used in a with statement whatever this method returns will be the
        context manager.
        """

    def after(self, *exc):
        """
        Called on exit. Arguments and return value of this method have
        the same meaning as the __exit__ method of a normal context
        manager.
        """

Both before and after methods are optional (but providing neither is somewhat pointless). See the tests for more usage examples.

POSIX context manager to temporarily silence, or filter lines from stdout (Python)

2010-03-03T06:17:23-08:00

Python recipe 577083 by pwaller (contextmanager, freopen, silence, stdout, with). Revision 2.

Fed up with libraries you don't have control over emitting text into your precious stdout?

If they use stdout through python, then you can just change sys.stdout to be something else. If they are printing directly to stdout through a C module, or some other means, then you are stuck.

.. at least until you discover the with silence(): block!

Caveats: Non-portable, tested only on 2.6 under Linux, uses threading.

Example output:

$ python silence_file.py 
Before with block..
Sensible stuff!
After the silence block

Simple lock-queue via Memcached (Python)

2008-11-19T01:32:07-08:00

Python recipe 576567 by Tal Einat (concurrency, contextmanager, lock, locking, memcache, memcached, queue).

A simple lock-queue (FIFO) context manager implemented with Memcached.

In essence this is a normal lock, where the requests to acquire the lock are granted in the order in which they were originally made. Note that requests to acquire the lock are always blocking.