contextmanager

Suppose I have some kind of context manager (from a third-party library) that I am using like so: with freeze_time(test_dt): lines_of_code_1 lines_of_code_2 lines_of_code_3 But, suppose if there is no value for test_dt, the context manager should not run, but all of the remaining code should run, like so: if test_dt: with freeze_time(test_dt): lines_of_code_1 lines_of_code_2 lines_of_code_3 else: lines_of_code_1 lines_of_code_2 lines_of_code_3 Assume that lines_of_code here is 2-3 lines of code which are exactly identical, is there a cleaner way of writing this? I'm aware that I could write

This question already has an answer here: How to check if an object is created with `with` statement? 5 answers Is there a way in Python to write a class that will error unless it's used with a with statement? # Okay: with Foo() as f1: f1.func1() f1.func2() # Not okay: f2 = Foo() f2.func1() I can do it manually: have __enter__ set a flag and have every other method check for that flag. But is there a nicer way to do it? Here's code for the not-so-since way: class Foo(object): def __init__(self): self._entered = False def __enter__(self): self._entered = True return self def _verify_entered

I want something like this: from contextlib import contextmanager @contextmanager def loop(seq): for i in seq: try: do_setup(i) yield # with body executes here do_cleanup(i) except CustomError as e: print(e) with loop([1,2,3]): do_something_else() do_whatever() But contextmanager doesn't work because it expects the generator to yield exactly once. The reason why I want this is because I basically want to make my own custom for loop. I have a modified IPython that is used to control test equipment. It's obviously a full Python REPL, but most of the time the user is just calling predefined

I'm trying to make a quick and dirty caching system for Python, using the trick that a context-manager can be made to conditionally skip the code in its context — see Skipping execution of -with- block . I've stumbled upon a weird failure case of this and I was wondering if someone can help understand and fix this. Before anyone says this, I know what I'm doing is terrible and I shouldn't do it, etc, etc. Anyway, here is the code for the tricky context manager: import sys import inspect class SkippableContext(object): def __init__(self,mode=0): """ if mode = 0, proceed as normal if mode = 1,

I have timeout context manager that works perfectly with signals but it raises error in multithread mode because signals work only in main thread. def timeout_handler(signum, frame): raise TimeoutException() @contextmanager def timeout(seconds): old_handler = signal.signal(signal.SIGALRM, timeout_handler) signal.alarm(seconds) try: yield finally: signal.alarm(0) signal.signal(signal.SIGALRM, old_handler) I've seen decorator implementation of timeout but I don't know how to pass yield inside class derived from threading.Thread . My variant won't work. @contextmanager def timelimit(seconds):

import contextlib import time @contextlib.contextmanager def time_print(task_name): t = time.time() try: yield finally: print task_name, "took", time.time() - t, "seconds." def doproc(): x=1+1 with time_print("processes"): [doproc() for _ in range(500)] # processes took 15.236166954 seconds. when does doproc get executed when using this decorator? yield expression returns control to the whatever is using the generator. The generator pauses at this point, which means that the @contextmanager decorator knows that the code is done with the setup part. In other words, everything you want to do in