robotframework 7.0.1rc2__zip → 7.1__zip

{robotframework-7.0.1rc2 → 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.1rc2 → robotframework-7.1}/src/robot/running/model.py

@@ -43,7 +43,7 @@ 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
@@ -84,7 +84,13 @@ 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 is planned for RF 7.1.
+    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
@@ -116,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|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
@@ -359,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.1rc2 → 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.1rc2 → 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.1rc2 → 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.1rc2 → 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.1rc2 → 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.1rc2 → 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.1rc2 → 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.1rc2 → 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.1rc2 → 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.1rc2 → 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.1rc2 → 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.1rc2'
+VERSION = '7.1'
 
 
 def get_version(naked=False):

{robotframework-7.0.1rc2 → robotframework-7.1}/src/robotframework.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: robotframework
-Version: 7.0.1rc2
+Version: 7.1
 Summary: Generic automation framework for acceptance testing and robotic process automation (RPA)
 Home-page: https://robotframework.org
 Author: Pekka Klärck
@@ -10,7 +10,7 @@ Download-URL: https://pypi.org/project/robotframework
 Project-URL: Source, https://github.com/robotframework/robotframework
 Project-URL: Issue Tracker, https://github.com/robotframework/robotframework/issues
 Project-URL: Documentation, https://robotframework.org/robotframework
-Project-URL: Release Notes, https://github.com/robotframework/robotframework/blob/master/doc/releasenotes/rf-7.0.1rc2.rst
+Project-URL: Release Notes, https://github.com/robotframework/robotframework/blob/master/doc/releasenotes/rf-7.1.rst
 Project-URL: Slack, http://slack.robotframework.org
 Description: Robot Framework
         ===============
@@ -176,6 +176,7 @@ Classifier: Programming Language :: Python :: 3.9
 Classifier: Programming Language :: Python :: 3.10
 Classifier: Programming Language :: Python :: 3.11
 Classifier: Programming Language :: Python :: 3.12
+Classifier: Programming Language :: Python :: 3.13
 Classifier: Programming Language :: Python :: Implementation :: CPython
 Classifier: Programming Language :: Python :: Implementation :: PyPy
 Classifier: Topic :: Software Development :: Testing