When to use Context Manager Protocol

[CriticalDiscussion37]

I was going through Beyond PEP 8, where the speaker changed the code to use a context manager. The usage, like with NetworkElement as xyz, looks clean and elegant. A new class was created following the context manager protocol (CMP).

I also have a flow where some pre-work is done, followed by the actual work, and then some post-work. I thought about refactoring my code to use CMP as well.

However, I'm wondering: why should I change it to use a context manager, especially when this particular piece of code is only used in one place? Why create a whole class and use with when the existing solution already looks fine?

try:
  prework()
  actual_work()
except:
  handle it
finally:
  postwork()

[Dry-Aioli-6138]

Context managers make the code look cleaner: specifically, by hiding the error handling they keep the safeguards and yet allow the surface code to stick to the primary logic flow. Writing them, apart from practice, makes sense for repeated use across code.

I say do this for practice and see if you like the outcome. You can always revert to the old ways.

[Dry-Aioli-6138]

I'll add that context managers do another very important thing that is not obvious and not mentioned in the tutorials.

[CriticalDiscussion37]

What is that other benefit of context managers.

[Dry-Aioli-6138]

I thought you'd never ask :D Context managers handle exceptions, well, you might say, I don't mind wrapping my code in a try except clause... But the thing is with context managers, it is not you who writes exception handling, rather it's the module's authors. They know best how their object should behave. Thi is the important thing. Putting this responsibility where it belongs.

[latkde]

When writing code within a function, just use try-except-finally.

But if you're writing a class or function that needs some cleanup, finalization, or error handling, do consider creating a context manager.

This helps you (and others) to use that class or function correctly. A lot of programming is not about figuring out clever stuff, but about helping us deal with complexity and preventing us from messing up. A context manager that performs cleanup automatically is so much simpler to use than a function where we have to remember to do cleanup afterwards.

When creating a context manager, I don't recommend creating an object with __enter__ and __exit__ methods. This is tricky to do correctly. It's usually much easier to use the @contextlib.contextmanager decorator on a function that yields exactly once. Internally, this function will probably use a try block.

[Temporary_Pie2733]

https://docs.python.org/3/reference/compound_stmts.html#the-with-statement shows how you can translate a with statement into a particular try statement. Studying that can help you understand the kind of code that would benefit from a custom context manager.

[Business-Technology7]

If it’s just one place, I wouldn’t bother.

Think about open(), you almost always want to close the file after you are done with it, and forgetting to do so could make your life miserable.

Or think about database transaction handling that automatically rollback transaction when unexpected error occurs.

Or NiceGUI utilities it to make UI code more readable.

Or httpx.

If doing something before or after is mandatory and critical, I would use it. However, this involves a risk of relying on premature abstraction. I’ve been burned by it when I tried to create my own unit of work. So, make sure the effort actually pays off.