holado 0.7.0__tar.gz → 0.8.0__tar.gz

{holado-0.7.0 → holado-0.8.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: holado
-Version: 0.7.0
+Version: 0.8.0
 Summary: HolAdo framework
 Project-URL: Homepage, https://gitlab.com/holado_framework/python
 Project-URL: Issues, https://gitlab.com/holado_framework/python/-/issues
@@ -45,9 +45,9 @@ Requires-Dist: pympler; extra == 'all'
 Requires-Dist: pyopenssl; extra == 'all'
 Requires-Dist: pypika; extra == 'all'
 Requires-Dist: pysftp; extra == 'all'
-Requires-Dist: pyyaml; extra == 'all'
 Requires-Dist: redis; extra == 'all'
 Requires-Dist: redis-om; extra == 'all'
+Requires-Dist: ruamel-yaml; extra == 'all'
 Requires-Dist: sftpserver; extra == 'all'
 Requires-Dist: sql-metadata; extra == 'all'
 Requires-Dist: truststore; extra == 'all'
@@ -108,7 +108,7 @@ Requires-Dist: suds; extra == 'ws-suds'
 Provides-Extra: ws-zeep
 Requires-Dist: zeep; extra == 'ws-zeep'
 Provides-Extra: yaml
-Requires-Dist: pyyaml; extra == 'yaml'
+Requires-Dist: ruamel-yaml; extra == 'yaml'
 Description-Content-Type: text/markdown
 
 # HolAdo (Holistic Automation do)
@@ -169,6 +169,7 @@ Currently, main available modules are:
 
 Major upcomming capabilities:
 * WebUI interactions (with playright or selenium)
+* DB ORM
 
 
 # Community

{holado-0.7.0 → holado-0.8.0}/README.md

@@ -56,6 +56,7 @@ Currently, main available modules are:
 
 Major upcomming capabilities:
 * WebUI interactions (with playright or selenium)
+* DB ORM
 
 
 # Community

holado-0.8.0/packaging/VERSION

@@ -0,0 +1 @@
+0.8.0

{holado-0.7.0 → holado-0.8.0}/pyproject.toml

@@ -52,7 +52,7 @@ sftp = ["holado[ssl]", "paramiko<4.0.0", "pysftp", "sftpserver"]
 ssl = ["truststore", "certifi", "pyOpenSSL"]
 ws-suds = ["suds"]
 ws-zeep = ["zeep"]
-yaml = ["pyyaml"]
+yaml = ["ruamel.yaml"]
 
 [project.urls]
 Homepage = "https://gitlab.com/holado_framework/python"

{holado-0.7.0 → holado-0.8.0}/requirements_docker.txt

@@ -67,7 +67,8 @@ pympler     # memory profiling
 #py-spy      # deadlock
 
 # For yaml module
-pyyaml
+#pyyaml
+ruamel.yaml
 
 # For ssl: next packages have sometimes to be updated
 #pip-system-certs  #Note: [28/07/2025] since recent modifications in urllib, pip-system-certs is broken, it is recommended to use truststore instead

{holado-0.7.0 → holado-0.8.0}/src/holado/common/context/context.py

@@ -13,9 +13,6 @@
 
 import logging
 from holado.common.handlers.object import DeleteableObject, Object
-from holado_core.common.tools.tools import Tools
-from holado_core.common.exceptions.element_exception import ElementNotFoundException
-from holado_python.standard_library.typing import Typing
 
 logger = None
 
@@ -29,13 +26,43 @@ class Context(DeleteableObject):
     @summary: Mother class for any context class
     """
     
-    def __init__(self, name):
+    def __init__(self, name, with_post_process=False, persisted_kwargs=None):
         super().__init__(name)
         self.on_delete_call_gc_collect = True
         
         self.__objects = {}
         self.__on_delete_objects = []
         
+        # Post process management
+        if with_post_process:
+            self.__persisted_kwargs = persisted_kwargs if persisted_kwargs is not None else {}
+            self.__persisted_method_to_call_manager_inst = None
+            self.__post_process_funcs = []
+        
+    def initialize(self):
+        if self.__with_post_process:
+            self.__persisted_method_to_call_manager.ensure_persistent_db_exists()
+    
+    @property
+    def __with_post_process(self):
+        return hasattr(self, '_Context__persisted_method_to_call_manager_inst')
+    
+    def __verify_is_with_post_process(self):
+        if not self.__with_post_process:
+            from holado_core.common.exceptions.technical_exception import TechnicalException
+            raise TechnicalException(f"[{self.name}] This context doesn't manage post process")
+        
+    @property
+    def __persisted_method_to_call_manager(self):
+        self.__verify_is_with_post_process()
+        
+        if self.__persisted_method_to_call_manager_inst is None:
+            from holado.common.context.session_context import SessionContext
+            from holado_core.common.resource.persisted_method_to_call_manager import PersistedMethodToCallManager
+            self.__persisted_method_to_call_manager_inst = PersistedMethodToCallManager(scope_name=self.name, **self.__persisted_kwargs)
+            self.__persisted_method_to_call_manager_inst.initialize(SessionContext.instance().resource_manager, SessionContext.instance().expression_evaluator)
+        return self.__persisted_method_to_call_manager_inst
+        
     def get_context_name(self):
         return Object.name(self)
     
@@ -46,6 +73,8 @@ class Context(DeleteableObject):
     def remove_all_objects(self):
         from holado_core.common.exceptions.functional_exception import FunctionalException
         from holado_core.common.exceptions.technical_exception import TechnicalException
+        from holado_core.common.tools.tools import Tools
+        from holado_python.standard_library.typing import Typing
         
         keys = set(self.__objects.keys())
         if Tools.do_log(logger, logging.DEBUG):
@@ -67,6 +96,9 @@ class Context(DeleteableObject):
         self._remove(name, True)
         
     def _remove(self, name, remove_from_lifetime_manager):
+        from holado_core.common.tools.tools import Tools
+        from holado_python.standard_library.typing import Typing
+        
         obj = self.get_object(name)
         if Tools.do_log(logger, logging.DEBUG):
             logger.debug(f"[{self.name}] Removing object '{name}' (type: {Typing.get_object_class_fullname(obj)})")
@@ -133,13 +165,87 @@ class Context(DeleteableObject):
         raise NotImplementedError()
     
     def get_object_getter_eval_string(self, obj, raise_not_found=True):
+        from holado_python.standard_library.typing import Typing
+        
         name = self.get_object_name(obj)
         if name is not None:
             return f"{Typing.get_object_class_fullname(self)}.instance().get_object('{name}')"
         
         if raise_not_found:
+            from holado_core.common.exceptions.element_exception import ElementNotFoundException
             raise ElementNotFoundException(f"[{self.name}] Failed to find object of id {id(obj)}")
         else:
             return None
 
+    
+    
+    ### Post process management
+    
+    def add_post_process(self, func):
+        self.__verify_is_with_post_process()
+        
+        success = self.__persist_function(func)
+        if not success:
+            logger.debug(f"[{self.name}] Add post process in memory, persistence in DB has failed (post process function: {func})")
+            self.__post_process_funcs.append(func)
+    
+    def __persist_function(self, func):
+        from holado.common.context.session_context import SessionContext
+        from holado_core.common.exceptions.technical_exception import TechnicalException
+        from holado_core.common.tools.tools import Tools
+        from holado_python.standard_library.typing import Typing
+        
+        try:
+            if Typing.is_function(func._target):
+                func_qualname = Typing.get_function_fullname(func._target)
+                self.__persisted_method_to_call_manager.add_function_to_call(
+                    func_qualname, args_list=func._args, kwargs_dict=func._kwargs, 
+                    use="post_process", use_index=None)
+                return True
+            elif Typing.is_method(func._target):
+                meth_func = Typing.get_method_function(func._target)
+                func_qualname = Typing.get_function_fullname(meth_func)
+                meth_obj = Typing.get_method_object_instance(func._target)
+                self_getter_eval_str = SessionContext.instance().get_object_getter_eval_string(meth_obj, raise_not_found=False)
+                if self_getter_eval_str is not None:
+                    self.__persisted_method_to_call_manager.add_method_to_call(
+                        func_qualname, self_getter_eval_str, args_list=func._args, kwargs_dict=func._kwargs, 
+                        use="post_process", use_index=None)
+                    return True
+            else:
+                raise TechnicalException(f"[{self.name}] Unmanaged target type '{Typing.get_object_class_fullname(func._target)}'")
+        except TechnicalException as exc:
+            raise exc
+        except Exception as exc:
+            logger.warning(f"[{self.name}] Failed to persist function {func}: {Tools.represent_exception(exc)}")
+        return False
+        
+    def do_post_processes(self):
+        self.__verify_is_with_post_process()
+        
+        # First call functions that were not persisted
+        for func in self.__post_process_funcs:
+            try:
+                func.run()
+            except Exception as exc:
+                # logger.error(f"Error while post processing [{func}]: {exc}")
+                logger.exception(f"[{self.name}] Error while post processing [{func}]: {exc}")
+        
+        # Call persisted functions and methods
+        try:
+            self.do_persisted_post_processes()
+        except Exception as exc:
+            logger.exception(f"[{self.name}] Error while scenario post processing persisted methods: {exc}")
+        
+    def do_persisted_post_processes(self):
+        """Call functions and methods persisted by a previous context instance
+        Note: This is useful especially when a context was deleted (like on process kill) before post processes could be performed
+        """
+        self.__verify_is_with_post_process()
+        
+        self.__persisted_method_to_call_manager.call_functions_and_methods(use="post_process")
+        
+    def get_number_of_persisted_post_processes_to_perform(self):
+        return self.__persisted_method_to_call_manager.get_number_of_functions_and_method_to_call()
+
 

{holado-0.7.0 → holado-0.8.0}/src/holado/common/context/session_context.py

@@ -66,7 +66,7 @@ class SessionContext(Context):
             logger.debug(f"Reset of session context")
     
     def __init__(self, name="Session"):
-        super().__init__(name)
+        super().__init__(name, with_post_process=True)
         
         self.__with_session_path = None
         
@@ -82,7 +82,7 @@ class SessionContext(Context):
         try:
             if self.object_state in [ObjectStates.Deleting, ObjectStates.Deleted]:
                 return
-    
+            
             self.delete_object()
         except Exception as exc:
             if "Python is likely shutting down" in str(exc):
@@ -120,7 +120,7 @@ class SessionContext(Context):
         """
         Override this method to initialize the session context after its configuration and new session creation.
         """
-        pass
+        super().initialize()
         
     @property
     def services(self):
@@ -165,14 +165,25 @@ class SessionContext(Context):
             SessionContext.instance().log_manager.set_config()
     
     def before_all(self, behave_context):
+        log_prefix = f"[Before session] "
+        
         with self.__multitask_lock:
             self.behave_manager.set_main_context(behave_context)
             self.report_manager.before_all()
         
         # Set variable with session context instance
         self.variable_manager.register_variable("SESSION_CONTEXT", self)
-    
+        
+        logger.info(f"{log_prefix}Doing previous session post processes if needed...")
+        self.do_persisted_post_processes()
+        
     def after_all(self):
+        log_prefix = f"[After session] "
+            
+        # Post processes
+        logger.info(f"{log_prefix}Post processing...")
+        self.do_post_processes()
+        
         with self.__multitask_lock:
             self.report_manager.after_all()
             self.behave_manager.clear()
@@ -304,7 +315,7 @@ class SessionContext(Context):
                 # MemoryProfiler.create_or_reset_tracker_of_objects_changes("scenarios objects")
         
             logger.info(f"{log_prefix}Doing previous scenario post processes if needed...")
-            self.get_scenario_context().do_previous_scenario_post_processes()
+            self.get_scenario_context().do_persisted_post_processes()
             
             logger.info(f"{log_prefix}End")
             logger.info(f"Start scenario [{scenario.name}]")

holado-0.8.0/src/holado_context/tests/behave/steps/private/common/context_steps.py

@@ -0,0 +1,68 @@
+# -*- 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_test.behave.behave import *  # @UnusedWildImport
+import logging
+from holado_test.scenario.step_tools import StepTools
+from holado_core.common.exceptions.technical_exception import TechnicalException
+
+logger = logging.getLogger(__name__)
+
+
+def __get_scenario_context():
+    return SessionContext.instance().get_scenario_context()
+
+def __get_text_interpreter():
+    return __get_scenario_context().get_text_interpreter()
+
+def __get_variable_manager():
+    return __get_scenario_context().get_variable_manager()
+
+
+def __get_context(context_name):
+    context_name = context_name.capitalize()
+    if context_name == SessionContext.instance().name:
+        return SessionContext.instance()
+    elif context_name == __get_scenario_context().name:
+        return __get_scenario_context()
+    else:
+        raise TechnicalException(f"Not found context of name '{context_name}'")
+
+@Step(r"execute post processes of (?P<context_name>{Str}) context")
+def step_impl(context, context_name):
+    context_name = StepTools.evaluate_scenario_parameter(context_name)
+    
+    context = __get_context(context_name)
+    context.do_post_processes()
+
+@Step(r"execute persisted post processes of (?P<context_name>{Str}) context")
+def step_impl(context, context_name):
+    context_name = StepTools.evaluate_scenario_parameter(context_name)
+    
+    context = __get_context(context_name)
+    context.do_persisted_post_processes()
+
+@Step(r"(?P<var_name>{Variable}) = number of persisted post processes to perform for (?P<context_name>{Str}) context")
+def step_impl(context, var_name, context_name):
+    var_name = StepTools.evaluate_variable_name(var_name)
+    context_name = StepTools.evaluate_scenario_parameter(context_name)
+    
+    context = __get_context(context_name)
+    res = context.get_number_of_persisted_post_processes_to_perform()
+    
+    __get_variable_manager().register_variable(var_name, res)
+
+

holado-0.8.0/src/holado_core/common/resource/persisted_method_to_call_manager.py

@@ -0,0 +1,253 @@
+
+#################################################
+# 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
+import json
+from holado_core.common.resource.persisted_data_manager import PersistedDataManager
+from holado_python.standard_library.typing import Typing
+from holado_core.common.exceptions.technical_exception import TechnicalException
+from holado_core.common.tools.tools import Tools
+from holado.common.handlers.undefined import undefined_value, undefined_argument
+from holado_python.common.tools.datetime import DateTime
+from holado_db.tools.db.query.base.query_builder import DBCompareOperator
+from holado.common.handlers.enums import AutoNumber
+
+logger = logging.getLogger(__name__)
+
+
+class MethodCallStatus(AutoNumber):
+    Ready = ()
+    Completed = ()
+    Failed = ()
+    Expired = ()
+    
+
+class PersistedMethodToCallManager(PersistedDataManager):
+    def __init__(self, scope_name, delete_on_success=True, delete_on_fail=False, delete_on_success_after_fail=False, expiration_try_counter=10, data_name="method", table_name="method_to_call", db_name="default"):
+        super().__init__(data_name=data_name, table_name=table_name, 
+                         table_sql_create=self._get_default_table_sql_create(table_name), 
+                         db_name=db_name)
+        self.__scope_name = scope_name
+        self.__delete_on_success = delete_on_success
+        self.__delete_on_fail = delete_on_fail
+        self.__delete_on_success_after_fail = delete_on_fail
+        self.__expiration_try_counter = expiration_try_counter
+    
+    def initialize(self, resource_manager, expression_evaluator):
+        super().initialize(resource_manager)
+        self.__expression_evaluator = expression_evaluator
+    
+    def _get_default_table_sql_create(self, table_name):
+        return f"""CREATE TABLE {table_name} (
+                id INTEGER PRIMARY KEY,
+                scope_name text NOT NULL,
+                function_qualname text NOT NULL,
+                self_getter TEXT,
+                args TEXT,
+                kwargs TEXT,
+                use text NOT NULL,
+                use_index integer NOT NULL,
+                created_at TEXT,
+                changed_at TEXT,
+                status TEXT,
+                try_counter INTEGER,
+                error TEXT,
+                do_delete_on_success INTEGER,
+                do_delete_on_fail INTEGER,
+                do_delete_on_success_after_fail INTEGER
+            )"""
+    
+    def add_function_to_call(self, function_qualname, args_list=None, kwargs_dict=None, use="default", use_index=0, add_if_exists=False, delete_on_success=undefined_argument, delete_on_fail=undefined_argument, delete_on_success_after_fail=undefined_argument):
+        """Add a function to call.
+        @param function_qualname: Qualified name of function
+        @param args_list: List of function args (default: None)
+        @param kwargs_dict: Dict of function kwargs (default: None)
+        @param use: Define persistent usage. It usually corresponds to a specific scope.
+        @param use_index: use index, useable to order the functions to call. By default all are 0. If set to None, it is automatically set to max(use_index)+1.
+        @param delete_on_success: If True, delete function after its success
+        @param delete_on_fail: If True, delete function after its fail
+        @param delete_on_success_after_fail: If True, delete function after its success even if it has previously failed
+        """
+        self.add_method_to_call(function_qualname, None, args_list, kwargs_dict, use, use_index, add_if_exists, delete_on_success, delete_on_fail, delete_on_success_after_fail)
+    
+    def add_method_to_call(self, function_qualname, self_getter_eval_str, args_list=None, kwargs_dict=None, use="default", use_index=0, add_if_exists=False, delete_on_success=undefined_argument, delete_on_fail=undefined_argument, delete_on_success_after_fail=undefined_argument):
+        """Add a method to call.
+        @param function_qualname: Qualified name of function
+        @param self_getter_eval_str: String to eval in order to get the self instance to use when calling method 
+        @param args_list: List of function args (default: None)
+        @param kwargs_dict: Dict of function kwargs (default: None)
+        @param use: Define persistent usage. It usually corresponds to a specific scope.
+        @param use_index: Use index, useable to order the functions to call. By default all are 0. If set to None, it is automatically set to max(use_index)+1.
+        @param add_if_exists: Add if method already exists (default: False)
+        @param delete_on_success: If True, delete method after its success
+        @param delete_on_fail: If True, delete method after its fail
+        @param delete_on_success_after_fail: If True, delete method after its success even if it has previously failed
+        """
+        # Define persisted data that can define if method is already persisted
+        data = {
+            'scope_name': self.__scope_name,
+            'function_qualname': function_qualname,
+            'self_getter': self_getter_eval_str,
+            'use': use,
+            }
+        if args_list is not None:
+            data['args'] = json.dumps(args_list)
+        if kwargs_dict is not None:
+            data['kwargs'] = json.dumps(kwargs_dict)
+        
+        # Return if data is already persisted and add_if_exists==True
+        filter_compare_data = [('status', DBCompareOperator.In, [MethodCallStatus.Ready.name, MethodCallStatus.Failed.name])]
+        if not add_if_exists and self.has_persisted_data(filter_data=data, filter_compare_data=filter_compare_data):
+            return
+        
+        # Persist data
+        if use_index is None:
+            use_index = self.__get_use_next_index(use)
+        now_str = DateTime.datetime_2_str(DateTime.utcnow())
+        data.update({
+            'use_index': use_index,
+            'created_at': now_str,
+            'changed_at': now_str,
+            'status': MethodCallStatus.Ready.name,
+            'try_counter': 0,
+            'do_delete_on_success': self.__get_db_on_delete_after_when_add_method(delete_on_success, self.__delete_on_success),
+            'do_delete_on_fail': self.__get_db_on_delete_after_when_add_method(delete_on_fail, self.__delete_on_fail),
+            'do_delete_on_success_after_fail': self.__get_db_on_delete_after_when_add_method(delete_on_success_after_fail, self.__delete_on_success_after_fail)
+            })
+        
+        self.add_persisted_data(data)
+    
+    def get_number_of_functions_and_method_to_call(self, use=undefined_argument):
+        methods_data = self.__get_functions_and_methods_to_call(use=use)
+        return len(methods_data)
+    
+    def __get_db_on_delete_after_when_add_method(self, method_delete, default_delete):
+        if method_delete is not undefined_argument:
+            if method_delete is undefined_value:
+                return -1
+            else:
+                return method_delete
+        else:
+            if default_delete is undefined_value:
+                return -1
+            else:
+                return default_delete
+        
+    def __get_do_delete_after_call(self, db_delete, default_delete):
+        if db_delete != -1:
+            return db_delete
+        else:
+            if default_delete is undefined_value:
+                return False
+            else:
+                return default_delete
+        
+    def __get_use_next_index(self, use):
+        datas = self.get_persisted_datas({'scope_name':self.__scope_name, 'use':use})
+        if datas:
+            return max(map(lambda x:x['use_index'], datas)) + 1
+        else:
+            return 0
+    
+    def __get_functions_and_methods_to_call(self, use=undefined_argument, use_index=None):
+        filter_data = {'scope_name':self.__scope_name}
+        if use is not undefined_argument:
+            filter_data['use'] = use
+            if use_index is not None:
+                filter_data['use_index'] = use_index
+        filter_compare_data = [('status', DBCompareOperator.In, [MethodCallStatus.Ready.name, MethodCallStatus.Failed.name])]
+        return self.get_persisted_datas(filter_data, filter_compare_data=filter_compare_data)
+    
+    def call_functions_and_methods(self, use="default", use_index=None):
+        """Call methods of given use
+        @param use: Define persistent usage. It usually corresponds to a specific scope.
+        @param use_index: If defined, call only functions and methods of given index.
+        @param delete_after_call: Define if function or method is deleted after call from persisted data.
+        """
+        # Get functions and methods to call
+        methods_data = self.__get_functions_and_methods_to_call(use=use)
+        
+        # Call methods
+        if methods_data:
+            for meth_index, meth_data in enumerate(methods_data):
+                status, do_delete, error = None, None, ''
+                try:
+                    self._call_function_or_method(meth_data)
+                except Exception as exc:
+                    error = Tools.represent_exception(exc, indent=8)
+                    msg_list = [f"Error while calling following method (use: '{use}' ; use index: {use_index} ; method index: {meth_index}):"]
+                    msg_list.append(Tools.represent_object(meth_data, 8))
+                    msg_list.append("    Error:")
+                    msg_list.append(error)
+                    msg_list.append("  => Continue to process persisted methods")
+                    msg_list.append("     WARNING: this method is removed from persisted methods to avoid recursive and blocking errors")
+                    logger.error("\n".join(msg_list))
+                    status = MethodCallStatus.Failed
+                    do_delete = self.__get_do_delete_after_call(meth_data['do_delete_on_fail'], self.__delete_on_fail)
+                else:
+                    status = MethodCallStatus.Completed
+                    if meth_data['try_counter'] == 0:
+                        do_delete = self.__get_do_delete_after_call(meth_data['do_delete_on_success'], self.__delete_on_success)
+                    else:
+                        do_delete = self.__get_do_delete_after_call(meth_data['do_delete_on_success_after_fail'], self.__delete_on_success_after_fail)
+                
+                self.__update_persisted_data_after_call(do_delete, meth_data, status, error)
+                
+    def __update_persisted_data_after_call(self, do_delete, meth_data, status, error):
+        if do_delete:
+            self.__delete_function_or_method(meth_data)
+        else:
+            self.__update_function_or_method_status(meth_data, status, error)
+    
+    def __delete_function_or_method(self, function_or_method_data):
+        filter_data = {'id':function_or_method_data['id']}
+        self.delete_persisted_data(filter_data)
+    
+    def __update_function_or_method_status(self, function_or_method_data, status, error):
+        filter_data = {'id':function_or_method_data['id']}
+        try_counter = function_or_method_data['try_counter'] + 1
+        if try_counter >= self.__expiration_try_counter and status == MethodCallStatus.Failed:
+            status = MethodCallStatus.Expired
+        
+        data = {
+            'status': status.name,
+            'try_counter': try_counter,
+            'error': error,
+            'changed_at': DateTime.datetime_2_str(DateTime.utcnow()),
+            }
+        self.update_persisted_data(data, filter_data=filter_data)
+    
+    def _call_function_or_method(self, function_or_method_data):
+        _, func = self.__expression_evaluator.evaluate_python_expression(function_or_method_data['function_qualname'])
+        if not Typing.is_function(func):
+            raise TechnicalException(f"Failed to evaluate python expression '{function_or_method_data['function_qualname']}' as a function (obtained: {func} [type: {Typing.get_object_class_fullname(func)}] ; function data: {function_or_method_data})")
+        
+        func_self = None
+        if function_or_method_data['self_getter'] is not None:
+            _, func_self = self.__expression_evaluator.evaluate_python_expression(function_or_method_data['self_getter'])
+        
+        if function_or_method_data['args'] is not None:
+            args = json.loads(function_or_method_data['args'])
+        else:
+            args = []
+        if function_or_method_data['kwargs'] is not None:
+            kwargs = json.loads(function_or_method_data['kwargs'])
+        else:
+            kwargs = {}
+        
+        if func_self is not None:
+            func(func_self, *args, **kwargs)
+        else:
+            func(*args, **kwargs)
+        
+