Coverage for contextlib2 : 63%

Hot-keys on this page
r m x p toggle line displays
j k next/prev highlighted chunk
0 (zero) top of page
1 (one) first highlighted chunk
"""contextlib2 - backports and enhancements to the contextlib module"""
"ContextStack", "ExitStack"]
"A base class or mixin that enables context managers to work as decorators."
"""Returns the context manager used to actually wrap the call to the decorated function.
The default implementation just returns *self*.
Overriding this method allows otherwise one-shot context managers like _GeneratorContextManager to support use as decorators via implicit recreation. """ return self
@wraps(func) def inner(*args, **kwds): with self.refresh_cm(): return func(*args, **kwds) return inner
"""Helper for @contextmanager decorator."""
# _GCM instances are one-shot context managers, so the # CM must be recreated each time a decorated function is # called return self.__class__(self.func, *self.args, **self.kwds)
except StopIteration: raise RuntimeError("generator didn't yield")
else: raise RuntimeError("generator didn't stop") else: if value is None: # Need to force instantiation so we can reliably # tell if we get the same exception back value = type() try: self.gen.throw(type, value, traceback) raise RuntimeError("generator didn't stop after throw()") except StopIteration as exc: # Suppress the exception *unless* it's the same exception that # was passed to throw(). This prevents a StopIteration # raised inside the "with" statement from being suppressed return exc is not value except: # only re-raise if it's *not* the exception that was # passed to throw(), because __exit__() must not raise # an exception unless __exit__() itself failed. But throw() # has to raise the exception to signal propagation, so this # fixes the impedance mismatch between the throw() protocol # and the __exit__() protocol. # if sys.exc_info()[1] is not value: raise
"""@contextmanager decorator.
Typical usage:
@contextmanager def some_generator(<arguments>): <setup> try: yield <value> finally: <cleanup>
This makes this:
with some_generator(<arguments>) as <variable>: <body>
equivalent to this:
<setup> try: <variable> = <value> <body> finally: <cleanup>
""" def helper(*args, **kwds):
"""Context to automatically close something at the end of a block.
Code like this:
with closing(<module>.open(<arguments>)) as f: <block>
is equivalent to this:
f = <module>.open(<arguments>) try: <block> finally: f.close()
""" self.thing = thing return self.thing self.thing.close()
# Inspired by discussions on http://bugs.python.org/issue13585 """Context manager for dynamic management of a stack of exit callbacks
For example:
with ExitStack() 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
"""
"""Preserve the context stack by transferring it to a new instance""" new_stack = type(self)() new_stack._exit_callbacks = self._exit_callbacks self._exit_callbacks = deque() return new_stack
"""Helper to correctly register callbacks to __exit__ methods"""
"""Registers a callback with the standard __exit__ method signature
Can suppress exceptions the same way __exit__ methods can.
Also accepts any object with an __exit__ method (registering the method instead of the object itself) """ # We use an unbound method rather than a bound method to follow # the standard lookup behaviour for special methods # Not a context manager, so assume its a callable else: self._push_cm_exit(exit, exit_method)
"""Registers an arbitrary callback and arguments.
Cannot suppress exceptions. """ def _exit_wrapper(exc_type, exc, tb): callback(*args, **kwds) # We changed the signature, so using @wraps is not appropriate, but # setting __wrapped__ may still help with introspection _exit_wrapper.__wrapped__ = callback self.push(_exit_wrapper) return callback # Allow use as a decorator
"""Enters the supplied context manager
If successful, also pushes its __exit__ method as a callback and returns the result of the __enter__ method. """ # We look up the special methods on the type to match the with statement
"""Immediately unwind the context stack""" self.__exit__(None, None, None)
return # This looks complicated, but it is really just # setting up a chain of try-expect statements to ensure # that outer callbacks still get invoked even if an # inner one throws an exception # Callbacks are removed from the list in FIFO order # but the recursion means they're invoked in LIFO order # Innermost callback is invoked directly # More callbacks left, so descend another level in the stack except: suppress_exc = cb(*sys.exc_info()) # Check if this cb suppressed the inner exception if not suppress_exc: raise else: # Check if inner cb suppressed the original exception exc_details = (None, None, None) # Kick off the recursive chain
# Preserve backwards compatibility """Backwards compatibility alias for ExitStack"""
return self.push(callback)
return self.callback(callback, *args, **kwds)
return self.pop_all() |