holado 0.2.4__tar.gz → 0.2.6__tar.gz

{holado-0.2.4 → holado-0.2.6}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: holado
-Version: 0.2.4
+Version: 0.2.6
 Summary: HolAdo framework
 Project-URL: Homepage, https://gitlab.com/holado_framework/python
 Project-URL: Issues, https://gitlab.com/holado_framework/python/-/issues

holado-0.2.6/packaging/VERSION

@@ -0,0 +1 @@
+0.2.6

{holado-0.2.4 → holado-0.2.6}/src/holado/__init__.py

@@ -27,7 +27,7 @@ except:
     with_behave = False
 
 logger = None
-
+__initialized = False
 
 def __initialize_holado_loggers():
     global logger
@@ -38,27 +38,29 @@ def __initialize_holado_loggers():
     
     
     
-def _initialize_logging(initialize_logging=True, logging_config_file=None, log_level=None, log_on_console=False, log_in_file=True):
+def _initialize_logging(use_holado_logger=True, logging_config_file_path=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)
+    holado_logging.configure(use_holado_logger=use_holado_logger, logging_config_file_path=logging_config_file_path, log_level=log_level, 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()
     
-    # Register LogManager in SessionContext
-    holado_logging.register()
-    
-    # Configure log manager
+    # Create session context
     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)
+    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):
@@ -70,54 +72,78 @@ def change_logging_config(log_level=None, log_on_console=False, log_in_file=True
 
 
 def initialize_minimal():
-    _initialize_logging(initialize_logging=False, logging_config_file=None,
-                        log_level=None, log_on_console=True, log_in_file=False)
+    # 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_on_console=True, log_in_file=False,
+               garbage_collector_periodicity=None)
 
-def initialize(TSessionContext=None, initialize_logging=True, logging_config_file=None, 
+def initialize(TSessionContext=None, use_holado_logger=True, logging_config_file_path=None, 
                log_level=None, log_on_console=False, log_in_file=True, 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)
-
-        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,
+    _initialize_logging(use_holado_logger=use_holado_logger, logging_config_file_path=logging_config_file_path,
                         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())
+    _import_modules(get_holado_module_names())
     
-    initialize_session_context(session_kwargs)
+    _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 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_on_console=True, log_in_file=False, 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, initialize_logging=initialize_logging, logging_config_file=logging_config_file, 
+    initialize(TSessionContext=TSessionContext, use_holado_logger=use_holado_logger, logging_config_file_path=logging_config_file_path, 
                log_level=log_level, log_on_console=log_on_console, log_in_file=log_in_file,
-               session_kwargs=session_kwargs )
+               session_kwargs=session_kwargs,
+               garbage_collector_periodicity=garbage_collector_periodicity )
     
     
-def initialize_session_context(session_kwargs=None):
+def _initialize_session_context(session_kwargs=None):
     from holado_core.common.tools.tools import Tools
     
     if Tools.do_log(logger, logging.DEBUG):
@@ -130,10 +156,18 @@ def initialize_session_context(session_kwargs=None):
     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__))
-    return os.path.normpath(os.path.join(here, "..", ".."))
+    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__))
@@ -143,7 +177,7 @@ 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):
+def _import_modules(module_names):
     from holado_core.common.tools.tools import Tools
     
     imported_modules = __import_modules(module_names)
@@ -272,6 +306,8 @@ def print_imported_modules(prefix):
     
 
 # Process minimal initialization of HolAdo
-initialize_minimal()
+# 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-0.2.4 → holado-0.2.6}/src/holado/common/context/service_manager.py

@@ -170,13 +170,21 @@ class ServiceManager(object):
         return context.get_object(name)
     
     def add_context_property(self, name, context_type, raise_if_service_exist=None):
-        if raise_if_service_exist is None or raise_if_service_exist:
-            self.__verify_service_doesnt_exist(name, context_type, raise_if_service_exist)
+        # Note: next lines are commented, to allow to set again the service in context type
+        # if raise_if_service_exist is None or raise_if_service_exist:
+        #     self.__verify_service_doesnt_exist(name, context_type, raise_if_service_exist)
+        if hasattr(context_type, name):
+            logger.debug(f"Set again the property '{name}' in context type {context_type}")
         
         @property
         def context_service_property(self_context):
             return self._get_context_service(name, self_context)
         setattr(context_type, name, context_service_property)
+        
+        @property
+        def context_has_service_property(self_context):
+            return self_context.has_object(name)
+        setattr(context_type, 'has_' + name, context_has_service_property)
     
     def add_shortcut_property_to_context_service(self, name, dst_type, context_type, raise_if_service_exist=None):
         from holado_multitask.multiprocessing.context.process_context import ProcessContext

{holado-0.2.4 → holado-0.2.6}/src/holado/common/context/session_context.py

@@ -18,6 +18,7 @@ import os.path
 from holado.common.context.context import Context
 from holado_core.common.tools.tools import Tools
 import threading
+from holado.common.handlers.enums import ObjectStates
 
 
 logger = logging
@@ -32,16 +33,37 @@ class SessionContext(Context):
     
     # Singleton management
     __instance = None
+    __is_resetting_instance = False
     
     @staticmethod
     def instance() -> TSessionContext:
+        # Note: If session context istance is under reset, consider it is already None
+        if SessionContext.__is_resetting_instance:
+            return None
+        
         if SessionContext.__instance is None:
             SessionContext.__instance = SessionContext.TSessionContext()
-            # print(f"Created session context of type {SessionContext.TSessionContext}")
+            logger.debug(f"Created session context of type {SessionContext.TSessionContext}")
+            # logging.log(45, f"Created session context of type {SessionContext.TSessionContext}")
             # import traceback
-            # print("".join(traceback.format_list(traceback.extract_stack())))
+            # logging.log(45, "".join(traceback.format_list(traceback.extract_stack())))
         return SessionContext.__instance
     
+    @staticmethod
+    def has_instance() -> bool:
+        if SessionContext.__is_resetting_instance:
+            return False
+        else:
+            return SessionContext.__instance is not None
+    
+    @staticmethod
+    def _reset_instance():
+        if SessionContext.__instance is not None:
+            logger.debug(f"Resetting session context")
+            SessionContext.__is_resetting_instance = True
+            SessionContext.__instance = None
+            SessionContext.__is_resetting_instance = False
+            logger.debug(f"Reset of session context")
     
     def __init__(self, name="Session"):
         super().__init__(name)
@@ -55,12 +77,27 @@ class SessionContext(Context):
         self.__multitask_lock = threading.RLock()
         self.__multitask_step_lock = threading.RLock()
         
+    def __del__(self):
+        # Note: Override Object.__del__ since it supposes that SessionContext is initialized, whereas SessionContext is deleting
+        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):
+                # Simply return
+                return
+            else:
+                raise exc
+    
     def _delete_object(self):
-        logger.info(f"Delete session context - Interrupting and unregistering all threads...")
         # if Tools.do_log(logger, logging.DEBUG):
         #     logger.debug("Interrupting and unregistering all threads for scenario [{}]".format(scenario.name))
-        self.threads_manager.interrupt_all_threads(scope="Session")
-        self.threads_manager.unregister_all_threads(scope="Session", keep_alive=False)
+        if self.has_threads_manager:
+            logger.info(f"Delete session context - Interrupting and unregistering all threads...")
+            self.threads_manager.interrupt_all_threads(scope="Session")
+            self.threads_manager.unregister_all_threads(scope="Session", keep_alive=False)
         
         # Delete session context
         logger.info(f"Delete session context - Deleting context objects...")
@@ -76,11 +113,6 @@ class SessionContext(Context):
             
         self.__with_session_path = session_kwargs.get("with_session_path", True)
         
-        # 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()
-        
         # Create this thread context
         self.multitask_manager.get_thread_context()
     
@@ -122,14 +154,13 @@ class SessionContext(Context):
             name = "session_{}".format(datetime.now().strftime("%Y-%m-%d_%H-%M-%S"))
             report_path = self.path_manager.get_reports_path(name)
             logger.info(f"Reports location: {report_path}")
-            # print(f"Reports location: {report_path}")
+            print(f"Reports location: {report_path}")
         self.report_manager.new_session(report_path)
             
         # Logging configuration
         if self.with_session_path and SessionContext.instance().log_manager.in_file:
             log_filename = os.path.join(report_path, "logs", "report.log")
             self.path_manager.makedirs(log_filename)
-            SessionContext.instance().log_manager.on_console = False
             SessionContext.instance().log_manager.set_root_log_file(log_filename)
             SessionContext.instance().log_manager.set_config()
     

{holado-0.2.4 → holado-0.2.6}/src/holado/common/handlers/object.py

@@ -14,7 +14,6 @@
 from builtins import object
 import logging
 from holado.common.handlers.enums import ObjectStates
-from holado.common.tools.gc_manager import GcManager
 
 logger = None
 
@@ -66,15 +65,24 @@ class DeleteableObject(Object):
     
     def __del__(self):
         try:
-            from holado_multitask.multithreading.functionthreaded import FunctionThreaded
-            
             if self.object_state in [ObjectStates.Deleting, ObjectStates.Deleted]:
                 return
             
-            # Note: Garbage collector default mecanism is incompatible with custom object finalizers (cf GcManager.Method __del__ is called by garbage collector. This call can be done in any thread at any moment.
-            if GcManager.is_collect_threaded():
+            if logger.isEnabledFor(logging.DEBUG):
+                logger.debug(f"Deleting object of ID {id(self)} and type {type(self)}")
+            if logger.isEnabledFor(logging.TRACE):  # @UndefinedVariable
+                import traceback
+                logger.trace("".join(traceback.format_list(traceback.extract_stack())))
+            
+            # Notes: 
+            #   - Garbage collector default mecanism is incompatible with custom object finalizers (cf GcManager.Method __del__ is called by garbage collector. This call can be done in any thread at any moment.
+            #   - When SessionContext is under deletion, delete any object by thread is not possible
+            from holado.common.context.session_context import SessionContext
+            from holado.common.tools.gc_manager import GcManager
+            if GcManager.is_collect_threaded() or isinstance(self, SessionContext.TSessionContext) or not SessionContext.has_instance():
                 self.__delete()
             else:
+                from holado_multitask.multithreading.functionthreaded import FunctionThreaded
                 func = FunctionThreaded(self.__delete, name=f"delete object '{self.name}'", register_thread=False)
                 func.start()
                 func.join(timeout=30, raise_if_still_alive=False)   # timeout of 30s to limit deadlock impact ; raise to False since exceptions are omitted in gc collect context
@@ -128,6 +136,7 @@ class DeleteableObject(Object):
         
         # Call garbage collector
         if self.__on_delete_gc_collect:
+            from holado.common.tools.gc_manager import GcManager
             GcManager.collect()
         
         self.object_state = ObjectStates.Deleted

{holado-0.2.4 → holado-0.2.6}/src/holado/common/handlers/undefined.py

@@ -11,13 +11,21 @@
 #################################################
 
 import logging
+from holado.common.handlers.object import Object
 
 logger = logging.getLogger(__name__)
 
 
-class Undefined(object):
-    def __init__(self, undefined_value=0):
+class Undefined(Object):
+    def __init__(self, name, undefined_value=0):
+        super().__init__(name)
         self.__value = undefined_value
+    
+    def __str__(self)->str:
+        if self.name is not None:
+            return f"<{self.name}>"
+        else:
+            return super().__str__()
 
 def is_undefined(obj):
     return isinstance(obj, Undefined)
@@ -25,15 +33,17 @@ def is_undefined(obj):
 
 # Define specific undefined objects
 
-undefined_argument = Undefined(0)
-undefined_value = Undefined(1)
+undefined_argument = Undefined("Undefined argument", 0)
+undefined_value = Undefined("Undefined value", 1)
+not_applicable = Undefined("Not Applicable", 2)
+to_be_defined = Undefined("To be defined", 3)               # Usage: initial variable value defining it is to be defined. It is useful when undefined_value can be a possible value.
 
 
 
 # Define specific default values
 # Note: Real value is defined by methods managing these values as argument.
 
-default_value = Undefined(2)
-default_context = Undefined(3)      # Example of real value: for ThreadsManager it means "current ScenarioContext" if a scenario context exists else "SessionContext".
+default_value = Undefined("Default value", 10)
+default_context = Undefined("Defautl context", 11)      # Example of real value: for ThreadsManager it means "current ScenarioContext" if a scenario context exists else "SessionContext".
 
 

{holado-0.2.4 → holado-0.2.6}/src/holado/holado_config.py

@@ -16,6 +16,7 @@ class Config(object):
     """HolAdo project configuration"""
 
     # Timeouts
+    session_timeout_seconds = 7 * 24 * 3600     # Session timeout is by default to 7 days
     timeout_seconds = 240            # Default timeout
     join_timeout_seconds = 1800      # Long timeout used when a join should stop without deadlock. When this timeout is reached, a TimeoutTechnicalException is raised
 

{holado-0.2.4 → holado-0.2.6}/src/holado_core/common/block/scope_steps.py

@@ -107,7 +107,7 @@ class ScopeWhileSteps(ScopeSteps):
         self._process_start()
         try:
             n = 0
-            cond = self.__expression_evaluator.evaluate_python_expression(self.__condition_expression)
+            _, cond = self.__expression_evaluator.evaluate_python_expression(self.__condition_expression)
             if not (isinstance(cond, bool) or Converter.is_boolean(cond)):
                 raise FunctionalException(f"Condition expression is not a boolean: [{self.__condition_expression}] => [{cond}] (type: {Typing.get_object_class_fullname(cond)})")
             
@@ -129,7 +129,7 @@ class ScopeWhileSteps(ScopeSteps):
                     if self.__scope_manager:
                         self.__scope_manager.reset_scope_level("steps", origin_level)
                 
-                cond = self.__expression_evaluator.evaluate_python_expression(self.__condition_expression)
+                _, cond = self.__expression_evaluator.evaluate_python_expression(self.__condition_expression)
                 if not (isinstance(cond, bool) or Converter.is_boolean(cond)):
                     raise FunctionalException(f"Condition expression is not a boolean: [{self.__condition_expression}] => [{cond}] (type: {Typing.get_object_class_fullname(cond)})")
         finally:

{holado-0.2.4 → holado-0.2.6}/src/holado_core/common/resource/persisted_method_to_call_manager.py

@@ -108,13 +108,13 @@ class PersistedMethodToCallManager(PersistedDataManager):
         self.delete_persisted_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'])
+        _, 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'])
+            _, 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'])

{holado-0.2.4 → holado-0.2.6}/src/holado_core/common/tools/path_manager.py

@@ -122,10 +122,14 @@ class PathManager(object):
         else:
             os.replace(src, dst)
     
+    def get_user_home_path(self):
+        import pathlib
+        return str(pathlib.Path.home())
+    
     def get_local_resources_path(self, name=None):
-        base_path = os.getenv('HOLADO_TEST_LOCAL_RESOURCES_BASEDIR')
+        base_path = os.getenv('HOLADO_LOCAL_RESOURCES_BASEDIR')
         if base_path is None:
-            raise Exception("Missing environment variable HOLADO_TEST_LOCAL_RESOURCES_BASEDIR with HolAdo local resources base path")
+            base_path = os.path.join(self.get_user_home_path(), '.holado', 'resources')
         
         if name is not None:
             return os.path.join(base_path, name)
@@ -133,9 +137,9 @@ class PathManager(object):
             return base_path
     
     def get_reports_path(self, name=None):
-        base_path = os.getenv('HOLADO_TEST_OUTPUT_BASEDIR')
+        base_path = os.getenv('HOLADO_OUTPUT_BASEDIR')
         if base_path is None:
-            raise Exception("Missing environment variable HOLADO_TEST_OUTPUT_BASEDIR with HolAdo output base path")
+            base_path = os.path.join(self.get_user_home_path(), '.holado', 'output')
         
         if name is not None:
             return os.path.join(base_path, "reports", name)

{holado-0.2.4 → holado-0.2.6}/src/holado_core/common/tools/tools.py

@@ -90,12 +90,17 @@ class Tools(object):
                 
                 if Converter.is_dict(obj):
                     # logger.print(f"+++++ Tools.__represent_object: is dict")
-                    res_list = [f"{str(type(obj))}({id_obj})"] if full_details else [""]
+                    res_list = [f"{str(type(obj))}({id_obj})"] if full_details else []
                     # keys = sorted(value.keys())
                     keys = list(obj.keys())
                     for key in keys:
                         # logger.print(f"+++++ Tools.__represent_object:     key: {key}")
-                        res_list.append(f"    {key}: {cls.__represent_object(obj[key], 4, False, full_details, access_type, _internal)}")
+                        val_str = cls.__represent_object(obj[key], 0, True, full_details, access_type, _internal)
+                        if '\n' in val_str:
+                            res_list.append(f"    {key}:")
+                            res_list.append(Tools.indent_string(4, val_str))
+                        else:
+                            res_list.append(f"    {key}: {val_str}")
                     res = "\n".join(res_list)
                 elif Converter.is_list(obj):
                     # logger.print(f"+++++ Tools.__represent_object: is list")
@@ -104,7 +109,13 @@ class Tools(object):
                     for el in obj:
                     # for index, el in enumerate(obj):
                     #     logger.print(f"+++++ Tools.__represent_object:     index: {index}")
-                        res_list.append(cls.__represent_object(el, 4, True, full_details, access_type, _internal))
+                        el_str = cls.__represent_object(el, 0, True, full_details, access_type, _internal)
+                        if '\n' in el_str:
+                            res_list.append("    {")
+                            res_list.append(Tools.indent_string(4, el_str))
+                            res_list.append("    }")
+                        else:
+                            res_list.append(f"    {el_str}")
                     if not full_details:
                         res_list.append("]")
                     res = "\n".join(res_list)
@@ -141,13 +152,19 @@ class Tools(object):
         return res
     
     @classmethod
-    def do_log(cls, logger, log_level):
-        return logger.isEnabledFor(log_level)
+    def do_log_level(cls, log_level, max_log_level):
+        """Define the log level to use: if log_level is greater than max_log_level, return max_log_level.
+        """
+        return min(log_level, max_log_level)
     
     @classmethod
-    def do_log_if_objects_are_different(cls, logger, log_level, obj1, obj2):
+    def do_log(cls, logger, log_level, max_log_level=logging.CRITICAL):
+        return logger.isEnabledFor(cls.do_log_level(log_level, max_log_level))
+    
+    @classmethod
+    def do_log_if_objects_are_different(cls, logger, log_level, obj1, obj2, max_log_level=logging.CRITICAL):
         try:
-            return cls.do_log(logger, log_level) and (obj1 != obj2)
+            return cls.do_log(logger, log_level, max_log_level) and (obj1 != obj2)
         except Exception as exc:
             if Tools.do_log(logger, logging.TRACE):  # @UndefinedVariable
                 logger.trace(f"Assume a log is needed since usually a comparison fails on mismatching types and thus objects are different. Obtained error: {exc}")

holado-0.2.6/src/holado_examples/scripts/script_custom_initialization.py

@@ -0,0 +1,16 @@
+import holado
+
+
+# Initialize HolAdo with default behaviours and custom parameters
+
+holado.initialize_for_script(log_on_console=True, log_in_file=True)
+
+import logging
+logging.print("After 'holado.initialize_for_script(log_on_console=True, log_in_file=True)', HolAdo is initialized for scripts with:")
+logging.print("  - add logging levels 'trace' and 'print'")
+logging.print("  - do logs on console and in file")
+logging.print("  - a default session context is initialialized with all available HolAdo services")
+logging.print("  - a session folder is created that will contains at least log files")
+logging.print("  - launch garbage collector periodically (without specifying garbage_collector_periodicity, default periodicity is 10 s)")
+
+

holado-0.2.6/src/holado_examples/scripts/script_minimal_initialization.py

@@ -0,0 +1,23 @@
+import holado
+
+
+# Minimal HolAdo initialization for scripts
+holado.initialize_for_script()
+
+import logging
+logging.print("After 'holado.initialize_for_script()', HolAdo is initialized minimally for scripts with:")
+logging.print("  - add logging levels 'trace' and 'print'")
+logging.print("  - do logs on console but not in file")
+logging.print("  - a default session context is initialialized with all available HolAdo services")
+logging.print("  - no session folder is created")
+
+
+# Launch manually garbage collector periodically
+from holado.common.tools.gc_manager import GcManager
+from holado.common.handlers.undefined import default_value
+GcManager.collect_periodically(collect_periodicity=default_value) 
+logging.print("After 'GcManager.collect_periodically(collect_periodicity=default_value)', garbage collector is launched periodically (with default periodicity that is 10 s)")
+
+
+
+

holado-0.2.6/src/holado_examples/tests/behave/testing_solution/__main__.py

@@ -0,0 +1,13 @@
+# -*- coding: utf-8 -*-
+
+
+# This main is only needed to debug behave execution (and thus testing solution) with breakpoints
+
+import re
+import sys
+
+from behave.__main__ import main
+
+if __name__ == '__main__':
+    sys.argv[0] = re.sub(r'(-script\.pyw?|\.exe)?$', '', sys.argv[0])
+    sys.exit(main())

holado-0.2.6/src/holado_examples/tests/behave/testing_solution/behave_environment.py

@@ -0,0 +1,35 @@
+# -*- coding: utf-8 -*-
+
+import holado_test.behave.behave_environment
+
+
+# Import default hook implementation
+from holado_test.behave.behave_environment import *
+
+# Redefine specific hook implementation
+def before_all(context):
+    holado_test.behave.behave_environment.before_all(context)
+
+def after_all(context):
+    holado_test.behave.behave_environment.after_all(context)
+
+def before_feature(context, feature):
+    holado_test.behave.behave_environment.before_feature(context, feature)
+
+def after_feature(context, feature):
+    holado_test.behave.behave_environment.after_feature(context, feature)
+
+def before_scenario(context, scenario):
+    holado_test.behave.behave_environment.before_scenario(context, scenario)
+
+def after_scenario(context, scenario):
+    holado_test.behave.behave_environment.after_scenario(context, scenario)
+
+def before_step(context, step):
+    holado_test.behave.behave_environment.before_step(context, step)
+
+def after_step(context, step):
+    holado_test.behave.behave_environment.after_step(context, step)
+
+    
+