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

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:

holado_scripting/text/interpreter/text_interpreter.py

@@ -60,12 +60,11 @@ class TextInterpreter(TextInspecter):
         if str_to_interpret is None:
             return None
         
-        if Tools.do_log(logger, logging.TRACE):  # @UndefinedVariable
-        
-            logger.trace("Interpreting '{}'...".format(str_to_interpret))
+        if Tools.do_log(logger, logging.TRACE, max_log_level=log_level):  # @UndefinedVariable
+            logger.log(Tools.do_log_level(logging.TRACE, log_level), "Interpreting '{}'...".format(str_to_interpret))  # @UndefinedVariable
         
         # Interpret and get result as object
-        res, _ = self.__interpret(str_to_interpret, eval_params=eval_params)
+        res, _ = self.__interpret(str_to_interpret, eval_params=eval_params, log_level=log_level)
 
         if Tools.do_log_if_objects_are_different(logger, log_level, str_to_interpret, res):
             logger.log(log_level, "Interpreting '{}' -> [{}] (type: {})".format(str_to_interpret, res, type(res)))
@@ -82,18 +81,17 @@ class TextInterpreter(TextInspecter):
         if str_to_interpret is None:
             return None
         
-        if Tools.do_log(logger, logging.TRACE):  # @UndefinedVariable
-        
-            logger.trace("Interpreting sections in '{}'...".format(str_to_interpret))
+        if Tools.do_log(logger, logging.TRACE, max_log_level=log_level):  # @UndefinedVariable
+            logger.log(Tools.do_log_level(logging.TRACE, log_level), "Interpreting sections in '{}'...".format(str_to_interpret))  # @UndefinedVariable
         
         # Interpret and get result as object
-        res, locals_ = self.__interpret(str_to_interpret, replace_sections_by_variables=True, eval_params=eval_params)
+        res, locals_ = self.__interpret(str_to_interpret, replace_sections_by_variables=True, eval_params=eval_params, log_level=log_level)
 
         if Tools.do_log_if_objects_are_different(logger, log_level, str_to_interpret, res):
             logger.log(log_level, f"Interpreting sections in '{str_to_interpret}' -> [{res}] (type: {type(res)}, locals: {locals_})")
         return res, locals_
 
-    def __interpret(self, str_to_interpret, replace_sections_by_variables=False, eval_params=EvaluateParameters.default_without_raise()):
+    def __interpret(self, str_to_interpret, replace_sections_by_variables=False, eval_params=EvaluateParameters.default_without_raise(), log_level=logging.DEBUG):
         res = None
         locals_ = {}
         
@@ -103,7 +101,7 @@ class TextInterpreter(TextInspecter):
             r_match = self.__regex_to_be_interpreted.match(str_to_interpret)
             if r_match:
                 str_under_interpret = r_match.group(1).strip()
-                res = self.__interpret_text(str_under_interpret, eval_params=eval_params)
+                res = self.__interpret_text(str_under_interpret, eval_params=eval_params, log_level=log_level)
                 # Text is not interpretable ; expect it will be the case later
                 if res == str_under_interpret:
                     res = str_to_interpret
@@ -112,19 +110,20 @@ class TextInterpreter(TextInspecter):
             else:
                 raise TechnicalException(f"Failed to find interpret section whereas its indexes were found")
         else:
-            res, locals_ = self.__find_and_interpret_sections(str_to_interpret, replace_sections_by_variables=replace_sections_by_variables, eval_params=eval_params)
+            res, locals_ = self.__find_and_interpret_sections(str_to_interpret, replace_sections_by_variables=replace_sections_by_variables, eval_params=eval_params, log_level=log_level)
             
         return res, locals_
     
-    def __interpret_text(self, text, eval_params=EvaluateParameters.default_without_raise()):
+    def __interpret_text(self, text, eval_params=EvaluateParameters.default_without_raise(), log_level=logging.DEBUG):  # @UndefinedVariable
         # Manage functions
         if self._has_function(text, with_interpreted=False):
-            return self.__evaluate_function(text, eval_params=eval_params)
+            return self.__evaluate_function(text, eval_params=eval_params, log_level=log_level)
         
         # Manage evaluation
-        return self._expression_evaluator.evaluate_expression(text, eval_params=eval_params, log_level=logging.TRACE)  # @UndefinedVariable
+        _, res = self._expression_evaluator.evaluate_expression(text, eval_params=eval_params, log_level=Tools.do_log_level(log_level, logging.TRACE))  # @UndefinedVariable
+        return res
     
-    def __find_and_interpret_sections(self, str_to_interpret, replace_sections_by_variables=False, eval_params=EvaluateParameters.default_without_raise()):
+    def __find_and_interpret_sections(self, str_to_interpret, replace_sections_by_variables=False, eval_params=EvaluateParameters.default_without_raise(), log_level=logging.DEBUG):
         res = str_to_interpret
         locals_ = {}
         
@@ -145,7 +144,7 @@ class TextInterpreter(TextInspecter):
             sub_str = res[ind_beg:ind_end]
             
             # Interpret sub-section
-            interpreted_value = self.interpret(sub_str, eval_params=eval_params)
+            interpreted_value = self.interpret(sub_str, eval_params=eval_params, log_level=log_level)
             
             # Manage sections that aren't interpretable
             interpreted_str = f"{interpreted_value}"
@@ -170,7 +169,7 @@ class TextInterpreter(TextInspecter):
                 
         return res, locals_
     
-    def __evaluate_function(self, fct_str, eval_params=EvaluateParameters.default_without_raise()):
+    def __evaluate_function(self, fct_str, eval_params=EvaluateParameters.default_without_raise(), log_level=logging.DEBUG):
         func_name, args_str = self._get_function_and_args_strings(fct_str, with_interpreted=False)
         func = self._get_function(func_name) if func_name is not None else None
         if func is None:
@@ -178,8 +177,8 @@ class TextInterpreter(TextInspecter):
         
         args = self._get_args(args_str)
         
-        if Tools.do_log(logger, logging.TRACE):  # @UndefinedVariable
-            logger.trace(f"Evaluating function '{func_name}' with args {args}")
+        if Tools.do_log(logger, logging.TRACE, max_log_level=log_level):  # @UndefinedVariable
+            logger.log(Tools.do_log_level(logging.TRACE, max_log_level=log_level), f"Evaluating function '{func_name}' with args {args}")  # @UndefinedVariable
             # logger.trace(f"Evaluating function '{func_name}' with args {args} (eval_params: {eval_params})", stack_info=True)
         try:
             res = func.apply(args)
@@ -189,8 +188,8 @@ class TextInterpreter(TextInspecter):
             else:
                 res = fct_str
                 
-        if Tools.do_log(logger, logging.DEBUG):
-            logger.debug(f"Evaluate function [{fct_str}] => [{func_name}({', '.join(args)})] => [{res}] (type: {Typing.get_object_class_fullname(res)})")
+        if Tools.do_log(logger, log_level):
+            logger.log(log_level, f"Evaluate function [{fct_str}] => [{func_name}({', '.join(args)})] => [{res}] (type: {Typing.get_object_class_fullname(res)})")
         return res
     
     def __register_default_functions(self, dynamic_text_manager):

holado_test/behave/behave_environment.py

@@ -22,6 +22,8 @@ from holado_test.behave.scenario.behave_step_tools import BehaveStepTools
 from holado_test.scenario.step_tools import StepTools
 from holado_test.test_config import TestConfig
 import time
+from behave.model_core import Status
+from holado.common.handlers.undefined import undefined_value
 
 
 logger = logging.getLogger(__name__)
@@ -107,23 +109,40 @@ def after_step(context, step):
         # Session context
         SessionContext.instance().after_step(step)
         
-        # Log failures
-        if step.status == "failed":
-            step_descr = __step_description(step)
-            var_step_descr = StepTools.evaluate_variable_name(step_descr)
-            interpreted_step_descr = StepTools.evaluate_string_parameter(step_descr)
-            msg = "Step failed:\n    step:\n{}{}{}\n    error:\n{}\n    step attributes:\n{}".format(
-                Tools.indent_string(8, step_descr),
+        # Log step result
+        step_descr = __step_description(step)
+        try:
+            var_step_descr = StepTools.evaluate_variable_name(step_descr, log_level=logging.NOTSET)
+        except:
+            var_step_descr = "[ERROR during evaluation]"
+        try:
+            interpreted_step_descr = StepTools.evaluate_string_parameter(step_descr, log_level=logging.NOTSET)
+        except:
+            interpreted_step_descr = "[ERROR during interpretation]"
+        if step.status in [Status.failed, Status.error] or interpreted_step_descr != step_descr or var_step_descr != interpreted_step_descr:
+            msg = "Step {}:\n    step:\n{}{}{}".format(
+                step.status.name, Tools.indent_string(8, step_descr),
                 "" if interpreted_step_descr == step_descr else "\n    interpreted step:\n{}".format(Tools.indent_string(8, interpreted_step_descr)),
-                "" if var_step_descr == interpreted_step_descr else "\n    partially interpreted step:\n{}".format(Tools.indent_string(8, var_step_descr)),
-                Tools.indent_string(8, __step_error(step)),
-                Tools.indent_string(8, __step_attributes(step)) )
-            if step.hook_failed:
-                msg += "\n    Hook failed"
+                "" if var_step_descr == interpreted_step_descr else "\n    partially interpreted step:\n{}".format(Tools.indent_string(8, var_step_descr)) )
+            
+            if step.status in [Status.failed, Status.error]:
+                msg += "\n    error:\n{}\n    step attributes:\n{}".format(
+                    Tools.indent_string(8, __step_error(step)),
+                    Tools.indent_string(8, __step_attributes(step)) )
+                if step.hook_failed:
+                    msg += "\n    Hook failed"
+        elif '\n' in step_descr:
+            msg = "Step {}:\n{}".format(step.status.name, Tools.indent_string(4, step_descr))
+        else:
+            msg = "Step {}: {}".format(step.status.name, step_descr)
+        
+        if step.status in [Status.failed, Status.error]:
             logger.error(msg)
             
             if TestConfig.wait_on_step_failure_s > 0:
                 time.sleep(TestConfig.wait_on_step_failure_s)
+        else:
+            logger.debug(msg)
     except:
         logger.exception(f"Hook error (step: {step})")
         raise

holado_test/behave/independant_runner.py

@@ -14,6 +14,7 @@
 import logging
 from behave.runner import Runner
 from behave.parser import parse_feature
+from holado.holado_config import Config
 
 
 logger = logging.getLogger(__name__)
@@ -55,12 +56,9 @@ class IndependantRunner(Runner):
         feature_text = \
             """
             Feature: Fake
-            
                 Scenario: Fake
-                    # Wait 7 days
-                    Given DELAY = ${7 * 24 * 3600}
-                    When wait DELAY seconds
-            """
+                    When wait {runner_session_timeout} seconds
+            """.format(runner_session_timeout=Config.session_timeout_seconds)
         feature = parse_feature(feature_text)
         
         return super().run_model([feature])