robotframework 7.0.1rc1__zip → 7.1__zip

{robotframework-7.0.1rc1 → robotframework-7.1}/src/robot/running/librarykeywordrunner.py

@@ -49,32 +49,38 @@ class LibraryKeywordRunner:
         with StatusReporter(data, result, context, run, implementation=kw):
             if run:
                 with assignment.assigner(context) as assigner:
-                    return_value = self._run(kw, data.args, result, context)
+                    return_value = self._run(data, kw, context)
                     assigner.assign(return_value)
                     return return_value
 
     def _config_result(self, result: KeywordResult, data: KeywordData,
                        kw: 'LibraryKeyword', assignment):
+        args = tuple(data.args)
+        if data.named_args:
+            args += tuple(f'{n}={v}' for n, v in data.named_args.items())
         result.config(name=self.name,
                       owner=kw.owner.name,
                       doc=kw.short_doc,
-                      args=data.args,
+                      args=args,
                       assign=tuple(assignment),
                       tags=kw.tags,
                       type=data.type)
 
-    def _run(self, kw: 'LibraryKeyword', args, result: KeywordResult, context):
+    def _run(self, data: KeywordData, kw: 'LibraryKeyword', context):
         if self.pre_run_messages:
             for message in self.pre_run_messages:
                 context.output.message(message)
         variables = context.variables if not context.dry_run else None
-        positional, named = kw.resolve_arguments(args, variables, self.languages)
+        positional, named = self._resolve_arguments(data, kw, variables)
         context.output.trace(lambda: self._trace_log_args(positional, named),
                              write_if_flat=False)
         if kw.error:
             raise DataError(kw.error)
         return self._execute(kw.method, positional, named, context)
 
+    def _resolve_arguments(self, data: KeywordData, kw: 'LibraryKeyword', variables=None):
+        return kw.resolve_arguments(data.args, data.named_args, variables, self.languages)
+
     def _trace_log_args(self, positional, named):
         args = [prepr(arg) for arg in positional]
         args += ['%s=%s' % (safe_str(n), prepr(v)) for n, v in named]
@@ -127,18 +133,20 @@ class LibraryKeywordRunner:
         self._config_result(result, data, kw, assignment)
         with StatusReporter(data, result, context, run=False, implementation=kw):
             assignment.validate_assignment()
-            self._dry_run(kw, data.args, result, context)
+            if self._executed_in_dry_run(kw):
+                self._run(data, kw, context)
+            else:
+                self._resolve_arguments(data, kw)
+            self._end_dry_run(data, kw, result, context)
 
-    def _dry_run(self, kw: 'LibraryKeyword', args, result: KeywordResult, context):
-        if self._executed_in_dry_run(kw):
-            self._run(kw, args, result, context)
-        else:
-            kw.resolve_arguments(args, languages=self.languages)
+    def _end_dry_run(self, data: KeywordData, kw: 'LibraryKeyword',
+                     result: KeywordResult, context):
+        pass
 
     def _executed_in_dry_run(self, kw: 'LibraryKeyword'):
         return (kw.owner.name == 'BuiltIn'
                 and kw.name in ('Import Library', 'Set Library Search Order',
-                                'Set Tags', 'Remove Tags'))
+                                'Set Tags', 'Remove Tags', 'Import Resource'))
 
 
 class EmbeddedArgumentsRunner(LibraryKeywordRunner):
@@ -147,11 +155,9 @@ class EmbeddedArgumentsRunner(LibraryKeywordRunner):
         super().__init__(keyword, name)
         self.embedded_args = keyword.embedded.match(name).groups()
 
-    def _run(self, kw: 'LibraryKeyword', args, result: KeywordResult, context):
-        return super()._run(kw, self.embedded_args + args, result, context)
-
-    def _dry_run(self, kw: 'LibraryKeyword', args, result: KeywordResult, context):
-        return super()._dry_run(kw, self.embedded_args + args, result, context)
+    def _resolve_arguments(self, data: KeywordData, kw: 'LibraryKeyword', variables=None):
+        return kw.resolve_arguments(self.embedded_args + data.args, data.named_args,
+                                    variables, self.languages)
 
     def _config_result(self, result: KeywordResult, data: KeywordData,
                        kw: 'LibraryKeyword', assignment):
@@ -177,12 +183,12 @@ class RunKeywordRunner(LibraryKeywordRunner):
         finally:
             STOP_SIGNAL_MONITOR.stop_running_keyword()
 
-    def _dry_run(self, kw: 'LibraryKeyword', args, result: KeywordResult, context):
-        super()._dry_run(kw, args, result, context)
+    def _end_dry_run(self, data: KeywordData, kw: 'LibraryKeyword',
+                     result: KeywordResult, context):
         wrapper = UserKeyword(name=kw.name,
                               doc="Wraps keywords executed by '{kw.name}' in dry-run.",
                               parent=kw.parent)
-        wrapper.body = [k for k in self._get_dry_run_keywords(kw, args)
+        wrapper.body = [k for k in self._get_dry_run_keywords(kw, data.args)
                         if not contains_variable(k.name)]
         BodyRunner(context).run(wrapper, result)
 

{robotframework-7.0.1rc1 → robotframework-7.1}/src/robot/running/model.py

@@ -36,14 +36,14 @@ __ http://robotframework.org/robotframework/latest/RobotFrameworkUserGuide.html#
 
 import warnings
 from pathlib import Path
-from typing import Literal, Mapping, Sequence, TYPE_CHECKING, TypeVar, Union
+from typing import Any, Literal, Mapping, Sequence, TYPE_CHECKING, TypeVar, Union
 
 from robot import model
 from robot.conf import RobotSettings
 from robot.errors import BreakLoop, ContinueLoop, DataError, ReturnFromKeyword, VariableError
 from robot.model import BodyItem, DataDict, TestSuites
 from robot.output import LOGGER, Output, pyloggingconf
-from robot.utils import setter
+from robot.utils import format_assign_message, setter
 from robot.variables import VariableResolver
 
 from .bodyrunner import ForRunner, IfRunner, KeywordRunner, TryRunner, WhileRunner
@@ -80,6 +80,35 @@ class WithSource:
         return self.parent.source if self.parent is not None else None
 
 
+class Argument:
+    """A temporary API for creating named arguments with non-string values.
+
+    This class was added in RF 7.0.1 (#5031) after a failed attempt to add a public
+    API for this purpose in RF 7.0 (#5000). A better public API that allows passing
+    named arguments separately was added in RF 7.1 (#5143).
+
+    If you need to support also RF 7.0, you can pass named arguments as two-item tuples
+    like `(name, value)` and positional arguments as one-item tuples like `(value,)`.
+    That approach does not work anymore in RF 7.0.1, though, so the code needs to be
+    conditional depending on Robot Framework version.
+
+    The main limitation of this class is that it is not compatible with the JSON model.
+    The current plan is to remove this in the future, possibly already in RF 8.0, but
+    we can consider preserving it if it turns out to be useful.
+    """
+
+    def __init__(self, name: 'str|None', value: Any):
+        """
+        :param name: Argument name. If ``None``, argument is considered positional.
+        :param value: Argument value.
+        """
+        self.name = name
+        self.value = value
+
+    def __str__(self):
+        return str(self.value) if self.name is None else f'{self.name}={self.value}'
+
+
 @Body.register
 class Keyword(model.Keyword, WithSource):
     """Represents an executable keyword call.
@@ -93,24 +122,33 @@ class Keyword(model.Keyword, WithSource):
     The actual keyword that is executed depends on the context where this model
     is executed.
 
-    Arguments originating from normal Robot Framework data are stored as list of
-    strings in the exact same format as in the data. This means that arguments can
-    have variables and escape characters, and that named arguments are specified
-    using the ``name=value`` syntax.
+    Arguments originating from normal Robot Framework data are stored in the
+    :attr:`args` attribute as a tuple of strings in the exact same format as in
+    the data. This means that arguments can have variables and escape characters,
+    and that named arguments are specified using the ``name=value`` syntax.
+
+    When creating keywords programmatically, it is possible to set :attr:`named_args`
+    separately and use :attr:`args` only for positional arguments. Argument values
+    do not need to be strings, but also in this case strings can contain variables
+    and normal Robot Framework escaping rules must be taken into account.
     """
-    __slots__ = ['lineno']
+    __slots__ = ['named_args', 'lineno']
 
     def __init__(self, name: str = '',
-                 args: Sequence[str] = (),
+                 args: 'Sequence[str|Argument|Any]' = (),
+                 named_args: 'Mapping[str, Any]|None' = None,
                  assign: Sequence[str] = (),
                  type: str = BodyItem.KEYWORD,
                  parent: BodyItemParent = None,
                  lineno: 'int|None' = None):
         super().__init__(name, args, assign, type, parent)
+        self.named_args = named_args
         self.lineno = lineno
 
     def to_dict(self) -> DataDict:
         data = super().to_dict()
+        if self.named_args is not None:
+            data['named_args'] = self.named_args
         if self.lineno:
             data['lineno'] = self.lineno
         return data
@@ -336,35 +374,39 @@ class Var(model.Var, WithSource):
     def run(self, result, context, run=True, templated=False):
         result = result.body.create_var(self.name, self.value, self.scope, self.separator)
         with StatusReporter(self, result, context, run):
-            if run:
-                if self.error:
-                    raise DataError(self.error, syntax=True)
-                if not context.dry_run:
-                    scope = self._get_scope(context.variables)
-                    setter = getattr(context.variables, f'set_{scope}')
-                    try:
-                        resolver = VariableResolver.from_variable(self)
-                        setter(self._resolve_name(self.name, context.variables),
-                               resolver.resolve(context.variables))
-                    except DataError as err:
-                        raise VariableError(f"Setting variable '{self.name}' failed: {err}")
+            if self.error and run:
+                raise DataError(self.error, syntax=True)
+            if not run or context.dry_run:
+                return
+            scope, config = self._get_scope(context.variables)
+            set_variable = getattr(context.variables, f'set_{scope}')
+            try:
+                name, value = self._resolve_name_and_value(context.variables)
+                set_variable(name, value, **config)
+                context.info(format_assign_message(name, value))
+            except DataError as err:
+                raise VariableError(f"Setting variable '{self.name}' failed: {err}")
 
     def _get_scope(self, variables):
         if not self.scope:
-            return 'local'
+            return 'local', {}
         try:
             scope = variables.replace_string(self.scope)
             if scope.upper() == 'TASK':
-                return 'test'
-            if scope.upper() in ('GLOBAL', 'SUITE', 'TEST', 'LOCAL'):
-                return scope.lower()
+                return 'test', {}
+            if scope.upper() == 'SUITES':
+                return 'suite', {'children': True}
+            if scope.upper() in ('LOCAL', 'TEST', 'SUITE', 'GLOBAL'):
+                return scope.lower(), {}
             raise DataError(f"Value '{scope}' is not accepted. Valid values are "
-                            f"'GLOBAL', 'SUITE', 'TEST', 'TASK' and 'LOCAL'.")
+                            f"'LOCAL', 'TEST', 'TASK', 'SUITE', 'SUITES' and 'GLOBAL'.")
         except DataError as err:
             raise DataError(f"Invalid VAR scope: {err}")
 
-    def _resolve_name(self, name, variables):
-        return name[:2] + variables.replace_string(name[2:-1]) + '}'
+    def _resolve_name_and_value(self, variables):
+        name = self.name[:2] + variables.replace_string(self.name[2:-1]) + '}'
+        value = VariableResolver.from_variable(self).resolve(variables)
+        return name, value
 
     def to_dict(self) -> DataDict:
         data = super().to_dict()

{robotframework-7.0.1rc1 → robotframework-7.1}/src/robot/running/namespace.py

@@ -87,9 +87,7 @@ class Namespace:
             self.variables.set_from_variable_section(resource.variables, overwrite)
             self._kw_store.resources[path] = resource
             self._handle_imports(resource.imports)
-            LOGGER.imported("Resource", resource.name,
-                            importer=str(import_setting.source),
-                            source=path)
+            LOGGER.resource_import(resource, import_setting)
         else:
             LOGGER.info(f"Resource file '{path}' already imported by "
                         f"suite '{self._suite_name}'.")
@@ -109,10 +107,10 @@ class Namespace:
         if overwrite or (path, args) not in self._imported_variable_files:
             self._imported_variable_files.add((path, args))
             self.variables.set_from_file(path, args, overwrite)
-            LOGGER.imported("Variables", os.path.basename(path),
-                            args=list(args),
-                            importer=str(import_setting.source),
-                            source=path)
+            LOGGER.variables_import({'name': os.path.basename(path),
+                                     'args': args,
+                                     'source': path},
+                                    importer=import_setting)
         else:
             msg = f"Variable file '{path}'"
             if args:
@@ -131,11 +129,7 @@ class Namespace:
                         f"'{self._suite_name}'.")
             return
         if notify:
-            LOGGER.imported("Library", lib.name,
-                            args=list(import_setting.args),
-                            originalname=lib.real_name,
-                            importer=str(import_setting.source),
-                            source=str(lib.source or ''))
+            LOGGER.library_import(lib, import_setting)
         self._kw_store.libraries[lib.name] = lib
         lib.scope_manager.start_suite()
         if self._running_test:
@@ -287,30 +281,30 @@ class KeywordStore:
         else:
             raise KeywordError(message)
 
-    def _get_runner(self, name):
+    def _get_runner(self, name, strip_bdd_prefix=True):
         if not name:
             raise DataError('Keyword name cannot be empty.')
         if not is_string(name):
             raise DataError('Keyword name must be a string.')
-        runner = self._get_runner_from_suite_file(name)
+        runner = None
+        if strip_bdd_prefix:
+            runner = self._get_bdd_style_runner(name)
+        if not runner:
+            runner = self._get_runner_from_suite_file(name)
         if not runner and '.' in name:
             runner = self._get_explicit_runner(name)
         if not runner:
             runner = self._get_implicit_runner(name)
-        if not runner:
-            runner = self._get_bdd_style_runner(name, self.languages.bdd_prefixes)
         return runner
 
-    def _get_bdd_style_runner(self, name, prefixes):
-        parts = name.split()
-        for index in range(1, len(parts)):
-            prefix = ' '.join(parts[:index]).title()
-            if prefix in prefixes:
-                runner = self._get_runner(' '.join(parts[index:]))
-                if runner:
-                    runner = copy.copy(runner)
-                    runner.name = name
-                    return runner
+    def _get_bdd_style_runner(self, name):
+        match = self.languages.bdd_prefix_regexp.match(name)
+        if match:
+            runner = self._get_runner(name[match.end():], strip_bdd_prefix=False)
+            if runner:
+                runner = copy.copy(runner)
+                runner.name = name
+                return runner
         return None
 
     def _get_implicit_runner(self, name):

{robotframework-7.0.1rc1 → robotframework-7.1}/src/robot/running/resourcemodel.py

@@ -28,10 +28,13 @@ from .model import Body, BodyItemParent, Keyword, TestSuite
 from .userkeywordrunner import UserKeywordRunner, EmbeddedArgumentsRunner
 
 if TYPE_CHECKING:
+    from robot.conf import LanguagesLike
     from robot.parsing import File
 
 
 class ResourceFile(ModelObject):
+    """Represents a resource file."""
+
     repr_args = ('source',)
     __slots__ = ('_source', 'owner', 'doc', 'keyword_finder')
 
@@ -234,7 +237,8 @@ class UserKeyword(KeywordImplementation):
         """
         return bool(self._teardown)
 
-    def create_runner(self, name: 'str|None', languages=None) \
+    def create_runner(self, name: 'str|None',
+                      languages: 'LanguagesLike' = None) \
             -> 'UserKeywordRunner|EmbeddedArgumentsRunner':
         if self.embedded:
             return EmbeddedArgumentsRunner(self, name)
@@ -317,8 +321,12 @@ class Variable(ModelObject):
             data['error'] = self.error
         return data
 
+    def _include_in_repr(self, name: str, value: Any) -> bool:
+        return not (name == 'separator' and value is None)
+
 
 class Import(ModelObject):
+    """Represents library, resource file or variable file import."""
     repr_args = ('type', 'name', 'args', 'alias')
     LIBRARY = 'LIBRARY'
     RESOURCE = 'RESOURCE'

{robotframework-7.0.1rc1 → robotframework-7.1}/src/robot/running/statusreporter.py

@@ -52,10 +52,10 @@ class StatusReporter:
             message = ' ' + doc.split('*', 2)[-1].strip()
             self.context.warn(f"Keyword '{name}' is deprecated.{message}")
 
-    def __exit__(self, exc_type, exc_val, exc_tb):
+    def __exit__(self, exc_type, exc_value, exc_traceback):
         context = self.context
         result = self.result
-        failure = self._get_failure(exc_type, exc_val, exc_tb, context)
+        failure = self._get_failure(exc_value, context)
         if failure is None:
             result.status = self.pass_status
         else:
@@ -65,12 +65,17 @@ class StatusReporter:
         if self.initial_test_status == 'PASS':
             context.test.status = result.status
         result.elapsed_time = datetime.now() - result.start_time
+        orig_status = (result.status, result.message)
         context.end_body_item(self.data, result, self.implementation)
-        if failure is not exc_val and not self.suppress:
+        if orig_status != (result.status, result.message):
+            if result.passed or result.not_run:
+                return True
+            raise ExecutionFailed(result.message, skip=result.skipped)
+        if failure is not exc_value and not self.suppress:
             raise failure
         return self.suppress
 
-    def _get_failure(self, exc_type, exc_value, exc_tb, context):
+    def _get_failure(self, exc_value, context):
         if exc_value is None:
             return None
         if isinstance(exc_value, ExecutionStatus):

{robotframework-7.0.1rc1 → robotframework-7.1}/src/robot/running/testlibraries.py

@@ -171,7 +171,7 @@ class TestLibrary:
         if inspect.ismodule(code):
             lib = cls.from_module(code, name, real_name, source, create_keywords, logger)
             if args:    # Resolving arguments reports an error.
-                lib.init.resolve_arguments(args, variables)
+                lib.init.resolve_arguments(args, variables=variables)
             return lib
         return cls.from_class(code, name, real_name, source, args or (), variables,
                               create_keywords, logger)
@@ -316,7 +316,7 @@ class ClassLibrary(TestLibrary):
                    logger=LOGGER) -> 'ClassLibrary':
         init = LibraryInit.from_class(klass)
         library = cls(klass, init, name, real_name, source, logger)
-        positional, named = init.args.resolve(args, variables)
+        positional, named = init.args.resolve(args, variables=variables)
         init.positional, init.named = list(positional), dict(named)
         if create_keywords:
             library.create_keywords()

{robotframework-7.0.1rc1 → robotframework-7.1}/src/robot/running/userkeywordrunner.py

@@ -55,13 +55,16 @@ class UserKeywordRunner:
 
     def _config_result(self, result: KeywordResult, data: KeywordData,
                        kw: 'UserKeyword', assignment, variables):
+        args = tuple(data.args)
+        if data.named_args:
+            args += tuple(f'{n}={v}' for n, v in data.named_args.items())
         doc = variables.replace_string(kw.doc, ignore_errors=True)
         doc, tags = split_tags_from_doc(doc)
         tags = variables.replace_list(kw.tags, ignore_errors=True) + tags
         result.config(name=self.name,
                       owner=kw.owner.name,
                       doc=getshortdoc(doc),
-                      args=data.args,
+                      args=args,
                       assign=tuple(assignment),
                       tags=tags,
                       type=data.type)
@@ -71,7 +74,7 @@ class UserKeywordRunner:
             for message in self.pre_run_messages:
                 context.output.message(message)
         variables = context.variables
-        positional, named = self._resolve_arguments(kw, data.args, variables)
+        positional, named = self._resolve_arguments(data, kw, variables)
         with context.user_keyword(kw):
             self._set_arguments(kw, positional, named, context)
             if kw.timeout:
@@ -89,8 +92,8 @@ class UserKeywordRunner:
                     raise exception
                 return return_value
 
-    def _resolve_arguments(self, kw: 'UserKeyword', args, variables=None):
-        return kw.resolve_arguments(args, variables)
+    def _resolve_arguments(self, data: KeywordData, kw: 'UserKeyword', variables=None):
+        return kw.resolve_arguments(data.args, data.named_args, variables)
 
     def _set_arguments(self, kw: 'UserKeyword', positional, named, context):
         variables = context.variables
@@ -222,7 +225,7 @@ class UserKeywordRunner:
         if self.pre_run_messages:
             for message in self.pre_run_messages:
                 context.output.message(message)
-        self._resolve_arguments(kw, data.args)
+        self._resolve_arguments(data, kw)
         with context.user_keyword(kw):
             if kw.timeout:
                 timeout = KeywordTimeout(kw.timeout, context.variables)
@@ -238,8 +241,8 @@ class EmbeddedArgumentsRunner(UserKeywordRunner):
         super().__init__(keyword, name)
         self.embedded_args = keyword.embedded.match(name).groups()
 
-    def _resolve_arguments(self, kw: 'UserKeyword', args, variables=None):
-        result = super()._resolve_arguments(kw, args, variables)
+    def _resolve_arguments(self, data: KeywordData, kw: 'UserKeyword', variables=None):
+        result = super()._resolve_arguments(data, kw, variables)
         if variables:
             embedded = [variables.replace_scalar(e) for e in self.embedded_args]
             self.embedded_args = kw.embedded.map(embedded)

{robotframework-7.0.1rc1 → robotframework-7.1}/src/robot/utils/encodingsniffer.py

@@ -18,7 +18,7 @@ import sys
 import locale
 
 from .misc import isatty
-from .platform import UNIXY, WINDOWS
+from .platform import PY_VERSION, UNIXY, WINDOWS
 
 
 if UNIXY:
@@ -53,6 +53,8 @@ def _get_encoding(platform_getters, default):
 
 
 def _get_python_system_encoding():
+    if PY_VERSION >= (3, 11):
+        return locale.getencoding()
     # ValueError occurs with PyPy 3.10 if language config is invalid.
     # https://foss.heptapod.net/pypy/pypy/-/issues/3975
     try:

{robotframework-7.0.1rc1 → robotframework-7.1}/src/robot/utils/robottime.py

@@ -86,7 +86,7 @@ def _time_string_to_secs(timestr):
     timestr = _normalize_timestr(timestr)
     if not timestr:
         return None
-    nanos = micros = millis = secs = mins = hours = days = 0
+    nanos = micros = millis = secs = mins = hours = days = weeks = 0
     if timestr[0] == '-':
         sign = -1
         timestr = timestr[1:]
@@ -102,13 +102,14 @@ def _time_string_to_secs(timestr):
             elif c == 'm': mins   = float(''.join(temp)); temp = []
             elif c == 'h': hours  = float(''.join(temp)); temp = []
             elif c == 'd': days   = float(''.join(temp)); temp = []
+            elif c == 'w': weeks  = float(''.join(temp)); temp = []
             else: temp.append(c)
         except ValueError:
             return None
     if temp:
         return None
     return sign * (nanos/1E9 + micros/1E6 + millis/1000 + secs +
-                   mins*60 + hours*60*60 + days*60*60*24)
+                   mins*60 + hours*60*60 + days*60*60*24 + weeks*60*60*24*7)
 
 
 def _normalize_timestr(timestr):
@@ -120,7 +121,8 @@ def _normalize_timestr(timestr):
                                ('s', ['second', 'sec']),
                                ('m', ['minute', 'min']),
                                ('h', ['hour']),
-                               ('d', ['day'])]:
+                               ('d', ['day']),
+                               ('w', ['week'])]:
         plural_aliases = [a+'s' for a in aliases if not a.endswith('s')]
         for alias in plural_aliases + aliases:
             if alias in timestr:

{robotframework-7.0.1rc1 → robotframework-7.1}/src/robot/variables/evaluation.py

@@ -27,9 +27,6 @@ from .search import VariableMatches
 from .notfound import variable_not_found
 
 
-PYTHON_BUILTINS = set(builtins.__dict__)
-
-
 def evaluate_expression(expression, variables, modules=None, namespace=None,
                         resolve_variables=False):
     original = expression
@@ -146,7 +143,7 @@ class EvaluationNamespace(MutableMapping):
         self.namespace.pop(key)
 
     def _import_module(self, name):
-        if name in PYTHON_BUILTINS:
+        if hasattr(builtins, name):
             raise KeyError
         try:
             return __import__(name)

{robotframework-7.0.1rc1 → robotframework-7.1}/src/robot/variables/scopes.py

@@ -192,7 +192,8 @@ class GlobalVariables(Variables):
                                 'include': Tags(settings.include),
                                 'exclude': Tags(settings.exclude),
                                 'skip': Tags(settings.skip),
-                                'skip_on_failure': Tags(settings.skip_on_failure)
+                                'skip_on_failure': Tags(settings.skip_on_failure),
+                                'console_width': settings.console_width
                             })),
                             ('${/}', os.sep),
                             ('${:}', os.pathsep),

{robotframework-7.0.1rc1 → robotframework-7.1}/src/robot/variables/tablesetter.py

@@ -13,8 +13,7 @@
 #  See the License for the specific language governing permissions and
 #  limitations under the License.
 
-from contextlib import contextmanager
-from typing import Sequence, TYPE_CHECKING
+from typing import Any, Sequence, TYPE_CHECKING
 
 from robot.errors import DataError
 from robot.utils import DotDict, split_from_equals
@@ -23,7 +22,7 @@ from .resolvable import Resolvable
 from .search import is_assign, is_list_variable, is_dict_variable
 
 if TYPE_CHECKING:
-    from robot.running.model import Var, Variable
+    from robot.running import Var, Variable
     from .store import VariableStore
 
 
@@ -35,8 +34,8 @@ class VariableTableSetter:
     def set(self, variables: 'Sequence[Variable]', overwrite: bool = False):
         for var in variables:
             try:
-                value = VariableResolver.from_variable(var)
-                self.store.add(var.name, value, overwrite)
+                resolver = VariableResolver.from_variable(var)
+                self.store.add(var.name, resolver, overwrite)
             except DataError as err:
                 var.report_error(str(err))
 
@@ -46,7 +45,8 @@ class VariableResolver(Resolvable):
     def __init__(self, value: Sequence[str], error_reporter=None):
         self.value = tuple(value)
         self.error_reporter = error_reporter
-        self._resolving = False
+        self.resolving = False
+        self.resolved = False
 
     @classmethod
     def from_name_and_value(cls, name: str, value: 'str|Sequence[str]',
@@ -69,22 +69,19 @@ class VariableResolver(Resolvable):
         return cls.from_name_and_value(var.name, var.value, var.separator,
                                        getattr(var, 'report_error', None))
 
-    def resolve(self, variables):
-        with self._avoid_recursion:
-            return self._replace_variables(variables)
-
-    @property
-    @contextmanager
-    def _avoid_recursion(self):
-        if self._resolving:
+    def resolve(self, variables) -> Any:
+        if self.resolving:
             raise DataError('Recursive variable definition.')
-        self._resolving = True
-        try:
-            yield
-        finally:
-            self._resolving = False
+        if not self.resolved:
+            self.resolving = True
+            try:
+                self.value = self._replace_variables(variables)
+            finally:
+                self.resolving = False
+            self.resolved = True
+        return self.value
 
-    def _replace_variables(self, variables):
+    def _replace_variables(self, variables) -> Any:
         raise NotImplementedError
 
     def report_error(self, error):

{robotframework-7.0.1rc1 → robotframework-7.1}/src/robot/version.py

@@ -18,7 +18,7 @@ import sys
 
 # Version number typically updated by running `invoke set-version <version>`.
 # Run `invoke --help set-version` or see tasks.py for details.
-VERSION = '7.0.1rc1'
+VERSION = '7.1'
 
 
 def get_version(naked=False):