robotframework 6.1rc1__zip → 7.0a1__zip

{robotframework-6.1rc1 → robotframework-7.0a1}/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.1rc1 → robotframework-7.0a1}/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.1rc1 → robotframework-7.0a1}/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.1rc1 → robotframework-7.0a1}/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:
@@ -154,7 +154,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):

{robotframework-6.1rc1 → robotframework-7.0a1}/src/robot/variables/search.py

@@ -14,59 +14,79 @@
 #  limitations under the License.
 
 import re
+from typing import Iterator, Sequence
 
 from robot.errors import VariableError
 from robot.utils import is_string
 
 
-def search_variable(string, identifiers='$@&%*', ignore_errors=False):
+def search_variable(string: str, identifiers: Sequence[str] = '$@&%*',
+                    ignore_errors: bool = False) -> 'VariableMatch':
     if not (is_string(string) and '{' in string):
         return VariableMatch(string)
     return _search_variable(string, identifiers, ignore_errors)
 
 
-def contains_variable(string, identifiers='$@&'):
+def contains_variable(string: str, identifiers: Sequence[str] = '$@&') -> bool:
     match = search_variable(string, identifiers, ignore_errors=True)
     return bool(match)
 
 
-def is_variable(string, identifiers='$@&'):
+def is_variable(string: str, identifiers: Sequence[str] = '$@&') -> bool:
     match = search_variable(string, identifiers, ignore_errors=True)
     return match.is_variable()
 
 
-def is_scalar_variable(string):
+def is_scalar_variable(string: str) -> bool:
     return is_variable(string, '$')
 
 
-def is_list_variable(string):
+def is_list_variable(string: str) -> bool:
     return is_variable(string, '@')
 
 
-def is_dict_variable(string):
+def is_dict_variable(string: str) -> bool:
     return is_variable(string, '&')
 
 
-def is_assign(string, identifiers='$@&', allow_assign_mark=False, allow_items=False):
+def is_assign(string: str,
+              identifiers: Sequence[str] = '$@&',
+              allow_assign_mark: bool = False,
+              allow_nested: bool = False,
+              allow_items: bool = False) -> bool:
     match = search_variable(string, identifiers, ignore_errors=True)
-    return match.is_assign(allow_assign_mark, allow_items=allow_items)
+    return match.is_assign(allow_assign_mark, allow_nested, allow_items)
 
 
-def is_scalar_assign(string, allow_assign_mark=False, allow_items=False):
-    return is_assign(string, '$', allow_assign_mark, allow_items)
+def is_scalar_assign(string: str,
+                     allow_assign_mark: bool = False,
+                     allow_nested: bool = False,
+                     allow_items: bool = False) -> bool:
+    return is_assign(string, '$', allow_assign_mark, allow_nested, allow_items)
 
 
-def is_list_assign(string, allow_assign_mark=False, allow_items=False):
-    return is_assign(string, '@', allow_assign_mark, allow_items)
+def is_list_assign(string: str,
+                   allow_assign_mark: bool = False,
+                   allow_nested: bool = False,
+                   allow_items: bool = False) -> bool:
+    return is_assign(string, '@', allow_assign_mark, allow_nested, allow_items)
 
 
-def is_dict_assign(string, allow_assign_mark=False, allow_items=False):
-    return is_assign(string, '&', allow_assign_mark, allow_items)
+def is_dict_assign(string: str,
+                   allow_assign_mark: bool = False,
+                   allow_nested: bool = False,
+                   allow_items: bool = False) -> bool:
+    return is_assign(string, '&', allow_assign_mark, allow_nested, allow_items)
 
 
 class VariableMatch:
 
-    def __init__(self, string, identifier=None, base=None, items=(), start=-1, end=-1):
+    def __init__(self, string: str,
+                 identifier: 'str|None' = None,
+                 base: 'str|None' = None,
+                 items: 'tuple[str, ...]' = (),
+                 start: int = -1,
+                 end: int = -1):
         self.string = string
         self.identifier = identifier
         self.base = base
@@ -84,66 +104,70 @@ class VariableMatch:
             )
 
     @property
-    def name(self):
-        return '%s{%s}' % (self.identifier, self.base) if self else None
+    def name(self) -> 'str|None':
+        return f'{self.identifier}{{{self.base}}}' if self.identifier else None
 
     @property
-    def before(self):
+    def before(self) -> str:
         return self.string[:self.start] if self.identifier else self.string
 
     @property
-    def match(self):
+    def match(self) -> 'str|None':
         return self.string[self.start:self.end] if self.identifier else None
 
     @property
-    def after(self):
-        return self.string[self.end:] if self.identifier else None
+    def after(self) -> str:
+        return self.string[self.end:] if self.identifier else ''
 
-    def is_variable(self):
+    def is_variable(self) -> bool:
         return bool(self.identifier
                     and self.base
                     and self.start == 0
                     and self.end == len(self.string))
 
-    def is_scalar_variable(self):
+    def is_scalar_variable(self) -> bool:
         return self.identifier == '$' and self.is_variable()
 
-    def is_list_variable(self):
+    def is_list_variable(self) -> bool:
         return self.identifier == '@' and self.is_variable()
 
-    def is_dict_variable(self):
+    def is_dict_variable(self) -> bool:
         return self.identifier == '&' and self.is_variable()
 
-    def is_assign(self,
-                  allow_assign_mark=False, allow_nested=False, allow_items=False):
+    def is_assign(self, allow_assign_mark: bool = False, allow_nested: bool = False,
+                  allow_items: bool = False) -> bool:
         if allow_assign_mark and self.string.endswith('='):
             match = search_variable(self.string[:-1].rstrip(), ignore_errors=True)
-            return match.is_assign(allow_items=allow_items)
+            return match.is_assign(allow_nested=allow_nested, allow_items=allow_items)
         return (self.is_variable()
                 and self.identifier in '$@&'
                 and (allow_items or not self.items)
                 and (allow_nested or not search_variable(self.base)))
 
-    def is_scalar_assign(self, allow_assign_mark=False, allow_nested=False):
+    def is_scalar_assign(self, allow_assign_mark: bool = False,
+                         allow_nested: bool = False) -> bool:
         return self.identifier == '$' and self.is_assign(allow_assign_mark, allow_nested)
 
-    def is_list_assign(self, allow_assign_mark=False, allow_nested=False):
+    def is_list_assign(self, allow_assign_mark: bool = False,
+                       allow_nested: bool = False) -> bool:
         return self.identifier == '@' and self.is_assign(allow_assign_mark, allow_nested)
 
-    def is_dict_assign(self, allow_assign_mark=False, allow_nested=False):
+    def is_dict_assign(self, allow_assign_mark: bool = False,
+                       allow_nested: bool = False) -> bool:
         return self.identifier == '&' and self.is_assign(allow_assign_mark, allow_nested)
 
-    def __bool__(self):
+    def __bool__(self) -> bool:
         return self.identifier is not None
 
-    def __str__(self):
+    def __str__(self) -> str:
         if not self:
             return '<no match>'
         items = ''.join('[%s]' % i for i in self.items) if self.items else ''
         return '%s{%s}%s' % (self.identifier, self.base, items)
 
 
-def _search_variable(string, identifiers, ignore_errors=False):
+def _search_variable(string: str, identifiers: Sequence[str],
+                     ignore_errors: bool = False) -> VariableMatch:
     start = _find_variable_start(string, identifiers)
     if start < 0:
         return VariableMatch(string)
@@ -194,7 +218,7 @@ def _search_variable(string, identifiers, ignore_errors=False):
             raise VariableError(f"Variable '{incomplete}' was not closed properly.")
         raise VariableError(f"Variable item '{incomplete}' was not closed properly.")
 
-    return match if match else VariableMatch(match)
+    return match
 
 
 def _find_variable_start(string, identifiers):
@@ -233,26 +257,27 @@ def unescape_variable_syntax(item):
     return re.sub(r'(\\+)(?=(.+))', handle_escapes, item)
 
 
-class VariableIterator:
+class VariableMatches:
 
-    def __init__(self, string, identifiers='$@&%', ignore_errors=False):
+    def __init__(self, string: str, identifiers: Sequence[str] = '$@&%',
+                 ignore_errors: bool = False):
         self.string = string
         self.identifiers = identifiers
         self.ignore_errors = ignore_errors
 
-    def __iter__(self):
+    def __iter__(self) -> Iterator[VariableMatch]:
         remaining = self.string
         while True:
             match = search_variable(remaining, self.identifiers, self.ignore_errors)
             if not match:
                 break
             remaining = match.after
-            yield match.before, match.match, remaining
+            yield match
 
-    def __len__(self):
+    def __len__(self) -> int:
         return sum(1 for _ in self)
 
-    def __bool__(self):
+    def __bool__(self) -> bool:
         try:
             next(iter(self))
         except StopIteration: