holado 0.13.22__py3-none-any.whl

holado_multitask/multithreading/threadsmanager.py

@@ -0,0 +1,167 @@
+
+#################################################
+# 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 logging
+from holado_core.common.exceptions.technical_exception import TechnicalException
+import holado_multitask.multithreading as hmm
+from holado.common.handlers.undefined import default_context, undefined_argument
+from holado_multitask.multitasking.multitask_manager import MultitaskManager
+
+logger = logging.getLogger(__name__)
+
+
+class ThreadsManager(object):
+    """
+    Manage threads run by HolAdo, so that each thread can use HolAdo services.
+    """
+    
+    __has_native_id = hasattr(threading, '_HAVE_THREAD_NATIVE_ID') and threading._HAVE_THREAD_NATIVE_ID  # @UndefinedVariable
+    
+    @classmethod
+    def has_native_id(cls):
+        return cls.__has_native_id
+    
+    def __init__(self, multitask_manager):
+        self.__multitask_manager = multitask_manager
+        self.__managed_threads_lock = threading.Lock()
+        self.__managed_threads_by_scope = {}
+    
+    def __get_scope_name(self, scope, create_if_doesnt_exist=True):
+        res = MultitaskManager.get_scope_name(scope)
+        
+        if create_if_doesnt_exist:
+            with self.__managed_threads_lock:
+                if res not in self.__managed_threads_by_scope:
+                    self.__managed_threads_by_scope[res] = {}
+        
+        return res
+    
+    def is_thread_registered(self, name, scope=default_context):
+        scope_name = self.__get_scope_name(scope, create_if_doesnt_exist=False)
+        with self.__managed_threads_lock:
+            return scope_name in self.__managed_threads_by_scope and name in self.__managed_threads_by_scope[scope_name]
+        
+    def register_thread(self, name, thread, scope=default_context):
+        scope_name = self.__get_scope_name(scope)
+        with self.__managed_threads_lock:
+            if name in self.__managed_threads_by_scope[scope_name]:
+                # logger.error(f"A thread with name '{name}' is already registered, it will be overwritten: {self.__managed_threads_by_scope[name]}")
+                logger.error(f"A thread with name '{name}' is already registered in scope '{scope_name}', it will be overwritten: {self.__managed_threads_by_scope[scope_name][name]}", stack_info=True)
+            else:
+                logger.debug(f"Registered thread with name '{name}' in scope '{scope_name}': {thread}")
+            self.__managed_threads_by_scope[scope_name][name] = thread
+        return scope_name
+
+    def unregister_thread(self, name, scope=default_context):
+        scope_name = self.__get_scope_name(scope)
+        with self.__managed_threads_lock:
+            if name in self.__managed_threads_by_scope[scope_name]:
+                if self.__managed_threads_by_scope[scope_name][name].is_alive():
+                    logger.warn(f"Unregistering thread with name '{name}' from scope '{scope_name}' whereas it is still alive")
+                else:
+                    logger.debug(f"Unregistered thread with name '{name}' from scope '{scope_name}'")
+                del self.__managed_threads_by_scope[scope_name][name]
+            else:
+                raise Exception(f"Not registered thread of name '{name}' in scope '{scope_name}'")
+        return scope_name
+
+    def get_thread(self, name, scope=default_context):
+        scope_name = self.__get_scope_name(scope)
+        with self.__managed_threads_lock:
+            if name in self.__managed_threads_by_scope[scope_name]:
+                return self.__managed_threads_by_scope[scope_name][name]
+            else:
+                raise Exception(f"Not registered thread of name '{name}' in scope '{scope_name}'")
+
+    def interrupt_thread(self, name, scope=default_context, with_join=True, join_timeout=undefined_argument, raise_if_not_interruptable=True):
+        interrupt_status, join_status = False, False
+        
+        thread = self.get_thread(name, scope=scope)
+        if thread.is_alive():
+            if self.is_interruptable(thread=thread):
+                try:
+                    thread.interrupt()
+                except Exception as exc:
+                    # logger.exception("Failed to interrupt thread of name '{}'".format(name))
+                    raise exc
+                else:
+                    interrupt_status = True
+                
+                if with_join:
+                    join_status = thread.join(join_timeout)
+            elif raise_if_not_interruptable:
+                raise TechnicalException("Thread '{}' is not interruptable".format(name))
+        
+        return interrupt_status, join_status
+        
+    def join_thread(self, name, scope=default_context, timeout=undefined_argument):
+        thread = self.get_thread(name, scope=scope)
+        if thread.is_alive():
+            thread.join(timeout=timeout)
+
+    def interrupt_all_threads(self, scope=default_context, with_join=True, join_timeout=undefined_argument):
+        """Interrupt all threads that are interruptable."""
+        names = self.get_thread_names(scope=scope)
+        logger.debug(f"Interrupting all threads in scope '{self.__get_scope_name(scope)}': {names}")
+        interrupted_names = []
+        for name in names:
+            try:
+                interrupt_status, _ = self.interrupt_thread(name, scope=scope, with_join=False, raise_if_not_interruptable=False)
+            except Exception:
+                logger.exception("Failed to interrupt thread of name '{}'".format(name))
+            else:
+                if interrupt_status:
+                    interrupted_names.append(name)
+        
+        if with_join:
+            self.__join_threads(interrupted_names, scope=scope, timeout=join_timeout, skip_not_interruptable=True)
+
+    def join_all_threads(self, scope=default_context, timeout=undefined_argument, skip_not_interruptable=False):
+        names = self.get_thread_names(scope=scope)
+        self.__join_threads(names, scope=scope, timeout=timeout, skip_not_interruptable=skip_not_interruptable)
+
+    def __join_threads(self, thread_names, scope=default_context, timeout=undefined_argument, skip_not_interruptable=False):
+        for name in thread_names:
+            if skip_not_interruptable and not self.is_interruptable(name=name, scope=scope):
+                continue
+            self.join_thread(name, scope=scope, timeout=timeout)
+    
+    def unregister_all_threads(self, scope=default_context, keep_alive=True):
+        names = self.get_thread_names(scope=scope)
+        for name in names:
+            thread = self.get_thread(name, scope=scope)
+            if not keep_alive or keep_alive and not thread.is_alive():
+                self.unregister_thread(name, scope=scope)
+    
+    def get_thread_names(self, scope=default_context):
+        scope_name = self.__get_scope_name(scope)
+        with self.__managed_threads_lock:
+            return sorted(list( self.__managed_threads_by_scope[scope_name].keys() ))
+    
+    def get_alive_thread_names(self, scope=default_context):
+        scope_name = self.__get_scope_name(scope)
+        with self.__managed_threads_lock:
+            res = sorted(list( self.__managed_threads_by_scope[scope_name].keys() ))
+            res = [name for name in res if self.__managed_threads_by_scope[scope_name][name].is_alive()]
+            
+    def is_interruptable(self, thread=None, name=None, scope=default_context):
+        if name is not None:
+            thread = self.get_thread(name, scope=scope)
+        if thread is None:
+            raise TechnicalException("At least one argument must be not None")
+        
+        return isinstance(thread, hmm.thread.InterruptableThread) and thread.is_interruptable
+    
+    
+    

holado_multitask/multithreading/timer.py

@@ -0,0 +1,51 @@
+
+#################################################
+# 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 holado_multitask.multithreading.thread import InterruptableThread
+from threading import Event
+from holado.common.handlers.undefined import default_context
+
+
+class Timer(InterruptableThread):
+    """ Helper class managing a timer.
+    
+    The functional code is a copy of threading.Timer, but it inherists from HolAdo Thread class.
+    """
+    
+    def __init__(self, name, interval, function, args=None, kwargs=None, default_wait_timeout=None, register_thread=True, register_scope=default_context):
+        super().__init__(name, default_wait_timeout=default_wait_timeout, register_thread=register_thread, register_scope=register_scope, delay_before_run_sec=None, delay_between_run_sec=None)
+        
+        self.interval = interval
+        self.function = function
+        self.args = args if args is not None else []
+        self.kwargs = kwargs if kwargs is not None else {}
+        self.finished = Event()
+
+    def interrupt(self):
+        self.cancel()
+        super().interrupt()
+        
+    def cancel(self):
+        """Stop the timer if it hasn't finished yet."""
+        self.finished.set()
+
+    def run(self):
+        # Wait timer interval or canceled (ie finished==True)
+        self.finished.wait(self.interval)
+        
+        # Run function if not canceled
+        if not self.finished.is_set():
+            self.function(*self.args, **self.kwargs)
+        self.finished.set()
+
+

holado_multitask/tests/behave/steps/__init__.py

@@ -0,0 +1,17 @@
+# -*- coding: utf-8 -*-
+
+#################################################
+# 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 .multiprocessing_steps import *
+from .multithreading_steps import *

holado_multitask/tests/behave/steps/multiprocessing_steps.py

@@ -0,0 +1,138 @@
+# -*- coding: utf-8 -*-
+
+#################################################
+# 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 holado.common.context.session_context import SessionContext
+from holado_core.common.exceptions.functional_exception import FunctionalException
+from holado_test.behave.behave import *  # @UnusedWildImport
+from holado_core.common.block.function import Function
+from holado_test.scenario.step_tools import StepTools
+import logging
+from holado_test.behave.scenario.behave_step_tools import BehaveStepTools
+from holado_scripting.common.tools.evaluate_parameters import EvaluateParameters
+from holado_multitask.multiprocessing.periodic_function_process import PeriodicFunctionProcess
+from holado_multitask.multiprocessing.function_process import FunctionProcess
+
+logger = logging.getLogger(__name__)
+
+
+def __get_scenario_context():
+    return SessionContext.instance().get_scenario_context()
+
+def __get_processes_manager():
+    return SessionContext.instance().processes_manager
+
+def __get_variable_manager():
+    return __get_scenario_context().get_variable_manager()
+
+
+@Given(r"(?P<var_name>{Variable}) = new process that calls steps(?P<is_periodic_str> periodically)?(?: \((?:delay before: (?P<delay_before_str>{Float}) s)?(?: ; )?(?:period: (?P<period_str>{Float}) s(?: ; nb times: (?P<nb_times_str>{Int}))?)?(?: ; )?(?:format with: (?P<format_with>{Variable}(?:, {Variable})*))?\))?")
+def step_impl(context, var_name, is_periodic_str, delay_before_str, period_str, nb_times_str, format_with):
+    """
+    Create a process with given steps.
+    Notes: 
+        - Each created process use a copy of the variable manager. 
+        - Thus the variables, defined in variable manager before process creation, can be used in the steps. 
+        - But variables created or updated in the steps by the process will affect only the process itself and won't affect the original variable manager or other processes.
+    """
+    var_name = StepTools.evaluate_variable_name(var_name)
+    delay_before_sec = StepTools.evaluate_scenario_parameter(delay_before_str)
+    period_sec = StepTools.evaluate_scenario_parameter(period_str)
+    nb_times = StepTools.evaluate_scenario_parameter(nb_times_str)
+    format_with = StepTools.evaluate_variable_name(format_with)
+    steps = BehaveStepTools.get_step_multiline_text(context, eval_params=EvaluateParameters.nothing())
+    
+    if is_periodic_str is not None and period_sec is None:
+        raise FunctionalException(f"Period must be defined for periodic steps")
+    if format_with is not None:
+        steps = StepTools.format_steps_with(steps, format_with.split(', '))
+    
+    if period_sec is not None:
+        proc_name = f"PROC_CALL_STEPS_PERIODICALLY[{var_name};{period_sec}]"
+        func = PeriodicFunctionProcess(period_sec, execute_steps, args=[steps], name=proc_name, delay_before_run_sec=delay_before_sec, nb_times=nb_times)
+        res = func.unique_name
+    else:
+        proc_name = f"PROC_CALL_STEPS[{var_name}]"
+        func = FunctionProcess(execute_steps, args=[steps], name=proc_name, delay_before_run_sec=delay_before_sec)
+        res = func.unique_name
+    
+    __get_variable_manager().register_variable(var_name, res)
+
+@Given(r"(?P<var_name>{Variable}) = call steps in a process(?: \((?:delay before: (?P<delay_before_str>{Float}) s)?(?: ; )?(?:format with: (?P<format_with>{Variable}(?:, {Variable})*))?\))?")
+def step_impl(context, var_name, delay_before_str, format_with):
+    """
+    Create and start a process with given steps.
+    Notes: 
+        - Each created process use a copy of the variable manager. 
+        - Thus the variables, defined in variable manager before process creation, can be used in the steps. 
+        - But variables created or updated in the steps by the process will affect only the process itself and won't affect the original variable manager or other processes.
+    """
+    var_name = StepTools.evaluate_variable_name(var_name)
+    delay_before_sec = StepTools.evaluate_scenario_parameter(delay_before_str)
+    format_with = StepTools.evaluate_variable_name(format_with)
+    steps = BehaveStepTools.get_step_multiline_text(context, eval_params=EvaluateParameters.nothing())
+    
+    step_params_list = []
+    if delay_before_sec is not None:
+        step_params_list.append(f"delay before: {delay_before_sec} s")
+    if format_with is not None:
+        step_params_list.append(f"format with: {format_with} s")
+    step_params = " (" + " ; ".join(step_params_list) + ")" if len(step_params_list) > 0 else ""
+    
+    execute_steps(u"""
+        Given {var_name} = new process that calls steps{step_params}
+            \"""{steps}\"""
+        Given start process {var_name}
+        """.format(var_name=var_name, step_params=step_params, steps=BehaveStepTools.format_steps_as_parameter(steps, 12)))
+
+@Given(r"for process (?P<var_name>{Variable}), call steps for interrupt(?: \(format with: (?P<format_with>{Variable}(?:, {Variable})*)\))?")
+def step_impl(context, var_name, format_with):
+    proc_id = StepTools.evaluate_variable_value(var_name)
+    format_with = StepTools.evaluate_variable_name(format_with)
+    steps = BehaveStepTools.get_step_multiline_text(context, eval_params=EvaluateParameters.nothing())
+    
+    if format_with is not None:
+        steps = StepTools.format_steps_with(steps, format_with.split(', '))
+        
+    interrupt_func = Function(execute_steps, steps)
+    
+    func = __get_processes_manager().get_process(proc_id)
+    if hasattr(func, "interrupt_function"):
+        func.interrupt_function = interrupt_func
+    else:
+        raise FunctionalException("Process '{}' is not interruptable by a function".format(var_name))
+
+@Step(r'start process (?P<var_name>{Variable})')
+def step_impl(context, var_name):
+    proc_id = StepTools.evaluate_variable_value(var_name)
+    
+    proc = __get_processes_manager().get_process(proc_id)
+    proc.start()
+
+@Step(r'join process (?P<var_name>{Variable})')
+def step_impl(context, var_name):
+    proc_id = StepTools.evaluate_variable_value(var_name)
+    
+    proc = __get_processes_manager().get_process(proc_id)
+    proc.join()
+
+@Step(r'stop process (?P<var_name>{Variable})')
+def step_impl(context, var_name):
+    proc_id = StepTools.evaluate_variable_value(var_name)
+    
+    proc = __get_processes_manager().get_process(proc_id)
+    proc.interrupt()
+
+
+

holado_multitask/tests/behave/steps/multithreading_steps.py

@@ -0,0 +1,129 @@
+# -*- coding: utf-8 -*-
+
+#################################################
+# 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 holado.common.context.session_context import SessionContext
+from holado_core.common.exceptions.functional_exception import FunctionalException
+from holado_multitask.multithreading.functionthreaded import FunctionThreaded
+from holado_core.common.block.function import Function
+from holado_test.scenario.step_tools import StepTools
+import logging
+from holado_test.behave.scenario.behave_step_tools import BehaveStepTools
+from holado_scripting.common.tools.evaluate_parameters import EvaluateParameters
+from holado_test.behave.behave import *  # @UnusedWildImport
+from holado_multitask.multithreading.periodicfunctionthreaded import PeriodicFunctionThreaded
+from holado.common.handlers.undefined import undefined_argument
+
+
+logger = logging.getLogger(__name__)
+
+
+def __get_scenario_context():
+    return SessionContext.instance().get_scenario_context()
+
+def __get_threads_manager():
+    return SessionContext.instance().threads_manager
+
+def __get_variable_manager():
+    return __get_scenario_context().get_variable_manager()
+
+
+
+
+@Given(r"(?P<var_name>{Variable}) = new thread that calls steps(?P<is_periodic_str> periodically)?(?: \((?:delay before: (?P<delay_before_str>{Float}) s)?(?: ; )?(?:period: (?P<period_str>{Float}) s(?: ; nb times: (?P<nb_times_str>{Int}))?)?(?: ; )?(?:format with: (?P<format_with>{Variable}(?:, {Variable})*))?\))?")
+def step_impl(context, var_name, is_periodic_str, delay_before_str, period_str, nb_times_str, format_with):
+    var_name = StepTools.evaluate_variable_name(var_name)
+    delay_before_sec = StepTools.evaluate_scenario_parameter(delay_before_str)
+    period_sec = StepTools.evaluate_scenario_parameter(period_str)
+    nb_times = StepTools.evaluate_scenario_parameter(nb_times_str)
+    format_with = StepTools.evaluate_variable_name(format_with)
+    steps = BehaveStepTools.get_step_multiline_text(context, eval_params=EvaluateParameters.nothing())
+    
+    if is_periodic_str is not None and period_sec is None:
+        raise FunctionalException(f"Period must be defined for periodic steps")
+    if format_with is not None:
+        steps = StepTools.format_steps_with(steps, format_with.split(', '))
+    
+    if period_sec is not None:
+        thread_name = f"CALL_STEPS_PERIODICALLY[{var_name};{period_sec}]"
+        func = PeriodicFunctionThreaded(period_sec, execute_steps, args=[steps], name=thread_name, delay_before_run_sec=delay_before_sec, nb_times=nb_times)
+        res = func.unique_name
+    else:
+        thread_name = f"CALL_STEPS[{var_name}]"
+        func = FunctionThreaded(execute_steps, args=[steps], name=thread_name, delay_before_run_sec=delay_before_sec)
+        res = func.unique_name
+    
+    __get_variable_manager().register_variable(var_name, res)
+
+@Given(r"(?P<var_name>{Variable}) = call steps in a thread(?: \((?:delay before: (?P<delay_before_str>{Float}) s)?(?: ; )?(?:format with: (?P<format_with>{Variable}(?:, {Variable})*))?\))?")
+def step_impl(context, var_name, delay_before_str, format_with):
+    var_name = StepTools.evaluate_variable_name(var_name)
+    delay_before_sec = StepTools.evaluate_scenario_parameter(delay_before_str)
+    format_with = StepTools.evaluate_variable_name(format_with)
+    steps = BehaveStepTools.get_step_multiline_text(context, eval_params=EvaluateParameters.nothing())
+    
+    step_params_list = []
+    if delay_before_sec is not None:
+        step_params_list.append(f"delay before: {delay_before_sec} s")
+    if format_with is not None:
+        step_params_list.append(f"format with: {format_with} s")
+    step_params = " (" + " ; ".join(step_params_list) + ")" if len(step_params_list) > 0 else ""
+    
+    execute_steps(u"""
+        Given {var_name} = new thread that calls steps{step_params}
+            \"""{steps}\"""
+        Given start thread {var_name}
+        """.format(var_name=var_name, step_params=step_params, steps=BehaveStepTools.format_steps_as_parameter(steps, 12)))
+
+@Given(r"for thread (?P<var_name>{Variable}), call steps for interrupt(?: \(format with: (?P<format_with>{Variable}(?:, {Variable})*)\))?")
+def step_impl(context, var_name, format_with):
+    thread_id = StepTools.evaluate_variable_value(var_name)
+    format_with = StepTools.evaluate_variable_name(format_with)
+    steps = BehaveStepTools.get_step_multiline_text(context, eval_params=EvaluateParameters.nothing())
+    
+    if format_with is not None:
+        steps = StepTools.format_steps_with(steps, format_with.split(', '))
+        
+    interrupt_func = Function(execute_steps, steps)
+    
+    func = __get_threads_manager().get_thread(thread_id)
+    if hasattr(func, "interrupt_function"):
+        func.interrupt_function = interrupt_func
+    else:
+        raise FunctionalException("Thread '{}' is not interruptable by a function".format(var_name))
+
+@Step(r'start thread (?P<var_name>{Variable})')
+def step_impl(context, var_name):
+    thread_id = StepTools.evaluate_variable_value(var_name)
+    
+    thread = __get_threads_manager().get_thread(thread_id)
+    thread.start()
+
+@Step(r'join thread (?P<var_name>{Variable})(?: \(timeout: (?P<timeout_str>{Variable}) s\))?')
+def step_impl(context, var_name, timeout_str):
+    thread_id = StepTools.evaluate_variable_value(var_name)
+    timeout = StepTools.evaluate_variable_value(timeout_str) if timeout_str is not None else undefined_argument
+    
+    __get_threads_manager().join_thread(thread_id, timeout=timeout)
+
+@Step(r'stop thread (?P<var_name>{Variable})')
+def step_impl(context, var_name):
+    thread_id = StepTools.evaluate_variable_value(var_name)
+    
+    thread = __get_threads_manager().get_thread(thread_id)
+    thread.interrupt()
+
+
+
+

holado_protobuf/__init__.py

@@ -0,0 +1,61 @@
+# -*- coding: utf-8 -*-
+
+#################################################
+# 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.
+#################################################
+
+
+
+def dependencies():
+    return None
+
+def register():
+    from holado.common.context.session_context import SessionContext
+    from holado_python.common.tools.comparators.datetime_comparator import DatetimeComparator
+    from holado_python.common.tools.datetime import DateTime
+    
+    from holado_protobuf.ipc.protobuf.protobuf_messages import ProtobufMessages
+    if ProtobufMessages.is_available():
+        SessionContext.instance().services.register_service_type("protobuf_messages", ProtobufMessages,
+                            lambda m: m.initialize() )
+    
+        from holado_protobuf.ipc.protobuf.protobuf_converter import ProtobufConverter
+        SessionContext.instance().services.register_service_type("protobuf_converter", ProtobufConverter,
+                            lambda m: m.initialize(SessionContext.instance().protobuf_messages) )
+    
+        from holado_protobuf.ipc.protobuf.protobuf_modifier import ProtobufModifier
+        SessionContext.instance().services.register_service_type("protobuf_modifier", ProtobufModifier,
+                            lambda m: m.initialize(SessionContext.instance().protobuf_messages) )
+        
+        
+        # Register json conversion
+        
+        from holado_json.ipc.json_types import JsonTypes
+        
+        def to_json_from_message(msg):
+            converter = SessionContext.instance().protobuf_converter
+            return converter.convert_protobuf_object_to_json_object(msg)
+        
+        JsonTypes.register_resource_for_type_in_class('protobuf.message', None, ProtobufMessages.is_object_message, 
+                                (None, to_json_from_message, None), index=0)
+        
+        
+        # Register datetime conversion
+        
+        from holado_protobuf.ipc.protobuf.types.google.protobuf import Timestamp
+        DatetimeComparator.register_resource_for_type_in_class('protobuf.Timestamp', None, 
+                                                               lambda o: isinstance(o, Timestamp.protobuf_class()), 
+                                                               lambda o: DateTime.seconds_nanos_to_datetime(o.seconds, o.nanos),
+                                                               index=0)
+
+        
+        
+        

holado_protobuf/ipc/protobuf/abstracts/type.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.
+#################################################
+
+import logging
+from holado_core.common.exceptions.technical_exception import TechnicalException
+import abc
+from holado_python.standard_library.typing import Typing
+
+logger = logging.getLogger(__name__)
+
+
+class Type(object):
+    """
+    Manage actions related to a specific protobuf type
+    """
+    __metaclass__ = abc.ABCMeta
+
+    @classmethod
+    def protobuf_class(cls):
+        raise NotImplementedError('Method not implemented!')
+    
+    @classmethod
+    def is_instance_of(cls, obj, raise_exception=False):
+        res = isinstance(obj, cls.protobuf_class())
+        if not res and raise_exception:
+            raise TechnicalException(f"Object has to be of protobuf type {cls.protobuf_class()} (obtained type: {Typing.get_object_class_fullname(obj)}")
+        return res
+        
+    @classmethod
+    def set_object_value(cls, obj, value, raise_exception=False):
+        cls.is_instance_of(obj, raise_exception=True)
+        return cls._set_object_value(obj, value, raise_exception=raise_exception)
+
+
+