holado 0.13.22__py3-none-any.whl

holado_multitask/multithreading/loopfunctionthreaded.py

@@ -0,0 +1,45 @@
+
+#################################################
+# HolAdo (Holistic Automation do)
+#
+# (C) Copyright 2021-2025 by Eric Klumpp
+# 
+# Permission is hereby granted, free of charge, to any person obtaining a copy of this software and associated documentation files (the “Software”), to deal in the Software without restriction, including without limitation the rights to use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of the Software, and to permit persons to whom the Software is furnished to do so, subject to the following conditions:
+# 
+# The above copyright notice and this permission notice shall be included in all copies or substantial portions of the Software.
+
+# The Software is provided “as is”, without warranty of any kind, express or implied, including but not limited to the warranties of merchantability, fitness for a particular purpose and noninfringement. In no event shall the authors or copyright holders be liable for any claim, damages or other liability, whether in an action of contract, tort or otherwise, arising from, out of or in connection with the software or the use or other dealings in the Software.
+#################################################
+
+from builtins import super
+import logging
+from holado_multitask.multithreading.functionthreaded import FunctionThreaded
+from holado_multitask.multithreading.loopthread import LoopThread
+from holado.common.handlers.undefined import default_context
+
+logger = logging.getLogger(__name__)
+
+
+class LoopFunctionThreaded(LoopThread):
+    '''
+    Execute in a thread given function with given arguments.
+    '''
+    
+    def __init__(self, target, args=None, kwargs=None, name=None, default_wait_timeout=None, register_thread=True, register_scope=default_context, delay_before_run_sec=None, delay_between_run_sec=None, nb_times=None, with_next_loop_datetime=False):
+        super().__init__(name if name is not None else f"Loop function '{target}'", default_wait_timeout=default_wait_timeout, register_thread=register_thread, register_scope=register_scope, delay_before_run_sec=delay_before_run_sec, delay_between_run_sec=delay_between_run_sec, nb_times=nb_times, with_next_loop_datetime=with_next_loop_datetime)
+
+        self.__function_threaded = FunctionThreaded(target, args, kwargs)
+
+    @property
+    def function_threaded(self):
+        return self.__function_threaded
+
+    def run_loop(self):
+        try:
+            self.__function_threaded.run()
+        except Exception as exc:
+            msg = "Exception catched while processing function:\n    [{}]".format(repr(exc))
+            logger.exception(msg)
+    
+    
+    

holado_multitask/multithreading/loopthread.py

@@ -0,0 +1,110 @@
+
+#################################################
+# HolAdo (Holistic Automation do)
+#
+# (C) Copyright 2021-2025 by Eric Klumpp
+# 
+# Permission is hereby granted, free of charge, to any person obtaining a copy of this software and associated documentation files (the “Software”), to deal in the Software without restriction, including without limitation the rights to use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of the Software, and to permit persons to whom the Software is furnished to do so, subject to the following conditions:
+# 
+# The above copyright notice and this permission notice shall be included in all copies or substantial portions of the Software.
+
+# The Software is provided “as is”, without warranty of any kind, express or implied, including but not limited to the warranties of merchantability, fitness for a particular purpose and noninfringement. In no event shall the authors or copyright holders be liable for any claim, damages or other liability, whether in an action of contract, tort or otherwise, arising from, out of or in connection with the software or the use or other dealings in the Software.
+#################################################
+
+import threading
+import time
+import logging
+import holado_multitask.multithreading.thread as ctt
+from holado.common.handlers.undefined import default_context
+from holado_python.common.tools.datetime import DateTime
+
+logger = logging.getLogger(__name__)
+
+
+class LoopThread(ctt.InterruptableThread):
+    """ Helper class managing a loop in a thread."""
+
+    def __init__(self, name, default_wait_timeout=None, register_thread=True, register_scope=default_context, delay_before_run_sec=None, delay_between_run_sec=None, nb_times=None, with_next_loop_datetime=False):
+        super().__init__(name, default_wait_timeout=default_wait_timeout, register_thread=register_thread, register_scope=register_scope, delay_before_run_sec=delay_before_run_sec, delay_between_run_sec=delay_between_run_sec)
+        
+        self.__nb_times = nb_times
+        
+        # Manage loops
+        self.__with_next_loop_datetime = with_next_loop_datetime
+        self.__is_under_loop = threading.Event()
+        self.__next_loop_datetime = DateTime.now() if self.__with_next_loop_datetime else None
+        self.__loop_counter = 0
+        
+    @property
+    def next_loop_datetime(self):
+        return self.__next_loop_datetime
+
+    @next_loop_datetime.setter
+    def next_loop_datetime(self, dt):
+        self.__next_loop_datetime = dt
+
+    @property
+    def loop_counter(self):
+        return self.__loop_counter
+        
+    def run(self):
+        logger.info("Loop thread '{}' is launched.".format(self.name))
+        
+        self.wait_before_run()
+        
+        counter = 0
+        while not self.is_interrupted:
+#             logger.debug("[Thread '{}'] New run".format(self.name))
+            try:
+                if self.does_need_run_loop():
+                    with self._is_lock:
+                        self._is_idle.clear()
+                        self.__is_under_loop.set()
+                        self.__loop_counter += 1
+                    
+                    self.run_loop()
+                    counter += 1
+                    
+                    with self._is_lock:
+                        self.__is_under_loop.clear()
+                        self._is_idle.set()
+                        
+                    # Stop if nb_times is reached
+                    if self.__nb_times is not None:
+                        if counter >= self.__nb_times:
+                            break
+                    
+                    if not self.__with_next_loop_datetime:
+                        self.wait_between_run()
+                else:
+                    time.sleep(self._get_sleep_time_before_next_loop())
+                    
+            except:
+                logger.exception(f"[Thread '{self.name}'] Exception catched during loop")
+
+        logger.info(f"Loop thread '{self.name}' has finished.")
+        
+    def does_need_run_loop(self):
+        if self.__with_next_loop_datetime:
+            return DateTime.now() >= self.__next_loop_datetime
+        else:
+            return True
+    
+    def _get_sleep_time_before_next_loop(self):
+        if self.__with_next_loop_datetime:
+            now = DateTime.now()
+            if now < self.__next_loop_datetime:
+                delta = self.__next_loop_datetime - now
+                res = delta.total_seconds()
+                if res > 1:
+                    return 1
+                else:
+                    return res
+        return 0
+    
+    def run_loop(self):
+        raise NotImplementedError()
+
+    def wait_is_under_loop(self, timeout=None):
+        self._wait(self.__is_under_loop, "is under loop", timeout=timeout)
+

holado_multitask/multithreading/periodicfunctionthreaded.py

@@ -0,0 +1,135 @@
+
+#################################################
+# HolAdo (Holistic Automation do)
+#
+# (C) Copyright 2021-2025 by Eric Klumpp
+# 
+# Permission is hereby granted, free of charge, to any person obtaining a copy of this software and associated documentation files (the “Software”), to deal in the Software without restriction, including without limitation the rights to use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of the Software, and to permit persons to whom the Software is furnished to do so, subject to the following conditions:
+# 
+# The above copyright notice and this permission notice shall be included in all copies or substantial portions of the Software.
+
+# The Software is provided “as is”, without warranty of any kind, express or implied, including but not limited to the warranties of merchantability, fitness for a particular purpose and noninfringement. In no event shall the authors or copyright holders be liable for any claim, damages or other liability, whether in an action of contract, tort or otherwise, arising from, out of or in connection with the software or the use or other dealings in the Software.
+#################################################
+
+from builtins import super
+import logging
+import threading
+import time
+from holado_multitask.multithreading.thread import InterruptableThread
+from holado_multitask.multithreading.functionthreaded import FunctionThreaded
+from holado_core.common.tools.tools import Tools
+from holado_core.common.exceptions.technical_exception import TechnicalException
+from holado.common.handlers.undefined import default_context
+
+logger = logging.getLogger(__name__)
+
+
+class PeriodicFunctionThreaded(InterruptableThread):
+    '''
+    Execute periodically in a thread given function with given arguments.
+    
+    Implementation uses a precise timer, in order to globally satisfy the desired periodicity (with a precision of around a nanosecond, depending to system latency).
+    But implementation is quite simple, function is executed around each timer ticks : it is based on waits after function execution of the time needed to satisfy periodicity.
+    If function execution is greater than periodicity, a warning is logged, and function is run immediately without waiting next timer tick.
+    
+    For fast periodicity, it is recommended to disable logs by setting property 'do_log' to False (and also 'do_log_warning' if needed).
+    '''
+    
+    def __init__(self, period_seconds, target, args=None, kwargs=None, name=None, default_wait_timeout=None, register_thread=True, register_scope=default_context, delay_before_run_sec=None, nb_times=None):
+        super().__init__(name if name is not None else f"PeriodicFunctionThreaded({repr(target)})", default_wait_timeout=default_wait_timeout, register_thread=register_thread, register_scope=register_scope, delay_before_run_sec=delay_before_run_sec, delay_between_run_sec=None)
+
+        self.__period_seconds = period_seconds
+        if self.__period_seconds < 1e-8:
+            raise TechnicalException(f"Periodicity must be at least 10ns")
+        self.__nb_times = nb_times
+        self.__function_threaded = FunctionThreaded(target, args, kwargs)
+        self.__do_log = True
+        self.__do_log_warning = True
+        
+        if isinstance(self.__period_seconds, int) or self.__period_seconds % 1 < 1e-9 or self.__period_seconds % 1 > 1 - 1e-9:
+            self.__timer = Tools.timer_s
+            self.__timer_period = self.__period_seconds
+            self.__timer_unity = "s"
+            self.__timer_s_value = 1
+        else:
+            self.__timer = Tools.timer_ns
+            self.__timer_period = self.__period_seconds * 1e9
+            self.__timer_unity = "ns"
+            self.__timer_s_value = 1e9
+
+    @property
+    def function_threaded(self):
+        return self.__function_threaded
+
+    @property
+    def do_log(self):
+        return self.__do_log
+
+    @do_log.setter
+    def do_log(self, do_log):
+        self.__do_log = do_log
+
+    @property
+    def do_log_warning(self):
+        return self.__do_log_warning
+
+    @do_log_warning.setter
+    def do_log_warning(self, do_log):
+        self.__do_log_warning = do_log
+
+    def run(self):
+        logger.info(f"[{self.name}] Thread managing periodic function.")
+        
+        self.wait_before_run()
+        
+        start = self.__timer()
+        count = 0
+        while not self.is_interrupted:
+            # Process function
+            if self.do_log:
+                logger.info(f"[{self.name}] Processing periodic iteration {count+1}...")
+            beg = self.__timer()
+            try:
+                self.__function_threaded.run()
+            except Exception as exc:
+                logger.exception(f"[{self.name}] Exception catched while processing function:\n    [{repr(exc)}]")
+            finally:
+                count += 1
+                iter_dur = self.__timer() - beg
+                
+            # Define next iteration timer
+            next_timer = start + count * self.__timer_period
+            wait_duration = next_timer - self.__timer()
+            skip_wait = wait_duration < 0
+            if skip_wait:
+                if self.do_log_warning:
+                    logger.warning(f"[{self.name}] {count}'th iteration finished too late (of {-wait_duration} {self.__timer_unity}) to process next iteration on time (duration: {iter_dur} {self.__timer_unity} ; periodicity: {self.__timer_period} {self.__timer_unity}). Processing immediatelly next iteration")
+                
+                while wait_duration + self.__timer_period < 0:
+                    if self.do_log_warning:
+                        logger.warning(f"[{self.name}] Failed to process {count+1}'th iteration, its activity period is passed")
+                    count += 1
+                    next_timer = start + count * self.__timer_period
+                    wait_duration = next_timer - self.__timer()
+            
+            # Stop if nb_times is reached
+            if self.__nb_times is not None:
+                if count >= self.__nb_times:
+                    break
+            
+            # Wait periodicity
+            if not skip_wait:
+                if self.do_log:
+                    logger.info(f"[{self.name}] Waiting {wait_duration} {self.__timer_unity} to process next periodic function...")
+                while not self.is_interrupted and threading.active_count() > 0:
+                    if wait_duration > 0.1 * self.__timer_s_value:
+                        time.sleep(0.1)
+                        wait_duration = next_timer - self.__timer()
+                    else:
+                        if wait_duration > 1e-9 * self.__timer_s_value:
+                            time.sleep(wait_duration / self.__timer_s_value)
+                        break
+                    
+        logger.info(f"[{self.name}] Thead of periodic function has finished.")
+        
+        

holado_multitask/multithreading/reflection/inspect.py

@@ -0,0 +1,47 @@
+
+#################################################
+# HolAdo (Holistic Automation do)
+#
+# (C) Copyright 2021-2025 by Eric Klumpp
+# 
+# Permission is hereby granted, free of charge, to any person obtaining a copy of this software and associated documentation files (the “Software”), to deal in the Software without restriction, including without limitation the rights to use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of the Software, and to permit persons to whom the Software is furnished to do so, subject to the following conditions:
+# 
+# The above copyright notice and this permission notice shall be included in all copies or substantial portions of the Software.
+
+# The Software is provided “as is”, without warranty of any kind, express or implied, including but not limited to the warranties of merchantability, fitness for a particular purpose and noninfringement. In no event shall the authors or copyright holders be liable for any claim, damages or other liability, whether in an action of contract, tort or otherwise, arising from, out of or in connection with the software or the use or other dealings in the Software.
+#################################################
+
+
+import inspect
+from holado_core.common.tools.tools import Tools
+
+
+def get_stack(limit=None, start=0):
+    """
+    Get the call stack at the point of the caller.
+    
+    @param limit: the number of frames to get (default: all remaining frames)
+    @param start: the offset of the first frame preceding the caller (default 0 means the method calling get_stack)
+    """   
+    
+    # The call stack.
+    stack = inspect.stack()
+    
+    # The index of the first frame to print.
+    begin = start + 1
+    if limit:
+        end = min(begin + limit, len(stack))
+    else:
+        end = len(stack)
+    
+    return stack[begin:end]
+    
+def represent_stack(limit=None, start=0, indent=0):
+    res_list = []
+    for frame in get_stack(limit, start+1):
+        file, line, func = frame[1:4]
+        res_list.append(f"{file}, line {line} in function {func}")
+    return Tools.indent_string(indent, "\n".join(res_list))
+
+
+    

holado_multitask/multithreading/reflection/sys.py

@@ -0,0 +1,29 @@
+
+#################################################
+# HolAdo (Holistic Automation do)
+#
+# (C) Copyright 2021-2025 by Eric Klumpp
+# 
+# Permission is hereby granted, free of charge, to any person obtaining a copy of this software and associated documentation files (the “Software”), to deal in the Software without restriction, including without limitation the rights to use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of the Software, and to permit persons to whom the Software is furnished to do so, subject to the following conditions:
+# 
+# The above copyright notice and this permission notice shall be included in all copies or substantial portions of the Software.
+
+# The Software is provided “as is”, without warranty of any kind, express or implied, including but not limited to the warranties of merchantability, fitness for a particular purpose and noninfringement. In no event shall the authors or copyright holders be liable for any claim, damages or other liability, whether in an action of contract, tort or otherwise, arising from, out of or in connection with the software or the use or other dealings in the Software.
+#################################################
+
+
+import sys
+
+
+def get_current_function_name(offset=0):
+    """
+    Get the name of the function at the point of the caller.
+    
+    @param offset: the offset of the target function (default 0 means the method calling get_current_function_name)
+    """   
+    
+    frame = sys._getframe(1 + offset)
+    return frame.f_code.co_name
+
+
+    

holado_multitask/multithreading/reflection/traceback.py

@@ -0,0 +1,35 @@
+
+#################################################
+# HolAdo (Holistic Automation do)
+#
+# (C) Copyright 2021-2025 by Eric Klumpp
+# 
+# Permission is hereby granted, free of charge, to any person obtaining a copy of this software and associated documentation files (the “Software”), to deal in the Software without restriction, including without limitation the rights to use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of the Software, and to permit persons to whom the Software is furnished to do so, subject to the following conditions:
+# 
+# The above copyright notice and this permission notice shall be included in all copies or substantial portions of the Software.
+
+# The Software is provided “as is”, without warranty of any kind, express or implied, including but not limited to the warranties of merchantability, fitness for a particular purpose and noninfringement. In no event shall the authors or copyright holders be liable for any claim, damages or other liability, whether in an action of contract, tort or otherwise, arising from, out of or in connection with the software or the use or other dealings in the Software.
+#################################################
+
+
+import traceback
+from holado_core.common.tools.tools import Tools
+
+
+def get_stack(limit=None, start=0):
+    """
+    Get the call stack at the point of the caller.
+    
+    @param limit: the number of frames to get (default: all remaining frames)
+    @param start: the offset of the first frame preceding the caller (default 0 means the method calling get_stack)
+    """   
+    
+    stack = traceback.extract_stack(limit=limit+2 if limit is not None else None)
+    return stack[:-1-start]
+    
+def represent_stack(limit=None, start=0, indent=0):
+    frames = get_stack(limit, start+1)
+    return Tools.indent_string(indent, "".join(traceback.format_list(frames)))
+
+
+    

holado_multitask/multithreading/thread.py

@@ -0,0 +1,203 @@
+
+#################################################
+# HolAdo (Holistic Automation do)
+#
+# (C) Copyright 2021-2025 by Eric Klumpp
+# 
+# Permission is hereby granted, free of charge, to any person obtaining a copy of this software and associated documentation files (the “Software”), to deal in the Software without restriction, including without limitation the rights to use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of the Software, and to permit persons to whom the Software is furnished to do so, subject to the following conditions:
+# 
+# The above copyright notice and this permission notice shall be included in all copies or substantial portions of the Software.
+
+# The Software is provided “as is”, without warranty of any kind, express or implied, including but not limited to the warranties of merchantability, fitness for a particular purpose and noninfringement. In no event shall the authors or copyright holders be liable for any claim, damages or other liability, whether in an action of contract, tort or otherwise, arising from, out of or in connection with the software or the use or other dealings in the Software.
+#################################################
+
+import threading
+from holado.holado_config import Config
+import logging
+from holado.common.context.session_context import SessionContext
+import time
+from holado_multitask.multitasking.multitask_manager import MultitaskManager
+from holado_python.standard_library.typing import Typing
+from holado.common.handlers.undefined import undefined_argument, default_context
+from holado_core.common.exceptions.technical_exception import TimeoutTechnicalException
+from holado_core.common.exceptions.functional_exception import FunctionalException
+from holado_python.common.tools.datetime import DateTime, FORMAT_DATETIME_ISO
+from holado.common.handlers.object import DeleteableObject
+
+logger = logging.getLogger(__name__)
+
+
+class Thread(threading.Thread, DeleteableObject):
+    """ Helper class managing a thread."""
+    
+    def __init__(self, name, default_wait_timeout=None, register_thread=True, register_scope=default_context, delay_before_run_sec=None, delay_between_run_sec=None):
+        threading.Thread.__init__(self)
+        DeleteableObject.__init__(self, name)
+        
+        if default_wait_timeout is None:
+            default_wait_timeout = Config.timeout_seconds * 1000
+            
+        # Note: if SessionContext doesn't have an instance (like during session context reset), use name+now as unique name
+        self.__unique_name = SessionContext.instance().multitask_manager.prepare_thread(name) if SessionContext.has_instance() else f"{name}_{DateTime.datetime_2_str(DateTime.now(), FORMAT_DATETIME_ISO)}"
+        self.__default_wait_timeout = default_wait_timeout
+        self.__delay_before_run_sec = delay_before_run_sec
+        self.__delay_between_run_sec = delay_between_run_sec
+
+        # Put thread as daemon
+        self.daemon = True
+        
+        # Manage thread status
+        self._is_lock = threading.Lock()
+        self._is_idle = threading.Event()
+        self._is_idle.set()
+        
+        # Register thread
+        # Note: Do not register thread if session context doesn't have an instance (like during session context reset)
+        self.__is_registered = False
+        self.__register_scope = None
+        if register_thread and SessionContext.has_instance():
+            # Registered name has to be unique
+            SessionContext.instance().threads_manager.register_thread(self.__unique_name, self, scope=register_scope)
+            self.__is_registered = True
+            self.__register_scope = register_scope
+            self.on_delete_call_func(self.__unregister_thread)
+        
+    @property
+    def unique_name(self):
+        return self.__unique_name
+
+    @property
+    def default_wait_timeout(self):
+        return self.__default_wait_timeout
+        
+    @default_wait_timeout.setter
+    def default_wait_timeout(self, timeout):
+        self.__default_wait_timeout = timeout
+        
+    @property
+    def delay_before_run_seconds(self):
+        return self.__delay_before_run_sec
+        
+    @property
+    def delay_between_run_seconds(self):
+        return self.__delay_between_run_sec
+        
+    def _set_ident(self):
+        super()._set_ident()
+        if not MultitaskManager.has_thread_native_id() and SessionContext.has_instance():
+            SessionContext.instance().multitask_manager.set_thread_uid(self.__unique_name, MultitaskManager.get_thread_uid(thread=self))
+        
+    if MultitaskManager.has_thread_native_id():
+        def _set_native_id(self):
+            super()._set_native_id()
+            if SessionContext.has_instance():
+                SessionContext.instance().multitask_manager.set_thread_uid(self.__unique_name, MultitaskManager.get_thread_uid(thread=self))
+        
+    def join(self, timeout=undefined_argument, raise_if_still_alive=True):
+        """
+        See Thread.join documentation for default behavior. 
+        
+        This implementation returns if join succeeded, ie if thread is still alive after join.
+        
+        This implementation also tries to avoid deadlocks by special and default timeout value undefined_argument.
+        With any other timeout value, including None, default behavior is happening.
+        If timeout argument is undefined_argument, it means that it should stop by itself without deadlock.
+        In this case, a timeout value Config.join_timeout_seconds is used.
+        
+        If argument raise_if_still_alive is True (default) after join and if thread is still alive after join, an exception is raised.
+        If timeout is undefined_argument, a TimeoutTechnicalException is raised, else a FunctionalException.
+        """
+        timeout_str = "long and finite" if timeout is undefined_argument else f"{timeout}s" if timeout else "none"
+        logger.debug(f"Joining thread '{self.name}' ; timeout={timeout_str} ...")
+        
+        real_timeout = timeout if timeout is not undefined_argument else Config.join_timeout_seconds
+        super().join(real_timeout)
+        
+        logger.debug(f"End of joining thread '{self.name}' ; timeout={timeout_str} ; alive:{self.is_alive()}")
+        
+        if self.is_alive():
+            if raise_if_still_alive:
+                if timeout is undefined_argument:
+                    raise TimeoutTechnicalException(f"Thread '{self.name}' is still alive after join (timeout: {real_timeout} s)")
+                else:
+                    raise FunctionalException(f"Thread '{self.name}' is still alive after join (timeout: {real_timeout} s)")
+            else:
+                logger.error(f"Thread '{self.name}' is still alive after join (timeout: {real_timeout} s)")
+        
+        return self.is_alive()
+    
+    def wait_before_run(self, do_log_exception=True):
+        if self.delay_before_run_seconds is not None:
+            try:
+                time.sleep(self.delay_before_run_seconds)
+            except Exception:
+                if do_log_exception:
+                    logger.exception(f"[Thread '{self.name}'] Exception while waiting delay before run (delay: {self.delay_before_run_seconds} ; type: {Typing.get_object_class_fullname(self.delay_before_run_seconds)})")
+
+    def wait_between_run(self, do_log_exception=True):
+        if self.delay_between_run_seconds is not None:
+            try:
+                time.sleep(self.delay_between_run_seconds)
+            except Exception:
+                if do_log_exception:
+                    logger.exception(f"[Thread '{self.name}'] Exception while waiting delay between run (delay: {self.delay_between_run_seconds} ; type: {Typing.get_object_class_fullname(self.delay_between_run_seconds)})")
+
+    def wait_is_idle(self, timeout=None):
+        """ Wait event self._is_idle"""
+        self._wait(self.__is_idle, "is idle", timeout=timeout)
+
+    def _wait(self, event, event_details, timeout=None):
+        """ Wait given threading.Event"""
+        is_set = False
+        wait_round_counter = 0
+        round_wait_seconds = 1
+        if timeout is None:
+            timeout = self.__default_wait_timeout
+        
+        logger.debug("[{}] Waiting {}...".format(self.name, event_details))
+        while not is_set:
+            wait_round_counter += 1
+            is_set = event.wait(round_wait_seconds)
+            
+            if not is_set:
+                if wait_round_counter * round_wait_seconds * 1000 > timeout:
+                    raise TimeoutError("[{}] Timeout when waiting {}".format(self.name, event_details))
+                elif wait_round_counter % 10 == 0:
+                    logger.debug("[{}] Still waiting {} (round {})".format(self.name, event_details, wait_round_counter))
+        logger.debug("[{}] Finished waiting {}...".format(self.name, event_details))
+    
+    def __unregister_thread(self):
+        if self.__is_registered:
+            if SessionContext.instance().threads_manager.is_thread_registered(self.__unique_name, scope=self.__register_scope):
+                SessionContext.instance().threads_manager.unregister_thread(self.__unique_name, scope=self.__register_scope)
+            self.__is_registered = False
+
+
+class InterruptableThread(Thread):
+    """ Helper class managing a thread interruptable."""
+    
+    def __init__(self, name, default_wait_timeout=None, register_thread=True, register_scope=default_context, delay_before_run_sec=None, delay_between_run_sec=None):
+        super().__init__(name, default_wait_timeout=default_wait_timeout, register_thread=register_thread, register_scope=register_scope, delay_before_run_sec=delay_before_run_sec, delay_between_run_sec=delay_between_run_sec)
+
+        # Manage interrupt
+        self.__interrupt_lock = threading.Lock()
+        self.__interrupt_event = threading.Event()
+    
+    @property    
+    def is_interruptable(self):
+        return True
+    
+    @property
+    def is_interrupted(self):
+        with self.__interrupt_lock:
+            return self.__interrupt_event.is_set()
+
+    def interrupt(self):
+        if not self.is_interrupted:
+            logger.debug("Interrupt thread '{}'".format(self.name))
+            with self.__interrupt_lock:
+                self.__interrupt_event.set()
+    
+    def _raise_if_interrupted(self):
+        if self.is_interrupted:
+            raise InterruptedError