robotframework 6.1rc1__zip → 7.0a1__zip

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

@@ -13,50 +13,53 @@
 #  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_string, is_dict_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, argspec, resolve_named=True,
-                 resolve_variables_until=None, dict_to_kwargs=False):
-        self._named_resolver = NamedArgumentResolver(argspec) \
-            if resolve_named else NullNamedArgumentResolver()
-        self._variable_replacer = VariableReplacer(resolve_variables_until)
-        self._dict_to_kwargs = DictToKwargs(argspec, dict_to_kwargs)
-        self._argument_validator = ArgumentValidator(argspec)
+    def __init__(self, spec: 'ArgumentSpec',
+                 resolve_named: bool = True,
+                 resolve_variables_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_variables_until)
+        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)
-        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)
+        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, argspec):
-        """:type argspec: :py:class:`robot.running.arguments.ArgumentSpec`"""
-        self._argspec = argspec
+    def __init__(self, spec: 'ArgumentSpec'):
+        self.spec = spec
 
     def resolve(self, arguments, variables=None):
-        positional = []
         named = []
-        for arg in arguments:
+        for arg in arguments[len(self.spec.embedded):]:
             if is_dict_variable(arg):
                 named.append(arg)
             elif self._is_named(arg, named, variables):
                 named.append(split_from_equals(arg))
             elif named:
                 self._raise_positional_after_named()
-            else:
-                positional.append(arg)
+        positional = arguments[:-len(named)] if named else arguments
         return positional, named
 
     def _is_named(self, arg, previous_named, variables=None):
@@ -68,15 +71,13 @@ class NamedArgumentResolver:
                 name = variables.replace_scalar(name)
             except DataError:
                 return False
-        spec = self._argspec
         return bool(previous_named or
-                    spec.var_named or
-                    name in spec.positional_or_named or
-                    name in spec.named_only)
+                    self.spec.var_named or
+                    name in self.spec.named)
 
     def _raise_positional_after_named(self):
-        raise DataError("%s '%s' got positional argument after named arguments."
-                        % (self._argspec.type.capitalize(), self._argspec.name))
+        raise DataError(f"{self.spec.type.capitalize()} '{self.spec.name}' "
+                        f"got positional argument after named arguments.")
 
 
 class NullNamedArgumentResolver:
@@ -87,30 +88,37 @@ class NullNamedArgumentResolver:
 
 class DictToKwargs:
 
-    def __init__(self, argspec, enabled=False):
-        self._maxargs = argspec.maxargs
-        self._enabled = enabled and bool(argspec.var_named)
+    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):
+        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:
+        if named or len(positional) != self.maxargs + 1:
             return False
         return is_dict_like(positional[-1])
 
 
 class VariableReplacer:
 
-    def __init__(self, resolve_until=None):
-        self._resolve_until = resolve_until
+    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:
-            positional = variables.replace_list(positional, self._resolve_until)
+            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.

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

@@ -15,13 +15,14 @@
 
 import sys
 from enum import Enum
-from typing import Union, Tuple
+from typing import Any
 
-from robot.utils import has_args, is_union, safe_str, setter, type_repr
+from robot.utils import NOT_SET, safe_str, setter
 
 from .argumentconverter import ArgumentConverter
 from .argumentmapper import ArgumentMapper
 from .argumentresolver import ArgumentResolver
+from .typeinfo import TypeInfo
 from .typevalidator import TypeValidator
 
 
@@ -29,25 +30,31 @@ class ArgumentSpec:
 
     def __init__(self, name=None, type='Keyword', positional_only=None,
                  positional_or_named=None, var_positional=None, named_only=None,
-                 var_named=None, defaults=None, types=None):
+                 var_named=None, embedded=None, defaults=None, types=None):
         self.name = name
         self.type = type
+        # FIXME: Use tuples, not lists. Consider using __slots__.
         self.positional_only = positional_only or []
         self.positional_or_named = positional_or_named or []
         self.var_positional = var_positional
         self.named_only = named_only or []
         self.var_named = var_named
+        self.embedded = embedded or ()
         self.defaults = defaults or {}
         self.types = types
 
     @setter
-    def types(self, types):
+    def types(self, types) -> 'dict[str, TypeInfo]':
         return TypeValidator(self).validate(types)
 
     @property
     def positional(self):
         return self.positional_only + self.positional_or_named
 
+    @property
+    def named(self):
+        return self.named_only + self.positional_or_named
+
     @property
     def minargs(self):
         return len([arg for arg in self.positional if arg not in self.defaults])
@@ -84,28 +91,27 @@ class ArgumentSpec:
         return mapper.map(positional, named, replace_defaults)
 
     def __iter__(self):
-        notset = ArgInfo.NOTSET
         get_type = (self.types or {}).get
         get_default = self.defaults.get
         for arg in self.positional_only:
             yield ArgInfo(ArgInfo.POSITIONAL_ONLY, arg,
-                          get_type(arg, notset), get_default(arg, notset))
+                          get_type(arg), get_default(arg, NOT_SET))
         if self.positional_only:
             yield ArgInfo(ArgInfo.POSITIONAL_ONLY_MARKER)
         for arg in self.positional_or_named:
             yield ArgInfo(ArgInfo.POSITIONAL_OR_NAMED, arg,
-                          get_type(arg, notset), get_default(arg, notset))
+                          get_type(arg), get_default(arg, NOT_SET))
         if self.var_positional:
             yield ArgInfo(ArgInfo.VAR_POSITIONAL, self.var_positional,
-                          get_type(self.var_positional, notset))
+                          get_type(self.var_positional))
         elif self.named_only:
             yield ArgInfo(ArgInfo.NAMED_ONLY_MARKER)
         for arg in self.named_only:
             yield ArgInfo(ArgInfo.NAMED_ONLY, arg,
-                          get_type(arg, notset), get_default(arg, notset))
+                          get_type(arg), get_default(arg, NOT_SET))
         if self.var_named:
             yield ArgInfo(ArgInfo.VAR_NAMED, self.var_named,
-                          get_type(self.var_named, notset))
+                          get_type(self.var_named))
 
     def __bool__(self):
         return any([self.positional_only, self.positional_or_named, self.var_positional,
@@ -117,7 +123,6 @@ class ArgumentSpec:
 
 class ArgInfo:
     """Contains argument information. Only used by Libdoc."""
-    NOTSET = object()
     POSITIONAL_ONLY = 'POSITIONAL_ONLY'
     POSITIONAL_ONLY_MARKER = 'POSITIONAL_ONLY_MARKER'
     POSITIONAL_OR_NAMED = 'POSITIONAL_OR_NAMED'
@@ -126,10 +131,13 @@ class ArgInfo:
     NAMED_ONLY = 'NAMED_ONLY'
     VAR_NAMED = 'VAR_NAMED'
 
-    def __init__(self, kind, name='', type=NOTSET, default=NOTSET):
+    def __init__(self, kind: str,
+                 name: str = '',
+                 type: 'TypeInfo|None' = None,
+                 default: Any = NOT_SET):
         self.kind = kind
         self.name = name
-        self.type = TypeInfo.from_type(type)
+        self.type = type or TypeInfo()
         self.default = default
 
     @property
@@ -137,21 +145,12 @@ class ArgInfo:
         if self.kind in (self.POSITIONAL_ONLY,
                          self.POSITIONAL_OR_NAMED,
                          self.NAMED_ONLY):
-            return self.default is self.NOTSET
+            return self.default is NOT_SET
         return False
 
-    @property
-    def types_reprs(self):
-        """Deprecated. Use :attr:`type` instead."""
-        if not self.type:
-            return []
-        if self.type.is_union:
-            return [str(t) for t in self.type.nested]
-        return [str(self.type)]
-
     @property
     def default_repr(self):
-        if self.default is self.NOTSET:
+        if self.default is NOT_SET:
             return None
         if isinstance(self.default, Enum):
             return self.default.name
@@ -172,71 +171,6 @@ class ArgInfo:
             default_sep = ' = '
         else:
             default_sep = '='
-        if self.default is not self.NOTSET:
+        if self.default is not NOT_SET:
             ret = f'{ret}{default_sep}{self.default_repr}'
         return ret
-
-
-Type = Union[type, str, tuple, type(ArgInfo.NOTSET)]
-
-
-class TypeInfo:
-    """Represents argument type. Only used by Libdoc.
-
-    With unions and parametrized types, :attr:`nested` contains nested types.
-    """
-    NOTSET = ArgInfo.NOTSET
-
-    def __init__(self, type: Type = NOTSET, nested: Tuple['TypeInfo'] = ()):
-        self.type = type
-        self.nested = nested
-
-    @property
-    def name(self) -> str:
-        if isinstance(self.type, str):
-            return self.type
-        return type_repr(self.type, nested=False)
-
-    @property
-    def is_union(self) -> bool:
-        if isinstance(self.type, str):
-            return self.type == 'Union'
-        return is_union(self.type, allow_tuple=True)
-
-    @classmethod
-    def from_type(cls, type: Type) -> 'TypeInfo':
-        if type is cls.NOTSET:
-            return cls()
-        if isinstance(type, dict):
-            return cls.from_dict(type)
-        if isinstance(type, (tuple, list)):
-            if not type:
-                return cls()
-            if len(type) == 1:
-                return cls(type[0])
-            nested = tuple(cls.from_type(t) for t in type)
-            return cls('Union', nested)
-        if has_args(type):
-            nested = tuple(cls.from_type(t) for t in type.__args__)
-            return cls(type, nested)
-        return cls(type)
-
-    @classmethod
-    def from_dict(cls, data: dict) -> 'TypeInfo':
-        if not data:
-            return cls()
-        nested = tuple(cls.from_dict(n) for n in data['nested'])
-        return cls(data['name'], nested)
-
-    def __str__(self):
-        if self.is_union:
-            return ' | '.join(str(n) for n in self.nested)
-        if isinstance(self.type, str):
-            if self.nested:
-                nested = ', '.join(str(n) for n in self.nested)
-                return f'{self.name}[{nested}]'
-            return self.name
-        return type_repr(self.type)
-
-    def __bool__(self):
-        return self.type is not self.NOTSET

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

@@ -13,44 +13,49 @@
 #  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 plural_or_not, seq2str
+from robot.utils import plural_or_not as s, seq2str
 from robot.variables import is_dict_variable, is_list_variable
 
+if TYPE_CHECKING:
+    from .argumentspec import ArgumentSpec
+
 
 class ArgumentValidator:
 
-    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 validate(self, positional, named, dryrun=False):
         named = set(name for name, value in named)
         if dryrun and (any(is_list_variable(arg) for arg in positional) or
                        any(is_dict_variable(arg) for arg in named)):
             return
-        self._validate_no_multiple_values(positional, named, self._argspec)
-        self._validate_no_positional_only_as_named(named, self._argspec)
-        self._validate_positional_limits(positional, named, self._argspec)
-        self._validate_no_mandatory_missing(positional, named, self._argspec)
-        self._validate_no_named_only_missing(named, self._argspec)
-        self._validate_no_extra_named(named, self._argspec)
+        self._validate_no_multiple_values(positional, named, self.arg_spec)
+        self._validate_no_positional_only_as_named(named, self.arg_spec)
+        self._validate_positional_limits(positional, named, self.arg_spec)
+        self._validate_no_mandatory_missing(positional, named, self.arg_spec)
+        self._validate_no_named_only_missing(named, self.arg_spec)
+        self._validate_no_extra_named(named, self.arg_spec)
 
     def _validate_no_multiple_values(self, positional, named, spec):
-        for name in spec.positional[:len(positional)]:
+        for name in spec.positional[:len(positional)-len(spec.embedded)]:
             if name in named and name not in spec.positional_only:
-                self._raise_error("got multiple values for argument '%s'" % name)
+                self._raise_error(f"got multiple values for argument '{name}'")
 
     def _raise_error(self, message):
-        raise DataError("%s '%s' %s." % (self._argspec.type.capitalize(),
-                                         self._argspec.name, message))
+        spec = self.arg_spec
+        name = f"'{spec.name}' " if spec.name else ''
+        raise DataError(f"{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("does not accept argument '%s' as named "
-                                      "argument" % name)
+                    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)
@@ -61,32 +66,34 @@ class ArgumentValidator:
         return sum(1 for n in named if n in spec.positional_or_named)
 
     def _raise_wrong_count(self, count, spec):
-        minend = plural_or_not(spec.minargs)
-        if spec.minargs == spec.maxargs:
-            expected = '%d argument%s' % (spec.minargs, minend)
+        embedded = len(spec.embedded)
+        minargs = spec.minargs - embedded
+        maxargs = spec.maxargs - embedded
+        if minargs == maxargs:
+            expected = f'{minargs} argument{s(minargs)}'
         elif not spec.var_positional:
-            expected = '%d to %d arguments' % (spec.minargs, spec.maxargs)
+            expected = f'{minargs} to {maxargs} arguments'
         else:
-            expected = 'at least %d argument%s' % (spec.minargs, minend)
+            expected = f'at least {minargs} argument{s(minargs)}'
         if spec.var_named or spec.named_only:
             expected = expected.replace('argument', 'non-named argument')
-        self._raise_error("expected %s, got %d" % (expected, count))
+        self._raise_error(f"expected {expected}, got {count - embedded}")
 
     def _validate_no_mandatory_missing(self, positional, named, spec):
         for name in spec.positional[len(positional):]:
             if name not in spec.defaults and name not in named:
-                self._raise_error("missing value for argument '%s'" % name)
+                self._raise_error(f"missing value for argument '{name}'")
 
     def _validate_no_named_only_missing(self, named, spec):
         defined = set(named) | set(spec.defaults)
         missing = [arg for arg in spec.named_only if arg not in defined]
         if missing:
-            self._raise_error("missing named-only argument%s %s"
-                              % (plural_or_not(missing), seq2str(sorted(missing))))
+            self._raise_error(f"missing named-only argument{s(missing)} "
+                              f"{seq2str(sorted(missing))}")
 
     def _validate_no_extra_named(self, named, spec):
         if not spec.var_named:
             extra = set(named) - set(spec.positional_or_named) - set(spec.named_only)
             if extra:
-                self._raise_error("got unexpected named argument%s %s"
-                                  % (plural_or_not(extra), seq2str(sorted(extra))))
+                self._raise_error(f"got unexpected named argument{s(extra)} "
+                                  f"{seq2str(sorted(extra))}")

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

@@ -13,9 +13,7 @@
 #  See the License for the specific language governing permissions and
 #  limitations under the License.
 
-from robot.utils import getdoc, is_union, seq2str, type_name
-
-from .argumentparser import PythonArgumentParser
+from robot.utils import getdoc, seq2str, type_name
 
 
 class CustomArgumentConverters:
@@ -24,12 +22,14 @@ class CustomArgumentConverters:
         self.converters = converters
 
     @classmethod
-    def from_dict(cls, converters, library):
+    def from_dict(cls, converters, library=None):
         valid = []
         for type_, conv in converters.items():
             try:
                 info = ConverterInfo.for_converter(type_, conv, library)
             except TypeError as err:
+                if library is None:
+                    raise
                 library.report_error(str(err))
             else:
                 valid.append(info)
@@ -78,20 +78,23 @@ class ConverterInfo:
             raise TypeError(f'Custom converters must be callable, converter for '
                             f'{type_name(type_)} is {type_name(converter)}.')
         spec = cls._get_arg_spec(converter)
-        arg_type = spec.types.get(spec.positional and spec.positional[0] or spec.var_positional)
-        if arg_type is None:
+        type_info = spec.types.get(spec.positional[0] if spec.positional
+                                   else spec.var_positional)
+        if type_info is None:
             accepts = ()
-        elif is_union(arg_type):
-            accepts = arg_type.__args__
-        elif hasattr(arg_type, '__origin__'):
-            accepts = (arg_type.__origin__,)
+        elif type_info.is_union:
+            accepts = type_info.nested
         else:
-            accepts = (arg_type,)
+            accepts = (type_info,)
+        accepts = tuple(info.type for info in accepts)
         pass_library = spec.minargs == 2 or spec.var_positional
         return cls(type_, converter, accepts, library if pass_library else None)
 
     @classmethod
     def _get_arg_spec(cls, converter):
+        # Avoid cyclic import. Yuck.
+        from .argumentparser import PythonArgumentParser
+
         spec = PythonArgumentParser(type='Converter').parse(converter)
         if spec.minargs > 2:
             required = seq2str([a for a in spec.positional if a not in spec.defaults])

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

@@ -17,10 +17,9 @@ import re
 
 from robot.errors import DataError
 from robot.utils import get_error_message, is_string
-from robot.variables import VariableIterator
+from robot.variables import VariableMatches
 
-
-ENABLE_STRICT_ARGUMENT_VALIDATION = False
+from ..context import EXECUTION_CONTEXTS
 
 
 class EmbeddedArguments:
@@ -42,31 +41,27 @@ class EmbeddedArguments:
         return list(zip(self.args, values))
 
     def validate(self, values):
-        # Validating that embedded args match custom regexps also if args are
-        # given as variables was initially implemented in RF 6.0. It needed
-        # to be reverted due to backwards incompatibility reasons but the plan
-        # is to enable it again in RF 7.0:
-        # https://github.com/robotframework/robotframework/issues/4069
-        #
-        # TODO: Emit deprecation warnings if patterns don't match in RF 6.1:
-        # https://github.com/robotframework/robotframework/issues/4524
-        #
-        # Because the plan is to add validation back, the code was not removed
-        # but the `ENABLE_STRICT_ARGUMENT_VALIDATION` guard was added instead.
-        # Enabling validation requires only removing the following two lines
-        # (along with this comment). If someone wants to enable strict validation
-        # already now, they set `ENABLE_STRICT_ARGUMENT_VALIDATION` to True
-        # before running tests.
-        if not ENABLE_STRICT_ARGUMENT_VALIDATION:
-            return
+        """Validate that embedded args match custom regexps.
+
+        Initial validation is done already when matching keywords, but this
+        validation makes sure arguments match also if they are given as variables.
+
+        Currently, argument not matching only causes a deprecation warning, but
+        that will be changed to an actual failure in RF 8.0:
+        https://github.com/robotframework/robotframework/issues/4069
+        """
         if not self.custom_patterns:
             return
         for arg, value in zip(self.args, values):
             if arg in self.custom_patterns and is_string(value):
                 pattern = self.custom_patterns[arg]
                 if not re.fullmatch(pattern, value):
-                    raise ValueError(f"Embedded argument '{arg}' got value '{value}' "
-                                     f"that does not match custom pattern '{pattern}'.")
+                    # TODO: Change to `raise ValueError(...)` in RF 8.0.
+                    context = EXECUTION_CONTEXTS.current
+                    context.warn(f"Embedded argument '{arg}' got value {value!r} "
+                                 f"that does not match custom pattern {pattern!r}. "
+                                 f"The argument is still accepted, but this behavior "
+                                 f"will change in Robot Framework 8.0.")
 
     def __bool__(self):
         return self.name is not None
@@ -84,14 +79,16 @@ class EmbeddedArgumentParser:
         args = []
         custom_patterns = {}
         name_regexp = ['^']
-        for before, variable, string in VariableIterator(string, identifiers='$'):
-            name, pattern, custom = self._get_name_and_pattern(variable[2:-1])
+        after = string
+        for match in VariableMatches(string, identifiers='$'):
+            name, pattern, custom = self._get_name_and_pattern(match.base)
             args.append(name)
             if custom:
                 custom_patterns[name] = pattern
                 pattern = self._format_custom_regexp(pattern)
-            name_regexp.extend([re.escape(before), f'({pattern})'])
-        name_regexp.extend([re.escape(string), '$'])
+            name_regexp.extend([re.escape(match.before), f'({pattern})'])
+            after = match.after
+        name_regexp.extend([re.escape(after), '$'])
         name = self._compile_regexp(name_regexp) if args else None
         return EmbeddedArguments(name, args, custom_patterns or None)