I have a class which implements a context manager, its __init__ has a signature and the __enter__ returns an instance of the class.
Along with several methods which implement functionality on the instance, I have one method which itself must open a context manager against a call on an instance attribute. This context manager does not return an instance of itself, it merely opens a context. I am not thrilled about is the implementation I have used and I am wondering if there is a better way. It's been a long time since I have worked in Python and I am probably overlooking something obvious. Syntactically I achieve what I want in use, but it looks awkward in its implementation. How can I clean up the first class and decorator to implement the functionality on a method in the Foo class? class MethodContextManager: def __init__(self, obj, key, value): self.obj = obj self.key = key self.value = value def __enter__(self): self.obj.some_method(key, value) def __exit__(self, exc_type, exc_val, exc_tb): self.obj.another_method() def method_context_manager(func): def wrapper(self, key, value): return MethodContextManager(self.instance, key, value) return wrapper class Foo: def __init__(self, bar): self.bar = bar self.instance = None def __enter__(self): self.instance = SomeFunc(this.bar) return self def __exit__(self, exc_type, exc_val, exc_tb): # Cleanup... @method_context_manager def baz(self, key, value): pass with Foo(bar) as foo: foo.other_call() with foo.baz(42, "a"): foo.other_call() with foo.baz(420, None): foo.other_call() foo.other_call() foo.other_call() foo.other_call() -- https://mail.python.org/mailman/listinfo/python-list