robotframework 6.1rc1__zip → 7.0__zip

{robotframework-6.1rc1 → robotframework-7.0}/src/robot/running/arguments/argumentmapper.py

@@ -13,59 +13,62 @@
 #  See the License for the specific language governing permissions and
 #  limitations under the License.
 
+from typing import TYPE_CHECKING
+
 from robot.errors import DataError
 
+if TYPE_CHECKING:
+    from .argumentspec import ArgumentSpec
+
 
 class ArgumentMapper:
 
-    def __init__(self, argspec):
-        """:type argspec: :py:class:`robot.running.arguments.ArgumentSpec`"""
-        self._argspec = argspec
+    def __init__(self, arg_spec: 'ArgumentSpec'):
+        self.arg_spec = arg_spec
 
     def map(self, positional, named, replace_defaults=True):
-        template = KeywordCallTemplate(self._argspec)
+        template = KeywordCallTemplate(self.arg_spec)
         template.fill_positional(positional)
         template.fill_named(named)
         if replace_defaults:
             template.replace_defaults()
-        return template.args, template.kwargs
+        return template.positional, template.named
 
 
 class KeywordCallTemplate:
 
-    def __init__(self, argspec):
-        """:type argspec: :py:class:`robot.running.arguments.ArgumentSpec`"""
-        self._argspec = argspec
-        self.args = [None if arg not in argspec.defaults
-                     else DefaultValue(argspec.defaults[arg])
-                     for arg in argspec.positional]
-        self.kwargs = []
+    def __init__(self, spec: 'ArgumentSpec'):
+        self.spec = spec
+        self.positional = [DefaultValue(spec.defaults[arg])
+                           if arg in spec.defaults else None
+                           for arg in spec.positional]
+        self.named = []
 
     def fill_positional(self, positional):
-        self.args[:len(positional)] = positional
+        self.positional[:len(positional)] = positional
 
     def fill_named(self, named):
-        spec = self._argspec
+        spec = self.spec
         for name, value in named:
             if name in spec.positional_or_named:
                 index = spec.positional_or_named.index(name)
-                self.args[index] = value
+                self.positional[index] = value
             elif spec.var_named or name in spec.named_only:
-                self.kwargs.append((name, value))
+                self.named.append((name, value))
             else:
-                raise DataError("Non-existing named argument '%s'." % name)
+                raise DataError(f"Non-existing named argument '{name}'.")
         named_names = {name for name, _ in named}
         for name in spec.named_only:
             if name not in named_names:
                 value = DefaultValue(spec.defaults[name])
-                self.kwargs.append((name, value))
+                self.named.append((name, value))
 
     def replace_defaults(self):
         is_default = lambda arg: isinstance(arg, DefaultValue)
-        while self.args and is_default(self.args[-1]):
-            self.args.pop()
-        self.args = [a if not is_default(a) else a.value for a in self.args]
-        self.kwargs = [(n, v) for n, v in self.kwargs if not is_default(v)]
+        while self.positional and is_default(self.positional[-1]):
+            self.positional.pop()
+        self.positional = [a if not is_default(a) else a.value for a in self.positional]
+        self.named = [(n, v) for n, v in self.named if not is_default(v)]
 
 
 class DefaultValue:
@@ -77,5 +80,4 @@ class DefaultValue:
         try:
             return variables.replace_scalar(self.value)
         except DataError as err:
-            raise DataError('Resolving argument default values failed: %s'
-                            % err.message)
+            raise DataError(f'Resolving argument default values failed: {err}')

{robotframework-6.1rc1 → robotframework-7.0}/src/robot/running/arguments/argumentparser.py

@@ -15,7 +15,7 @@
 
 from abc import ABC, abstractmethod
 from inspect import isclass, signature, Parameter
-from typing import get_type_hints
+from typing import Any, Callable, get_type_hints
 
 from robot.errors import DataError
 from robot.utils import is_string, split_from_equals
@@ -26,110 +26,134 @@ from .argumentspec import ArgumentSpec
 
 class ArgumentParser(ABC):
 
-    def __init__(self, type='Keyword', error_reporter=None):
-        self._type = type
-        self._error_reporter = error_reporter
+    def __init__(self, type: str = 'Keyword',
+                 error_reporter: 'Callable[[str], None] | None' = None):
+        self.type = type
+        self.error_reporter = error_reporter
 
     @abstractmethod
-    def parse(self, source, name=None):
+    def parse(self, source: Any, name: 'str|None' = None) -> ArgumentSpec:
         raise NotImplementedError
 
-    def _report_error(self, error):
-        if self._error_reporter:
-            self._error_reporter(error)
+    def _report_error(self, error: str):
+        if self.error_reporter:
+            self.error_reporter(error)
         else:
             raise DataError(f'Invalid argument specification: {error}')
 
 
 class PythonArgumentParser(ArgumentParser):
 
-    def parse(self, handler, name=None):
-        spec = ArgumentSpec(name, self._type)
-        self._set_args(spec, handler)
-        self._set_types(spec, handler)
-        return spec
-
-    def _set_args(self, spec, handler):
+    def parse(self, method, name=None):
         try:
-            sig = signature(handler)
-        except ValueError:  # Can occur w/ C functions (incl. many builtins).
-            spec.var_positional = 'args'
-            return
+            sig = signature(method)
+        except ValueError:        # Can occur with C functions (incl. many builtins).
+            return ArgumentSpec(name, self.type, var_positional='args')
+        except TypeError as err:  # Occurs if handler isn't actually callable.
+            raise DataError(str(err))
         parameters = list(sig.parameters.values())
         # `inspect.signature` drops `self` with bound methods and that's the case when
         # inspecting keywords. `__init__` is got directly from class (i.e. isn't bound)
         # so we need to handle that case ourselves.
         # Partial objects do not have __name__ at least in Python =< 3.10.
-        if getattr(handler, '__name__', None) == '__init__':
+        if getattr(method, '__name__', None) == '__init__':
             parameters = parameters[1:]
-        setters = {
-            Parameter.POSITIONAL_ONLY: spec.positional_only.append,
-            Parameter.POSITIONAL_OR_KEYWORD: spec.positional_or_named.append,
-            Parameter.VAR_POSITIONAL: lambda name: setattr(spec, 'var_positional', name),
-            Parameter.KEYWORD_ONLY: spec.named_only.append,
-            Parameter.VAR_KEYWORD: lambda name: setattr(spec, 'var_named', name),
-        }
+        spec = self._create_spec(parameters, name)
+        self._set_types(spec, method)
+        return spec
+
+    def _create_spec(self, parameters, name):
+        positional_only = []
+        positional_or_named = []
+        var_positional = None
+        named_only = []
+        var_named = None
+        defaults = {}
         for param in parameters:
-            setters[param.kind](param.name)
+            kind = param.kind
+            if kind == Parameter.POSITIONAL_ONLY:
+                positional_only.append(param.name)
+            elif kind == Parameter.POSITIONAL_OR_KEYWORD:
+                positional_or_named.append(param.name)
+            elif kind == Parameter.VAR_POSITIONAL:
+                var_positional = param.name
+            elif kind == Parameter.KEYWORD_ONLY:
+                named_only.append(param.name)
+            elif kind == Parameter.VAR_KEYWORD:
+                var_named = param.name
             if param.default is not param.empty:
-                spec.defaults[param.name] = param.default
+                defaults[param.name] = param.default
+        return ArgumentSpec(name, self.type, positional_only, positional_or_named,
+                            var_positional, named_only, var_named, defaults)
+
+    def _set_types(self, spec, method):
+        types = self._get_types(method)
+        if isinstance(types, dict) and 'return' in types:
+            spec.return_type = types.pop('return')
+        spec.types = types
 
-    def _set_types(self, spec, handler):
+    def _get_types(self, method):
         # If types are set using the `@keyword` decorator, use them. Including when
-        # types are explicitly disabled with `@keyword(types=None)`. Otherwise read
+        # types are explicitly disabled with `@keyword(types=None)`. Otherwise get
         # type hints.
-        if isclass(handler):
-            handler = handler.__init__
-        robot_types = getattr(handler, 'robot_types', ())
-        if robot_types or robot_types is None:
-            spec.types = robot_types
-        else:
-            spec.types = self._get_type_hints(handler)
-
-    def _get_type_hints(self, handler):
+        if isclass(method):
+            method = method.__init__
+        types = getattr(method, 'robot_types', ())
+        if types or types is None:
+            return types
         try:
-            return get_type_hints(handler)
+            return get_type_hints(method)
         except Exception:  # Can raise pretty much anything
             # Not all functions have `__annotations__`.
             # https://github.com/robotframework/robotframework/issues/4059
-            return getattr(handler, '__annotations__', {})
+            return getattr(method, '__annotations__', {})
 
 
 class ArgumentSpecParser(ArgumentParser):
 
-    def parse(self, argspec, name=None):
-        spec = ArgumentSpec(name, self._type)
-        named_only = positional_only_separator_seen = False
-        for arg in argspec:
+    def parse(self, arguments, name=None):
+        positional_only = []
+        positional_or_named = []
+        var_positional = None
+        named_only = []
+        var_named = None
+        defaults = {}
+        named_only_separator_seen = positional_only_separator_seen = False
+        target = positional_or_named
+        for arg in arguments:
             arg = self._validate_arg(arg)
-            if spec.var_named:
+            if var_named:
                 self._report_error('Only last argument can be kwargs.')
             elif self._is_positional_only_separator(arg):
-                if named_only:
-                    self._report_error('Positional-only separator must be before '
-                                       'named-only arguments.')
                 if positional_only_separator_seen:
                     self._report_error('Too many positional-only separators.')
-                spec.positional_only = spec.positional_or_named
-                spec.positional_or_named = []
+                if named_only_separator_seen:
+                    self._report_error('Positional-only separator must be before '
+                                       'named-only arguments.')
+                positional_only = positional_or_named
+                target = positional_or_named = []
                 positional_only_separator_seen = True
             elif isinstance(arg, tuple):
                 arg, default = arg
-                arg = self._add_arg(spec, arg, named_only)
-                spec.defaults[arg] = default
+                arg = self._format_arg(arg)
+                target.append(arg)
+                defaults[arg] = default
             elif self._is_var_named(arg):
-                spec.var_named = self._format_var_named(arg)
+                var_named = self._format_var_named(arg)
             elif self._is_var_positional(arg):
-                if named_only:
+                if named_only_separator_seen:
                     self._report_error('Cannot have multiple varargs.')
                 if not self._is_named_only_separator(arg):
-                    spec.var_positional = self._format_var_positional(arg)
-                named_only = True
-            elif spec.defaults and not named_only:
+                    var_positional = self._format_var_positional(arg)
+                named_only_separator_seen = True
+                target = named_only
+            elif defaults and not named_only_separator_seen:
                 self._report_error('Non-default argument after default arguments.')
             else:
-                self._add_arg(spec, arg, named_only)
-        return spec
+                arg = self._format_arg(arg)
+                target.append(arg)
+        return ArgumentSpec(name, self.type, positional_only, positional_or_named,
+                            var_positional, named_only, var_named, defaults)
 
     @abstractmethod
     def _validate_arg(self, arg):

robotframework-7.0/src/robot/running/arguments/argumentresolver.py

@@ -0,0 +1,158 @@
+#  Copyright 2008-2015 Nokia Networks
+#  Copyright 2016-     Robot Framework Foundation
+#
+#  Licensed under the Apache License, Version 2.0 (the "License");
+#  you may not use this file except in compliance with the License.
+#  You may obtain a copy of the License at
+#
+#      http://www.apache.org/licenses/LICENSE-2.0
+#
+#  Unless required by applicable law or agreed to in writing, software
+#  distributed under the License is distributed on an "AS IS" BASIS,
+#  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+#  See the License for the specific language governing permissions and
+#  limitations under the License.
+
+from typing import TYPE_CHECKING
+
+from robot.errors import DataError
+from robot.utils import is_dict_like, is_list_like, split_from_equals
+from robot.variables import is_dict_variable
+
+from .argumentvalidator import ArgumentValidator
+
+if TYPE_CHECKING:
+    from .argumentspec import ArgumentSpec
+
+
+class ArgumentResolver:
+
+    def __init__(self, spec: 'ArgumentSpec',
+                 resolve_named: bool = True,
+                 resolve_args_until: 'int|None' = None,
+                 dict_to_kwargs: bool = False):
+        self.named_resolver = NamedArgumentResolver(spec) \
+              if resolve_named else NullNamedArgumentResolver()
+        self.variable_replacer = VariableReplacer(spec, resolve_args_until)
+        self.dict_to_kwargs = DictToKwargs(spec, dict_to_kwargs)
+        self.argument_validator = ArgumentValidator(spec)
+
+    def resolve(self, arguments, variables=None):
+        if len(arguments) == 2 and is_list_like(arguments[0]) and is_dict_like(arguments[1]):
+            positional = list(arguments[0])
+            named = list(arguments[1].items())
+        else:
+            positional, named = self.named_resolver.resolve(arguments, variables)
+            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)
+        return positional, named
+
+
+class NamedArgumentResolver:
+
+    def __init__(self, spec: 'ArgumentSpec'):
+        self.spec = spec
+
+    def resolve(self, arguments, variables=None):
+        spec = self.spec
+        positional = list(arguments[:len(spec.embedded)])
+        named = []
+        for arg in arguments[len(spec.embedded):]:
+            if is_dict_variable(arg):
+                named.append(arg)
+            else:
+                name, value = self._split_named(arg, named, variables, spec)
+                if name is not None:
+                    named.append((name, value))
+                elif named:
+                    self._raise_positional_after_named()
+                else:
+                    positional.append(value)
+        return positional, named
+
+    def _split_named(self, arg, previous_named, variables, spec):
+        if isinstance(arg, tuple):
+            if len(arg) == 2 and isinstance(arg[0], str):
+                return arg
+            elif len(arg) == 1:
+                return None, arg[0]
+            else:
+                return None, arg
+        name, value = split_from_equals(arg)
+        if value is None or not self._is_named(name, previous_named, variables, spec):
+            return None, arg
+        return name, value
+
+    def _is_named(self, name, previous_named, variables, spec):
+        if previous_named or spec.var_named:
+            return True
+        if variables:
+            try:
+                name = variables.replace_scalar(name)
+            except DataError:
+                return False
+        return name in spec.named
+
+    def _raise_positional_after_named(self):
+        raise DataError(f"{self.spec.type.capitalize()} '{self.spec.name}' "
+                        f"got positional argument after named arguments.")
+
+
+class NullNamedArgumentResolver:
+
+    def resolve(self, arguments, variables=None):
+        return arguments, []
+
+
+class DictToKwargs:
+
+    def __init__(self, spec: 'ArgumentSpec', enabled: bool = False):
+        self.maxargs = spec.maxargs
+        self.enabled = enabled and bool(spec.var_named)
+
+    def handle(self, positional, named):
+        if self.enabled and self._extra_arg_has_kwargs(positional, named):
+            named = positional.pop().items()
+        return positional, named
+
+    def _extra_arg_has_kwargs(self, positional, named):
+        if named or len(positional) != self.maxargs + 1:
+            return False
+        return is_dict_like(positional[-1])
+
+
+class VariableReplacer:
+
+    def __init__(self, spec: 'ArgumentSpec', resolve_until: 'int|None' = None):
+        self.spec = spec
+        self.resolve_until = resolve_until
+
+    def replace(self, positional, named, variables=None):
+        # `variables` is None in dry-run mode and when using Libdoc.
+        if variables:
+            if self.spec.embedded:
+                embedded = len(self.spec.embedded)
+                positional = [
+                    variables.replace_scalar(emb) for emb in positional[:embedded]
+                ] + variables.replace_list(positional[embedded:])
+            else:
+                positional = variables.replace_list(positional, self.resolve_until)
+            named = list(self._replace_named(named, variables.replace_scalar))
+        else:
+            # If `var` isn't a tuple, it's a &{dict} variables.
+            named = [var if isinstance(var, tuple) else (var, var) for var in named]
+        return positional, named
+
+    def _replace_named(self, named, replace_scalar):
+        for item in named:
+            for name, value in self._get_replaced_named(item, replace_scalar):
+                if not isinstance(name, str):
+                    raise DataError('Argument names must be strings.')
+                yield name, value
+
+    def _get_replaced_named(self, item, replace_scalar):
+        if not isinstance(item, tuple):
+            return replace_scalar(item).items()
+        name, value = item
+        return [(replace_scalar(name), replace_scalar(value))]