contextmanager

I use Python 2.7 and I know that I can write this: with A() as a, B() as b: do_something() I want to provide a convenience helper which does both. The usage of this helper should look like this: with AB() as ab: do_something() Now AB() should do both: Create context A() and create context B(). I have no clue how to write this convenience helper Don't re-invent the wheel; this is not as simple as it looks. Context managers are treated as a stack , and should be exited in reverse order in which they are entered, for example. If an exception occurred, this order matters , as any context manager

I'm familiar with using python's with statement as a means of ensuring finalization of an object in the event of an exception being thrown. This usually looks like with file.open('myfile.txt') as f: do stuff... which is short-hand for f = file.open('myfile.txt'): try: do stuff... finally: f.close() or whatever other finalization routine a class may present. I recently came across a piece of code dealing with OpenGL that presented this: with self.shader: (Many OpenGL commands) Note that absence of any as keyword. Does this indicate that the __enter__ and __exit__ methods of the class are still

Is it possible to ensure the __exit__() method is called even if there is an exception in __enter__() ? >>> class TstContx(object): ... def __enter__(self): ... raise Exception('Oops in __enter__') ... ... def __exit__(self, e_typ, e_val, trcbak): ... print "This isn't running" ... >>> with TstContx(): ... pass ... Traceback (most recent call last): File "<stdin>", line 1, in <module> File "<stdin>", line 3, in __enter__ Exception: Oops in __enter__ >>> Edit This is as close as I could get... class TstContx(object): def __enter__(self): try: # __enter__ code except Exception as e self.init_exc

Suppose you are using a multiprocessing.Pool object, and you are using the initializer setting of the constructor to pass an initializer function that then creates a resource in the global namespace. Assume resource has a context manager. How would you handle the life-cycle of the context managed resource provided it has to live through the life of the process, but be properly cleaned up at the end? So far, I have something somewhat like this: resource_cm = None resource = None def _worker_init(args): global resource resource_cm = open_resource(args) resource = resource_cm.__enter__() From

We have code that invokes a variable number of context managers depending on runtime parameters: from contextlib import nested, contextmanager @contextmanager def my_context(arg): print("entering", arg) try: yield arg finally: print("exiting", arg) def my_fn(items): with nested(*(my_context(arg) for arg in items)) as managers: print("processing under", managers) my_fn(range(3)) However, contextlib.nested is deprecated since Python 2.7 : DeprecationWarning: With-statements now directly support multiple context managers The answers to Multiple variables in Python 'with' statement indicate that

It seems like it would be only natural to do something like: with socket(socket.AF_INET, socket.SOCK_DGRAM) as s: but Python doesn't implement a context manager for socket. Can I easily use it as a context manager, and if so, how? Martijn Pieters The socket module is fairly low-level, giving you almost direct access to the C library functionality. You can always use the contextlib.contextmanager decorator to build your own: import socket from contextlib import contextmanager @contextmanager def socketcontext(*args, **kw): s = socket.socket(*args, **kw) try: yield s finally: s.close() with