robotframework 6.1.1__zip → 7.0__zip

robotframework-6.1.1/src/robot/running/arguments/argumentconverter.py

@@ -1,79 +0,0 @@
-#  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 robot.variables import contains_variable
-
-from .typeconverters import TypeConverter
-
-
-class ArgumentConverter:
-
-    def __init__(self, argspec, converters, dry_run=False, languages=None):
-        """:type argspec: :py:class:`robot.running.arguments.ArgumentSpec`"""
-        self._argspec = argspec
-        self._converters = converters
-        self._dry_run = dry_run
-        self._languages = languages
-
-    def convert(self, positional, named):
-        return self._convert_positional(positional), self._convert_named(named)
-
-    def _convert_positional(self, positional):
-        names = self._argspec.positional
-        converted = [self._convert(name, value)
-                     for name, value in zip(names, positional)]
-        if self._argspec.var_positional:
-            converted.extend(self._convert(self._argspec.var_positional, value)
-                             for value in positional[len(names):])
-        return converted
-
-    def _convert_named(self, named):
-        names = set(self._argspec.positional) | set(self._argspec.named_only)
-        var_named = self._argspec.var_named
-        return [(name, self._convert(name if name in names else var_named, value))
-                for name, value in named]
-
-    def _convert(self, name, value):
-        spec = self._argspec
-        if (spec.types is None
-                or self._dry_run and contains_variable(value, identifiers='$@&%')):
-            return value
-        conversion_error = None
-        # Don't convert None if argument has None as a default value.
-        # Python < 3.11 adds None to type hints automatically when using None as
-        # a default value which preserves None automatically. This code keeps
-        # the same behavior also with newer Python versions.
-        if value is None and name in spec.defaults and spec.defaults[name] is None:
-            return value
-        if name in spec.types:
-            converter = TypeConverter.converter_for(spec.types[name], self._converters,
-                                                    self._languages)
-            if converter:
-                try:
-                    return converter.convert(name, value)
-                except ValueError as err:
-                    conversion_error = err
-        if name in spec.defaults:
-            converter = TypeConverter.converter_for(type(spec.defaults[name]),
-                                                    languages=self._languages)
-            if converter:
-                try:
-                    return converter.convert(name, value, explicit_type=False,
-                                             strict=bool(conversion_error))
-                except ValueError as err:
-                    conversion_error = conversion_error or err
-        if conversion_error:
-            raise conversion_error
-        return value

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

@@ -1,131 +0,0 @@
-#  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 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
-
-
-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 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)
-        return positional, named
-
-
-class NamedArgumentResolver:
-
-    def __init__(self, argspec):
-        """:type argspec: :py:class:`robot.running.arguments.ArgumentSpec`"""
-        self._argspec = argspec
-
-    def resolve(self, arguments, variables=None):
-        positional = []
-        named = []
-        for arg in arguments:
-            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)
-        return positional, named
-
-    def _is_named(self, arg, previous_named, variables=None):
-        name, value = split_from_equals(arg)
-        if value is None:
-            return False
-        if variables:
-            try:
-                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)
-
-    def _raise_positional_after_named(self):
-        raise DataError("%s '%s' got positional argument after named arguments."
-                        % (self._argspec.type.capitalize(), self._argspec.name))
-
-
-class NullNamedArgumentResolver:
-
-    def resolve(self, arguments, variables=None):
-        return arguments, {}
-
-
-class DictToKwargs:
-
-    def __init__(self, argspec, enabled=False):
-        self._maxargs = argspec.maxargs
-        self._enabled = enabled and bool(argspec.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, resolve_until=None):
-        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)
-            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 is_string(name):
-                    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))]

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

@@ -1,146 +0,0 @@
-#  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 robot.errors import DataError
-from robot.utils import get_error_message, is_string
-from robot.variables import VariableIterator
-
-
-ENABLE_STRICT_ARGUMENT_VALIDATION = False
-
-
-class EmbeddedArguments:
-
-    def __init__(self, name=None, args=(), custom_patterns=None):
-        self.name = name
-        self.args = args
-        self.custom_patterns = custom_patterns
-
-    @classmethod
-    def from_name(cls, name):
-        return EmbeddedArgumentParser().parse(name) if '${' in name else cls()
-
-    def match(self, name):
-        return self.name.match(name)
-
-    def map(self, values):
-        self.validate(values)
-        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
-        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}'.")
-
-    def __bool__(self):
-        return self.name is not None
-
-
-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):
-        args = []
-        custom_patterns = {}
-        name_regexp = ['^']
-        for before, variable, string in VariableIterator(string, identifiers='$'):
-            name, pattern, custom = self._get_name_and_pattern(variable[2:-1])
-            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 = self._compile_regexp(name_regexp) if args else None
-        return EmbeddedArguments(name, args, custom_patterns or None)
-
-    def _get_name_and_pattern(self, name):
-        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):
-        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):
-        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):
-        return self._regexp_group_start.sub(self._regexp_group_escape, pattern)
-
-    def _unescape_curly_braces(self, pattern):
-        # 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):
-        # 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):
-        return f'{pattern}|{self._variable_pattern}'
-
-    def _compile_regexp(self, pattern):
-        try:
-            return re.compile(''.join(pattern), re.IGNORECASE)
-        except Exception:
-            raise DataError("Compiling embedded arguments regexp failed: %s"
-                            % get_error_message())

robotframework-6.1.1/src/robot/running/arguments/typevalidator.py

@@ -1,56 +0,0 @@
-#  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 robot.errors import DataError
-from robot.utils import (is_dict_like, is_list_like, plural_or_not as s,
-                         seq2str, type_name)
-
-
-class TypeValidator:
-
-    def __init__(self, argspec):
-        """:type argspec: :py:class:`robot.running.arguments.ArgumentSpec`"""
-        self._argspec = argspec
-
-    def validate(self, types):
-        if types is None:
-            return None
-        if not types:
-            return {}
-        if is_dict_like(types):
-            return self.validate_type_dict(types)
-        if is_list_like(types):
-            return self.convert_type_list_to_dict(types)
-        raise DataError('Type information must be given as a dictionary or '
-                        'a list, got %s.' % type_name(types))
-
-    def validate_type_dict(self, types):
-        # 'return' isn't used for anything yet but it may be shown by Libdoc
-        # in the future. Trying to be forward compatible.
-        names = set(self._argspec.argument_names + ['return'])
-        extra = [t for t in types if t not in names]
-        if extra:
-            raise DataError('Type information given to non-existing '
-                            'argument%s %s.'
-                            % (s(extra), seq2str(sorted(extra))))
-        return types
-
-    def convert_type_list_to_dict(self, types):
-        names = self._argspec.argument_names
-        if len(types) > len(names):
-            raise DataError('Type information given to %d argument%s but '
-                            'keyword has only %d argument%s.'
-                            % (len(types), s(types), len(names), s(names)))
-        return {name: value for name, value in zip(names, types) if value}