Lib/contextlib.py

   1 """Utilities for with-statement contexts.  See PEP 343."""
   2
   3 import sys
   4
   5 __all__ = ["contextmanager", "nested", "closing"]
   6
   7 class GeneratorContextManager(object):
   8     """Helper for @contextmanager decorator."""
   9
  10     def __init__(self, gen):
  11         self.gen = gen
  12
  13     def __enter__(self):
  14         try:
  15             return self.gen.next()
  16         except StopIteration:
  17             raise RuntimeError("generator didn't yield")
  18
  19     def __exit__(self, type, value, traceback):
  20         if type is None:
  21             try:
  22                 self.gen.next()
  23             except StopIteration:
  24                 return
  25             else:
  26                 raise RuntimeError("generator didn't stop")
  27         else:
  28             try:
  29                 self.gen.throw(type, value, traceback)
  30                 raise RuntimeError("generator didn't stop after throw()")
  31             except StopIteration, exc:
  32                 # Suppress the exception *unless* it's the same exception that
  33                 # was passed to throw().  This prevents a StopIteration
  34                 # raised inside the "with" statement from being suppressed
  35                 return exc is not value
  36             except:
  37                 # only re-raise if it's *not* the exception that was
  38                 # passed to throw(), because __exit__() must not raise
  39                 # an exception unless __exit__() itself failed.  But throw()
  40                 # has to raise the exception to signal propagation, so this
  41                 # fixes the impedance mismatch between the throw() protocol
  42                 # and the __exit__() protocol.
  43                 #
  44                 if sys.exc_info()[1] is not value:
  45                     raise
  46
  47
  48 def contextmanager(func):
  49     """@contextmanager decorator.
  50
  51     Typical usage:
  52
  53         @contextmanager
  54         def some_generator(<arguments>):
  55             <setup>
  56             try:
  57                 yield <value>
  58             finally:
  59                 <cleanup>
  60
  61     This makes this:
  62
  63         with some_generator(<arguments>) as <variable>:
  64             <body>
  65
  66     equivalent to this:
  67
  68         <setup>
  69         try:
  70             <variable> = <value>
  71             <body>
  72         finally:
  73             <cleanup>
  74
  75     """
  76     def helper(*args, **kwds):
  77         return GeneratorContextManager(func(*args, **kwds))
  78     try:
  79         helper.__name__ = func.__name__
  80         helper.__doc__ = func.__doc__
  81         helper.__dict__ = func.__dict__
  82     except:
  83         pass
  84     return helper
  85
  86
  87 @contextmanager
  88 def nested(*managers):
  89     """Support multiple context managers in a single with-statement.
  90
  91     Code like this:
  92
  93         with nested(A, B, C) as (X, Y, Z):
  94             <body>
  95
  96     is equivalent to this:
  97
  98         with A as X:
  99             with B as Y:
 100                 with C as Z:
 101                     <body>
 102
 103     """
 104     exits = []
 105     vars = []
 106     exc = (None, None, None)
 107     try:
 108         for mgr in managers:
 109             exit = mgr.__exit__
 110             enter = mgr.__enter__
 111             vars.append(enter())
 112             exits.append(exit)
 113         yield vars
 114     except:
 115         exc = sys.exc_info()
 116     finally:
 117         while exits:
 118             exit = exits.pop()
 119             try:
 120                 if exit(*exc):
 121                     exc = (None, None, None)
 122             except:
 123                 exc = sys.exc_info()
 124         if exc != (None, None, None):
 125             # Don't rely on sys.exc_info() still containing
 126             # the right information. Another exception may
 127             # have been raised and caught by an exit method
 128             raise exc[0], exc[1], exc[2]
 129
 130
 131 class closing(object):
 132     """Context to automatically close something at the end of a block.
 133
 134     Code like this:
 135
 136         with closing(<module>.open(<arguments>)) as f:
 137             <block>
 138
 139     is equivalent to this:
 140
 141         f = <module>.open(<arguments>)
 142         try:
 143             <block>
 144         finally:
 145             f.close()
 146
 147     """
 148     def __init__(self, thing):
 149         self.thing = thing
 150     def __enter__(self):
 151         return self.thing
 152     def __exit__(self, *exc_info):
 153         self.thing.close()