holado 0.2.5__py3-none-any.whl → 0.2.7__py3-none-any.whl

holado_helper/script/initialize_script.py

@@ -16,9 +16,9 @@
 # Usually, it is copied and adapted for specific usage.
 
 import os
-import sys
 import logging
 import argparse
+from holado_helper.initialize_holado import insert_sys_path, insert_sys_paths
 
 
 def _chdir(path):
@@ -26,26 +26,6 @@ def _chdir(path):
     os.chdir(path)
     return res
 
-def __insert_sys_path(path):
-    if path not in sys.path:
-        sys.path.insert(0, path)
-
-def _insert_sys_paths(additional_sys_paths=None):
-    # Insert additional paths
-    if additional_sys_paths is not None:
-        for sp in additional_sys_paths:
-            __insert_sys_path(sp)
-            
-    # Insert Holado paths
-    holado_path = os.getenv('HOLADO_PATH')
-    if holado_path is None:
-        # If HolAdo sources are not cloned on this environment, use path within this installation
-        from holado import get_holado_path
-        holado_path = get_holado_path()
-    __insert_sys_path(os.path.join(holado_path) )
-    __insert_sys_path(os.path.join(holado_path, "src") )
-    __insert_sys_path(os.path.join(holado_path, "tests", "behave") )
-    
 def _initialize_holado(TSessionContext=None, logging_config_file_path=None, log_level=logging.WARNING, log_in_file=False, with_session_path=False, **kwargs):
     import holado
     session_kwargs={'with_session_path':with_session_path or log_in_file}
@@ -67,7 +47,7 @@ def initialize(work_dir_path=None, change_work_dir=True,
     
     if additional_sys_paths:
         sys_paths.extend(additional_sys_paths)
-    _insert_sys_paths(sys_paths)
+    insert_sys_paths(sys_paths)
     
     logging_config_file_path=None
     for dir_path in [res, work_dir_path, os.getcwd()]:
@@ -84,7 +64,7 @@ def initialize(work_dir_path=None, change_work_dir=True,
 def change_working_dir(work_dir_path=None):
     if work_dir_path:
         res = _chdir(work_dir_path)
-        __insert_sys_path(work_dir_path)
+        insert_sys_path(work_dir_path)
         return res
     else:
         return None

holado_helper/script/script.py

@@ -76,7 +76,7 @@ class Script(object):
         return parser
     
     def change_working_dir(self, work_dir_path):
-        from initialize_script import change_working_dir as init_cd    # @UnresolvedImport
+        from holado_helper.script.initialize_script import change_working_dir as init_cd    # @UnresolvedImport
         
         # If user working dir is not yet defined, save current working dir as user working dir
         if self.__user_work_dir is None:
@@ -90,7 +90,7 @@ class Script(object):
     
     def initialize(self):
         if self.args is not None and hasattr(self.args, 'log_level') and hasattr(self.args, 'log_in_file'):
-            from initialize_script import change_logging_config # @UnresolvedImport
+            from holado_helper.script.initialize_script import change_logging_config # @UnresolvedImport
             change_logging_config(log_level=self.args.log_level, log_in_file=self.args.log_in_file)
     
     def run(self):

holado_protobuf/ipc/protobuf/protobuf_messages.py

@@ -301,7 +301,7 @@ class ProtobufMessages(object):
                 if ValueTableManager.verify_table_is_name_value_table(fields_table, raise_exception=False):
                     self.__set_object_fields_with_name_value_table(res, fields_table)
                 else:
-                    raise TechnicalException(f"When defining parameter fields_table, it must be a Name/Value table")
+                    raise TechnicalException(f"When defining parameter fields_table, it must be a Name/Value table: [{Typing.get_object_class_fullname(fields_table)}]\n{fields_table.represent(4)}")
             elif fields_dict is not None:
                 self.__set_object_fields_with_dict(res, fields_dict)
             

holado_scripting/common/tools/evaluate_parameters.py

@@ -11,6 +11,7 @@
 #################################################
 
 import copy
+from holado.common.handlers.undefined import undefined_value
 
 
 class EvaluateParameters(object):
@@ -23,7 +24,8 @@ class EvaluateParameters(object):
     
     def __init__(self, do_interpret=True, do_eval_variable=True, do_eval=True, \
                  raise_on_interpret_error=True, raise_on_variable_eval_error=True, raise_on_eval_error=True,
-                 do_interpret_recursively=False, do_eval_variable_recursively=False):
+                 do_interpret_recursively=False, do_eval_variable_recursively=False,
+                 result_type=undefined_value):
         """
         Constructor
         @param  
@@ -36,9 +38,11 @@ class EvaluateParameters(object):
         self.raise_on_interpret_error = raise_on_interpret_error
         self.raise_on_variable_eval_error = raise_on_variable_eval_error
         self.raise_on_eval_error = raise_on_eval_error
+        self.result_type = result_type
+        self.result_is_str = result_type is str
     
     def __str__(self)->str:
-        return f"{{interpret:({self.do_interpret},recursive:{self.do_interpret_recursively},raise:{self.raise_on_interpret_error}) ; eval variable:({self.do_eval_variable},recursive:{self.do_eval_variable_recursively},raise:{self.raise_on_variable_eval_error}) ; eval:({self.do_eval},raise:{self.raise_on_eval_error})}}"
+        return f"{{interpret:({self.do_interpret},recursive:{self.do_interpret_recursively},raise:{self.raise_on_interpret_error}) ; eval variable:({self.do_eval_variable},recursive:{self.do_eval_variable_recursively},raise:{self.raise_on_variable_eval_error}) ; eval:({self.do_eval},raise:{self.raise_on_eval_error}) ; result type:{self.result_type}}}"
     
     def with_interpret(self, do_interpret):
         """
@@ -160,6 +164,20 @@ class EvaluateParameters(object):
         @return Same parameters but without raise
         """
         return self.with_raise(False)
+        
+    def with_result_type(self, result_type=undefined_value):
+        """
+        Note: if result_type types are same, self instance is returned, else a new one is returned
+        @param result_type Evaluation result type
+        @return Same parameters but with result_type
+        """
+        if self.result_type == result_type:
+            return self
+        else:
+            res = copy.deepcopy(self)
+            res.result_type = result_type
+            res.result_is_str = result_type is str
+            return res
     
     @staticmethod
     def default(raise_exception=True):
@@ -178,7 +196,7 @@ class EvaluateParameters(object):
         @return Default evaluate parameters with raises
         """
         if EvaluateParameters.__instance_default is None:
-            EvaluateParameters.__instance_default = EvaluateParameters(True, True, True, True, True, True)
+            EvaluateParameters.__instance_default = EvaluateParameters(True, True, True, True, True, True, undefined_value)
         return EvaluateParameters.__instance_default
     
     @staticmethod
@@ -187,7 +205,7 @@ class EvaluateParameters(object):
         @return Default evaluate parameters without any raise
         """
         if EvaluateParameters.__instance_default_without_raise is None:
-            EvaluateParameters.__instance_default_without_raise = EvaluateParameters(True, True, True, False, False, False)
+            EvaluateParameters.__instance_default_without_raise = EvaluateParameters(True, True, True, False, False, False, undefined_value)
         return EvaluateParameters.__instance_default_without_raise
     
     @staticmethod
@@ -204,7 +222,7 @@ class EvaluateParameters(object):
         @return Default evaluate parameters without any raise
         """
         if EvaluateParameters.__instance_nothing is None:
-            EvaluateParameters.__instance_nothing = EvaluateParameters(False, False, False, False, False, False)
+            EvaluateParameters.__instance_nothing = EvaluateParameters(False, False, False, False, False, False, undefined_value)
         return EvaluateParameters.__instance_nothing
 
 

holado_scripting/common/tools/expression_evaluator.py

@@ -25,7 +25,7 @@ from holado_scripting.common.tools.evaluate_parameters import EvaluateParameters
 from holado.holado_config import Config
 from holado_multitask.multitasking.multitask_manager import MultitaskManager
 from holado_python.standard_library.typing import Typing
-from holado.common.handlers.undefined import undefined_value
+from holado.common.handlers.undefined import undefined_value, not_applicable
 
 logger = logging.getLogger(__name__)
 
@@ -47,52 +47,49 @@ class ExpressionEvaluator(object):
         self.__variable_manager = variable_manager
             
     def evaluate_expression(self, expression, unescape_string_method=None, eval_params=EvaluateParameters.default(), log_level=logging.DEBUG):
-        value_type, value, value_to_eval = self.extract_expression_information(expression, unescape_string_method)
+        value_type, value, value_to_eval = self.extract_expression_information(expression, unescape_string_method, eval_params=eval_params)
         if value_to_eval is not undefined_value:
-            res = self.evaluate_expression_of_information(value_type, value_to_eval, eval_params=eval_params)
+            if ValueTypes.is_string(value_type):
+                eval_params = eval_params.with_result_type(str)
+            res_type, res = self.evaluate_expression_of_information(value_type, value_to_eval, eval_params=eval_params, log_level=log_level)
+            if Tools.do_log(logger, log_level):
+                logger.log(log_level, f"Evaluate expression [{expression}] => ({value_type.name}, {value}, '{value_to_eval}') => ({res_type.name}) [{res}] (type: {Typing.get_object_class_fullname(res)})    (with evaluate parameters: {eval_params})")
         else:
-            res = value
-        if Tools.do_log(logger, log_level):
-            logger.log(log_level, f"Evaluate expression [{expression}] => ({value_type}, {value}, '{value_to_eval}') => [{res}] (type: {Typing.get_object_class_fullname(res)})    (with evaluate parameters: {eval_params})")
-        return res
+            res_type, res = value_type, value
+            if Tools.do_log(logger, log_level):
+                logger.log(log_level, f"Evaluate expression [{expression}] => ({res_type.name}) [{res}] (type: {Typing.get_object_class_fullname(res)})    (with evaluate parameters: {eval_params})")
+        return res_type, res
 
     def evaluate_python_expression(self, expression, eval_params=EvaluateParameters.default(), log_level=logging.DEBUG):
-        res = self.evaluate_expression_of_information(ValueTypes.Symbol, expression, eval_params=eval_params)
+        res_type, res = self.evaluate_expression_of_information(ValueTypes.Symbol, expression, eval_params=eval_params, log_level=log_level)
         if Tools.do_log(logger, log_level):
-            logger.log(log_level, f"Evaluate python expression [{expression}] => [{res}] (type: {Typing.get_object_class_fullname(res)})    (with evaluate parameters: {eval_params})")
-        return res
+            logger.log(log_level, f"Evaluate python expression [{expression}] => ({res_type.name}) [{res}] (type: {Typing.get_object_class_fullname(res)})    (with evaluate parameters: {eval_params})")
+        return res_type, res
 
-    def extract_expression_information(self, expression, unescape_string_method=None, log_level=logging.TRACE):  # @UndefinedVariable
-        res = self.__extract_expression_information(expression, unescape_string_method=unescape_string_method)
+    def extract_expression_information(self, expression, unescape_string_method=None, eval_params=EvaluateParameters.default(), log_level=logging.TRACE):  # @UndefinedVariable
+        res = self.__extract_expression_information(expression, unescape_string_method=unescape_string_method, eval_params=eval_params)
         if Tools.do_log(logger, log_level):
             logger.log(log_level, f"Extract expression information [{expression}] => {res}")
         return res
 
-    def __extract_expression_information(self, expression, unescape_string_method=None):
+    def __extract_expression_information(self, expression, unescape_string_method=None, eval_params=EvaluateParameters.default()):
         if isinstance(expression, str):
-            return self.__extract_expression_information_str(expression, unescape_string_method = unescape_string_method)
+            return self.__extract_expression_information_str(expression, unescape_string_method=unescape_string_method, eval_params=eval_params)
         else:
-            return self.__extract_value_information(expression)
+            return (*self.__extract_value_information(expression, from_symbol=False, from_str=False), undefined_value)
 
-    def __extract_expression_information_str(self, expression, unescape_string_method=None):
+    def __extract_expression_information_str(self, expression, unescape_string_method=None, eval_params=EvaluateParameters.default()):
         if unescape_string_method is None:
             from holado_test.scenario.step_tools import StepTools
             unescape_string_method = StepTools.unescape_string
             
         try:
             expr_content = expression.strip()
-
-            # Manage usual types    
-            if expr_content == Config.NONE_SYMBOL:
-                return (ValueTypes.Null, None, undefined_value)
-            elif expr_content == Config.NOT_APPLICABLE_SYMBOL:
-                return (ValueTypes.NotApplicable, undefined_value, undefined_value)
-            elif Converter.is_boolean(expr_content):
-                return (ValueTypes.Boolean, Converter.to_boolean(expr_content), undefined_value)
-            elif Converter.is_integer(expr_content):
-                return (ValueTypes.Integer, int(expr_content), undefined_value)
-            elif Converter.is_float(expr_content):
-                return (ValueTypes.Float, float(expr_content), undefined_value)
+            
+            # Manage usual types
+            value_type, value = self.__extract_value_information(expr_content, from_symbol=not eval_params.result_is_str, from_str=not eval_params.result_is_str)
+            if value_type != ValueTypes.String:
+                return (value_type, value, undefined_value)
             
             # Manage strings
             for end_sym, val_type in [(Config.DYNAMIC_SYMBOL, ValueTypes.DynamicString), 
@@ -104,73 +101,73 @@ class ExpressionEvaluator(object):
                     if unescape_string_method is not None:
                         text = unescape_string_method(text)
                     return (val_type, undefined_value, text)
-                
-            # # Manage evaluated values
-            # try:
-            #     value_evaluated = eval(expr_content)
-            #     evaluated = True
-            # except (SyntaxError, NameError, ValueError):
-            #     evaluated = False
-            # if evaluated:
-            #     if isinstance(value_evaluated, bool):
-            #         value_type = ValueTypes.Boolean
-            #     elif isinstance(value_evaluated, int):
-            #         value_type = ValueTypes.Integer
-            #     elif isinstance(value_evaluated, float):
-            #         value_type = ValueTypes.Float
-            #     elif isinstance(value_evaluated, str):
-            #         value_type = ValueTypes.String
-            #     else:
-            #         value_type = ValueTypes.Generic
-            #     return (value_type, value_evaluated)
             
             # Else consider content as a symbol
             return (ValueTypes.Symbol, undefined_value, expr_content)
         except Exception as exc:
             raise TechnicalException(f"Error while extracting expression information in expression [{expression}] (type: {Typing.get_object_class_fullname(expression)})") from exc
 
-    def extract_value_information(self, value):
-        return self.__extract_value_information(value)
+    def extract_value_information(self, value, *, from_symbol=True, from_str=True):
+        return self.__extract_value_information(value, from_symbol=from_symbol, from_str=from_str)
 
-    def __extract_value_information(self, value):
+    def __extract_value_information(self, value, *, from_symbol=False, from_str=False):
         if value is undefined_value:
-            return (ValueTypes.Undefined, undefined_value, undefined_value)
+            return (ValueTypes.Undefined, undefined_value)
+        elif value is not_applicable:
+            return (ValueTypes.NotApplicable, not_applicable)
         elif value is None:
-            return (ValueTypes.Null, None, undefined_value)
+            return (ValueTypes.Null, None)
         elif isinstance(value, bool):
-            return (ValueTypes.Boolean, value, undefined_value)
+            return (ValueTypes.Boolean, value)
         elif isinstance(value, int):
-            return (ValueTypes.Integer, value, undefined_value)
+            return (ValueTypes.Integer, value)
         elif isinstance(value, float):
-            return (ValueTypes.Float, value, undefined_value)
+            return (ValueTypes.Float, value)
         elif isinstance(value, str):
-            return (ValueTypes.String, value, undefined_value)
+            if from_symbol:
+                if value == Config.NONE_SYMBOL:
+                    return (ValueTypes.Null, None)
+                elif value == Config.NOT_APPLICABLE_SYMBOL:
+                    return (ValueTypes.NotApplicable, not_applicable)
+            
+            if from_str:
+                if Converter.is_boolean(value):
+                    return (ValueTypes.Boolean, Converter.to_boolean(value))
+                elif Converter.is_integer(value):
+                    return (ValueTypes.Integer, int(value))
+                elif Converter.is_float(value):
+                    return (ValueTypes.Float, float(value))
+            
+            return (ValueTypes.String, value)
         else:
-            return (ValueTypes.Generic, value, undefined_value)
+            return (ValueTypes.Generic, value)
         
-    def evaluate_expression_of_information(self, value_type, value, eval_params=EvaluateParameters.default()):
-        if Tools.do_log(logger, logging.TRACE):  # @UndefinedVariable
-            logger.trace(f"Evaluating expression of information ({value_type.name}, {value}, {eval_params})")
-        res = self.__evaluate_expression_of_information(value_type, value, eval_params=eval_params)
-        if Tools.do_log(logger, logging.TRACE):  # @UndefinedVariable
-            logger.trace(f"Evaluate expression of information ({value_type.name}, {value}) => [{res}] (type: {Typing.get_object_class_fullname(res)})    (with evaluate parameters: {eval_params})")
-        return res
+    def evaluate_expression_of_information(self, value_type, value, eval_params=EvaluateParameters.default(), log_level=logging.DEBUG):
+        if Tools.do_log(logger, logging.TRACE, max_log_level=log_level):  # @UndefinedVariable
+            logger.log(Tools.do_log_level(logging.TRACE, log_level), f"Evaluating expression of information ({value_type.name}, {value}, {eval_params})")  # @UndefinedVariable
+        res_type, res = self.__evaluate_expression_of_information(value_type, value, eval_params=eval_params, log_level=log_level)
+        if Tools.do_log(logger, logging.TRACE, max_log_level=log_level):  # @UndefinedVariable
+            logger.log(Tools.do_log_level(logging.TRACE, log_level), f"Evaluate expression of information ({value_type.name}, {value}) => ({res_type.name}) [{res}] (type: {Typing.get_object_class_fullname(res)})    (with evaluate parameters: {eval_params})")  # @UndefinedVariable
+        return res_type, res
         
-    def __evaluate_expression_of_information(self, value_type, value, eval_params=EvaluateParameters.default()):
-        if value_type in [ValueTypes.Null]:
-            return None
+    def __evaluate_expression_of_information(self, value_type, value, eval_params=EvaluateParameters.default(), log_level=logging.DEBUG):
+        if value_type in [ValueTypes.NotApplicable]:
+            return (value_type, not_applicable)
+        elif value_type in [ValueTypes.Null]:
+            return (value_type, None)
         elif value_type in [ValueTypes.Boolean, ValueTypes.Integer, ValueTypes.Float, ValueTypes.Generic]:
-            return value
-        elif value_type in [ValueTypes.String, ValueTypes.DynamicString, ValueTypes.ThreadDynamicString, ValueTypes.UniqueString]:
-            return self.__evaluate_expression_of_information_string(value_type, value, eval_params=eval_params)
+            return (value_type, value)
+        elif ValueTypes.is_string(value_type):
+            eval_params = eval_params.with_result_type(str)
+            return self.__evaluate_expression_of_information_string(value_type, value, eval_params=eval_params, log_level=log_level)
         elif value_type in [ValueTypes.Symbol]:
-            return self.__evaluate_expression_of_information_symbol(value, eval_params=eval_params)
+            return self.__evaluate_expression_of_information_symbol(value, eval_params=eval_params, log_level=log_level)
         else:
-            return value
+            return self.__extract_value_information(value)
         
-    def __evaluate_expression_of_information_string(self, value_type, value, eval_params=EvaluateParameters.default_without_raise()):
+    def __evaluate_expression_of_information_string(self, value_type, value, eval_params=EvaluateParameters.default_without_raise(), log_level=logging.DEBUG):
         if eval_params.do_interpret:
-            res = self.__text_interpreter.interpret(value, eval_params=eval_params)
+            res = self.__text_interpreter.interpret(value, eval_params=eval_params, log_level=log_level)
         else:
             res = value
             
@@ -180,75 +177,80 @@ class ExpressionEvaluator(object):
             res = str(res)
             
         if value_type == ValueTypes.DynamicString:
-            return self.__dynamic_text_manager.get(res)
+            res = self.__dynamic_text_manager.get(res)
         elif value_type == ValueTypes.ThreadDynamicString:
-            return self.__dynamic_text_manager.get(res, scope=MultitaskManager.get_thread_id())
+            res = self.__dynamic_text_manager.get(res, scope=MultitaskManager.get_thread_id())
         elif value_type == ValueTypes.UniqueString:
-            return res + self.__unique_value_manager.new_string(padding_length=Config.unique_string_padding_length)
-        else:
-            return res
+            res = res + self.__unique_value_manager.new_string(padding_length=Config.unique_string_padding_length)
+        
+        return self.extract_value_information(res, from_symbol=not eval_params.result_is_str, from_str=not eval_params.result_is_str)
         
-    def __evaluate_expression_of_information_symbol(self, value, eval_params=EvaluateParameters.default()):
-        if logger.isEnabledFor(logging.TRACE):  # @UndefinedVariable
-            logger.trace(f"Evaluating symbol ([{value}], {eval_params})")
+    def __evaluate_expression_of_information_symbol(self, value, eval_params=EvaluateParameters.default(), log_level=logging.DEBUG):
+        if Tools.do_log(logger, logging.TRACE, max_log_level=log_level):  # @UndefinedVariable
+            logger.log(Tools.do_log_level(logging.TRACE, log_level), f"Evaluating symbol ([{value}], {eval_params})")  # @UndefinedVariable
         res = value
         
         # Replace explicit interpret parts
         if eval_params.do_interpret and isinstance(res, str):
-            res, _, is_evaluated = self.__evaluate_interpret_expression(res, eval_params=eval_params)
+            res, _, is_evaluated = self.__evaluate_interpret_expression(res, eval_params=eval_params, log_level=log_level)
             if is_evaluated:
                 # If symbol is already evaluated, stop evaluation process
-                if logger.isEnabledFor(logging.TRACE):  # @UndefinedVariable
-                    logger.trace(f"Evaluate symbol [{value}]  =>  [{res}] (type: {Typing.get_object_class_fullname(res)})    (after interpret, with evaluate parameters: {eval_params})")
-                return res
+                # Note: evaluation of string was already done if asked, thus just evaluate symbols
+                res_type, res = self.__extract_value_information(res, from_symbol=not eval_params.result_is_str, from_str=not eval_params.result_is_str)
+                if Tools.do_log(logger, logging.TRACE, max_log_level=log_level):  # @UndefinedVariable
+                    logger.log(Tools.do_log_level(logging.TRACE, log_level), f"Evaluate symbol [{value}]  =>  ({res_type.name}) [{res}] (type: {Typing.get_object_class_fullname(res)})    (after interpret, with evaluate parameters: {eval_params})")  # @UndefinedVariable
+                return res_type, res
             # if logger.isEnabledFor(logging.TRACE):  # @UndefinedVariable
             #     logger.trace(f"Evaluate symbol [{value}] - after interpret:  [{res}] (type: {Typing.get_object_class_fullname(res)})    (with evaluate parameters: {eval_params})")
         
         # Evaluate variable expression
         # Note: if an eval must be done after interpret, variable shouldn't be evaluated unless it can makes failing eval
         if eval_params.do_eval_variable and isinstance(res, str) and len(res) > 0:
-            result, is_evaluated = self.__evaluate_variable_expression(res, eval_params=eval_params)
+            result, is_evaluated = self.__evaluate_variable_expression(res, eval_params=eval_params, log_level=log_level)
             if is_evaluated:
                 # If symbol is a variable expression, don't evaluate the result of the variable
-                if logger.isEnabledFor(logging.TRACE):  # @UndefinedVariable
-                    logger.trace(f"Evaluate symbol [{value}]  =>  [{result}] (type: {Typing.get_object_class_fullname(result)})    (after variable evaluation, with evaluate parameters: {eval_params})")
-                return result
+                res_type, res = self.__extract_value_information(result, from_symbol=False, from_str=False)
+                if Tools.do_log(logger, logging.TRACE, max_log_level=log_level):  # @UndefinedVariable
+                    logger.log(Tools.do_log_level(logging.TRACE, log_level), f"Evaluate symbol [{value}]  =>  ({res_type.name}) [{res}] (type: {Typing.get_object_class_fullname(res)})    (after variable evaluation, with evaluate parameters: {eval_params})")  # @UndefinedVariable
+                return res_type, res
         
         # Evaluate expression
         # if eval_params.do_eval and (isinstance(res, str) or isinstance(res, bytes)):    # Commented as it doesn't work currently with bytes
         if eval_params.do_eval and isinstance(res, str):
-            res = self.__evaluate_expression(res, locals_={}, eval_params=eval_params)
+            res = self.__evaluate_expression(res, locals_={}, eval_params=eval_params, log_level=log_level)
             
         # logger.debug(f"Evaluate symbol [{value}] => [{res}] (type: {Typing.get_object_class_fullname(res)})")
-        if logger.isEnabledFor(logging.TRACE):  # @UndefinedVariable
-            logger.trace(f"Evaluate symbol [{value}]  =>  [{res}] (type: {Typing.get_object_class_fullname(res)})    (after full evaluation, with evaluate parameters: {eval_params})")
-        return res
+        # Note: evaluation of string was already done if asked, thus just evaluate symbols
+        res_type, res = self.__extract_value_information(res, from_symbol=not eval_params.result_is_str, from_str=not eval_params.result_is_str)
+        if Tools.do_log(logger, logging.TRACE, max_log_level=log_level):  # @UndefinedVariable
+            logger.log(Tools.do_log_level(logging.TRACE, log_level), f"Evaluate symbol [{value}]  =>  [{res}] (type: {Typing.get_object_class_fullname(res)})    (after full evaluation, with evaluate parameters: {eval_params})")  # @UndefinedVariable
+        return res_type, res
         
-    def __evaluate_interpret_expression(self, value, eval_params=EvaluateParameters.default()):
+    def __evaluate_interpret_expression(self, value, eval_params=EvaluateParameters.default(), log_level=logging.DEBUG):
         result, is_interpreted, is_evaluated = value, False, False
         
         nb_sections = self.__text_interpreter.get_number_of_sections(value)
         if nb_sections > 0:
             # If eval is authorized, and many sections exists, prefer interpret sections and eval result
             if eval_params.do_eval and nb_sections > 1:
-                result, locals_ = self.__text_interpreter._interpret_sections(value, eval_params=eval_params)
+                result, locals_ = self.__text_interpreter._interpret_sections(value, eval_params=eval_params, log_level=log_level)
                 if result != value:
-                    result = self.__evaluate_expression(result, locals_, eval_params=eval_params)
+                    result = self.__evaluate_expression(result, locals_, eval_params=eval_params, log_level=log_level)
                     is_evaluated = True
             else:
-                result = self.__text_interpreter.interpret(value, eval_params=eval_params)
+                result = self.__text_interpreter.interpret(value, eval_params=eval_params, log_level=log_level)
             is_interpreted = result != value
         
         # Manage recursive interpret, only in case of first interpret and if it wasn't evaluated
         if eval_params.do_interpret_recursively and is_interpreted and not is_evaluated and isinstance(result, str):
-            new_result, new_is_interpreted, new_is_evaluated = self.__evaluate_interpret_expression(result, eval_params.with_raise_on_interpret_error(False))
+            new_result, new_is_interpreted, new_is_evaluated = self.__evaluate_interpret_expression(result, eval_params.with_raise_on_interpret_error(False), log_level=log_level)
             if new_is_interpreted:
                 result = new_result
                 is_evaluated = new_is_evaluated
         
         return result, is_interpreted, is_evaluated
         
-    def __evaluate_variable_expression(self, value, eval_params=EvaluateParameters.default()):
+    def __evaluate_variable_expression(self, value, eval_params=EvaluateParameters.default(), log_level=logging.DEBUG):
         is_evaluated, result = False, None
         
         if self.__variable_manager.exists_variable(value):
@@ -261,20 +263,20 @@ class ExpressionEvaluator(object):
                 if eval_params.raise_on_variable_eval_error:
                     raise exc
                 else:
-                    # logger.error(f"Error while evaluating variable expression [{value}]: {exc}")
-                    logger.error(f"Error while evaluating variable expression [{value}]: {Tools.represent_exception(exc)}\n -> traceback:\n{traceback.represent_stack(indent=4)}")
+                    if Tools.do_log(logger, log_level):
+                        logger.log(log_level, f"Error while evaluating variable expression [{value}]: {Tools.represent_exception(exc)}\n -> traceback:\n{traceback.represent_stack(indent=4)}")
             else:
                 is_evaluated = True
         
         # Manage recursive evaluation, only in case of first variable evaluation
         if eval_params.do_eval_variable_recursively and is_evaluated and isinstance(result, str) and result != value:
-            new_result, new_is_evaluated = self.__evaluate_variable_expression(result, eval_params.with_raise_on_variable_eval_error(False))
+            new_result, new_is_evaluated = self.__evaluate_variable_expression(result, eval_params.with_raise_on_variable_eval_error(False), log_level=log_level)
             if new_is_evaluated:
                 result = new_result
         
         return result, is_evaluated
         
-    def __evaluate_expression(self, value, locals_, eval_params=EvaluateParameters.default()):
+    def __evaluate_expression(self, value, locals_, eval_params=EvaluateParameters.default(), log_level=logging.DEBUG):
         res = value
         while True:
             try:
@@ -301,20 +303,20 @@ class ExpressionEvaluator(object):
                     
                 # If no import is done
                 if not is_imported:
-                    if Tools.do_log(logger, logging.DEBUG):
-                        logger.debug(f"Error while evaluating expression [{value}]: {exc}")
+                    if Tools.do_log(logger, logging.DEBUG, max_log_level=log_level):
+                        logger.log(Tools.do_log_level(logging.DEBUG, log_level), f"Error while evaluating expression [{value}]: {exc}")
                     break
             except Exception as exc:
                 if eval_params.raise_on_eval_error:
                     raise exc
                 else:
-                    if Tools.do_log(logger, logging.TRACE):  # @UndefinedVariable
-                        logger.trace(f"Error while evaluating expression [{value}]: {Tools.represent_exception(exc)}")
-                    elif Tools.do_log(logger, logging.DEBUG):
+                    if Tools.do_log(logger, logging.TRACE, max_log_level=log_level):  # @UndefinedVariable
+                        logger.log(Tools.do_log_level(logging.TRACE, log_level), f"Error while evaluating expression [{value}]: {Tools.represent_exception(exc)}")  # @UndefinedVariable
+                    elif Tools.do_log(logger, logging.DEBUG, max_log_level=log_level):
                         if isinstance(exc, SyntaxError):
-                            logger.debug(f"Error while evaluating expression [{value}]: {repr(exc)}")
+                            logger.log(Tools.do_log_level(logging.DEBUG, log_level), f"Error while evaluating expression [{value}]: {repr(exc)}")
                         else:
-                            logger.debug(f"Error while evaluating expression [{value}]: [{Typing.get_object_class_fullname(exc)}] {exc}")
+                            logger.log(Tools.do_log_level(logging.DEBUG, log_level), f"Error while evaluating expression [{value}]: [{Typing.get_object_class_fullname(exc)}] {exc}")
                 break
             else:
                 if not isinstance(result, types.ModuleType):
@@ -374,7 +376,7 @@ class ExpressionEvaluator(object):
     
     def extract_string_value(self, expression, unescape_string_method=None, log_level=logging.DEBUG):
         value_type, value_str, value_to_eval = self.extract_expression_information(expression, unescape_string_method)
-        if value_type in [ValueTypes.String, ValueTypes.DynamicString, ValueTypes.ThreadDynamicString, ValueTypes.UniqueString]:
+        if ValueTypes.is_string(value_type):
             if value_to_eval is not undefined_value:
                 res = value_to_eval
             else:
@@ -382,6 +384,6 @@ class ExpressionEvaluator(object):
         else:
             res = expression
         if Tools.do_log(logger, log_level):
-            logger.debug(f"Extract string value [{expression}] => ({value_type}, '{value_str}') => [{res}] (type: {Typing.get_object_class_fullname(res)})")
+            logger.log(log_level, f"Extract string value [{expression}] => ({value_type}, '{value_str}') => [{res}] (type: {Typing.get_object_class_fullname(res)})")
         return res
 

holado_scripting/tests/behave/steps/scenario/if_steps.py

@@ -49,7 +49,7 @@ def __get_expression_evaluator():
 def step_impl(context, condition_expression):
     __get_scope_manager().log_conditions_info(f"Before evaluation of if condition expression [{condition_expression}]")
     __get_scope_manager().increase_condition_level()
-    cond = __get_expression_evaluator().evaluate_python_expression(condition_expression)
+    _, cond = __get_expression_evaluator().evaluate_python_expression(condition_expression)
     if isinstance(cond, bool) or Converter.is_boolean(cond):
         if isinstance(cond, bool) and cond or Converter.is_boolean(cond) and Converter.to_boolean(cond):
             __get_scope_manager().enter_in_valid_condition()
@@ -61,7 +61,7 @@ def step_impl(context, condition_expression):
 def step_impl(context, condition_expression):
     __get_scope_manager().leave_condition()
     if not __get_scope_manager().had_valid_condition():
-        cond = __get_expression_evaluator().evaluate_python_expression(condition_expression)
+        _, cond = __get_expression_evaluator().evaluate_python_expression(condition_expression)
         if isinstance(cond, bool) or Converter.is_boolean(cond):
             if isinstance(cond, bool) and cond or Converter.is_boolean(cond) and Converter.to_boolean(cond):
                 __get_scope_manager().enter_in_valid_condition()

holado_scripting/text/interpreter/functions/function_hex_to_bytes.py

@@ -38,7 +38,7 @@ class FunctionHexToBytes(BaseFunction):
         
         # Evaluate parameter
         if isinstance(src, str):
-            src_eval = self.__expression_evaluator.evaluate_expression(src)
+            _, src_eval = self.__expression_evaluator.evaluate_expression(src)
             if isinstance(src_eval, bytes) or isinstance(src_eval, str):
                 src = src_eval
             else: