Pythonic way to check for a condition with a timeout?

Question

I need to check for a certain condition before a timeout. If the condition is met before the limit then I return True, otherwise I return False.

I'm doing this in the following way:

def foobar():
    counter = 1
    condition_met = False
    while counter < max_limit:
        if <conditions are met>:
            condition_met = True
            break
        time.sleep(10)
        counter += 1
    return condition_met

I'm wondering if there's a more pythonic way to do the same thing.

Answer 1

A really good way to time things is by using—shock—the time module:

import time

def foo():
    max_limit = 25  # Seconds.

    start = time.time()
    condition_met = False
    while time.time() - start < max_limit:
        if <conditions are met>:
            condition_met = True
            break
        time.sleep(10)

    return condition_met

See? The module is good for more than just sleeping. ;¬)

Answer 2

I am assuming you have a code in a function. The below code get rid of a variable condition_met and break statement.

counter = 1
# condition_met = False
while counter < max_limit:
    if <conditions are met>:
        # condition_met = True
        return True   # get rid of break statement
    time.sleep(10)
    counter += 1
return False

Answer 3

If it were not for the time.sleep, your loop would be equivalent to

for _ in range(max_limit):
    if <condition>:
        return True
    # time.sleep(10)
return False

Which is equivalent to return any(<condition> for _ in range(max_limit).

Thus, you could (ab)use any and or to check whether the condition is met up to a certai number of times while waiting a bit before each check:

any(time.sleep(10) or <condition> for _ in range(max_limit))

This will first evaluate time.sleep, which returns None, and then evaluate the condition, until the condition is met or the range is exhausted.

The only caveat is that this will call time.sleep even before the first check of the condition. To fix this, you can first check the counter variable and only if that is > 0 call time.sleep:

any(i and time.sleep(10) or <condition> for i in range(10))

Whether that's clearer than the long loop is for you to decide.

---

As suggested in comments, you can in fact just invert the above any clause to

any(<condition> or time.sleep(10) for _ in range(max_limit))

This will first check the condition and only if the condition is false will sleep. It also ready much more naturally than any of the above two appraoches.

Answer 4

Here's another way to do it that uses a threading.Timer in conjunction with a function decorator to know when a given time limit has been exceeded.

I adapted the approach in @Aaron Hall's answer to a very similar Timeout on a function call question so it can be used without killing the main thread (i.e. the caller) in the process.

In this scheme, a Timer object is created to call a quit function after a time_limit number of seconds has elapsed. If that happens the quit function prints out a notification message and then causes a KeyboardInterrupt exception to be raised by calling _thread.interrupt_main(). The decorator() function wrapped around the original function catches this exception and makes it appear that the function returned False — conversely, if that doesn't happen, it cancels the Timer thread and returns True.

from random import randint
import sys
import time
import threading
import _thread as thread  # Low-level threading API


def interupt_after(time_limit):
    ''' Decorator to raise KeyboardInterrupt if function takes more than
        `time_limit` seconds to execute.
    '''
    def quit_func(func_name):
        print('{0}() took too long'.format(func_name), file=sys.stderr)
        sys.stderr.flush()
        thread.interrupt_main()  # Raises KeyboardInterrupt.

    def decorator(func):
        def decorated(*args, **kwargs):
            timer = threading.Timer(time_limit, quit_func, args=[func.__name__])
            timer.start()
            try:
                func(*args, **kwargs)  # Note return value ignored.
            except KeyboardInterrupt:
                return False
            finally:
                timer.cancel()
            return True
        return decorated

    return decorator


if __name__ == '__main__':

    @interupt_after(5)
    def foo(lo, hi):
        mid = (lo+hi) // 2
        condition_met = False
        while not condition_met:
            if randint(lo, hi) == mid:  # Condition to meet.
                condition_met = True
                break
            time.sleep(1)

        return condition_met

    print(f'foo(40, 44):', foo(40, 44))
    print('-fini-')

It prints this when the condition is met in the allotted time:

foo(40, 44): True
-fini-

and this when it's not:

foo() took too long
foo(40, 44): False
-fini-