The context manager can optionally return an object, to be assigned to the identifier named by as. And it is the object returned by the __enter__ method that is assigned by as, not necessarily the context manager itself. Using as <identifier> helps when you create a new object, like the open() call does, but not … Read more
As far as I understand, __init__() and __enter__() methods of the context manager are called exactly once each, one after another, leaving no chance for any other code to be executed in between. And your understanding is incorrect. __init__ is called when the object is created, __enter__ when it is entered with with statement, and … Read more
Since Python 3.7, you can write: from contextlib import asynccontextmanager @asynccontextmanager async def smtp_connection(): client = SMTPAsync() … try: await client.connect(smtp_url, smtp_port) await client.starttls() await client.login(smtp_username, smtp_password) yield client finally: await client.quit() Before 3.7, you can use the async_generator package for this. On 3.6, you can write: # This import changed, everything else is the … Read more
A StringIO instance is an open file already. The open command, on the other hand, only takes filenames, to return an open file. A StringIO instance is not suitable as a filename. Also, you don’t need to close a StringIO instance, so there is no need to use it as a context manager either. While … Read more
How about overriding unittest.TestCase.run() as illustrated below? This approach doesn’t require calling any private methods or doing something to every method, which is what the questioner wanted. from contextlib import contextmanager import unittest @contextmanager def resource_manager(): yield ‘foo’ class MyTest(unittest.TestCase): def run(self, result=None): with resource_manager() as resource: self.resource = resource super(MyTest, self).run(result) def test(self): self.assertEqual(‘foo’, … Read more
Starting in Python 3.2, support for this is even included in the standard library. Deriving from the class contextlib.ContextDecorator makes it easy to write classes that can be used as both, a decorator or a context manager. This functionality could be easily backported to Python 2.x — here is a basic implementation: class ContextDecorator(object): def … Read more
Python 3.7 and above: use contextlib.nullcontext, specifically designed for this reason. Before Python 3.7, the standard library does not offer a context manager specifically designed for these use cases, but there are some workarounds. Since Python 3.4, contextlib.suppress can be used for that purpose in the first case, i.e. when there is no as clause: … Read more
In Python 2.7 and 3.1 and above, you can write: with A() as X, B() as Y, C() as Z: do_something() This is normally the best method to use, but if you have an unknown-length list of context managers you’ll need one of the below methods. In Python 3.3, you can enter an unknown-length list … Read more
Using these magic methods (__enter__, __exit__) allows you to implement objects which can be used easily with the with statement. The idea is that it makes it easy to build code which needs some ‘cleandown’ code executed (think of it as a try-finally block). Some more explanation here. A useful example could be a database … Read more