holado 0.10.0__tar.gz → 0.10.1__tar.gz

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: holado
-Version: 0.10.0
+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.10.0 → 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.10.0 → holado-0.10.1}/src/holado_ais/ais/ais_messages.py

@@ -94,13 +94,14 @@ class AISMessages(object):
             
             # 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 not isinstance(tag_block_str, bytes):
-                tag_block_str = tag_block_str.encode('utf8')
-            logger.print(f"++++++++++++ {tag_block_str=}")
-            tag_block = TagBlock(tag_block_str)
-            tag_block.init()
-            tag_block_dict = tag_block.asdict() if tag_block is not None else None
-            if tag_block_dict is not None:
+            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
@@ -175,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)
         

{holado-0.10.0 → 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.10.0 → 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.10.0 → 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.10.0 → 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.10.0 → 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])

{holado-0.10.0 → holado-0.10.1}/src/holado_test/common/context/feature_context.py

@@ -73,7 +73,9 @@ class FeatureContext(Context):
         if not self.has_variable_manager():
             manager = VariableManager(SessionContext.instance().multitask_manager.get_thread_context().get_variable_manager())
             self.set_object("variable_manager", manager)
-            manager.initialize(SessionContext.instance().dynamic_text_manager, SessionContext.instance().unique_value_manager)
+            file_path = SessionContext.instance().report_manager.current_feature_report.get_path("logs", "variable_update.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.10.0 → holado-0.10.1}/src/holado_test/common/context/scenario_context.py

@@ -135,7 +135,9 @@ class ScenarioContext(Context):
         if not self.has_variable_manager():
             manager = VariableManager(SessionContext.instance().get_feature_context().get_variable_manager())
             self.set_object("variable_manager", manager)
-            manager.initialize(self.get_dynamic_text_manager(), SessionContext.instance().unique_value_manager)
+            file_path = SessionContext.instance().report_manager.current_scenario_report.get_path("logs", "variable_update.log")
+            manager.initialize(self.get_dynamic_text_manager(), SessionContext.instance().unique_value_manager,
+                               variable_update_log_file_path=file_path)
         return self.get_object("variable_manager")
     
     def has_expression_evaluator(self):

holado-0.10.0/packaging/VERSION

@@ -1 +0,0 @@
-0.10.0

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

@@ -1,21 +0,0 @@
------BEGIN CERTIFICATE-----
-MIIDZTCCAk2gAwIBAgIBKjANBgkqhkiG9w0BAQsFADCBizELMAkGA1UEBhMCVVMx
-CzAJBgNVBAgMAkNBMRYwFAYDVQQHDA1TYW4gRnJhbmNpc2NvMQ8wDQYDVQQKDAZ0
-Y3BiaW4xDDAKBgNVBAsMA29wczETMBEGA1UEAwwKdGNwYmluLmNvbTEjMCEGCSqG
-SIb3DQEJARYUaGFycnliYWdkaUBnbWFpbC5jb20wHhcNMjUxMDAyMTMzNjQ1WhcN
-MjUxMDAzMTMzNjQ1WjAcMRowGAYDVQQDDBF0Y3BiaW4uY29tLWNsaWVudDCCASIw
-DQYJKoZIhvcNAQEBBQADggEPADCCAQoCggEBAK2xah/MsJKGnIpj84nYfBRCeAh8
-MmN5dZwUCteehkX+wFhioEx1loAIqcqs6MPe7qQdeROuOZlGeiDR/6X0mnDsgyR4
-qUnrIaRHS3EFWGtGp0WRLsQhKNvtxAHL7dErz7BoxTO5gV/w6dcT3uPORfZxkZdm
-6t01t7DwPFktopQju9E8eeMBKVKaO1RrclZKkWEyfuHP3wNpIE6GwsH8jCn4I+r/
-Y8Pgd+k4EyCaH+ngtFbS0lEhxxuqTpPRYyQrlEDMa1i/nETuMiL2WFkjEO2gEX/p
-w05GlO3YUTDpaXWUWZf+Ck7MYevrFDC57oSZvMwTn5pJrQztvNJjFc+YF6kCAwEA
-AaNCMEAwHQYDVR0OBBYEFLuHuKWOQ/U1+OpiGgffNV1faI9qMB8GA1UdIwQYMBaA
-FOLuMowBSAZfV5v82LmlaIIOvU/DMA0GCSqGSIb3DQEBCwUAA4IBAQBYIRlg6Paz
-ALTKoBm8nRB19n4d7Ay+U1bUBCP2U5vZkUTSu05ttQXT72TaFIaT04pFs9uIHGFZ
-9yhP2DgbuCaexQrvf9yf6nnoCqLjlhJ8Y0NmscK14Hp9GgVSnkXeweL82gFsXB45
-FaqqyDn20QiH14nwU2H7g8y/Ys0PIemhjG8UT7OjSLyhkaCkxwYy88N/2YjX3hGH
-9eTHvfMZ+9E7Urh3DevivhfPQnX/6lUAOK7Sr+WTIEjpZ89Lz/rLltRCXoXv75C4
-PdRoxB2/lo+3+X1i4B7ujaduZDLaMyPcckbpuTYxjPZtoxhLyYkKgzQTUMwYsVrW
-DoI6HuqlfzoH
------END CERTIFICATE-----

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

@@ -1,28 +0,0 @@
------BEGIN PRIVATE KEY-----
-MIIEvgIBADANBgkqhkiG9w0BAQEFAASCBKgwggSkAgEAAoIBAQCtsWofzLCShpyK
-Y/OJ2HwUQngIfDJjeXWcFArXnoZF/sBYYqBMdZaACKnKrOjD3u6kHXkTrjmZRnog
-0f+l9Jpw7IMkeKlJ6yGkR0txBVhrRqdFkS7EISjb7cQBy+3RK8+waMUzuYFf8OnX
-E97jzkX2cZGXZurdNbew8DxZLaKUI7vRPHnjASlSmjtUa3JWSpFhMn7hz98DaSBO
-hsLB/Iwp+CPq/2PD4HfpOBMgmh/p4LRW0tJRIccbqk6T0WMkK5RAzGtYv5xE7jIi
-9lhZIxDtoBF/6cNORpTt2FEw6Wl1lFmX/gpOzGHr6xQwue6EmbzME5+aSa0M7bzS
-YxXPmBepAgMBAAECggEBAIqgeMTch2jKyxGg6HTyNUWuL0MGbOj7vaROUsD4os4m
-nrlsLegYSX/yaiF6k2QQ/4I4i7Prb8kneL3NHS8E5GaQPbLUIrj+UyFcTZfs3j7w
-avyY/SxIEuZFBBUy/6HcR6zSUeIQgnNiQiAImfJTZX9l8P9Xgsf+4Zb0hhXe2E1G
-TqLAYWnLoxD9us0rryQb37mRIREKcTO3qza+FXk32bWe83f1Dy46JJIChIoQg/QB
-hwzSL51ld22fy7p+bsqeI3HUDWHplq4T0lws0SGUd4IvntF9rNGYHAI+aUKwiUBC
-g/0se9+GBKeMSjhS11F9/Clg4i0E/tN/poOytA83aAECgYEA3+E0bhbaFAvzzevv
-tAWSXkwHSFZ745KsJSJ8OOVkd+ATleyGl3AoRTrDxNqY+R/TvBFaTyiY+zqGV6tj
-NI8SaSXuhRzbA9zDL2rSH7GIOeqzUs8PSUMk6JnmfCKk+aTBOoi8ULolHE4N6B45
-te3GVgy/luJK22pPLCMsmL+D0ykCgYEAxpzr8T2CPVtl33W+loGbvrqZ1xXgq/7n
-IsjHZdVdFsIIxFhtE2A2iO/7vMsLmwkZ7LgbtHcfEPOxjx5VzVt89l1I2lnP0jW+
-pjKrN/eyXcHnWLLPCEtXA06oIvyem/VMSGXumu7EcOJZjnG3/PmqCWCjc2UUo2lJ
-F2rQdC9bMIECgYEAl3nSdaI0j1e+79bw6kbSz8Z1LvaFAGce3klE72IV5h3QYqIU
-NqaGOMEX8DtPQU/NfPPovKJlT6Y7e1nU15zuAgLOLXZmoWhfD9ggr5z45Obtydub
-JiCt+ksW7WqrYNWef7JAaAZqUYpmUmUQ+w0UIuihQL9/kpGNW/m4lOkPknECgYAI
-gbodWAwXAq4nVwy1t5FrJuTl8HryAvX1aHIZ63yUN/VWK49ocAuF6/l1SaESn94r
-ZGtTXHLJMBbf0WXNaOi+SJqRN52OHF0xEySAPiy2lVKKWwZBDbEJZDoRXY6RkX0V
-8L+6hRWG3DsHvdkqjar5wdjeXWr34M+PoDSTdV/LgQKBgFAqJc4I91AK8Ah9Ba8k
-LqYtRFGFJ2J+p8QqcibfT6d6tZqWffxiXbQ5bS52/fmM3BdxEHjtzLdA7cOqCh6g
-79kxRb3B5jjq5JvGtLy89VphZ08W9dhzgL/l3KGtgMobfTYUEDaNk33oExhItQnx
-F97ecAMIx20oqFFOg6N0unwW
------END PRIVATE KEY-----