python
diff --git a/‎Lib/contextlib.py‎
Lines changed: 138 additions & 0 deletions b/‎Lib/contextlib.py‎
Lines changed: 138 additions & 0 deletions
diff --git a/‎Lib/decimal.py‎
Lines changed: 29 additions & 0 deletions b/‎Lib/decimal.py‎
Lines changed: 29 additions & 0 deletions
diff --git a/‎Lib/test/contextmanager.py‎
Lines changed: 0 additions & 33 deletions b/‎Lib/test/contextmanager.py‎
Lines changed: 0 additions & 33 deletions
diff --git a/‎Lib/test/nested.py‎
Lines changed: 0 additions & 40 deletions b/‎Lib/test/nested.py‎
Lines changed: 0 additions & 40 deletions
@@ -0,0 +1,138 @@
+"""Utilities for with-statement contexts.  See PEP 343."""
+
+import sys
+
+__all__ = ["contextmanager", "nested", "closing"]
+
+class GeneratorContextManager(object):
+    """Helper for @contextmanager decorator."""
+
+    def __init__(self, gen):
+        self.gen = gen
+
+    def __context__(self):
+        return self
+
+    def __enter__(self):
+        try:
+            return self.gen.next()
+        except StopIteration:
+            raise RuntimeError("generator didn't yield")
+
+    def __exit__(self, type, value, traceback):
+        if type is None:
+            try:
+                self.gen.next()
+            except StopIteration:
+                return
+            else:
+                raise RuntimeError("generator didn't stop")
+        else:
+            try:
+                self.gen.throw(type, value, traceback)
+            except StopIteration:
+                pass
+
+
+def contextmanager(func):
+    """@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):
+        return GeneratorContextManager(func(*args, **kwds))
+    try:
+        helper.__name__ = func.__name__
+        helper.__doc__ = func.__doc__
+    except:
+        pass
+    return helper
+
+
+@contextmanager
+def nested(*contexts):
+    """Support multiple context managers in a single with-statement.
+
+    Code like this:
+
+        with nested(A, B, C) as (X, Y, Z):
+            <body>
+
+    is equivalent to this:
+
+        with A as X:
+            with B as Y:
+                with C as Z:
+                    <body>
+
+    """
+    exits = []
+    vars = []
+    exc = (None, None, None)
+    try:
+        try:
+            for context in contexts:
+                mgr = context.__context__()
+                exit = mgr.__exit__
+                enter = mgr.__enter__
+                vars.append(enter())
+                exits.append(exit)
+            yield vars
+        except:
+            exc = sys.exc_info()
+    finally:
+        while exits:
+            exit = exits.pop()
+            try:
+                exit(*exc)
+            except:
+                exc = sys.exc_info()
+        if exc != (None, None, None):
+            raise
+
+
+@contextmanager
+def closing(thing):
+    """Context manager 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()
+
+    """
+    try:
+        yield thing
+    finally:
+        thing.close()
@@ -2173,6 +2173,32 @@ def __deepcopy__(self, memo):
 
 del name, val, globalname, rounding_functions
 
+class ContextManager(object):
+    """Helper class to simplify Context management.
+
+    Sample usage:
+
+    with decimal.ExtendedContext:
+        s = ...
+    return +s # Convert result to normal precision
+
+    with decimal.getcontext() as ctx:
+        ctx.prec += 2
+        s = ...
+    return +s
+
+    """
+    def __init__(self, new_context):
+        self.new_context = new_context
+    def __enter__(self):
+        self.saved_context = getcontext()
+        setcontext(self.new_context)
+        return self.new_context
+    def __exit__(self, t, v, tb):
+        setcontext(self.saved_context)
+        if t is not None:
+            raise t, v, tb
+
 class Context(object):
     """Contains the context for a Decimal instance.
 
@@ -2224,6 +2250,9 @@ def __repr__(self):
         s.append('traps=[' + ', '.join([t.__name__ for t, v in self.traps.items() if v]) + ']')
         return ', '.join(s) + ')'
 
+    def __context__(self):
+        return ContextManager(self.copy())
+
     def clear_flags(self):
         """Reset all flags to zero"""
         for flag in self.flags: