holado 0.13.22__py3-none-any.whl

holado_scripting/common/tools/variable_manager.py

@@ -0,0 +1,354 @@
+
+#################################################
+# HolAdo (Holistic Automation do)
+#
+# (C) Copyright 2021-2025 by Eric Klumpp
+# 
+# Permission is hereby granted, free of charge, to any person obtaining a copy of this software and associated documentation files (the “Software”), to deal in the Software without restriction, including without limitation the rights to use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of the Software, and to permit persons to whom the Software is furnished to do so, subject to the following conditions:
+# 
+# The above copyright notice and this permission notice shall be included in all copies or substantial portions of the Software.
+
+# The Software is provided “as is”, without warranty of any kind, express or implied, including but not limited to the warranties of merchantability, fitness for a particular purpose and noninfringement. In no event shall the authors or copyright holders be liable for any claim, damages or other liability, whether in an action of contract, tort or otherwise, arising from, out of or in connection with the software or the use or other dealings in the Software.
+#################################################
+
+import logging
+from holado_core.common.exceptions.functional_exception import FunctionalException
+import re
+from holado.common.handlers.object import Object, DeleteableObject
+from holado_core.common.tools.tools import Tools
+from holado.holado_config import Config
+from contextlib import contextmanager
+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):
+    """
+    Manage variables as couples of (name, value).
+    
+    Variable names can contain any character except: ".", "["
+    Variable names can end by any dynamic suffix symbol, the symbol will be replaced by the associated suffix.
+    """
+
+    def __init__(self, parent=None):
+        super().__init__("variable manager")
+        
+        self.__parent = parent
+        self.__dynamic_text_manager = None
+        self.__unique_value_manager = None
+        self.__variables = {}
+        
+        # Manage temporary variables
+        self.__temporary_variables_lock = threading.Lock()
+        self.__temporary_variables = {}
+        
+        # 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):
+        return self.__parent
+    
+    def _delete_object(self):
+        # Delete all variables
+        names = set(self.__variables.keys())
+        if Tools.do_log(logger, logging.DEBUG):
+            logger.debug(f"Removing {len(names)} variables: {names}")
+        for index, name in enumerate(names):
+            if name in self.__variables:
+                value = self.__variables[name]
+                if Tools.do_log(logger, logging.DEBUG):
+                    logger.debug(f"Removing variable {index+1}/{len(names)}: '{name}' (type: {Typing.get_object_class_fullname(value)})")
+                self.unregister_variable(name, through_parent=False, delete_value=True)
+        if Tools.do_log(logger, logging.DEBUG):
+            logger.debug(f"Finished to remove {len(names)} variables: {names}")
+                
+        # # 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
+        
+        uid = MultitaskManager.get_thread_uid()
+        with self.__temporary_variables_lock:
+            if uid not in self.__temporary_variables:
+                self.__temporary_variables[uid] = NamedTuple("TempVars", counter=int, variable_names=list)
+                self.__temporary_variables[uid].counter = 0
+                self.__temporary_variables[uid].variable_names = set()
+            self.__temporary_variables[uid].counter += 1
+            
+        try:
+            yield None
+        finally:
+            with self.__temporary_variables_lock:
+                self.__temporary_variables[uid].counter -= 1
+                if self.__temporary_variables[uid].counter == 0:
+                    logger.info(f"Unregistering temporary variables: {self.__temporary_variables[uid].variable_names}")
+                    for var_name in self.__temporary_variables[uid].variable_names:
+                        if self.exists_variable(var_name, through_parent=False):
+                            self.unregister_variable(var_name, through_parent=False, delete_value=True)
+                    del self.__temporary_variables[uid]
+                    GcManager.collect()
+        
+        
+    def new_local_variable_name(self, sub_name=None):
+        if sub_name is not None:
+            return f"__VAR_{sub_name}_{self.__unique_value_manager.new_string(do_log=False)}__"
+        else:
+            return f"__VAR{self.__unique_value_manager.new_string(do_log=False)}__"
+    
+    def new_variable_name(self):
+        res = None
+        while True:
+            res = self.new_local_variable_name()
+            if not self.exists_variable(variable_name=res):
+                break
+        return res
+    
+    def evaluate_variable_name(self, var_name):
+        if var_name.endswith(Config.DYNAMIC_SYMBOL):
+            return self.__dynamic_text_manager.get(var_name[:-1])
+        elif var_name.endswith(Config.THREAD_DYNAMIC_SYMBOL):
+            from holado_multitask.multitasking.multitask_manager import MultitaskManager
+            return self.__dynamic_text_manager.get(var_name[:-1], scope=MultitaskManager.get_thread_id())
+        elif var_name.endswith(Config.UNIQUE_SYMBOL):
+            return var_name[:-1] + self.__unique_value_manager.new_string(padding_length=Config.unique_string_padding_length)
+        else:
+            return var_name
+    
+    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)})...")
+        
+        names = variable_name.rsplit('.', 1)
+        if accept_expression and len(names) > 1:
+            if not self.exists_variable(expression=names[0]):
+                self.register_variable(names[0], Object())
+            var = self.get_value(names[0], through_patent=False)
+            setattr(var, names[1], 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(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()
+            with self.__temporary_variables_lock:
+                if uid in self.__temporary_variables:
+                    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]
+            if Tools.do_log(logger, logging.DEBUG):
+                logger.debug(f"Unregistering variable '{var_name}' (type: {Typing.get_object_class_fullname(value)})")
+                
+            if delete_value and isinstance(value, DeleteableObject):
+                try:
+                    value.delete_object()
+                except Exception:
+                    logger.exception(f"Catched exception while deleting object '{var_name}' (type: {Typing.get_object_class_fullname(value)})")
+                else:
+                    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:
+            return self.parent.unregister_variable(variable_name, through_parent=through_parent, delete_value=delete_value)
+        else:
+            raise FunctionalException(f"Variable '{var_name}' has not been found. Missing initialisation ?")
+        
+    def pop_variable(self, variable_name):
+        res = self.get_variable_value(variable_name, through_parent=False)
+        self.unregister_variable(variable_name, through_parent=False, delete_value=False)
+        return res
+    
+    def get_variable_value(self, variable_name, attributes = [], through_parent=True):
+        # Get variable value
+        var_name = self.evaluate_variable_name(variable_name)
+        if self.exists_variable(var_name, through_parent=False):
+            res = self.__variables[var_name]
+        elif through_parent and self.parent:
+            return self.parent.get_variable_value(variable_name, attributes)
+        else:
+            raise FunctionalException("Variable '{}' has not been found. Missing initialisation ?".format(variable_name))
+        
+        # If needed, call attributes
+        for attr in attributes:
+            res = getattr(res, attr)
+        
+        return res
+
+    def get_value(self, expression, through_patent=True):
+        res = None
+        
+        if self.is_variable_expression(expression, through_parent=through_patent):
+            try:
+                res = self.eval_variable_expression(expression, through_parent=through_patent)
+            except (SyntaxError, NameError):
+                raise FunctionalException("Expression '{}' is not evaluable. Is an initialization missing ?".format(expression))
+        else:
+            res = self.get_variable_value(expression, through_parent=through_patent)
+        
+        return res
+
+    def set_value(self, expression, value, through_parent=True):
+        if self.is_variable_expression(expression, through_parent=through_parent):
+            try:
+                self.exec_set_variable_expression(expression, value, through_parent=through_parent)
+            except (SyntaxError, NameError):
+                raise FunctionalException("Expression '{}' is not evaluable. Is an initialization missing ?".format(expression))
+        else:
+            self.register_variable(expression, value)
+
+    def exists_variable(self, variable_name=None, expression=None, through_parent=True):
+        if expression is not None:
+            expression = expression.strip()
+            m_operator = re.search("[.[]", expression)
+            if m_operator:
+                # Return directly False if found operator is not an operator
+                # EKL: Why this check is done ???
+                if m_operator.group(0) not in ['.', '[']:
+                    return False
+                # Begin by looking for variable existance
+                variable_name = expression[:m_operator.start()]
+            else:
+                variable_name = expression
+        
+        var_name = self.evaluate_variable_name(variable_name)
+        res = var_name in self.__variables
+        
+        # For expression, look if sub variable exist
+        if res and expression is not None and variable_name != expression:
+            try:
+                _ = self.eval_variable_expression(expression, through_parent=False)
+            except:
+                res = False
+            else:
+                res = True
+        
+        if not res and through_parent and self.parent:
+            if expression is not None:
+                res = self.parent.exists_variable(expression=expression)
+            else:
+                res = self.parent.exists_variable(variable_name=variable_name)
+        return res
+    
+    def is_variable_expression(self, expression, through_parent=True):
+        try:
+            var_name, expr_rest = self.__extract_expression_name(expression)
+            return len(var_name) > 0 and self.exists_variable(var_name, through_parent=through_parent) and len(expr_rest) > 0
+        except SyntaxError:
+            return False
+    
+    def eval_variable_expression(self, expression, through_parent=True):
+        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))
+        locals()[new_var_name] = var_value
+        
+        new_expr = f"{new_var_name}{expr_rest}"
+        try:
+            return eval(new_expr)
+        except Exception as exc:
+            try:
+                var_repr = Tools.represent_object(var_value)
+            except:
+                var_repr = str(var_value)
+            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))
+        locals()[new_var_name] = var_value
+        
+        new_var_value = self.new_local_variable_name(sub_name='value')
+        locals()[new_var_value] = value
+        
+        new_expr = f"{new_var_name}{expr_rest}={new_var_value}"
+        try:
+            exec(new_expr)
+        except Exception as exc:
+            try:
+                var_repr = Tools.represent_object(var_value)
+            except:
+                var_repr = str(var_value)
+            # 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(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])
+    
+    # def set_variable_expression(self, expression, value):
+    #     var_name, expr_rest = self.__extract_expression_name(expression)
+    #     if len(expr_rest) == 0:
+    #         self.register_variable(expression, value)
+    #     else:
+    #         var_value = self.get_variable_value(var_name)
+    #
+    #     while len(expr_rest) > 0:
+    #
+
+    
+    def __extract_expression_name(self, expression):
+        regex_name = re.compile("^([^.[]+)(.*)")
+        m = regex_name.match(expression)
+        if not m:
+            raise SyntaxError(f"Expression [{expression}] is not a variable expression")
+        var_name, expr_rest = m.group(1), m.group(2)
+        var_name = self.evaluate_variable_name(var_name)
+        return var_name, expr_rest
+        
+        
+        
+        
+        

holado_scripting/tests/behave/steps/__init__.py

@@ -0,0 +1,22 @@
+# -*- coding: utf-8 -*-
+
+#################################################
+# HolAdo (Holistic Automation do)
+#
+# (C) Copyright 2021-2025 by Eric Klumpp
+# 
+# Permission is hereby granted, free of charge, to any person obtaining a copy of this software and associated documentation files (the “Software”), to deal in the Software without restriction, including without limitation the rights to use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of the Software, and to permit persons to whom the Software is furnished to do so, subject to the following conditions:
+# 
+# The above copyright notice and this permission notice shall be included in all copies or substantial portions of the Software.
+
+# The Software is provided “as is”, without warranty of any kind, express or implied, including but not limited to the warranties of merchantability, fitness for a particular purpose and noninfringement. In no event shall the authors or copyright holders be liable for any claim, damages or other liability, whether in an action of contract, tort or otherwise, arising from, out of or in connection with the software or the use or other dealings in the Software.
+#################################################
+
+
+from .common.tools.variable_convert_steps import *
+from .common.tools.variable_new_steps import *
+from .common.tools.variable_steps import *
+from .common.tools.variable_verify_steps import *
+from .scenario.function_steps import *
+from .scenario.if_steps import *
+from .scenario.loop_steps import *

holado_scripting/tests/behave/steps/common/tools/variable_convert_steps.py

@@ -0,0 +1,159 @@
+# -*- coding: utf-8 -*-
+
+#################################################
+# HolAdo (Holistic Automation do)
+#
+# (C) Copyright 2021-2025 by Eric Klumpp
+# 
+# Permission is hereby granted, free of charge, to any person obtaining a copy of this software and associated documentation files (the “Software”), to deal in the Software without restriction, including without limitation the rights to use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of the Software, and to permit persons to whom the Software is furnished to do so, subject to the following conditions:
+# 
+# The above copyright notice and this permission notice shall be included in all copies or substantial portions of the Software.
+
+# The Software is provided “as is”, without warranty of any kind, express or implied, including but not limited to the warranties of merchantability, fitness for a particular purpose and noninfringement. In no event shall the authors or copyright holders be liable for any claim, damages or other liability, whether in an action of contract, tort or otherwise, arising from, out of or in connection with the software or the use or other dealings in the Software.
+#################################################
+
+
+from holado_test.scenario.step_tools import StepTools
+from holado.common.context.session_context import SessionContext
+from holado_test.behave.behave import *  # @UnusedWildImport
+from holado_core.common.exceptions.functional_exception import FunctionalException
+from holado_core.common.exceptions.technical_exception import TechnicalException
+import base64
+import codecs
+import logging
+from holado_core.common.tables.table import Table
+from holado_value.common.tables.value_table_with_header import ValueTableWithHeader
+from holado_value.common.tables.value_table import ValueTable
+from holado_core.common.tools.tools import Tools
+from holado_python.standard_library.typing import Typing
+from holado_value.common.tables.value_table_manager import ValueTableManager
+
+logger = logging.getLogger(__name__)
+
+
+def __get_scenario_context():
+    return SessionContext.instance().get_scenario_context()
+
+def __get_text_interpreter():
+    return __get_scenario_context().get_text_interpreter()
+
+def __get_unique_value_manager():
+    return SessionContext.instance().unique_value_manager
+
+def __get_variable_manager():
+    return __get_scenario_context().get_variable_manager()
+
+
+
+
+
+@Given(r"(?P<var_name>{Variable}) = convert list (?P<list_var_name>{Variable}) to list of object attribute (?P<attribute_name>{Str})")
+def step_impl(context, var_name, list_var_name, attribute_name):  # @DuplicatedSignature
+    var_name = StepTools.evaluate_variable_name(var_name)
+    attr_name = StepTools.evaluate_scenario_parameter(attribute_name)
+    list_obj = StepTools.evaluate_variable_value(list_var_name)
+    
+    res = []
+    for index, obj in enumerate(list_obj):
+        if hasattr(obj, attr_name):
+            attr_val = getattr(obj, attr_name)
+            if Tools.do_log(logger, logging.DEBUG):
+                logger.debug(f"Result list - add attribute value [{attr_val}] (type: {Typing.get_object_class_fullname(attr_val)} ; dir: {dir(attr_val)})")
+            res.append(attr_val)
+        else:
+            raise FunctionalException(f"In list, object of index {index} hasn't attribute '{attr_name}'")
+    
+    __get_variable_manager().register_variable(var_name, res)
+    
+@Step(r"(?P<var_name>{Variable}) = convert object value (?P<object_value>{Str}) to string")
+def step_impl(context, var_name, object_value):
+    var_name = StepTools.evaluate_variable_name(var_name)
+    object_value = StepTools.evaluate_variable_value(object_value)
+    if isinstance(object_value, bytes):
+        res = object_value.decode('utf-8')
+    else:
+        res = str(object_value)
+    __get_variable_manager().register_variable(var_name, res)
+    
+@Step(r"(?P<var_name>{Variable}) = convert object value (?P<object_value>{Str}) to integer")
+def step_impl(context, var_name, object_value):
+    var_name = StepTools.evaluate_variable_name(var_name)
+    object_value = StepTools.evaluate_variable_value(object_value)
+    __get_variable_manager().register_variable(var_name, int(object_value))
+    
+@Step(r"(?P<var_name>{Variable}) = convert object value (?P<object_value>{Str}) to list")
+def step_impl(context, var_name, object_value):
+    var_name = StepTools.evaluate_variable_name(var_name)
+    object_value = StepTools.evaluate_variable_value(object_value)
+    
+    if isinstance(object_value, Table):
+        table = object_value
+        if table.nb_columns > 1 and table.nb_rows > 1:
+            raise FunctionalException(f"Table must have only one column or only one row (table has {table.nb_columns} and {table.nb_rows})")
+        
+        if table.nb_columns > 1 and table.nb_rows == 1:
+            row = table.get_row(0)
+        elif table.nb_rows > 1 and table.nb_columns == 1:
+            row = table.get_column(0)
+        else:
+            row = None
+            
+        if row is not None:
+            if ValueTableManager.is_value_table(table):
+                res = [c.value for c in row]
+            else:
+                res = [c.content for c in row]
+        else:
+            res = []
+    else:
+        res = list(object_value)
+    
+    __get_variable_manager().register_variable(var_name, res)
+    
+@Step(r"(?P<var_name>{Variable}) = convert object value (?P<object_value>{Str}) to dict")
+def step_impl(context, var_name, object_value):
+    var_name = StepTools.evaluate_variable_name(var_name)
+    object_value = StepTools.evaluate_variable_value(object_value)
+    __get_variable_manager().register_variable(var_name, dict(object_value))
+
+@Step(r"(?P<var_name>{Variable}) = convert object value (?P<object_value>{Str}) to base 64")
+def step_impl(context, var_name, object_value):
+    var_name = StepTools.evaluate_variable_name(var_name)
+    object_value = StepTools.evaluate_variable_value(object_value)
+    if isinstance(object_value, bytes):
+        value_bytes = object_value
+    elif isinstance(object_value, str):
+        value_bytes = object_value.encode('utf-8')
+    else:
+        raise TechnicalException(f"Unexpected object value type {Typing.get_object_class_fullname(object_value)} (allowed types: string, bytes)")
+    res = base64.b64encode(value_bytes)
+    __get_variable_manager().register_variable(var_name, res)
+
+@Step(r"(?P<var_name>{Variable}) = convert hex string (?P<object_value>{Str}) to bytes")
+def step_impl(context, var_name, object_value):
+    var_name = StepTools.evaluate_variable_name(var_name)
+    object_value = StepTools.evaluate_scenario_parameter(object_value)
+    if isinstance(object_value, str):
+        res = codecs.decode(object_value, 'hex_codec')
+    else:
+        raise TechnicalException(f"Unexpected value type {Typing.get_object_class_fullname(object_value)}")
+    __get_variable_manager().register_variable(var_name, res)
+    
+@Step(r"(?P<var_name>{Variable}) = convert hex string (?P<object_value>{Str}) to base 64")
+def step_impl(context, var_name, object_value):
+    var_name = StepTools.evaluate_variable_name(var_name)
+    execute_steps(u"""
+        {keyword} __{var_name}_BYTES__ = convert hex string {object_value} to bytes
+        {keyword} {var_name} = convert object value __{var_name}_BYTES__ to base 64
+        """.format(keyword=context.step.keyword, var_name=var_name, object_value=object_value))
+    
+
+@Step(r"(?P<var_name>{Variable}) = convert base 64 (?P<value>{Str}) to bytes")
+def step_impl(context, var_name, value):
+    var_name = StepTools.evaluate_variable_name(var_name)
+    value = StepTools.evaluate_scenario_parameter(value)
+    if not isinstance(value, str):
+        raise TechnicalException(f"Unexpected value type {Typing.get_object_class_fullname(value)} (allowed types: string)")
+    res = base64.b64decode(value)
+    __get_variable_manager().register_variable(var_name, res)
+    

holado_scripting/tests/behave/steps/common/tools/variable_new_steps.py

@@ -0,0 +1,130 @@
+# -*- coding: utf-8 -*-
+
+#################################################
+# HolAdo (Holistic Automation do)
+#
+# (C) Copyright 2021-2025 by Eric Klumpp
+# 
+# Permission is hereby granted, free of charge, to any person obtaining a copy of this software and associated documentation files (the “Software”), to deal in the Software without restriction, including without limitation the rights to use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of the Software, and to permit persons to whom the Software is furnished to do so, subject to the following conditions:
+# 
+# The above copyright notice and this permission notice shall be included in all copies or substantial portions of the Software.
+
+# The Software is provided “as is”, without warranty of any kind, express or implied, including but not limited to the warranties of merchantability, fitness for a particular purpose and noninfringement. In no event shall the authors or copyright holders be liable for any claim, damages or other liability, whether in an action of contract, tort or otherwise, arising from, out of or in connection with the software or the use or other dealings in the Software.
+#################################################
+
+
+from holado_value.common.tables.value_table_manager import ValueTableManager
+from holado_test.scenario.step_tools import StepTools
+from holado.common.context.session_context import SessionContext
+from holado_test.behave.behave import *  # @UnusedWildImport
+import logging
+from holado_core.common.exceptions.functional_exception import FunctionalException
+from holado_test.behave.scenario.behave_step_tools import BehaveStepTools
+from holado_value.common.tables.converters.value_table_converter import ValueTableConverter
+from holado_python.standard_library.typing import Typing
+
+logger = logging.getLogger(__name__)
+
+
+def __get_scenario_context():
+    return SessionContext.instance().get_scenario_context()
+
+def __get_text_interpreter():
+    return __get_scenario_context().get_text_interpreter()
+
+def __get_unique_value_manager():
+    return SessionContext.instance().unique_value_manager
+
+def __get_variable_manager():
+    return __get_scenario_context().get_variable_manager()
+
+
+
+
+@Given(r"(?P<var_name>{Variable}) = new (?P<type_name>{Str}) with attributes")
+def step_impl(context, var_name, type_name):
+    var_name = StepTools.evaluate_variable_name(var_name)
+    type_name = StepTools.evaluate_string_parameter(type_name)
+    table = BehaveStepTools.convert_step_table_2_value_table_with_header(context.table)
+    
+    # Get class type
+    class_ = Typing.get_class_for_type_name(type_name)
+    
+    # Create object
+    obj = class_()
+    ValueTableManager.set_object_attributes_according_name_value_table(obj, table)
+    
+    # Store in variable
+    __get_variable_manager().register_variable(var_name, obj)
+
+@Given(r"(?P<var_name>{Variable}) = new (?P<type_name>{Str}) with constructor parameters")
+def step_impl(context, var_name, type_name):  # @DuplicatedSignature
+    var_name = StepTools.evaluate_variable_name(var_name)
+    type_name = StepTools.evaluate_string_parameter(type_name)
+    
+    # Get class type
+    class_ = Typing.get_class_for_type_name(type_name)
+    
+    # Create object
+    table = BehaveStepTools.convert_step_table_2_value_table_with_header(context.table)
+    unnamed_parameters, named_parameters = ValueTableConverter.convert_name_value_table_2_list_and_dict(table)
+    logger.info("creating new '{}' with parameters {} and {}".format(class_, unnamed_parameters, named_parameters))
+    obj = class_(*unnamed_parameters, **named_parameters)
+    
+    # Store in variable
+    __get_variable_manager().register_variable(var_name, obj)
+    
+@Given(r"(?P<var_name>{Variable}) = list")
+def step_impl(context, var_name):
+    var_name = StepTools.evaluate_variable_name(var_name)
+    table = BehaveStepTools.convert_step_table_2_value_table(context.table)
+    if table.nb_columns > 1 and table.nb_rows > 1:
+        raise FunctionalException("Table must be a single column or a single row")
+    
+    if table.nb_rows > 1:
+        res = list(table.get_column(0).cells_value)
+    else:
+        res = list(table.get_row(0).cells_value)
+    
+    # Store in variable
+    __get_variable_manager().register_variable(var_name, res)
+    
+@Given(r"(?P<var_name>{Variable}) = multiline text")
+def step_impl(context, var_name):
+    var_name = StepTools.evaluate_variable_name(var_name)
+    res = BehaveStepTools.get_step_multiline_text(context)
+    __get_variable_manager().register_variable(var_name, res)
+    
+@Given(r"(?P<var_name>{Variable}) = new unique integer")
+def step_impl(context, var_name):
+    var_name = StepTools.evaluate_variable_name(var_name)
+    res = __get_unique_value_manager().new_integer()
+    __get_variable_manager().register_variable(var_name, res)
+    
+@Given(r"(?P<var_name>{Variable}) = new unique HEX integer")
+def step_impl(context, var_name):
+    var_name = StepTools.evaluate_variable_name(var_name)
+    res = __get_unique_value_manager().new_hex()
+    __get_variable_manager().register_variable(var_name, res)
+    
+@Given(r"(?P<var_name>{Variable}) = new unique HEX integer \(length: (?P<length>{Int})\)")
+def step_impl(context, var_name, length):
+    var_name = StepTools.evaluate_variable_name(var_name)
+    length = StepTools.evaluate_scenario_parameter(length)
+    res = __get_unique_value_manager().new_hex(length=length)
+    __get_variable_manager().register_variable(var_name, res)
+    
+@Given(r"(?P<var_name>{Variable}) = new unique string")
+def step_impl(context, var_name):
+    var_name = StepTools.evaluate_variable_name(var_name)
+    res = __get_unique_value_manager().new_string()
+    __get_variable_manager().register_variable(var_name, res)
+    
+@Given(r"(?P<var_name>{Variable}) = new unique string \(padding length: (?P<pad_len>{Int})\)")
+def step_impl(context, var_name, pad_len):
+    var_name = StepTools.evaluate_variable_name(var_name)
+    pad_len = StepTools.evaluate_scenario_parameter(pad_len)
+    res = __get_unique_value_manager().new_string(padding_length=pad_len)
+    __get_variable_manager().register_variable(var_name, res)
+
+