holado 0.2.4__py3-none-any.whl → 0.2.6__py3-none-any.whl

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/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/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/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/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/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.dist-info → holado-0.2.6.dist-info}/METADATA

@@ -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