holado 0.2.1__py3-none-any.whl

holado/__init__.py

@@ -0,0 +1,263 @@
+# -*- 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
+
+
+def __initialize_holado_loggers():
+    global logger
+    logger = logging.getLogger(__name__)
+    
+    import holado.common
+    holado.common.initialize_loggers()
+    
+    
+    
+def _initialize_logging(initialize_logging=True, logging_config_file=None, log_level=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(initialize_logging=initialize_logging, log_level=log_level)
+    # print_imported_modules("[after import holado_logging]")
+
+    # Initialize holado loggers
+    __initialize_holado_loggers()
+    
+    # Register LogManager in SessionContext
+    holado_logging.register()
+    
+    # Configure log manager
+    from holado.common.context.session_context import SessionContext
+    SessionContext.instance().log_manager.on_console = log_on_console
+    SessionContext.instance().log_manager.in_file = log_in_file
+    if logging_config_file is not None:
+        SessionContext.instance().log_manager.set_config_file_path(logging_config_file, update_default_level=False)
+    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(TSessionContext=None, initialize_logging=True, logging_config_file=None, 
+               log_level=None, log_on_console=False, log_in_file=True, session_kwargs=None,
+               garbage_collector_periodicity=default_value):
+    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)
+    
+    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)
+
+        from holado.common.context.session_context import SessionContext
+        SessionContext.TSessionContext = TSessionContext
+    
+    # Initialize logging
+    _initialize_logging(initialize_logging=initialize_logging, logging_config_file=logging_config_file,
+                        log_level=log_level, 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")
+    
+    if Tools.do_log(logger, logging.DEBUG):
+        logger.debug("Importing HolAdo modules")
+    import_modules(get_holado_module_names())
+    
+    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)")
+    
+def initialize_for_script(TSessionContext=None, initialize_logging=True, logging_config_file=None, log_level=logging.WARNING, log_on_console=True, log_in_file=False, session_kwargs=None):
+    if session_kwargs is None:
+        session_kwargs={'with_session_path':log_in_file, 'raise_if_not_exist':False}
+        
+    initialize(TSessionContext=TSessionContext, initialize_logging=initialize_logging, logging_config_file=logging_config_file, 
+               log_level=log_level, log_on_console=log_on_console, log_in_file=log_in_file,
+               session_kwargs=session_kwargs )
+    
+    
+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 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(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)
+    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)}")
+            logger.warning(f"Failed to import HolAdo module '{module_name}': {str(exc)} (see debug logs for more details)")
+            pass
+        else:
+            if Tools.do_log(logger, logging.DEBUG):
+                logger.debug(f"Imported HolAdo module '{module_name}'")
+            res[module_name] = module
+    return res
+    
+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(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(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}")
+    
+    

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,145 @@
+
+#################################################
+# 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
+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
+
+def initialize_logger():
+    global logger
+    logger = logging.getLogger(__name__)
+
+
+class Context(DeleteableObject):
+    """
+    @summary: Mother class for any context class
+    """
+    
+    def __init__(self, name):
+        super().__init__(name)
+        self.on_delete_call_gc_collect = True
+        
+        self.__objects = {}
+        self.__on_delete_objects = []
+        
+    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
+        
+        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):
+        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):
+        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:
+            raise ElementNotFoundException(f"[{self.name}] Failed to find object of id {id(obj)}")
+        else:
+            return None
+
+