robotframework 7.0.1rc2__zip → 7.1rc1__zip

{robotframework-7.0.1rc2 → robotframework-7.1rc1}/src/robot/output/loggerapi.py

@@ -211,5 +211,16 @@ class LoggerApi:
     def imported(self, import_type: str, name: str, attrs):
         pass
 
+    def library_import(self, library: 'running.TestLibrary',
+                       importer: 'running.Import'):
+        pass
+
+    def resource_import(self, resource: 'running.ResourceFile',
+                        importer: 'running.Import'):
+        pass
+
+    def variables_import(self, attrs: dict, importer: 'running.Import'):
+        pass
+
     def close(self):
         pass

{robotframework-7.0.1rc2 → robotframework-7.1rc1}/src/robot/output/loggerhelper.py

@@ -141,7 +141,12 @@ class IsLogged:
         self.__init__(level)
         return old
 
-    def _level_to_int(self, level):
+    @classmethod
+    def validate_level(cls, level):
+        cls._level_to_int(level)
+
+    @classmethod
+    def _level_to_int(cls, level):
         try:
             return LEVELS[level.upper()]
         except KeyError:

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

@@ -18,7 +18,7 @@ from .debugfile import DebugFile
 from .listeners import Listeners, LibraryListeners
 from .logger import LOGGER
 from .loggerapi import LoggerApi
-from .loggerhelper import AbstractLogger
+from .loggerhelper import AbstractLogger, IsLogged
 from .xmllogger import XmlLoggerAdapter
 
 
@@ -179,6 +179,7 @@ class Output(AbstractLogger, LoggerApi):
             self.write(msg, 'TRACE')
 
     def set_log_level(self, level):
+        IsLogged.validate_level(level)
         pyloggingconf.set_level(level)
         self.listeners.set_log_level(level)
         self.library_listeners.set_log_level(level)

{robotframework-7.0.1rc2 → robotframework-7.1rc1}/src/robot/parsing/model/statements.py

@@ -1208,7 +1208,7 @@ class WhileHeader(Statement):
 class Var(Statement):
     type = Token.VAR
     options = {
-        'scope': ('GLOBAL', 'SUITE', 'TEST', 'TASK', 'LOCAL'),
+        'scope': ('LOCAL', 'TEST', 'TASK', 'SUITE', 'SUITES', 'GLOBAL'),
         'separator': None
     }
 

{robotframework-7.0.1rc2 → robotframework-7.1rc1}/src/robot/result/executionresult.py

@@ -64,6 +64,7 @@ class Result:
         #: :class:`~.executionerrors.ExecutionErrors` object.
         self.errors = errors or ExecutionErrors()
         self.generated_by_robot = True
+        self.generation_time = None
         self._status_rc = True
         self._stat_config = {}
         self.rpa = rpa

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

@@ -1133,7 +1133,7 @@ class TestSuite(model.TestSuite[Keyword, TestCase], StatusMixin):
         if output is None:
             output = StringIO()
         elif isinstance(output, (Path, str)):
-            output = open(output, 'w')
+            output = open(output, 'w', encoding='UTF-8')
             close = True
         return output, close
 

{robotframework-7.0.1rc2 → robotframework-7.1rc1}/src/robot/result/resultbuilder.py

@@ -13,8 +13,6 @@
 #  See the License for the specific language governing permissions and
 #  limitations under the License.
 
-from pathlib import Path
-
 from robot.errors import DataError
 from robot.model import SuiteVisitor
 from robot.utils import ET, ETSource, get_error_message
@@ -82,9 +80,13 @@ def _single_result(source, options):
 def _json_result(source, options):
     try:
         suite = TestSuite.from_json(source)
+    except IOError as err:
+        error = err.strerror
     except Exception:
-        raise DataError(f"Reading JSON source '{source}' failed: {get_error_message()}")
-    return Result(source, suite, rpa=options.pop('rpa', None))
+        error = get_error_message()
+    else:
+        return Result(source, suite, rpa=options.pop('rpa', None))
+    raise DataError(f"Reading JSON source '{source}' failed: {error}")
 
 
 def _xml_result(source, options):
@@ -150,27 +152,27 @@ class ExecutionResultBuilder:
                 elem.clear()
 
     def _omit_keywords(self, context):
-        omitted_kws = 0
+        omitted_elements = {'kw', 'for', 'while', 'if', 'try'}
+        omitted = 0
         for event, elem in context:
             # Teardowns aren't omitted yet to allow checking suite teardown status.
             # They'll be removed later when not needed in `build()`.
-            omit = elem.tag in ('kw', 'for', 'if') and elem.get('type') != 'TEARDOWN'
+            omit = elem.tag in omitted_elements and elem.get('type') != 'TEARDOWN'
             start = event == 'start'
             if omit and start:
-                omitted_kws += 1
-            if not omitted_kws:
+                omitted += 1
+            if not omitted:
                 yield event, elem
             elif not start:
                 elem.clear()
             if omit and not start:
-                omitted_kws -= 1
+                omitted -= 1
 
     def _flatten_keywords(self, context, flattened):
         # Performance optimized. Do not change without profiling!
         name_match, by_name = self._get_matcher(FlattenByNameMatcher, flattened)
         type_match, by_type = self._get_matcher(FlattenByTypeMatcher, flattened)
         started = -1    # if 0 or more, we are flattening
-        tags = []
         containers = {'kw', 'for', 'while', 'iter', 'if', 'try'}
         inside = 0    # to make sure we don't read tags from a test
         for event, elem in context:
@@ -185,7 +187,6 @@ class ExecutionResultBuilder:
                         started = 0
                     elif by_type and type_match(tag):
                         started = 0
-                    tags = []
             else:
                 if tag in containers:
                     inside -= 1

{robotframework-7.0.1rc2 → robotframework-7.1rc1}/src/robot/result/xmlelementhandlers.py

@@ -60,6 +60,9 @@ class ElementHandler:
 
     def _legacy_timestamp(self, elem, attr_name):
         ts = elem.get(attr_name)
+        return self._parse_legacy_timestamp(ts)
+
+    def _parse_legacy_timestamp(self, ts):
         if ts == 'N/A' or not ts:
             return None
         ts = ts.ljust(24, '0')
@@ -85,10 +88,19 @@ class RobotHandler(ElementHandler):
     def start(self, elem, result):
         generator = elem.get('generator', 'unknown').split()[0].upper()
         result.generated_by_robot = generator == 'ROBOT'
+        result.generation_time = self._parse_generation_time(elem.get('generated'))
         if result.rpa is None:
             result.rpa = elem.get('rpa', 'false') == 'true'
         return result
 
+    def _parse_generation_time(self, generated):
+        if not generated:
+            return None
+        try:
+            return datetime.fromisoformat(generated)
+        except ValueError:
+            return self._parse_legacy_timestamp(generated)
+
 
 @ElementHandler.register
 class SuiteHandler(ElementHandler):

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

@@ -123,6 +123,6 @@ from .librarykeyword import LibraryKeyword
 from .model import (Break, Continue, Error, For, ForIteration, If, IfBranch, Keyword,
                     Return, TestCase, TestSuite, Try, TryBranch, Var, While,
                     WhileIteration)
-from .resourcemodel import ResourceFile, UserKeyword
+from .resourcemodel import Import, ResourceFile, UserKeyword, Variable
 from .runkwregister import RUN_KW_REGISTER
 from .testlibraries import TestLibrary

{robotframework-7.0.1rc2 → robotframework-7.1rc1}/src/robot/running/arguments/argumentresolver.py

@@ -38,8 +38,11 @@ class ArgumentResolver:
         self.dict_to_kwargs = DictToKwargs(spec, dict_to_kwargs)
         self.argument_validator = ArgumentValidator(spec)
 
-    def resolve(self, arguments, variables=None):
-        positional, named = self.named_resolver.resolve(arguments, variables)
+    def resolve(self, args, named_args=None, variables=None):
+        if named_args is None:
+            positional, named = self.named_resolver.resolve(args, variables)
+        else:
+            positional, named = args, list(named_args.items())
         positional, named = self.variable_replacer.replace(positional, named, variables)
         positional, named = self.dict_to_kwargs.handle(positional, named)
         self.argument_validator.validate(positional, named, dryrun=variables is None)
@@ -52,14 +55,15 @@ class NamedArgumentResolver:
         self.spec = spec
 
     def resolve(self, arguments, variables=None):
-        spec = self.spec
-        positional = list(arguments[:len(spec.embedded)])
+        known_positional_count = max(len(self.spec.positional_only),
+                                     len(self.spec.embedded))
+        positional = list(arguments[:known_positional_count])
         named = []
-        for arg in arguments[len(spec.embedded):]:
+        for arg in arguments[known_positional_count:]:
             if is_dict_variable(arg):
                 named.append(arg)
             else:
-                name, value = self._split_named(arg, named, variables, spec)
+                name, value = self._split_named(arg, named, variables)
                 if name is not None:
                     named.append((name, value))
                 elif named:
@@ -68,23 +72,23 @@ class NamedArgumentResolver:
                     positional.append(value)
         return positional, named
 
-    def _split_named(self, arg, previous_named, variables, spec):
+    def _split_named(self, arg, previous_named, variables):
         if isinstance(arg, Argument):
             return arg.name, arg.value
         name, value = split_from_equals(arg)
-        if value is None or not self._is_named(name, previous_named, variables, spec):
+        if value is None or not self._is_named(name, previous_named, variables):
             return None, arg
         return name, value
 
-    def _is_named(self, name, previous_named, variables, spec):
-        if previous_named or spec.var_named:
+    def _is_named(self, name, previous_named, variables):
+        if previous_named or self.spec.var_named:
             return True
         if variables:
             try:
                 name = variables.replace_scalar(name)
             except DataError:
                 return False
-        return name in spec.named
+        return name in self.spec.named
 
     def _raise_positional_after_named(self):
         raise DataError(f"{self.spec.type.capitalize()} '{self.spec.name}' "

{robotframework-7.0.1rc2 → robotframework-7.1rc1}/src/robot/running/arguments/argumentspec.py

@@ -96,12 +96,12 @@ class ArgumentSpec(metaclass=SetterAwareType):
         return (self.positional_only + self.positional_or_named + var_positional +
                 self.named_only + var_named)
 
-    def resolve(self, arguments, variables=None, converters=None,
+    def resolve(self, args, named_args=None, variables=None, converters=None,
                 resolve_named=True, resolve_args_until=None,
                 dict_to_kwargs=False, languages=None) -> 'tuple[list, list]':
         resolver = ArgumentResolver(self, resolve_named, resolve_args_until,
                                     dict_to_kwargs)
-        positional, named = resolver.resolve(arguments, variables)
+        positional, named = resolver.resolve(args, named_args, variables)
         return self.convert(positional, named, converters, dry_run=not variables,
                             languages=languages)
 

{robotframework-7.0.1rc2 → robotframework-7.1rc1}/src/robot/running/arguments/argumentvalidator.py

@@ -34,7 +34,6 @@ class ArgumentValidator:
                        any(is_dict_variable(arg) for arg in named)):
             return
         self._validate_no_multiple_values(positional, named, self.spec)
-        self._validate_no_positional_only_as_named(named, self.spec)
         self._validate_positional_limits(positional, named, self.spec)
         self._validate_no_mandatory_missing(positional, named, self.spec)
         self._validate_no_named_only_missing(named, self.spec)
@@ -49,13 +48,6 @@ class ArgumentValidator:
         name = f"'{self.spec.name}' " if self.spec.name else ''
         raise DataError(f"{self.spec.type.capitalize()} {name}{message}.")
 
-    def _validate_no_positional_only_as_named(self, named, spec):
-        if not spec.var_named:
-            for name in named:
-                if name in spec.positional_only:
-                    self._raise_error(f"does not accept argument '{name}' as named "
-                                      f"argument")
-
     def _validate_positional_limits(self, positional, named, spec):
         count = len(positional) + self._named_positionals(named, spec)
         if not spec.minargs <= count <= spec.maxargs:

{robotframework-7.0.1rc2 → robotframework-7.1rc1}/src/robot/running/arguments/embedded.py

@@ -80,7 +80,7 @@ class EmbeddedArgumentParser:
         args = []
         custom_patterns = {}
         after = string
-        for match in VariableMatches(string, identifiers='$'):
+        for match in VariableMatches(' '.join(string.split()), identifiers='$'):
             arg, pattern, is_custom = self._get_name_and_pattern(match.base)
             args.append(arg)
             if is_custom:
@@ -139,7 +139,7 @@ class EmbeddedArgumentParser:
 
     def _compile_regexp(self, pattern: str) -> re.Pattern:
         try:
-            return re.compile(''.join(pattern), re.IGNORECASE)
+            return re.compile(pattern.replace(r'\ ', r'\s'), re.IGNORECASE)
         except Exception:
             raise DataError(f"Compiling embedded arguments regexp failed: "
                             f"{get_error_message()}")

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

@@ -54,9 +54,12 @@ class InvalidKeywordRunner:
 
     def run(self, data: KeywordData, result: KeywordResult, context, run=True):
         kw = self.keyword.bind(data)
+        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 if kw.owner else None,
-                      args=data.args,
+                      args=args,
                       assign=tuple(VariableAssignment(data.assign)),
                       type=data.type)
         with StatusReporter(data, result, context, run, implementation=kw):

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

@@ -14,7 +14,7 @@
 #  limitations under the License.
 
 from pathlib import Path
-from typing import Any, Literal, Sequence, TYPE_CHECKING
+from typing import Any, Literal, Mapping, Sequence, TYPE_CHECKING
 
 from robot.model import ModelObject, Tags
 from robot.utils import eq, getshortdoc, setter
@@ -23,6 +23,8 @@ from .arguments import ArgInfo, ArgumentSpec, EmbeddedArguments
 from .model import BodyItemParent, Keyword
 
 if TYPE_CHECKING:
+    from robot.conf import LanguagesLike
+
     from .librarykeywordrunner import LibraryKeywordRunner
     from .resourcemodel import ResourceFile
     from .testlibraries import TestLibrary
@@ -141,11 +143,13 @@ class KeywordImplementation(ModelObject):
             return self.embedded.match(name) is not None
         return eq(self.name, name, ignore='_')
 
-    def resolve_arguments(self, args: Sequence[str], variables=None,
-                          languages=None) -> 'tuple[list, list]':
-        return self.args.resolve(args, variables, languages=languages)
+    def resolve_arguments(self, args: 'Sequence[str|Any]',
+                          named_args: 'Mapping[str, Any]|None' = None,
+                          variables=None,
+                          languages: 'LanguagesLike' = None) -> 'tuple[list, list]':
+        return self.args.resolve(args, named_args, variables, languages=languages)
 
-    def create_runner(self, name: 'str|None', languages=None) \
+    def create_runner(self, name: 'str|None', languages: 'LanguagesLike' = None) \
             -> 'LibraryKeywordRunner|UserKeywordRunner':
         raise NotImplementedError
 

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

@@ -16,7 +16,7 @@
 import inspect
 from os.path import normpath
 from pathlib import Path
-from typing import Any, Callable, Generic, Sequence, TypeVar, TYPE_CHECKING
+from typing import Any, Callable, Generic, Mapping, Sequence, TypeVar, TYPE_CHECKING
 
 from robot.model import Tags
 from robot.errors import DataError
@@ -29,10 +29,13 @@ from .dynamicmethods import (GetKeywordArguments, GetKeywordDocumentation,
                              RunKeyword)
 from .model import BodyItemParent, Keyword
 from .keywordimplementation import KeywordImplementation
-from .librarykeywordrunner import EmbeddedArgumentsRunner, LibraryKeywordRunner, RunKeywordRunner
+from .librarykeywordrunner import (EmbeddedArgumentsRunner, LibraryKeywordRunner,
+                                   RunKeywordRunner)
 from .runkwregister import RUN_KW_REGISTER
 
 if TYPE_CHECKING:
+    from robot.conf import LanguagesLike
+
     from .testlibraries import DynamicLibrary, TestLibrary
 
 
@@ -73,7 +76,8 @@ class LibraryKeyword(KeywordImplementation):
                 return start_lineno + increment
         return start_lineno
 
-    def create_runner(self, name: 'str|None', languages=None) -> LibraryKeywordRunner:
+    def create_runner(self, name: 'str|None',
+                      languages: 'LanguagesLike' = None) -> LibraryKeywordRunner:
         if self.embedded:
             return EmbeddedArgumentsRunner(self, name)
         if self._resolve_args_until is not None:
@@ -81,10 +85,13 @@ class LibraryKeyword(KeywordImplementation):
             return RunKeywordRunner(self, execute_in_dry_run=dry_run)
         return LibraryKeywordRunner(self, languages=languages)
 
-    def resolve_arguments(self, args: Sequence[str], variables=None,
-                          languages=None) -> 'tuple[list, list]':
+    def resolve_arguments(self, args: 'Sequence[str|Any]',
+                          named_args: 'Mapping[str, Any]|None' = None,
+                          variables=None,
+                          languages: 'LanguagesLike' = None) -> 'tuple[list, list]':
         resolve_args_until = self._resolve_args_until
-        positional, named = self.args.resolve(args, variables, self.owner.converters,
+        positional, named = self.args.resolve(args, named_args, variables,
+                                              self.owner.converters,
                                               resolve_named=resolve_args_until is None,
                                               resolve_args_until=resolve_args_until,
                                               languages=languages)
@@ -198,9 +205,12 @@ class DynamicKeyword(LibraryKeyword):
     def from_name(cls, name: str, owner: 'DynamicLibrary') -> 'DynamicKeyword':
         return DynamicKeywordCreator(name, owner).create()
 
-    def resolve_arguments(self, arguments, variables=None,
-                          languages=None) -> 'tuple[list, list]':
-        positional, named = super().resolve_arguments(arguments, variables, languages)
+    def resolve_arguments(self, args: 'Sequence[str|Any]',
+                          named_args: 'Mapping[str, Any]|None' = None,
+                          variables=None,
+                          languages: 'LanguagesLike' = None) -> 'tuple[list, list]':
+        positional, named = super().resolve_arguments(args, named_args, variables,
+                                                      languages)
         if not self.owner.supports_named_args:
             positional, named = self.args.map(positional, named)
         return positional, named

{robotframework-7.0.1rc2 → robotframework-7.1rc1}/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.1rc1}/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()