robotframework 6.1rc1__zip → 7.0__zip

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

@@ -15,101 +15,140 @@
 
 import sys
 from enum import Enum
-from typing import Union, Tuple
+from typing import Any, Callable, Iterator, Mapping, Sequence
 
-from robot.utils import has_args, is_union, safe_str, setter, type_repr
+from robot.utils import NOT_SET, safe_str, setter, SetterAwareType
 
 from .argumentconverter import ArgumentConverter
 from .argumentmapper import ArgumentMapper
 from .argumentresolver import ArgumentResolver
+from .typeinfo import TypeInfo
 from .typevalidator import TypeValidator
 
 
-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):
+class ArgumentSpec(metaclass=SetterAwareType):
+    __slots__ = ['_name', 'type', 'positional_only', 'positional_or_named',
+                 'var_positional', 'named_only', 'var_named', 'embedded', 'defaults']
+
+    def __init__(self, name: 'str|Callable[[], str]|None' = None,
+                 type: str = 'Keyword',
+                 positional_only: Sequence[str] = (),
+                 positional_or_named: Sequence[str] = (),
+                 var_positional: 'str|None' = None,
+                 named_only: Sequence[str] = (),
+                 var_named: 'str|None' = None,
+                 defaults: 'Mapping[str, Any]|None' = None,
+                 embedded: Sequence[str] = (),
+                 types: 'Mapping[str, TypeInfo]|None' = None,
+                 return_type: 'TypeInfo|None' = None):
         self.name = name
         self.type = type
-        self.positional_only = positional_only or []
-        self.positional_or_named = positional_or_named or []
+        self.positional_only = tuple(positional_only)
+        self.positional_or_named = tuple(positional_or_named)
         self.var_positional = var_positional
-        self.named_only = named_only or []
+        self.named_only = tuple(named_only)
         self.var_named = var_named
+        self.embedded = tuple(embedded)
         self.defaults = defaults or {}
         self.types = types
+        self.return_type = return_type
+
+    @property
+    def name(self) -> 'str|None':
+        return self._name if not callable(self._name) else self._name()
+
+    @name.setter
+    def name(self, name: 'str|Callable[[], str]|None'):
+        self._name = name
 
     @setter
-    def types(self, types):
+    def types(self, types) -> 'dict[str, TypeInfo]|None':
         return TypeValidator(self).validate(types)
 
+    @setter
+    def return_type(self, hint) -> 'TypeInfo|None':
+        if hint in (None, type(None)):
+            return None
+        if isinstance(hint, TypeInfo):
+            return hint
+        return TypeInfo.from_type_hint(hint)
+
     @property
-    def positional(self):
+    def positional(self) -> 'tuple[str, ...]':
         return self.positional_only + self.positional_or_named
 
     @property
-    def minargs(self):
+    def named(self) -> 'tuple[str, ...]':
+        return self.named_only + self.positional_or_named
+
+    @property
+    def minargs(self) -> int:
         return len([arg for arg in self.positional if arg not in self.defaults])
 
     @property
-    def maxargs(self):
+    def maxargs(self) -> int:
         return len(self.positional) if not self.var_positional else sys.maxsize
 
     @property
-    def argument_names(self):
-        return (self.positional_only +
-                self.positional_or_named +
-                ([self.var_positional] if self.var_positional else []) +
-                self.named_only +
-                ([self.var_named] if self.var_named else []))
+    def argument_names(self) -> 'tuple[str, ...]':
+        var_positional = (self.var_positional,) if self.var_positional else ()
+        var_named = (self.var_named,) if self.var_named else ()
+        return (self.positional_only + self.positional_or_named + var_positional +
+                self.named_only + var_named)
 
     def resolve(self, arguments, variables=None, converters=None,
-                resolve_named=True, resolve_variables_until=None,
-                dict_to_kwargs=False, languages=None):
-        resolver = ArgumentResolver(self, resolve_named,
-                                    resolve_variables_until, dict_to_kwargs)
+                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)
         return self.convert(positional, named, converters, dry_run=not variables,
                             languages=languages)
 
-    def convert(self, positional, named, converters=None, dry_run=False, languages=None):
+    def convert(self, positional, named, converters=None, dry_run=False,
+                languages=None) -> 'tuple[list, list]':
         if self.types or self.defaults:
             converter = ArgumentConverter(self, converters, dry_run, languages)
             positional, named = converter.convert(positional, named)
         return positional, named
 
-    def map(self, positional, named, replace_defaults=True):
+    def map(self, positional, named, replace_defaults=True) -> 'tuple[list, list]':
         mapper = ArgumentMapper(self)
         return mapper.map(positional, named, replace_defaults)
 
-    def __iter__(self):
-        notset = ArgInfo.NOTSET
+    def copy(self) -> 'ArgumentSpec':
+        types = dict(self.types) if self.types is not None else None
+        return type(self)(self.name, self.type, self.positional_only,
+                          self.positional_or_named, self.var_positional,
+                          self.named_only, self.var_named, dict(self.defaults),
+                          self.embedded, types, self.return_type)
+
+    def __iter__(self) -> Iterator['ArgInfo']:
         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,
-                    self.named_only, self.var_named])
+                    self.named_only, self.var_named, self.return_type])
 
     def __str__(self):
         return ', '.join(str(arg) for arg in self)
@@ -117,7 +156,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,32 +164,26 @@ 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
-    def required(self):
+    def required(self) -> bool:
         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:
+    def default_repr(self) -> 'str|None':
+        if self.default is NOT_SET:
             return None
         if isinstance(self.default, Enum):
             return self.default.name
@@ -172,71 +204,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.0}/src/robot/running/arguments/argumentvalidator.py

@@ -13,44 +13,48 @@
 #  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.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.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)
+        self._validate_no_extra_named(named, self.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))
+        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("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 +65,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.0}/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])
@@ -109,5 +112,5 @@ class ConverterInfo:
     def convert(self, value):
         if not self.library:
             return self.converter(value)
-        return self.converter(value, self.library.get_instance())
+        return self.converter(value, self.library.instance)
 

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

@@ -0,0 +1,145 @@
+#  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.
+
+import re
+from typing import Any, Mapping, Sequence
+
+from robot.errors import DataError
+from robot.utils import get_error_message
+from robot.variables import VariableMatches
+
+from ..context import EXECUTION_CONTEXTS
+
+
+class EmbeddedArguments:
+
+    def __init__(self, name: re.Pattern,
+                 args: Sequence[str] = (),
+                 custom_patterns: 'Mapping[str, str]|None' = None):
+        self.name = name
+        self.args = tuple(args)
+        self.custom_patterns = custom_patterns or None
+
+    @classmethod
+    def from_name(cls, name: str) -> 'EmbeddedArguments|None':
+        return EmbeddedArgumentParser().parse(name) if '${' in name else None
+
+    def match(self, name: str) -> 're.Match|None':
+        return self.name.fullmatch(name)
+
+    def map(self, args: Sequence[Any]) -> 'list[tuple[str, Any]]':
+        self.validate(args)
+        return list(zip(self.args, args))
+
+    def validate(self, args: Sequence[Any]):
+        """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 ``ValueError`` in RF 8.0:
+        https://github.com/robotframework/robotframework/issues/4069
+        """
+        if not self.custom_patterns:
+            return
+        for name, value in zip(self.args, args):
+            if name in self.custom_patterns and isinstance(value, str):
+                pattern = self.custom_patterns[name]
+                if not re.fullmatch(pattern, value):
+                    # TODO: Change to `raise ValueError(...)` in RF 8.0.
+                    context = EXECUTION_CONTEXTS.current
+                    context.warn(f"Embedded argument '{name}' 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.")
+
+
+class EmbeddedArgumentParser:
+    _regexp_extension = re.compile(r'(?<!\\)\(\?.+\)')
+    _regexp_group_start = re.compile(r'(?<!\\)\((.*?)\)')
+    _escaped_curly = re.compile(r'(\\+)([{}])')
+    _regexp_group_escape = r'(?:\1)'
+    _default_pattern = '.*?'
+    _variable_pattern = r'\$\{[^\}]+\}'
+
+    def parse(self, string: str) -> 'EmbeddedArguments|None':
+        name_parts = ['^']
+        args = []
+        custom_patterns = {}
+        after = string
+        for match in VariableMatches(string, identifiers='$'):
+            arg, pattern, is_custom = self._get_name_and_pattern(match.base)
+            args.append(arg)
+            if is_custom:
+                custom_patterns[arg] = pattern
+                pattern = self._format_custom_regexp(pattern)
+            name_parts.extend([re.escape(match.before), f'({pattern})'])
+            after = match.after
+        if not args:
+            return None
+        name_parts.extend([re.escape(after), '$'])
+        name = self._compile_regexp(''.join(name_parts))
+        return EmbeddedArguments(name, args, custom_patterns)
+
+    def _get_name_and_pattern(self, name: str) -> 'tuple[str, str, bool]':
+        if ':' in name:
+            name, pattern = name.split(':', 1)
+            custom = True
+        else:
+            pattern = self._default_pattern
+            custom = False
+        return name, pattern, custom
+
+    def _format_custom_regexp(self, pattern: str) -> str:
+        for formatter in (self._regexp_extensions_are_not_allowed,
+                          self._make_groups_non_capturing,
+                          self._unescape_curly_braces,
+                          self._escape_escapes,
+                          self._add_automatic_variable_pattern):
+            pattern = formatter(pattern)
+        return pattern
+
+    def _regexp_extensions_are_not_allowed(self, pattern: str) -> str:
+        if self._regexp_extension.search(pattern):
+            raise DataError('Regexp extensions are not allowed in embedded arguments.')
+        return pattern
+
+    def _make_groups_non_capturing(self, pattern: str) -> str:
+        return self._regexp_group_start.sub(self._regexp_group_escape, pattern)
+
+    def _unescape_curly_braces(self, pattern: str) -> str:
+        # Users must escape possible lone curly braces in patters (e.g. `${x:\{}`)
+        # or otherwise the variable syntax is invalid.
+        def unescape(match):
+            backslashes = len(match.group(1))
+            return '\\' * (backslashes // 2 * 2) + match.group(2)
+        return self._escaped_curly.sub(unescape, pattern)
+
+    def _escape_escapes(self, pattern: str) -> str:
+        # When keywords are matched, embedded arguments have not yet been
+        # resolved which means possible escapes are still doubled. We thus
+        # need to double them in the pattern as well.
+        return pattern.replace(r'\\', r'\\\\')
+
+    def _add_automatic_variable_pattern(self, pattern: str) -> str:
+        return f'{pattern}|{self._variable_pattern}'
+
+    def _compile_regexp(self, pattern: str) -> re.Pattern:
+        try:
+            return re.compile(''.join(pattern), re.IGNORECASE)
+        except Exception:
+            raise DataError(f"Compiling embedded arguments regexp failed: "
+                            f"{get_error_message()}")