Menu
Article Case Studies

timeout for python function

Narkw Brahma

Narkw Brahma

• 2 min read

Timeout for Python Function

Timeout for a Python function is a mechanism that allows the programmer to set a maximum time limit for the execution of a function. If the function takes longer to execute than the set time limit, it will be terminated automatically.

Using the signal module

The signal module provides a way to interrupt a running process by sending a signal to it. We can use this module to set a timeout for a Python function.


import signal

class TimeoutError(Exception):
    pass

def timeout_handler(signum, frame):
    raise TimeoutError()

def my_function():
    signal.signal(signal.SIGALRM, timeout_handler)
    signal.alarm(10)  # 10 seconds
    # do some long operation
    signal.alarm(0)  # reset the alarm

In the above code, we defined a custom exception class called TimeoutError. Then we defined a signal handler called timeout_handler that raises this exception when called. We set this handler to listen for the SIGALRM signal, which is sent when the alarm timer set by signal.alarm() goes off. We set the timer for 10 seconds by calling signal.alarm(10).

To use this mechanism, we call my_function() which contains the long-running code. If the code takes longer than 10 seconds to execute, the TimeoutError exception will be raised, and we can handle it accordingly.

Using the threading module

The threading module provides another way to set a timeout for a Python function. We can create a new thread that runs the function and waits for it to finish. If the function takes longer than the set time limit, we can terminate the thread.


import threading

class MyThread(threading.Thread):
    def __init__(self, func, args=(), kwargs={}):
        super(MyThread, self).__init__()
        self.func = func
        self.args = args
        self.kwargs = kwargs
        self.result = None

    def run(self):
        self.result = self.func(*self.args, **self.kwargs)

def my_function():
    # do some long operation
    return result

def timeout_decorator(timeout):
    def decorate(func):
        def wrapper(*args, **kwargs):
            t = MyThread(func, args, kwargs)
            t.start()
            t.join(timeout)
            if t.is_alive():
                raise TimeoutError()
            return t.result
        return wrapper
    return decorate

my_function = timeout_decorator(10)(my_function)

In the above code, we defined a custom thread class called MyThread that takes a function and its arguments as input. We defined a run() method that runs the function and stores its result. We also defined a timeout_decorator() function that takes a timeout value and returns a decorator that can be used to decorate a function with a timeout.

To use this mechanism, we call my_function() which is decorated with the timeout_decorator(). The decorator creates a new thread that runs the function and waits for it to finish. If the function takes longer than 10 seconds to execute, the TimeoutError exception will be raised, and we can handle it accordingly.

Share