holado 0.9.3__tar.gz → 0.10.1__tar.gz

{holado-0.9.3 → holado-0.10.1}/PKG-INFO

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

holado-0.10.1/packaging/VERSION

@@ -0,0 +1 @@
+0.10.1

{holado-0.9.3 → holado-0.10.1}/src/holado/__init__.py

@@ -82,8 +82,8 @@ def initialize_minimal():
                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, session_kwargs=None,
-               garbage_collector_periodicity=default_value):
+               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
@@ -113,10 +113,16 @@ def initialize(TSessionContext=None, use_holado_logger=True, logging_config_file
     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
@@ -133,17 +139,29 @@ def initialize(TSessionContext=None, use_holado_logger=True, logging_config_file
     __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):
+                          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_on_console=log_on_console, log_in_file=log_in_file,
-               session_kwargs=session_kwargs,
+               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
     

{holado-0.9.3 → holado-0.10.1}/src/holado/common/context/session_context.py

@@ -295,15 +295,16 @@ class SessionContext(Context):
             scenario_context = ScenarioContext(scenario)
             self.get_feature_context().add_scenario(scenario_context)
             
-            # Set variable with scenario context instance
-            self.get_scenario_context().get_variable_manager().register_variable("SCENARIO_CONTEXT", self.get_scenario_context())
-            
-            # Report
+            # Report: create scenario report
             try:
                 self.report_manager.before_scenario(scenario_context, scenario)
             except:
                 logger.exception(f"{log_prefix}Error while updating report before scenario")
             
+            # Set variable with scenario context instance
+            # Note: must be after scenario report creation
+            self.get_scenario_context().get_variable_manager().register_variable("SCENARIO_CONTEXT", self.get_scenario_context())
+            
             # Behave context
             try:
                 self.behave_manager.before_scenario()

{holado-0.9.3 → holado-0.10.1}/src/holado/holado_config.py

@@ -15,7 +15,10 @@ import logging
 
 class Config(object):
     """HolAdo project configuration"""
-
+    
+    # Application properties
+    application_group = None
+    
     # Timeouts
     session_timeout_seconds = 7 * 24 * 3600     # Session timeout is by default to 7 days
     timeout_seconds = 240            # Default timeout

{holado-0.9.3 → holado-0.10.1}/src/holado_ais/ais/ais_messages.py

@@ -83,7 +83,38 @@ class AISMessages(object):
             message_type = self.__get_message_type(msg_type)
             res = message_type.create(**data)
             return res
-    
+        
+        def decode_nmea_raw_as_dict(self, raw, merge_tag_block_and_message_dicts=False, enum_as_int=False, ignore_spare=True):
+            # Convert NMEA raw to sentences
+            sentences = self.split_raw_to_sentences(raw)
+            
+            # Convert sentences to message type as dict
+            msg = self.decode(*sentences)
+            msg_dict = msg.asdict(enum_as_int=enum_as_int, ignore_spare=ignore_spare)
+            
+            # Extract tagblock of first sentence if present, and add tagblock information in result
+            tag_block_str, _ = self.split_sentence_to_tab_block_and_message(sentences[0])
+            if tag_block_str is None:
+                tag_block_dict = None
+            else:
+                if not isinstance(tag_block_str, bytes):
+                    tag_block_str = tag_block_str.encode('utf8')
+                tag_block = TagBlock(tag_block_str)
+                tag_block.init()
+                tag_block_dict = tag_block.asdict()
+                tag_block_dict = {k:v for k,v in tag_block_dict.items() if k != 'raw' and v is not None}
+            
+            # Build result
+            if merge_tag_block_and_message_dicts:
+                res = msg_dict
+                if tag_block_dict is not None:
+                    res.update(tag_block_dict)
+            elif tag_block_dict is not None:
+                res = (tag_block_dict, msg_dict)
+            else:
+                res = msg_dict
+            return res
+            
         def decode(self, *args, encoded_msg=None, parts_separator=b'\n'):
             if encoded_msg is not None:
                 if isinstance(encoded_msg, str):
@@ -145,7 +176,6 @@ class AISMessages(object):
             seq_id = kwargs.pop('seq_id') if 'seq_id' in kwargs else self.__tag_block_group_id % 10
             group_id = kwargs.pop('group_id') if 'group_id' in kwargs else None
             
-            logger.print(f"+++++++ encode_msg: {msg=} ; {talker_id=} ; {kwargs=}")
             sentences = pyais.encode_msg(msg, seq_id=seq_id, talker_id=talker_id, **kwargs)
             return self.__encode_add_tag_block(sentences, tag_block, with_tag_block=with_tag_block, group_id=group_id)
         
@@ -263,7 +293,7 @@ class AISMessages(object):
         
         res = ais_sentence.split(split_char)
         if len(res) > 1:
-            # Remove part before first '\'
+            # Tag block is present, remove part before first '\'
             del res[0]
         else:
             # Tag block is not present, insert it as None

{holado-0.9.3 → holado-0.10.1}/src/holado_ais/tests/behave/steps/ais/ais_messages_steps.py

@@ -22,6 +22,8 @@ from holado_test.behave.behave import *  # @UnusedWildImport
 from holado_ais.ais.enums import AISMessageType
 from holado_core.common.tools.string_tools import StrTools
 from holado_value.common.tables.converters.value_table_converter import ValueTableConverter
+from holado_core.common.block.function import Function
+from holado_core.common.exceptions.functional_exception import FunctionalException
 
 logger = logging.getLogger(__name__)
 
@@ -148,8 +150,26 @@ if AISMessages.is_available():
         
         __get_variable_manager().register_variable(var_name, res)
     
-    @Step(r"(?P<var_name>{Variable}) = decode NMEA AIS message (?P<encoded_ais_message>{Str})(?P<dictionnary_str> as dictionnary)?")
-    def step_impl(context, var_name, encoded_ais_message, dictionnary_str):
+    @Step(r"(?:(?P<tagblock_var_name>{Variable}), )?(?P<var_name>{Variable}) = decode NMEA AIS raw (?P<ais_raw>{Bytes}|{Str}) as dictionary(?: \((?P<merge_tag_block_and_message_dicts_str>merge tag block and message dictionaries)?\))?")
+    def step_impl(context, tagblock_var_name, var_name, ais_raw, merge_tag_block_and_message_dicts_str):
+        var_name = StepTools.evaluate_variable_name(var_name)
+        ais_raw = StepTools.evaluate_scenario_parameter(ais_raw)
+        merge_tag_block_and_message_dicts = merge_tag_block_and_message_dicts_str is not None
+        
+        res = __get_ais_messages().decode_nmea_raw_as_dict(ais_raw, merge_tag_block_and_message_dicts=merge_tag_block_and_message_dicts)
+        
+        if tagblock_var_name is None:
+            __get_variable_manager().register_variable(var_name, res)
+        else:
+            if len(res) == 2:
+                tb_dict, msg_dict = res
+            else:
+                tb_dict, msg_dict = None, res
+            __get_variable_manager().register_variable(tagblock_var_name, tb_dict)
+            __get_variable_manager().register_variable(var_name, msg_dict)
+    
+    @Step(r"(?P<var_name>{Variable}) = decode NMEA AIS message (?P<encoded_ais_message>{Str})(?P<dictionary_str> as dictionary)?")
+    def step_impl(context, var_name, encoded_ais_message, dictionary_str):
         var_name = StepTools.evaluate_variable_name(var_name)
         encoded_ais_message = StepTools.evaluate_scenario_parameter(encoded_ais_message)
         
@@ -158,7 +178,7 @@ if AISMessages.is_available():
         else:
             res = __get_ais_messages().decode(encoded_msg=encoded_ais_message)
             
-        if dictionnary_str is not None:
+        if dictionary_str is not None:
             res = res.asdict()
             
         __get_variable_manager().register_variable(var_name, res)

{holado-0.9.3 → holado-0.10.1}/src/holado_core/common/tools/path_manager.py

@@ -22,6 +22,7 @@ from datetime import datetime
 from holado_core.common.tools.tools import Tools
 from pathlib import Path
 from holado_python.common.tools.datetime import DateTime
+from holado.holado_config import Config
 
 logger = logging.getLogger(__name__)
 
@@ -162,10 +163,12 @@ class PathManager(object):
         if base_path is None:
             base_path = os.path.join(self.get_user_home_path(), '.holado', 'output')
         
+        res = os.path.join(base_path, "reports")
+        if Config.application_group is not None:
+            res = os.path.join(res, Config.application_group)
         if name is not None:
-            return os.path.join(base_path, "reports", name)
-        else:
-            return os.path.join(base_path, "reports")
+            res = os.path.join(res, name)
+        return res
     
     def chown(self, path, user = None, group = None):
         if user is not None or group is not None:

{holado-0.9.3/src/holado_docker/tools/docker_viewer → holado-0.10.1/src/holado_docker/tools/docker_controller}/server/rest/run.py

@@ -18,8 +18,11 @@ from initialize_holado import insert_holado_source_paths  # @UnresolvedImport
 insert_holado_source_paths(with_test_behave=False)
 
 # Initialize HolAdo
-from holado import initialize_minimal
-initialize_minimal()
+from holado import initialize
+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,
+           config_kwargs={'application_group':'docker_controller'},
+           garbage_collector_periodicity=None)
 
 
 app = connexion.FlaskApp(__name__, pythonic_params=True)

{holado-0.9.3/src/holado_docker/tools/docker_controller → holado-0.10.1/src/holado_docker/tools/docker_viewer}/server/rest/run.py

@@ -18,8 +18,11 @@ from initialize_holado import insert_holado_source_paths  # @UnresolvedImport
 insert_holado_source_paths(with_test_behave=False)
 
 # Initialize HolAdo
-from holado import initialize_minimal
-initialize_minimal()
+from holado import initialize
+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,
+           config_kwargs={'application_group':'docker_viewer'},
+           garbage_collector_periodicity=None)
 
 
 app = connexion.FlaskApp(__name__, pythonic_params=True)

{holado-0.9.3 → holado-0.10.1}/src/holado_logging/common/logging/log_manager.py

@@ -39,6 +39,7 @@ class LogManager(object):
         self.on_console = False
         self.__console_handler = None
         
+        # Manage file handlers
         self.in_file = True
         self.__files_lock = threading.Lock()
         self.__file_names = []
@@ -47,20 +48,26 @@ class LogManager(object):
         self.__root_file_handler = None
         self.__root_file_handler_active = False
         
+        # Manage file paths LIFO by loggers
+        self.__files_by_logger = {}
+        
         # Initialize format according python version
         from holado_multitask.multitasking.multitask_manager import MultitaskManager
         if MultitaskManager.has_thread_native_id():
             # Exists since python 3.8
             # self.format = '{asctime:s} | {thread_native_id:-5d} | {levelname:5s} | {name:50s} | {message:s}'
             self.format = '{asctime:s} | {process:-5d}-{thread_native_id:-5d} | {levelname:5s} | {name:50s} | {message:s}'
+            self.format_short = '{asctime:s} | {message:s}'
             self.style = '{'
         else:
             if sys.version_info > (3, 2):
                 # self.format = '{asctime:s} | {thread:-5d} | {levelname:5s} | {module:35s} | {message:s}'
                 self.format = '{asctime:s} | {process:-5d}-{thread:-5d} | {levelname:5s} | {name:50s} | {message:s}'
+                self.format_short = '{asctime:s} | {message:s}'
                 self.style = '{'
             else: 
                 self.format = '%(asctime)s | %(process)-5d-%(thread)-5d | %(levelname)5s | %(module)35s | %(message)s'
+                self.format_short = '%(asctime)s | %(message)s'
                 self.style = '%'
         
     def configure(self):
@@ -193,7 +200,6 @@ class LogManager(object):
         
     def add_root_file_handler(self):
         from holado_core.common.exceptions.technical_exception import TechnicalException
-        from holado_multitask.multitasking.multitask_manager import MultitaskManager
         
         logger_ = logging.getLogger()
             
@@ -201,13 +207,8 @@ class LogManager(object):
             raise TechnicalException("Root log file is not defined")
             
         if self.__root_file_handler is None:
-            logger_.info("Creating file handler to root file '{}'.".format(self.__root_file_name))
-            Path(os.path.dirname(self.__root_file_name)).mkdir(parents=True, exist_ok=True)
-            
-            self.__root_file_handler = logging.FileHandler(self.__root_file_name, mode='w', encoding='utf8')
-            self.__root_file_handler.setFormatter(logging.Formatter(fmt=self.format, style=self.style))
-            if MultitaskManager.has_thread_native_id():
-                self.__root_file_handler.addFilter(filter_thread_native_id)
+            logger.info("Creating file handler to root file '{}'.".format(self.__root_file_name))
+            self.__root_file_handler = self.__new_file_handler(self.__root_file_name)
             
         logger_.addHandler(self.__root_file_handler)
         self.__root_file_handler_active = True
@@ -215,15 +216,13 @@ class LogManager(object):
     def remove_root_file_handler(self, do_reset=False):
         logger_ = logging.getLogger()
         if self.__root_file_handler:
-            logger_.info(f"Removing log destination to root file '{self.__root_file_name}'.")
+            logger.info(f"Removing log destination to root file '{self.__root_file_name}'.")
             logger_.removeHandler(self.__root_file_handler)
             self.__root_file_handler_active = False
             if do_reset:
                 self.__root_file_handler = None
         
     def add_file_handler(self, file_name, logger_=None):
-        from holado_multitask.multitasking.multitask_manager import MultitaskManager
-        
         if logger_ is None:
             logger_ = logging.getLogger()
             
@@ -232,35 +231,59 @@ class LogManager(object):
             self.add_log_file(file_name)
             
         if file_name in self.__file_handlers:
-            logger_.debug("Log destination already set to file '{}'.".format(file_name))
+            logger.debug("Log destination already set to file '{}'.".format(file_name))
         else:
-            logger_.info("Adding log destination to file '{}'.".format(file_name))
-            Path(os.path.dirname(file_name)).mkdir(parents=True, exist_ok=True)
-            
-            file_handler = logging.FileHandler(file_name, mode='w', encoding='utf8')
-            file_handler.setFormatter(logging.Formatter(fmt=self.format, style=self.style))
-            if MultitaskManager.has_thread_native_id():
-                file_handler.addFilter(filter_thread_native_id)
-            
+            logger.info("Adding log destination to file '{}'.".format(file_name))
+            file_handler = self.__new_file_handler(file_name)
             self.__file_handlers[file_name] = file_handler
-            logger_.addHandler(file_handler)
-                
-    def remove_file_handler(self, file_name, logger_=None, do_remove_log_file=True):
-        from holado_core.common.exceptions.technical_exception import TechnicalException
+            self.add_existing_file_handler_to_logger(file_name, logger_)
+    
+    def __new_file_handler(self, file_path, use_format_short=False):
+        from holado_multitask.multitasking.multitask_manager import MultitaskManager
+        
+        Path(os.path.dirname(file_path)).mkdir(parents=True, exist_ok=True)
+        
+        res = logging.FileHandler(file_path, mode='w', encoding='utf8')
+        fmt = self.format_short if use_format_short else self.format
+        res.setFormatter(logging.Formatter(fmt=fmt, style=self.style))
+        if MultitaskManager.has_thread_native_id():
+            res.addFilter(filter_thread_native_id)
         
+        return res
+    
+    def remove_file_handler(self, file_name, logger_=None, do_remove_log_file=True):
         if logger_ is None:
             logger_ = logging.getLogger()
             
-        if file_name not in self.__file_handlers:
-            raise TechnicalException(f"Not set log destination to file '{file_name}'")
-        
-        logger_.info("Removing log destination to file '{}'.".format(file_name))
-        logger_.removeHandler(self.__file_handlers[file_name])
+        logger.info("Removing log destination to file '{}'.".format(file_name))
+        self.remove_existing_file_handler_from_logger(file_name, logger_)
         del self.__file_handlers[file_name]
         
         if do_remove_log_file:
             self.remove_log_file(file_name)
     
+    def add_existing_file_handler_to_logger(self, file_name, logger_):
+        from holado_core.common.exceptions.technical_exception import TechnicalException
+        
+        if self.__root_file_name == file_name:
+            file_handler = self.__root_file_handler
+        else:
+            if file_name not in self.__file_handlers:
+                raise TechnicalException(f"Not set log destination to file '{file_name}'")
+            file_handler = self.__file_handlers[file_name]
+        logger_.addHandler(file_handler)
+    
+    def remove_existing_file_handler_from_logger(self, file_name, logger_):
+        from holado_core.common.exceptions.technical_exception import TechnicalException
+        
+        if self.__root_file_name == file_name:
+            file_handler = self.__root_file_handler
+        else:
+            if file_name not in self.__file_handlers:
+                raise TechnicalException(f"Not set log destination to file '{file_name}'")
+            file_handler = self.__file_handlers[file_name]
+        logger_.removeHandler(file_handler)
+    
     def __remove_existing_file_handlers(self, log_level_if_exists=None):
         with self.__files_lock:
             if len(self.__file_names) > 0:
@@ -289,5 +312,24 @@ class LogManager(object):
             self.add_root_file_handler()
         self.remove_file_handler(file_name, do_remove_log_file=do_remove_log_file)
     
+    def enter_log_file_for_logger(self, logger_, file_path, use_format_short=False, switch_in=True):
+        logger_name = logger_.name
+        if logger_name not in self.__files_by_logger:
+            self.__files_by_logger[logger_name] = []
+        
+        if switch_in and len(self.__files_by_logger[logger_name]) > 0:
+            logger_.removeHandler(self.__files_by_logger[logger_name][-1][1])
+        
+        file_handler = self.__new_file_handler(file_path, use_format_short=use_format_short)
+        logger_.addHandler(file_handler)
+        self.__files_by_logger[logger_name].append( (file_path, file_handler) )
+        
+    def leave_log_file_for_logger(self, logger_, switch_out=True):
+        logger_name = logger_.name
+        _, file_handler = self.__files_by_logger[logger_name].pop()
+        logger_.removeHandler(file_handler)
+        
+        if switch_out and len(self.__files_by_logger[logger_name]) > 0:
+            logger_.addHandler(self.__files_by_logger[logger_name][-1][1])
     
     

{holado-0.9.3 → holado-0.10.1}/src/holado_multitask/multithreading/context/thread_context.py

@@ -61,7 +61,9 @@ class ThreadContext(Context):
                 
             manager = VariableManager(var_man)
             self.set_object("variable_manager", manager)
-            manager.initialize(SessionContext.instance().dynamic_text_manager, SessionContext.instance().unique_value_manager)
+            file_path = SessionContext.instance().report_manager.get_path("logs", f"variable_update-thread_{self.thread_uid}.log")
+            manager.initialize(SessionContext.instance().dynamic_text_manager, SessionContext.instance().unique_value_manager,
+                               variable_update_log_file_path=file_path)
         return self.get_object("variable_manager")
     
     

{holado-0.9.3 → holado-0.10.1}/src/holado_python/standard_library/queue.py

@@ -61,7 +61,7 @@ class IterableQueue(queue.Queue, typing.Iterable):
     
 
 class IterableLifoQueue(IterableQueue):
-    '''Copyt of implementation of queue.LifoQueue but inheriting of IterableQueue.'''
+    '''Copy of implementation of queue.LifoQueue but inheriting of IterableQueue.'''
 
     def _init(self, maxsize):
         self.queue = []

holado-0.10.1/src/holado_python/standard_library/ssl/resources/certificates/tcpbin.crt

@@ -0,0 +1,21 @@
+-----BEGIN CERTIFICATE-----
+MIIDZTCCAk2gAwIBAgIBKjANBgkqhkiG9w0BAQsFADCBizELMAkGA1UEBhMCVVMx
+CzAJBgNVBAgMAkNBMRYwFAYDVQQHDA1TYW4gRnJhbmNpc2NvMQ8wDQYDVQQKDAZ0
+Y3BiaW4xDDAKBgNVBAsMA29wczETMBEGA1UEAwwKdGNwYmluLmNvbTEjMCEGCSqG
+SIb3DQEJARYUaGFycnliYWdkaUBnbWFpbC5jb20wHhcNMjUxMDE2MjIzNTE5WhcN
+MjUxMDE3MjIzNTE5WjAcMRowGAYDVQQDDBF0Y3BiaW4uY29tLWNsaWVudDCCASIw
+DQYJKoZIhvcNAQEBBQADggEPADCCAQoCggEBAMxmg8CRudZQj9pgRnvPQrWyqn1A
+55RlXoax8OMEeEQHhreCOj69WV6K9OvHebbAtMNCEyXFwNUNX1XjlhhLcqhY5yLR
+5k9vgOoq2ribBwdMRnYyIajWp7y53L/J35Qf2FWNeS+3AXv/mWiYnGpTJZHXCMyo
+wOgDqeqz5wzl8ncvj5HWBkZm/mPDwK6fR/4SXMv+NIBooUKGZTST/1Q75/tvPhwf
+dpGWTUd1xKw3TKz63B+jAATdPbIxTnSxJY1uLdBZ1hUguGxrC+nvqgY0283lVz3n
+Jz7P2BCwmwmgRwBLIUw1381QuFJjGlKSglw/HraIfVyJASQqEk2gVil5Gr8CAwEA
+AaNCMEAwHQYDVR0OBBYEFMQRuiY7hUUnl5wxL6R6gnlhyXaiMB8GA1UdIwQYMBaA
+FOLuMowBSAZfV5v82LmlaIIOvU/DMA0GCSqGSIb3DQEBCwUAA4IBAQBAX/CniZsN
+9YWuDt7CS+YBpLRe46ryZXzmACpmz4uDzRs+3MRnCtOz1121dW0+zuPMdopxwjG2
+GyPirI1mDasoJDn5jRWP1NBvuFN7fcAVsMDi3vBMfzd+oV4Pcgi7uydcd0zX+onp
+1QIyNwAulQB03gfe6IcPAUwyTOtJoc7yo1W6eH/W+RGmj5BaUP+5SB3EHjqih6ds
+xPc4yJ43N1gYsXRZDoYuqmy+/h0JQmFupPJRAbOFbh3IsunbLXvsKXzlrgKlhsCg
+H0Kc97t7ZQNCzgymNnxsbepNddWwGF8hAj4FruFYtO9rt00aT2bqb9Yw4pRJ+fM8
+nDVx1r7BCieF
+-----END CERTIFICATE-----

holado-0.10.1/src/holado_python/standard_library/ssl/resources/certificates/tcpbin.key

@@ -0,0 +1,28 @@
+-----BEGIN PRIVATE KEY-----
+MIIEvQIBADANBgkqhkiG9w0BAQEFAASCBKcwggSjAgEAAoIBAQDMZoPAkbnWUI/a
+YEZ7z0K1sqp9QOeUZV6GsfDjBHhEB4a3gjo+vVleivTrx3m2wLTDQhMlxcDVDV9V
+45YYS3KoWOci0eZPb4DqKtq4mwcHTEZ2MiGo1qe8udy/yd+UH9hVjXkvtwF7/5lo
+mJxqUyWR1wjMqMDoA6nqs+cM5fJ3L4+R1gZGZv5jw8Cun0f+ElzL/jSAaKFChmU0
+k/9UO+f7bz4cH3aRlk1HdcSsN0ys+twfowAE3T2yMU50sSWNbi3QWdYVILhsawvp
+76oGNNvN5Vc95yc+z9gQsJsJoEcASyFMNd/NULhSYxpSkoJcPx62iH1ciQEkKhJN
+oFYpeRq/AgMBAAECggEAUKjruSRIl6A3BFAVwGnrw1P8H21rdY4DHVg+3Pc4lm/5
+45TKc1O5XqurNxgCmfG144/BiphdHjYmtvgWlQPA/VoH7B+0qQgxcTb0FQFoZqLc
+82uZCM2cZ8dYq354cjWW4zvu5LttJIea/EGtB/BD1SdsW4cEiQpZFTtlJBvh8NHo
+7+o0mPwwBrXmadsLlxDmhQ0Wsw4ltaK7eMBJlLalg9f/3uW4ArW0OXVK1ycszNXM
+2pfrp9zKYcPzWEP+wrC/6f+AXFDacUIzwxsfNtlI7O57t8pQXf5pkyeBHHlxCvN/
+XYx+UBWip6tRnlZRqNvl/8NC0JpX9P8xaeNp21haAQKBgQD1rlkZ9umlmC9PB5oc
+Tp00KC5KQmgfqRfEBEVzmm4yGHK0OMx0pCnP/ZONZaE4QX4TmeLCnUxgYCdxl6ep
+406g0i2ig7M+RZ18skh4ubpoiQlLIoNW2mOpV/Hzt53st0HAYogPubrVZAnn/KwA
+zehlj0w1yljBXDsK9c6deCdIgQKBgQDU/E12s8aCC0ngOSZqe0lkDWU/yQfX8BnJ
+cSA3dU1mwGzP+02N5AXZuxwUql1rjE45ERPISQ2+eHtUk3n7QH0+7KNRmj7Jk9xC
+QIN5lExdO3tAXo/muH6PCkyeNrkRSdfNgssYMVJZqbD8O5IM6v6yEbQHOxuskvvu
+uWRxQZTDPwKBgEfqcUqYbGx8z9xibUo7+Oh7mpFCPxiFdt96IJpmajtfzLPUrIS4
+SUUJBVgul7LP+Qfj0+0D/od3nhQyQHIKh8mrvJAF3UItPpxx06UDOP3An2fPAoM6
+ClJX3AtrhF72hdi6/vkbdQVh80RlQjQ6Ef0opTZZtQFk7iOXMJQHx/gBAoGAahxl
+T41Tifirzq1KaWSQ9OsDlZrHcJrrjgPxZA/qBxY5YAk440dGbuqcm+Mg9fMKCb5r
+V66lzU5jS4jKDhZcD9x/pakuPOmQo+VWW106Cn0W88Po967VRth/wZdL7sQWYwoV
+uzDfcVJsnc3j/tGZIQhW4/9b00fLgm0VEKP2xKsCgYEAkylyhMcTA9nuiBGecBFW
+fRbuL6tWcnj3b8lnNOoBFTp6uVSi7VTYcZttGP7zLa9v/LRegawpf1meOarn80Wo
+pz1Ot3ZEgx6iArdgdejSHbps58dTpoXp6YBlZR08G5tw2aHfppJYq2Vz3RLrv5Kf
+k6MQ4yJFgkb+8+cpvp3NxgA=
+-----END PRIVATE KEY-----

{holado-0.9.3 → holado-0.10.1}/src/holado_scripting/__init__.py

@@ -27,7 +27,8 @@ def register():
     from holado_scripting.common.tools.variable_manager import VariableManager
     SessionContext.instance().services.register_service_type("variable_manager", VariableManager,
                             lambda m: m.initialize(SessionContext.instance().dynamic_text_manager, 
-                                                   SessionContext.instance().unique_value_manager) )
+                                                   SessionContext.instance().unique_value_manager,
+                                                   variable_update_log_file_path=SessionContext.instance().report_manager.get_path("logs", "variable_update.log") ) )
     
     
     from holado_scripting.common.tools.expression_evaluator import ExpressionEvaluator

{holado-0.9.3 → holado-0.10.1}/src/holado_scripting/common/tools/variable_manager.py

@@ -22,8 +22,10 @@ from typing import NamedTuple
 import threading
 from holado.common.tools.gc_manager import GcManager
 from holado_python.standard_library.typing import Typing
+from holado.common.context.session_context import SessionContext
 
 logger = logging.getLogger(__name__)
+# logger_update = logging.getLogger(__name__ + ".update")
 
 
 class VariableManager(DeleteableObject):
@@ -46,9 +48,22 @@ class VariableManager(DeleteableObject):
         self.__temporary_variables_lock = threading.Lock()
         self.__temporary_variables = {}
         
-    def initialize(self, dynamic_text_manager, unique_value_manager):
+        # Manage variable update log file
+        self.__variable_update_log_file_path = None
+        self.__is_entered_in_variable_update_log_file = False
+        self.__logger_update = logging.getLogger(__name__ + f".update.{id(self)}")
+    
+    def initialize(self, dynamic_text_manager, unique_value_manager, variable_update_log_file_path=None):
+        """ Initialize variable manager
+        @param dynamic_text_manager Dynamic text manager instance to use
+        @param unique_value_manager Unique value manager instance to use
+        @param variable_update_log_filename If defined, log all variable updates in given file in addition to normal logs
+        """
         self.__dynamic_text_manager = dynamic_text_manager
         self.__unique_value_manager = unique_value_manager
+        
+        # Manage variable update log file
+        self.__variable_update_log_file_path = variable_update_log_file_path
     
     @property
     def parent(self):
@@ -71,6 +86,19 @@ class VariableManager(DeleteableObject):
         # # Clear variables
         # self.__variables.clear()
         
+        # Leave variable update log file
+        self.__leave_variable_update_log_file()
+    
+    def __enter_variable_update_log_file(self):
+        if self.__variable_update_log_file_path is not None and not self.__is_entered_in_variable_update_log_file:
+            SessionContext.instance().log_manager.enter_log_file_for_logger(self.__logger_update, self.__variable_update_log_file_path, use_format_short=True)
+            self.__is_entered_in_variable_update_log_file = True
+    
+    def __leave_variable_update_log_file(self):
+        if self.__variable_update_log_file_path is not None and self.__is_entered_in_variable_update_log_file:
+            SessionContext.instance().log_manager.leave_log_file_for_logger(self.__logger_update)
+            self.__is_entered_in_variable_update_log_file = False
+    
     @contextmanager
     def temporary_variables(self):
         from holado_multitask.multitasking.multitask_manager import MultitaskManager
@@ -125,6 +153,7 @@ class VariableManager(DeleteableObject):
     def register_variable(self, variable_name, value, accept_expression=True, log_level=logging.INFO):
         from holado_multitask.multitasking.multitask_manager import MultitaskManager
         
+        self.__enter_variable_update_log_file()
         if Tools.do_log(logger, logging.TRACE):  # @UndefinedVariable
             logger.trace(f"Setting variable: {variable_name}=[{value}] (type: {Typing.get_object_class_fullname(value)})...")
         
@@ -134,13 +163,13 @@ class VariableManager(DeleteableObject):
                 self.register_variable(names[0], Object())
             var = self.get_value(names[0], through_patent=False)
             setattr(var, names[1], value)
-            if Tools.do_log(logger, log_level):
-                logger.log(log_level, f"Set variable expression: {variable_name}=[{value}] (type: {Typing.get_object_class_fullname(value)})")
+            if Tools.do_log(self.__logger_update, log_level):
+                self.__logger_update.log(log_level, f"Set variable expression: {variable_name}=[{value}] (type: {Typing.get_object_class_fullname(value)})")
         else:
             var_name = self.evaluate_variable_name(variable_name)
             self.__variables[var_name] = value
-            if Tools.do_log(logger, log_level):
-                logger.log(log_level, f"Set variable: {var_name}=[{value}] (type: {Typing.get_object_class_fullname(value)})")
+            if Tools.do_log(self.__logger_update, log_level):
+                self.__logger_update.log(log_level, f"Set variable: {var_name}=[{value}] (type: {Typing.get_object_class_fullname(value)})")
                 
             # Manage temporary variables
             uid = MultitaskManager.get_thread_uid()
@@ -149,6 +178,8 @@ class VariableManager(DeleteableObject):
                     self.__temporary_variables[uid].variable_names.add(var_name)
                 
     def unregister_variable(self, variable_name, through_parent=False, delete_value=False):
+        self.__enter_variable_update_log_file()
+        
         var_name = self.evaluate_variable_name(variable_name)
         if self.exists_variable(var_name, through_parent=False):
             value = self.__variables[var_name]
@@ -161,8 +192,8 @@ class VariableManager(DeleteableObject):
                 except Exception:
                     logger.exception(f"Catched exception while deleting object '{var_name}' (type: {Typing.get_object_class_fullname(value)})")
                 else:
-                    if Tools.do_log(logger, logging.DEBUG):
-                        logger.debug(f"Deleted variable '{var_name}' (type: {Typing.get_object_class_fullname(value)})")
+                    if Tools.do_log(self.__logger_update, logging.DEBUG):
+                        self.__logger_update.debug(f"Deleted variable '{var_name}' (type: {Typing.get_object_class_fullname(value)})")
             
             del self.__variables[var_name]
         elif through_parent and self.parent:
@@ -270,6 +301,8 @@ class VariableManager(DeleteableObject):
             Tools.raise_same_exception_type(exc, f"{exc}\nVariable '{var_name}': {var_repr}", add_from=True)
     
     def exec_set_variable_expression(self, expression, value, through_parent=True, log_level=logging.INFO):
+        self.__enter_variable_update_log_file()
+        
         var_name, expr_rest = self.__extract_expression_name(expression)
         var_value = self.get_variable_value(var_name, through_parent=through_parent)
         new_var_name = self.new_local_variable_name(sub_name=self.__regular_variable_name(var_name))
@@ -289,8 +322,8 @@ class VariableManager(DeleteableObject):
             # Tools.raise_same_exception_type(exc, f"{exc}\nVariable '{var_name}': {var_repr}", add_from=True)
             raise FunctionalException(f"Failed to set value in variable expression (by exec): {expression}=[{value}] (type: {Typing.get_object_class_fullname(value)})\nVariable '{var_name}': {var_repr}") from exc
         else:
-            if Tools.do_log(logger, log_level):
-                logger.log(log_level, f"Set value in variable expression (by exec): {expression}=[{value}] (type: {Typing.get_object_class_fullname(value)})")
+            if Tools.do_log(self.__logger_update, log_level):
+                self.__logger_update.log(log_level, f"Set value in variable expression (by exec): {expression}=[{value}] (type: {Typing.get_object_class_fullname(value)})")
     
     def __regular_variable_name(self, name):
         return "".join([c if re.match(r'\w', c) else '_' for c in name])