holado 0.13.22__py3-none-any.whl

holado/__init__.py

@@ -0,0 +1,358 @@
+# -*- 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.
+#################################################
+
+
+import os
+import importlib
+import logging
+import copy
+from holado.common.handlers.undefined import default_value
+from holado.common.tools.gc_manager import GcManager
+
+try:
+    import behave
+    with_behave = True
+except:
+    with_behave = False
+
+logger = None
+__initialized = False
+
+
+def is_in_steps_catalog():
+    from holado_core.common.tools.converters.converter import Converter
+    return Converter.to_boolean(os.getenv("HOLADO_STEPS_CATALOG", False))
+
+
+def __initialize_holado_loggers():
+    global logger
+    logger = logging.getLogger(__name__)
+    
+    import holado.common
+    holado.common.initialize_loggers()
+    
+    
+    
+def _initialize_logging(use_holado_logger=True, logging_config_file_path=None, log_level=None, log_time_in_utc=None, log_on_console=False, log_in_file=True):
+    # print_imported_modules("[initialize]")
+    import holado_logging
+    # print_imported_modules("[after import holado_logging]")
+
+    # Configure logging module
+    holado_logging.configure(use_holado_logger=use_holado_logger, logging_config_file_path=logging_config_file_path, 
+                             log_level=log_level, log_time_in_utc=log_time_in_utc, log_on_console=log_on_console, log_in_file=log_in_file)
+    # print_imported_modules("[after import holado_logging]")
+
+    # Initialize holado loggers
+    __initialize_holado_loggers()
+    
+    # Create session context
+    from holado.common.context.session_context import SessionContext
+    if SessionContext.has_instance():
+        from holado_core.common.exceptions.technical_exception import TechnicalException
+        raise TechnicalException(f"Session context was initialized to early (before logging configuration)")
+    SessionContext.instance()
+    
+    # Initialize log manager and register it in session context
+    holado_logging.initialize_and_register()
+    
+    # Set whole logging configuration
+    SessionContext.instance().log_manager.set_config()
+    
+def change_logging_config(log_level=None, log_on_console=False, log_in_file=True):
+    from holado.common.context.session_context import SessionContext
+    SessionContext.instance().log_manager.set_level(log_level, do_set_config=False)
+    SessionContext.instance().log_manager.on_console = log_on_console
+    SessionContext.instance().log_manager.in_file = log_in_file
+    SessionContext.instance().log_manager.set_config()
+
+
+def initialize_minimal():
+    # initialize(TSessionContext=None, use_holado_logger=False, logging_config_file_path=None,
+    #            log_level=None, log_on_console=True, log_in_file=False,
+    #            session_kwargs={'with_session_path':False}, 
+    #            garbage_collector_periodicity=None)
+    initialize(TSessionContext=None, use_holado_logger=True, logging_config_file_path=None,
+               log_level=None, log_time_in_utc=None, log_on_console=True, log_in_file=False,
+               garbage_collector_periodicity=None)
+
+def initialize(TSessionContext=None, use_holado_logger=True, logging_config_file_path=None, 
+               log_level=None, log_time_in_utc=None, log_on_console=False, log_in_file=True, 
+               config_kwargs=None, session_kwargs=None, garbage_collector_periodicity=default_value):
+    global __initialized
+    if __initialized:
+        from holado_core.common.exceptions.technical_exception import TechnicalException
+        raise TechnicalException(f"HolAdo was already initialized")
+    
+    from holado_core.common.tools.tools import Tools
+    
+    if session_kwargs is None:
+        session_kwargs = {}
+    with_session_path = session_kwargs.get("with_session_path", True)
+    
+    # Reset session context before initializing logging
+    # Note: Session context must not be created before logging initialization
+    from holado.common.context.session_context import SessionContext
+    SessionContext._reset_instance()
+    if TSessionContext is not None:
+        if isinstance(TSessionContext, str):
+            module_name, class_type = TSessionContext.rsplit('.', maxsplit=1)
+            module = importlib.import_module(module_name)
+            TSessionContext = getattr(module, class_type)
+        
+        SessionContext.TSessionContext = TSessionContext
+    
+    # Initialize logging
+    _initialize_logging(use_holado_logger=use_holado_logger, logging_config_file_path=logging_config_file_path,
+                        log_level=log_level, log_time_in_utc=log_time_in_utc, log_on_console=log_on_console, log_in_file=log_in_file and with_session_path)
+    if Tools.do_log(logger, logging.DEBUG):
+        logger.debug("Configured logging")
+    
+    # Import modules
+    if Tools.do_log(logger, logging.DEBUG):
+        logger.debug("Importing HolAdo modules")
+    _import_modules(get_holado_module_names())
+    
+    # Update config with given kwargs
+    # Note: it is made after modules import to enable override modules specific config parameters
+    _update_config(config_kwargs)
+    
+    # Initialize session context
+    _initialize_session_context(session_kwargs)
+    
+    # Initialize garbage collector
+    if garbage_collector_periodicity is not None:
+        GcManager.collect_periodically(garbage_collector_periodicity)
+        logger.debug(f"Garbage collector is disabled, and collects are automatically done in a dedicated thread (periodicity: {GcManager.get_collect_periodicity()} s)")
+    
+    if with_behave:
+        # Register default behave parameter types
+        #TODO: make step tools a service
+        from holado_test.behave.scenario.behave_step_tools import BehaveStepTools
+        BehaveStepTools.register_default_types()
+    
+    __initialized = True
+    
+def initialize_for_script(TSessionContext=None, use_holado_logger=True, logging_config_file_path=None, 
+                          log_level=logging.WARNING, log_time_in_utc=None, log_on_console=True, log_in_file=False, 
+                          config_kwargs=None, session_kwargs=None, garbage_collector_periodicity=None):
+    if session_kwargs is None:
+        session_kwargs={'with_session_path':log_in_file, 'raise_if_not_exist':False}
+        
+    initialize(TSessionContext=TSessionContext, use_holado_logger=use_holado_logger, logging_config_file_path=logging_config_file_path, 
+               log_level=log_level, log_time_in_utc=log_time_in_utc, log_on_console=log_on_console, log_in_file=log_in_file,
+               config_kwargs=config_kwargs, session_kwargs=session_kwargs,
+               garbage_collector_periodicity=garbage_collector_periodicity )
+    
+
+def _update_config(config_kwargs):
+    from holado.holado_config import Config
+    
+    if config_kwargs is not None:
+        for name, value in config_kwargs.items():
+            if hasattr(Config, name):
+                setattr(Config, name, value)
+            else:
+                from holado_core.common.exceptions.technical_exception import TechnicalException
+                from holado_python.standard_library.typing import Typing
+                raise TechnicalException(f"Parameter '{name}' is not configurable, it doesn't exist. Available configurable parameters: {Typing.get_object_attributes(Config)}")
+
+def _initialize_session_context(session_kwargs=None):
+    from holado_core.common.tools.tools import Tools
+    
+    if Tools.do_log(logger, logging.DEBUG):
+        logger.debug("Initializing SessionContext")
+    from holado.common.context.session_context import SessionContext
+    
+    SessionContext.instance().configure(session_kwargs)
+    SessionContext.instance().new_session(session_kwargs)
+    SessionContext.instance().initialize(session_kwargs)
+    if Tools.do_log(logger, logging.DEBUG):
+        logger.debug("Initialized SessionContext")
+    
+def _is_in_holado_package(here=None):
+    if here is None:
+        here = os.path.abspath(os.path.dirname(__file__))
+    return 'site-packages' in here
+    
+def get_holado_path():
+    here = os.path.abspath(os.path.dirname(__file__))
+    if _is_in_holado_package(here):
+        from holado_core.common.exceptions.technical_exception import TechnicalException
+        raise TechnicalException(f"When using installed 'holado' package, the project HolAdo is not available")
+    else:
+        return os.path.normpath(os.path.join(here, "..", ".."))
+    
+def get_holado_src_path():
+    here = os.path.abspath(os.path.dirname(__file__))
+    return os.path.normpath(os.path.join(here, ".."))
+    
+def get_holado_module_names():
+    lp = sorted(os.listdir(get_holado_src_path()))
+    return [name for name in lp if name.startswith("holado_") and name not in ['holado_logging']]
+
+def _import_modules(module_names):
+    from holado_core.common.tools.tools import Tools
+    
+    imported_modules = __import_modules(module_names)
+    __configure_modules(imported_modules)
+    remaining_imported_modules = __register_modules_with_dependencies(imported_modules)
+    
+    # Register modules with cross dependencies
+    if remaining_imported_modules:
+        if Tools.do_log(logger, logging.DEBUG):
+            logger.debug(f"Registering modules with cross dependencies: {list(remaining_imported_modules.keys())}...")
+        for module_name in remaining_imported_modules:
+            if Tools.do_log(logger, logging.TRACE):  # @UndefinedVariable
+                logger.trace(f"Registering HolAdo module '{module_name}'...")
+            remaining_imported_modules[module_name].register()
+            if Tools.do_log(logger, logging.DEBUG):
+                logger.debug(f"Registered HolAdo module '{module_name}'")
+
+def __import_modules(module_names):
+    from holado_core.common.tools.tools import Tools
+    
+    if Tools.do_log(logger, logging.DEBUG):
+        logger.debug(f"Importing HolAdo modules: {module_names}")
+    
+    res = {}
+    for module_name in module_names:
+        if Tools.do_log(logger, logging.TRACE):  # @UndefinedVariable
+            logger.trace(f"Importing HolAdo module '{module_name}'...")
+        try:
+            module = importlib.import_module(module_name)
+        except Exception as exc:
+            if Tools.do_log(logger, logging.DEBUG):
+                logger.debug(f"Failed to import HolAdo module '{module_name}':\n{Tools.represent_exception(exc)}")
+            if "No module named" not in str(exc):
+                logger.warning(f"Failed to import HolAdo module '{module_name}': {str(exc)} (see debug logs for more details)")
+        else:
+            if Tools.do_log(logger, logging.DEBUG):
+                logger.debug(f"Imported HolAdo module '{module_name}'")
+            res[module_name] = module
+    return res
+    
+def __configure_modules(imported_modules):
+    from holado_core.common.tools.tools import Tools
+    
+    if Tools.do_log(logger, logging.DEBUG):
+        logger.debug(f"Configuring imported HolAdo modules: {sorted(imported_modules.keys())}")
+    
+    imported_module_names = list(imported_modules.keys())
+    for module_name in imported_module_names:
+        if Tools.do_log(logger, logging.TRACE):  # @UndefinedVariable
+            logger.trace(f"Configuring HolAdo module '{module_name}'...")
+        module = imported_modules[module_name]
+        if hasattr(module, 'configure_module'):
+            module.configure_module()
+            if Tools.do_log(logger, logging.DEBUG):
+                logger.debug(f"Configured HolAdo module '{module_name}'")
+        else:
+            if Tools.do_log(logger, logging.DEBUG):
+                logger.debug(f"Nothing to configure for HolAdo module '{module_name}'")
+    
+def __register_modules_with_dependencies(imported_modules):
+    from holado_core.common.tools.tools import Tools
+    
+    if Tools.do_log(logger, logging.DEBUG):
+        logger.debug(f"Registering imported HolAdo modules: {sorted(imported_modules.keys())}")
+    
+    registered_modules = set()
+    remaining_imported_modules = copy.copy(imported_modules)
+    has_new_registered = True
+    while has_new_registered:
+        has_new_registered = False
+        imported_module_names = list(remaining_imported_modules.keys())
+        for module_name in imported_module_names:
+            if Tools.do_log(logger, logging.TRACE):  # @UndefinedVariable
+                logger.trace(f"Registering HolAdo module '{module_name}'...")
+            module = remaining_imported_modules[module_name]
+            module_dependencies = set(module.dependencies()) if hasattr(module, 'dependencies') and module.dependencies() is not None else None
+            if module_dependencies is None or registered_modules.issuperset(module_dependencies):
+                if hasattr(module, 'register'):
+                    module.register()
+                    if Tools.do_log(logger, logging.DEBUG):
+                        logger.debug(f"Registered HolAdo module '{module_name}'")
+                else:
+                    if Tools.do_log(logger, logging.DEBUG):
+                        logger.debug(f"Nothing to register for HolAdo module '{module_name}'")
+                del remaining_imported_modules[module_name]
+                registered_modules.add(module_name)
+                has_new_registered = True
+            else:
+                if Tools.do_log(logger, logging.TRACE):  # @UndefinedVariable
+                    logger.trace(f"Pending registration of HolAdo module '{module_name}' due to dependencies: {module_dependencies.difference(registered_modules)}")
+    return remaining_imported_modules
+    
+def import_steps():
+    from holado_core.common.exceptions.technical_exception import TechnicalException
+    from holado_core.common.tools.tools import Tools
+    
+    lp = sorted(os.listdir(get_holado_src_path()))
+    for module_name in lp:
+        if module_name.startswith("holado_"):
+            if with_behave:
+                module_steps_package = f"{module_name}.tests.behave.steps"
+            else:
+                raise TechnicalException(f"'behave' is needed for steps")
+            try:
+                importlib.import_module(module_steps_package)
+            except Exception as exc:
+                if "No module named" in str(exc):
+                    if Tools.do_log(logger, logging.DEBUG):
+                        logger.debug(f"No steps in HolAdo module '{module_name}'")
+                    # logger.warning(f"No steps in HolAdo module '{module_name}'")
+                else:
+                    raise TechnicalException(f"Failed to import steps of HolAdo module '{module_name}'") from exc
+            else:
+                if Tools.do_log(logger, logging.DEBUG):
+                    logger.debug(f"Imported steps of HolAdo module '{module_name}'")
+            
+def import_private_steps():
+    from holado_core.common.tools.tools import Tools
+    
+    lp = sorted(os.listdir(get_holado_src_path()))
+    for module_name in lp:
+        if module_name.startswith("holado_"):
+            if with_behave:
+                module_steps_package = f"{module_name}.tests.behave.steps.private"
+            else:
+                from holado_core.common.exceptions.technical_exception import TechnicalException
+                raise TechnicalException(f"'behave' is needed for steps")
+            try:
+                importlib.import_module(module_steps_package)
+            except:
+                pass
+            else:
+                if Tools.do_log(logger, logging.DEBUG):
+                    logger.debug(f"Imported private steps of HolAdo module '{module_name}'")
+            
+def print_imported_modules(prefix):
+    import sys
+    import types
+
+    sys_modules = [v.__name__ for _,v in sys.modules.items() if isinstance(v, types.ModuleType)]
+    print(f"{prefix} sys modules: {sys_modules}")
+    
+    # globals_modules = [v.__name__ for _,v in globals().items() if isinstance(v, types.ModuleType)]
+    # print(f"{prefix} globals modules: {globals_modules}")
+    
+    
+
+# Process minimal initialization of HolAdo
+# Note: Currently, initialization can be done only once, thus minimal initialization is commented.
+#       As a consequence, the call of an initialize method is mandatory
+# initialize_minimal()
+
+

holado/common/__init__.py

@@ -0,0 +1,25 @@
+# -*- 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 initialize_loggers():
+    import holado.common.context
+    holado.common.context.initialize_loggers()
+    
+    import holado.common.handlers
+    holado.common.handlers.initialize_loggers()
+    
+    import holado.common.tools
+    holado.common.tools.initialize_loggers()
+    

holado/common/context/__init__.py

@@ -0,0 +1,25 @@
+# -*- 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 initialize_loggers():
+    import holado.common.context.context
+    holado.common.context.context.initialize_logger()
+    
+    import holado.common.context.service_manager
+    holado.common.context.service_manager.initialize_logger()
+    
+    import holado.common.context.session_context
+    holado.common.context.session_context.initialize_logger()
+    

holado/common/context/context.py

@@ -0,0 +1,248 @@
+
+#################################################
+# 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.common.handlers.object import DeleteableObject, Object
+
+logger = None
+
+def initialize_logger():
+    global logger
+    logger = logging.getLogger(__name__)
+
+
+class Context(DeleteableObject):
+    """
+    @summary: Mother class for any context class
+    """
+    
+    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 = []
+        
+    @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)
+            self.__persisted_method_to_call_manager_inst.ensure_persistent_db_exists()
+        return self.__persisted_method_to_call_manager_inst
+        
+    def get_context_name(self):
+        return Object.name(self)
+    
+    def _delete_object(self):
+        # Remove all objects
+        self.remove_all_objects()
+    
+    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):
+            logger.debug(f"[{self.name}] Removing {len(keys)} objects: {keys}")
+        for index, key in enumerate(keys):
+            if Tools.do_log(logger, logging.DEBUG):
+                logger.debug(f"[{self.name}] Removing object {index+1}/{len(keys)}: '{key}' (type: {Typing.get_object_class_fullname(self.get_object(key))})")
+            try:
+                self.remove_object(key)
+            except FunctionalException as exc:
+                raise TechnicalException() from exc
+        if Tools.do_log(logger, logging.DEBUG):
+            logger.debug(f"[{self.name}] Finished to remove {len(keys)} objects: {keys}")
+                
+    def remove_object(self, name):
+        if not self.has_object(name):
+            from holado_core.common.exceptions.technical_exception import TechnicalException
+            raise TechnicalException("Context doesn't contain object '{}'".format(name))
+        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)})")
+        if name in self.__on_delete_objects:
+            if isinstance(obj, DeleteableObject):
+                if Tools.do_log(logger, logging.TRACE):  # @UndefinedVariable
+                    logger.trace(f"[{self.name}] Deleting object '{name}'")
+                try:
+                    obj.delete_object()
+                except Exception:
+                    logger.exception(f"[{self.name}] Catched exception while deleting object '{name}'")
+                else:
+                    if Tools.do_log(logger, logging.DEBUG):
+                        logger.debug(f"[{self.name}] Deleted object '{name}'")
+            self.__on_delete_objects.remove(name)
+            
+        if self.has_object(name):
+            del self.__objects[name]
+#         if remove_from_lifetime_manager:
+#             from holado.common.context.session_context import SessionContext
+#             SessionContext.instance().get_object_lifetime_manager().remove_object_lifetime(name, self)
+        
+    def set_object(self, name, obj, raise_if_already_set = True):
+        from holado_core.common.exceptions.functional_exception import FunctionalException
+        from holado_core.common.exceptions.technical_exception import TechnicalException
+        
+        if obj is None:
+            if self.has_object(name):
+                try:
+                    self.remove_object(name)
+                except FunctionalException as e:
+                    raise TechnicalException() from e
+        else:
+            if raise_if_already_set and self.has_object(name):
+                raise TechnicalException(f"[{self.name}] Context already contains object '{name}'")
+            self._put(name, obj)
+                    
+    def _put(self, name, obj):
+        self.__objects[name] = obj
+        self.__on_delete_objects.append(name)
+        
+    def get_object(self, name):
+        if not self.has_object(name):
+            from holado_core.common.exceptions.technical_exception import TechnicalException
+            raise TechnicalException(f"[{self.name}] Context doesn't contain object '{name}'")
+        return self.__objects[name]
+
+    def has_object(self, name):
+        return name in self.__objects
+    
+    def get_object_name(self, obj):
+        for name, value in self.__objects.items():
+            if value is obj:
+                return name
+        return None
+        
+    def remove_lifetimed_object(self, object_id):
+        self._remove(object_id, False)
+        
+    def get_or_create_initilizable_object_by_class(self, object_class):
+        raise NotImplementedError()
+        
+    def get_or_create_object_by_class(self, object_class):
+        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()
+
+