robotframework 6.1.1__zip → 7.0__zip

{robotframework-6.1.1 → robotframework-7.0}/src/robot/variables/assigner.py

@@ -105,7 +105,7 @@ class VariableAssigner:
 
     def assign(self, return_value):
         context = self._context
-        context.output.trace(lambda: 'Return: %s' % prepr(return_value),
+        context.output.trace(lambda: f'Return: {prepr(return_value)}',
                              write_if_flat=False)
         resolver = ReturnValueResolver(self._assignment)
         for name, items, value in resolver.resolve(return_value):
@@ -120,7 +120,7 @@ class VariableAssigner:
             return False
         base, attr = [token.strip() for token in name[2:-1].rsplit('.', 1)]
         try:
-            var = variables.replace_scalar('${%s}' % base)
+            var = variables.replace_scalar(f'${{{base}}}')
         except VariableError:
             return False
         if not (self._variable_supports_extended_assign(var) and
@@ -128,9 +128,9 @@ class VariableAssigner:
             return False
         try:
             setattr(var, attr, value)
-        except:
-            raise VariableError("Setting attribute '%s' to variable '${%s}' failed: %s"
-                                % (attr, base, get_error_message()))
+        except Exception:
+            raise VariableError(f"Setting attribute '{attr}' to variable '${{{base}}}' "
+                                f"failed: {get_error_message()}")
         return True
 
     def _variable_supports_extended_assign(self, var):
@@ -172,14 +172,12 @@ class VariableAssigner:
         *nested, item = items
         decorated_nested_items = ''.join(f'[{item}]' for item in nested)
         var = variables.replace_scalar(f'${name[1:]}{decorated_nested_items}')
-
         if not self._variable_type_supports_item_assign(var):
             var_type = type_name(var)
             raise VariableError(
                 f"Variable '{name}{decorated_nested_items}' is {var_type} "
                 f"and does not support item assignment."
                 )
-
         selector = variables.replace_scalar(item)
         if isinstance(var, MutableSequence):
             try:
@@ -199,7 +197,10 @@ class VariableAssigner:
         return value
 
     def _normal_assign(self, name, value, variables):
-        variables[name] = value
+        try:
+            variables[name] = value
+        except DataError as err:
+            raise VariableError(f"Setting variable '{name}' failed: {err}")
         # Always return the actually assigned value.
         return value if name[0] == '$' else variables[name]
 
@@ -239,8 +240,8 @@ class _MultiReturnValueResolver:
     def __init__(self, assignments):
         self._names = []
         self._items = []
-        for assigment in assignments:
-            match: VariableMatch = search_variable(assigment)
+        for assign in assignments:
+            match: VariableMatch = search_variable(assign)
             self._names.append(match.name)
             self._items.append(match.items)
         self._min_count = len(assignments)
@@ -261,10 +262,10 @@ class _MultiReturnValueResolver:
             self._raise_expected_list(return_value)
 
     def _raise_expected_list(self, ret):
-        self._raise('Expected list-like value, got %s.' % type_name(ret))
+        self._raise(f'Expected list-like value, got {type_name(ret)}.')
 
     def _raise(self, error):
-        raise VariableError('Cannot set variables: %s' % error)
+        raise VariableError(f'Cannot set variables: {error}')
 
     def _validate(self, return_count):
         raise NotImplementedError
@@ -277,8 +278,7 @@ class ScalarsOnlyReturnValueResolver(_MultiReturnValueResolver):
 
     def _validate(self, return_count):
         if return_count != self._min_count:
-            self._raise('Expected %d return values, got %d.'
-                        % (self._min_count, return_count))
+            self._raise(f'Expected {self._min_count} return values, got {return_count}.')
 
     def _resolve(self, return_value):
         return list(zip(self._names, self._items, return_value))
@@ -287,18 +287,17 @@ class ScalarsOnlyReturnValueResolver(_MultiReturnValueResolver):
 class ScalarsAndListReturnValueResolver(_MultiReturnValueResolver):
 
     def __init__(self, assignments):
-        _MultiReturnValueResolver.__init__(self, assignments)
+        super().__init__(assignments)
         self._min_count -= 1
 
     def _validate(self, return_count):
         if return_count < self._min_count:
-            self._raise('Expected %d or more return values, got %d.'
-                        % (self._min_count, return_count))
+            self._raise(f'Expected {self._min_count} or more return values, '
+                        f'got {return_count}.')
 
     def _resolve(self, return_value):
         list_index = [a[0][0] for a in self._names].index('@')
         list_len = len(return_value) - len(self._names) + 1
-
         elements_before_list = list(zip(
             self._names[:list_index],
             self._items[:list_index],
@@ -314,5 +313,4 @@ class ScalarsAndListReturnValueResolver(_MultiReturnValueResolver):
             self._items[list_index],
             return_value[list_index:list_index+list_len],
         )]
-
         return elements_before_list + list_elements + elements_after_list

{robotframework-6.1.1 → robotframework-7.0}/src/robot/variables/evaluation.py

@@ -14,6 +14,7 @@
 #  limitations under the License.
 
 import builtins
+import re
 import token
 from collections.abc import MutableMapping
 from io import StringIO
@@ -22,7 +23,7 @@ from tokenize import generate_tokens, untokenize
 from robot.errors import DataError
 from robot.utils import get_error_message, type_name
 
-from .search import search_variable
+from .search import VariableMatches
 from .notfound import variable_not_found
 
 
@@ -44,12 +45,18 @@ def evaluate_expression(expression, variables, modules=None, namespace=None,
         return _evaluate(expression, variables.store, modules, namespace)
     except DataError as err:
         error = str(err)
-        recommendation = ''
-    except Exception:
+        variable_recommendation = ''
+    except Exception as err:
         error = get_error_message()
-        recommendation = _recommend_special_variables(original)
-    raise DataError(f"Evaluating expression '{expression}' failed: {error}\n\n"
-                    f"{recommendation}".strip())
+        variable_recommendation = ''
+        if isinstance(err, NameError) and 'RF_VAR_' in error:
+            name = re.search(r'RF_VAR_([\w_]*)', error).group(1)
+            error = (f"Robot Framework variable '${name}' is used in a scope "
+                     f"where it cannot be seen.")
+        else:
+            variable_recommendation = _recommend_special_variables(original)
+    raise DataError(f'Evaluating expression {expression!r} failed: {error}\n\n'
+                    f'{variable_recommendation}'.strip())
 
 
 def _evaluate(expression, variable_store, modules=None, namespace=None):
@@ -106,19 +113,15 @@ def _import_modules(module_names):
 
 
 def _recommend_special_variables(expression):
-    example = []
-    remaining = expression
-    while True:
-        match = search_variable(remaining)
-        if not match:
-            break
-        example[-1:] = [match.before, match.identifier, match.base, match.after]
-        remaining = example[-1]
-    if not example:
+    matches = VariableMatches(expression)
+    if not matches:
         return ''
+    example = []
+    for match in matches:
+        example[-1:] += [match.before, match.identifier, match.base, match.after]
     example = ''.join(example)
-    return (f"Variables in the original expression '{expression}' were resolved "
-            f"before the expression was evaluated. Try using '{example}' "
+    return (f"Variables in the original expression {expression!r} were resolved "
+            f"before the expression was evaluated. Try using {example!r} "
             f"syntax to avoid that. See Evaluating Expressions appendix in "
             f"Robot Framework User Guide for more details.")
 

{robotframework-6.1.1 → robotframework-7.0}/src/robot/variables/filesetter.py

@@ -23,14 +23,16 @@ except ImportError:
 
 from robot.errors import DataError
 from robot.output import LOGGER
-from robot.utils import (get_error_message, is_dict_like, is_list_like,
-                         is_string, seq2str2, type_name, DotDict, Importer)
+from robot.utils import (DotDict, get_error_message, Importer, is_dict_like,
+                         is_list_like, type_name)
+
+from .store import VariableStore
 
 
 class VariableFileSetter:
 
-    def __init__(self, store):
-        self._store = store
+    def __init__(self, store: VariableStore):
+        self.store = store
 
     def set(self, path_or_variables, args=None, overwrite=False):
         variables = self._import_if_needed(path_or_variables, args)
@@ -38,10 +40,9 @@ class VariableFileSetter:
         return variables
 
     def _import_if_needed(self, path_or_variables, args=None):
-        if not is_string(path_or_variables):
+        if not isinstance(path_or_variables, str):
             return path_or_variables
-        LOGGER.info("Importing variable file '%s' with args %s"
-                    % (path_or_variables, args))
+        LOGGER.info(f"Importing variable file '{path_or_variables}' with args {args}.")
         if path_or_variables.lower().endswith(('.yaml', '.yml')):
             importer = YamlImporter()
         elif path_or_variables.lower().endswith('.json'):
@@ -50,48 +51,14 @@ class VariableFileSetter:
             importer = PythonImporter()
         try:
             return importer.import_variables(path_or_variables, args)
-        except:
-            args = 'with arguments %s ' % seq2str2(args) if args else ''
-            raise DataError("Processing variable file '%s' %sfailed: %s"
-                            % (path_or_variables, args, get_error_message()))
+        except Exception:
+            args = f'with arguments {args} ' if args else ''
+            raise DataError(f"Processing variable file '{path_or_variables}' "
+                            f"{args}failed: {get_error_message()}")
 
     def _set(self, variables, overwrite=False):
         for name, value in variables:
-            self._store.add(name, value, overwrite)
-
-
-class YamlImporter:
-
-    def import_variables(self, path, args=None):
-        if args:
-            raise DataError('YAML variable files do not accept arguments.')
-        variables = self._import(path)
-        return [('${%s}' % name, self._dot_dict(value))
-                for name, value in variables]
-
-    def _import(self, path):
-        with io.open(path, encoding='UTF-8') as stream:
-            variables = self._load_yaml(stream)
-        if not is_dict_like(variables):
-            raise DataError('YAML variable file must be a mapping, got %s.'
-                            % type_name(variables))
-        return variables.items()
-
-    def _load_yaml(self, stream):
-        if not yaml:
-            raise DataError('Using YAML variable files requires PyYAML module '
-                            'to be installed. Typically you can install it '
-                            'by running `pip install pyyaml`.')
-        if yaml.__version__.split('.')[0] == '3':
-            return yaml.load(stream)
-        return yaml.full_load(stream)
-
-    def _dot_dict(self, value):
-        if is_dict_like(value):
-            return DotDict((k, self._dot_dict(v)) for k, v in value.items())
-        if is_list_like(value):
-            return [self._dot_dict(v) for v in value]
-        return value
+            self.store.add(name, value, overwrite, decorated=False)
 
 
 class PythonImporter:
@@ -102,24 +69,29 @@ class PythonImporter:
         return self._get_variables(var_file, args)
 
     def _get_variables(self, var_file, args):
-        if self._is_dynamic(var_file):
-            variables = self._get_dynamic(var_file, args)
-        else:
+        get_variables = (getattr(var_file, 'get_variables', None) or
+                         getattr(var_file, 'getVariables', None))
+        if get_variables:
+            variables = self._get_dynamic(get_variables, args)
+        elif not args:
             variables = self._get_static(var_file)
+        else:
+            raise DataError('Static variable files do not accept arguments.')
         return list(self._decorate_and_validate(variables))
 
-    def _is_dynamic(self, var_file):
-        return (hasattr(var_file, 'get_variables') or
-                hasattr(var_file, 'getVariables'))
-
-    def _get_dynamic(self, var_file, args):
-        get_variables = (getattr(var_file, 'get_variables', None) or
-                         getattr(var_file, 'getVariables'))
-        variables = get_variables(*args)
+    def _get_dynamic(self, get_variables, args):
+        positional, named = self._resolve_arguments(get_variables, args)
+        variables = get_variables(*positional, **dict(named))
         if is_dict_like(variables):
             return variables.items()
-        raise DataError("Expected '%s' to return dict-like value, got %s."
-                        % (get_variables.__name__, type_name(variables)))
+        raise DataError(f"Expected '{get_variables.__name__}' to return "
+                        f"a dictionary-like value, got {type_name(variables)}.")
+
+    def _resolve_arguments(self, get_variables, args):
+        # Avoid cyclic import. Yuck.
+        from robot.running.arguments import PythonArgumentParser
+        spec = PythonArgumentParser('variable file').parse(get_variables)
+        return spec.resolve(args)
 
     def _get_static(self, var_file):
         names = [attr for attr in dir(var_file) if not attr.startswith('_')]
@@ -132,40 +104,35 @@ class PythonImporter:
 
     def _decorate_and_validate(self, variables):
         for name, value in variables:
-            name = self._decorate(name)
-            self._validate(name, value)
+            if name.startswith('LIST__'):
+                if not is_list_like(value):
+                    raise DataError(f"Invalid variable '{name}': Expected a "
+                                    f"list-like value, got {type_name(value)}.")
+                name = name[6:]
+                value = list(value)
+            elif name.startswith('DICT__'):
+                if not is_dict_like(value):
+                    raise DataError(f"Invalid variable '{name}': Expected a "
+                                    f"dictionary-like value, got {type_name(value)}.")
+                name = name[6:]
+                value = DotDict(value)
             yield name, value
 
-    def _decorate(self, name):
-        if name.startswith('LIST__'):
-            return '@{%s}' % name[6:]
-        if name.startswith('DICT__'):
-            return '&{%s}' % name[6:]
-        return '${%s}' % name
-
-    def _validate(self, name, value):
-        if name[0] == '@' and not is_list_like(value):
-            raise DataError("Invalid variable '%s': Expected list-like value, "
-                            "got %s." % (name, type_name(value)))
-        if name[0] == '&' and not is_dict_like(value):
-            raise DataError("Invalid variable '%s': Expected dict-like value, "
-                            "got %s." % (name, type_name(value)))
-
 
 class JsonImporter:
+
     def import_variables(self, path, args=None):
         if args:
             raise DataError('JSON variable files do not accept arguments.')
         variables = self._import(path)
-        return [('${%s}' % name, self._dot_dict(value))
-                for name, value in variables]
+        return [(name, self._dot_dict(value)) for name, value in variables]
 
     def _import(self, path):
         with io.open(path, encoding='UTF-8') as stream:
             variables = json.load(stream)
         if not is_dict_like(variables):
-            raise DataError('JSON variable file must be a mapping, got %s.'
-                            % type_name(variables))
+            raise DataError(f'JSON variable file must be a mapping, '
+                            f'got {type_name(variables)}.')
         return variables.items()
 
     def _dot_dict(self, value):
@@ -174,3 +141,36 @@ class JsonImporter:
         if is_list_like(value):
             return [self._dot_dict(v) for v in value]
         return value
+
+
+class YamlImporter:
+
+    def import_variables(self, path, args=None):
+        if args:
+            raise DataError('YAML variable files do not accept arguments.')
+        variables = self._import(path)
+        return [(name, self._dot_dict(value)) for name, value in variables]
+
+    def _import(self, path):
+        with io.open(path, encoding='UTF-8') as stream:
+            variables = self._load_yaml(stream)
+        if not is_dict_like(variables):
+            raise DataError(f'YAML variable file must be a mapping, '
+                            f'got {type_name(variables)}.')
+        return variables.items()
+
+    def _load_yaml(self, stream):
+        if not yaml:
+            raise DataError('Using YAML variable files requires PyYAML module '
+                            'to be installed. Typically you can install it '
+                            'by running `pip install pyyaml`.')
+        if yaml.__version__.split('.')[0] == '3':
+            return yaml.load(stream)
+        return yaml.full_load(stream)
+
+    def _dot_dict(self, value):
+        if is_dict_like(value):
+            return DotDict((k, self._dot_dict(v)) for k, v in value.items())
+        if is_list_like(value):
+            return [self._dot_dict(v) for v in value]
+        return value

{robotframework-6.1.1 → robotframework-7.0}/src/robot/variables/replacer.py

@@ -42,33 +42,32 @@ class VariableReplacer:
         items = list(items or [])
         if replace_until is not None:
             return self._replace_list_until(items, replace_until, ignore_errors)
-        return list(self._replace_list(items, ignore_errors))
+        return self._replace_list(items, ignore_errors)
 
-    def _replace_list_until(self, items, replace_until, ignore_errors):
+    def _replace_list_until(self, items, limit, ignore_errors):
         # @{list} variables can contain more or less arguments than needed.
         # Therefore, we need to go through items one by one, and escape
         # possible extra items we got.
         replaced = []
-        while len(replaced) < replace_until and items:
+        while len(replaced) < limit and items:
             replaced.extend(self._replace_list([items.pop(0)], ignore_errors))
-        if len(replaced) > replace_until:
-            replaced[replace_until:] = [escape(item)
-                                        for item in replaced[replace_until:]]
+        if len(replaced) > limit:
+            replaced[limit:] = [escape(item) for item in replaced[limit:]]
         return replaced + items
 
     def _replace_list(self, items, ignore_errors):
+        result = []
         for item in items:
-            for value in self._replace_list_item(item, ignore_errors):
-                yield value
-
-    def _replace_list_item(self, item, ignore_errors):
-        match = search_variable(item, ignore_errors=ignore_errors)
-        if not match:
-            return [unescape(match.string)]
-        value = self.replace_scalar(match, ignore_errors)
-        if match.is_list_variable() and is_list_like(value):
-            return value
-        return [value]
+            match = search_variable(item, ignore_errors=ignore_errors)
+            if not match:
+                result.append(unescape(item))
+            else:
+                value = self._replace_scalar(match, ignore_errors)
+                if match.is_list_variable() and is_list_like(value):
+                    result.extend(value)
+                else:
+                    result.append(value)
+        return result
 
     def replace_scalar(self, item, ignore_errors=False):
         """Replaces variables from a scalar item.
@@ -77,20 +76,18 @@ class VariableReplacer:
         its value is returned. Otherwise, possible variables are replaced with
         'replace_string'. Result may be any object.
         """
-        match = self._search_variable(item, ignore_errors=ignore_errors)
+        if isinstance(item, VariableMatch):
+            match = item
+        else:
+            match = search_variable(item, ignore_errors=ignore_errors)
         if not match:
             return unescape(match.string)
         return self._replace_scalar(match, ignore_errors)
 
-    def _search_variable(self, item, ignore_errors):
-        if isinstance(item, VariableMatch):
-            return item
-        return search_variable(item, ignore_errors=ignore_errors)
-
     def _replace_scalar(self, match, ignore_errors=False):
-        if not match.is_variable():
-            return self.replace_string(match, ignore_errors=ignore_errors)
-        return self._get_variable_value(match, ignore_errors)
+        if match.is_variable():
+            return self._get_variable_value(match, ignore_errors)
+        return self._replace_string(match, unescape, ignore_errors)
 
     def replace_string(self, item, custom_unescaper=None, ignore_errors=False):
         """Replaces variables from a string. Result is always a string.
@@ -98,7 +95,10 @@ class VariableReplacer:
         Input can also be an already found VariableMatch.
         """
         unescaper = custom_unescaper or unescape
-        match = self._search_variable(item, ignore_errors=ignore_errors)
+        if isinstance(item, VariableMatch):
+            match = item
+        else:
+            match = search_variable(item, ignore_errors=ignore_errors)
         if not match:
             return safe_str(unescaper(match.string))
         return self._replace_string(match, unescaper, ignore_errors)
@@ -106,10 +106,8 @@ class VariableReplacer:
     def _replace_string(self, match, unescaper, ignore_errors):
         parts = []
         while match:
-            parts.extend([
-                unescaper(match.before),
-                safe_str(self._get_variable_value(match, ignore_errors))
-            ])
+            parts.append(unescaper(match.before))
+            parts.append(safe_str(self._get_variable_value(match, ignore_errors)))
             match = search_variable(match.after, ignore_errors=ignore_errors)
         parts.append(unescaper(match.string))
         return ''.join(parts)
@@ -126,17 +124,16 @@ class VariableReplacer:
             if match.items:
                 value = self._get_variable_item(match, value)
             try:
-                value = self._validate_value(match, value)
+                return self._validate_value(match, value)
             except VariableError:
                 raise
             except Exception:
                 error = get_error_message()
                 raise VariableError(f"Resolving variable '{match}' failed: {error}")
         except DataError:
-            if not ignore_errors:
-                raise
-            value = unescape(match.match)
-        return value
+            if ignore_errors:
+                return unescape(match.match)
+            raise
 
     def _get_variable_item(self, match, value):
         name = match.name

{robotframework-6.1.1 → robotframework-7.0}/src/robot/variables/scopes.py

@@ -113,9 +113,9 @@ class VariableScopes:
             else:
                 scope.set_from_file(variables, overwrite=overwrite)
 
-    def set_from_variable_table(self, variables, overwrite=False):
+    def set_from_variable_section(self, variables, overwrite=False):
         for scope in self._scopes_until_suite:
-            scope.set_from_variable_table(variables, overwrite)
+            scope.set_from_variable_section(variables, overwrite)
 
     def resolve_delayed(self):
         for scope in self._scopes_until_suite:
@@ -140,8 +140,7 @@ class VariableScopes:
             return
         for scope in self._scopes_until_suite:
             name, value = self._set_global_suite_or_test(scope, name, value)
-        if children:
-            self._variables_set.set_suite(name, value)
+        self._variables_set.set_suite(name, value, children)
 
     def set_test(self, name, value):
         if self._test is None:
@@ -154,7 +153,7 @@ class VariableScopes:
         self.current[name] = value
         self._variables_set.set_keyword(name, value)
 
-    def set_local_variable(self, name, value):
+    def set_local(self, name, value):
         self.current[name] = value
 
     def as_dict(self, decoration=True):
@@ -203,11 +202,11 @@ class GlobalVariables(Variables):
                             ('${False}', False),
                             ('${None}', None),
                             ('${null}', None),
-                            ('${OUTPUT_DIR}', settings.output_directory),
-                            ('${OUTPUT_FILE}', settings.output or 'NONE'),
-                            ('${REPORT_FILE}', settings.report or 'NONE'),
-                            ('${LOG_FILE}', settings.log or 'NONE'),
-                            ('${DEBUG_FILE}', settings.debug_file or 'NONE'),
+                            ('${OUTPUT_DIR}', str(settings.output_directory)),
+                            ('${OUTPUT_FILE}', str(settings.output or 'NONE')),
+                            ('${REPORT_FILE}', str(settings.report or 'NONE')),
+                            ('${LOG_FILE}', str(settings.log or 'NONE')),
+                            ('${DEBUG_FILE}', str(settings.debug_file or 'NONE')),
                             ('${LOG_LEVEL}', settings.log_level),
                             ('${PREV_TEST_NAME}', ''),
                             ('${PREV_TEST_STATUS}', ''),
@@ -252,8 +251,14 @@ class SetVariables:
             if name in scope:
                 scope.pop(name)
 
-    def set_suite(self, name, value):
-        self._suite[name] = value
+    def set_suite(self, name, value, children=False):
+        for scope in reversed(self._scopes):
+            if children:
+                scope[name] = value
+            elif name in scope:
+                scope.pop(name)
+            if scope is self._suite:
+                break
 
     def set_test(self, name, value):
         for scope in reversed(self._scopes):