robotframework 6.1.1__zip → 7.0a1__zip

robotframework-6.1.1/src/robot/output/listenerarguments.py

@@ -1,165 +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.model import BodyItem
-from robot.utils import is_list_like, is_dict_like, is_string, safe_str
-
-
-class ListenerArguments:
-
-    def __init__(self, arguments):
-        self._arguments = arguments
-        self._version2 = None
-        self._version3 = None
-
-    def get_arguments(self, version):
-        if version == 2:
-            if self._version2 is None:
-                self._version2 = self._get_version2_arguments(*self._arguments)
-            return self._version2
-        else:
-            if self._version3 is None:
-                self._version3 = self._get_version3_arguments(*self._arguments)
-            return self._version3
-
-    def _get_version2_arguments(self, *arguments):
-        return arguments
-
-    def _get_version3_arguments(self, *arguments):
-        return arguments
-
-    @classmethod
-    def by_method_name(cls, name, arguments):
-        Arguments = {'start_suite': StartSuiteArguments,
-                     'end_suite': EndSuiteArguments,
-                     'start_test': StartTestArguments,
-                     'end_test': EndTestArguments,
-                     'start_keyword': StartKeywordArguments,
-                     'end_keyword': EndKeywordArguments,
-                     'log_message': MessageArguments,
-                     'message': MessageArguments}.get(name, ListenerArguments)
-        return Arguments(arguments)
-
-
-class MessageArguments(ListenerArguments):
-
-    def _get_version2_arguments(self, msg):
-        attributes = {'timestamp': msg.timestamp,
-                      'message': msg.message,
-                      'level': msg.level,
-                      'html': 'yes' if msg.html else 'no'}
-        return attributes,
-
-    def _get_version3_arguments(self, msg):
-        return msg,
-
-
-class _ListenerArgumentsFromItem(ListenerArguments):
-    _attribute_names = None
-
-    def _get_version2_arguments(self, item):
-        attributes = dict((name, self._get_attribute_value(item, name))
-                          for name in self._attribute_names)
-        attributes.update(self._get_extra_attributes(item))
-        return item.name or '', attributes
-
-    def _get_attribute_value(self, item, name):
-        value = getattr(item, name)
-        if value is None:
-            return ''
-        return self._take_copy_of_mutable_value(value)
-
-    def _take_copy_of_mutable_value(self, value):
-        if is_dict_like(value):
-            return dict(value)
-        if is_list_like(value):
-            return list(value)
-        return value
-
-    def _get_extra_attributes(self, item):
-        return {}
-
-    def _get_version3_arguments(self, item):
-        return item.data, item.result
-
-
-class StartSuiteArguments(_ListenerArgumentsFromItem):
-    _attribute_names = ('id', 'longname', 'doc', 'metadata', 'starttime')
-
-    def _get_extra_attributes(self, suite):
-        return {'tests': [t.name for t in suite.tests],
-                'suites': [s.name for s in suite.suites],
-                'totaltests': suite.test_count,
-                'source': str(suite.source or '')}
-
-
-class EndSuiteArguments(StartSuiteArguments):
-    _attribute_names = ('id', 'longname', 'doc', 'metadata', 'starttime',
-                        'endtime', 'elapsedtime', 'status', 'message')
-
-    def _get_extra_attributes(self, suite):
-        attrs = super()._get_extra_attributes(suite)
-        attrs['statistics'] = suite.stat_message
-        return attrs
-
-
-class StartTestArguments(_ListenerArgumentsFromItem):
-    _attribute_names = ('id', 'longname', 'doc', 'tags', 'lineno', 'starttime')
-
-    def _get_extra_attributes(self, test):
-        return {'source': str(test.source or ''),
-                'template': test.template or '',
-                'originalname': test.data.name}
-
-
-class EndTestArguments(StartTestArguments):
-    _attribute_names = ('id', 'longname', 'doc', 'tags', 'lineno', 'starttime',
-                        'endtime', 'elapsedtime', 'status', 'message')
-
-
-class StartKeywordArguments(_ListenerArgumentsFromItem):
-    _attribute_names = ('doc', 'assign', 'tags', 'lineno', 'type', 'status', 'starttime')
-    _type_attributes = {
-        BodyItem.FOR: ('variables', 'flavor', 'values'),
-        BodyItem.IF: ('condition',),
-        BodyItem.ELSE_IF: ('condition',),
-        BodyItem.EXCEPT: ('patterns', 'pattern_type', 'variable'),
-        BodyItem.WHILE: ('condition', 'limit', 'on_limit_message'),
-        BodyItem.RETURN: ('values',),
-        BodyItem.ITERATION: ('variables',)
-    }
-    _for_flavor_attributes = {
-        'IN ENUMERATE': ('start',),
-        'IN ZIP': ('mode', 'fill')
-    }
-
-    def _get_extra_attributes(self, kw):
-        attrs = {'kwname': kw.kwname or '',
-                 'libname': kw.libname or '',
-                 'args': [a if is_string(a) else safe_str(a) for a in kw.args],
-                 'source': str(kw.source or '')}
-        if kw.type in self._type_attributes:
-            for name in self._type_attributes[kw.type]:
-                if hasattr(kw, name):
-                    attrs[name] = self._get_attribute_value(kw, name)
-        if kw.type == BodyItem.FOR:
-            for name in self._for_flavor_attributes.get(kw.flavor, ()):
-                attrs[name] = self._get_attribute_value(kw, name)
-        return attrs
-
-
-class EndKeywordArguments(StartKeywordArguments):
-    _attribute_names = ('doc', 'assign', 'tags', 'lineno', 'type', 'status',
-                        'starttime', 'endtime', 'elapsedtime')

robotframework-6.1.1/src/robot/output/listenermethods.py

@@ -1,113 +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 TimeoutError
-from robot.utils import get_error_details
-
-from .listenerarguments import ListenerArguments
-from .logger import LOGGER
-
-
-class ListenerMethods:
-
-    def __init__(self, method_name, listeners):
-        self._methods = []
-        self._method_name = method_name
-        if listeners:
-            self._register_methods(method_name, listeners)
-
-    def _register_methods(self, method_name, listeners):
-        for listener in listeners:
-            method = getattr(listener, method_name)
-            if method:
-                self._methods.append(ListenerMethod(method, listener))
-
-    def __call__(self, *args):
-        if self._methods:
-            args = ListenerArguments.by_method_name(self._method_name, args)
-            for method in self._methods:
-                method(args.get_arguments(method.version))
-
-    def __bool__(self):
-        return bool(self._methods)
-
-
-class LibraryListenerMethods:
-
-    def __init__(self, method_name):
-        self._method_stack = []
-        self._method_name = method_name
-
-    def new_suite_scope(self):
-        self._method_stack.append([])
-
-    def discard_suite_scope(self):
-        self._method_stack.pop()
-
-    def register(self, listeners, library):
-        methods = self._method_stack[-1]
-        for listener in listeners:
-            method = getattr(listener, self._method_name)
-            if method:
-                info = ListenerMethod(method, listener, library)
-                methods.append(info)
-
-    def unregister(self, library):
-        methods = [m for m in self._method_stack[-1] if m.library is not library]
-        self._method_stack[-1] = methods
-
-    def __call__(self, *args, **conf):
-        methods = self._get_methods(**conf)
-        if methods:
-            args = ListenerArguments.by_method_name(self._method_name, args)
-            for method in methods:
-                method(args.get_arguments(method.version))
-
-    def _get_methods(self, library=None):
-        if not (self._method_stack and self._method_stack[-1]):
-            return []
-        methods = self._method_stack[-1]
-        if library:
-            return [m for m in methods if m.library is library]
-        return methods
-
-
-class ListenerMethod:
-    # Flag to avoid recursive listener calls.
-    called = False
-
-    def __init__(self, method, listener, library=None):
-        self.method = method
-        self.listener_name = listener.name
-        self.version = listener.version
-        self.library = library
-
-    def __call__(self, args):
-        if self.called:
-            return
-        try:
-            ListenerMethod.called = True
-            self.method(*args)
-        except TimeoutError:
-            # Propagate possible timeouts:
-            # https://github.com/robotframework/robotframework/issues/2763
-            raise
-        except:
-            message, details = get_error_details()
-            LOGGER.error("Calling method '%s' of listener '%s' failed: %s"
-                         % (self.method.__name__, self.listener_name, message))
-            LOGGER.info("Details:\n%s" % details)
-        finally:
-            ListenerMethod.called = False

robotframework-6.1.1/src/robot/output/listeners.py

@@ -1,174 +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 os.path
-
-from robot.errors import DataError
-from robot.utils import Importer, is_string, split_args_from_name_or_path, type_name
-
-from .listenermethods import ListenerMethods, LibraryListenerMethods
-from .loggerhelper import AbstractLoggerProxy, IsLogged
-from .logger import LOGGER
-
-
-class Listeners:
-    _method_names = ('start_suite', 'end_suite', 'start_test', 'end_test',
-                     'start_keyword', 'end_keyword', 'log_message', 'message',
-                     'output_file', 'report_file', 'log_file', 'debug_file',
-                     'xunit_file', 'library_import', 'resource_import',
-                     'variables_import', 'close')
-
-    def __init__(self, listeners, log_level='INFO'):
-        self._is_logged = IsLogged(log_level)
-        listeners = ListenerProxy.import_listeners(listeners,
-                                                   self._method_names)
-        for name in self._method_names:
-            method = ListenerMethods(name, listeners)
-            if name.endswith(('_keyword', '_file', '_import', 'log_message')):
-                name = '_' + name
-            setattr(self, name, method)
-
-    def set_log_level(self, level):
-        self._is_logged.set_level(level)
-
-    def start_keyword(self, kw):
-        if kw.type not in (kw.IF_ELSE_ROOT, kw.TRY_EXCEPT_ROOT):
-            self._start_keyword(kw)
-
-    def end_keyword(self, kw):
-        if kw.type not in (kw.IF_ELSE_ROOT, kw.TRY_EXCEPT_ROOT):
-            self._end_keyword(kw)
-
-    def log_message(self, msg):
-        if self._is_logged(msg.level):
-            self._log_message(msg)
-
-    def imported(self, import_type, name, attrs):
-        method = getattr(self, '_%s_import' % import_type.lower())
-        method(name, attrs)
-
-    def output_file(self, file_type, path):
-        method = getattr(self, '_%s_file' % file_type.lower())
-        method(path)
-
-    def __bool__(self):
-        return any(isinstance(method, ListenerMethods) and method
-                   for method in self.__dict__.values())
-
-
-class LibraryListeners:
-    _method_names = ('start_suite', 'end_suite', 'start_test', 'end_test',
-                     'start_keyword', 'end_keyword', 'log_message', 'message',
-                     'close')
-
-    def __init__(self, log_level='INFO'):
-        self._is_logged = IsLogged(log_level)
-        for name in self._method_names:
-            method = LibraryListenerMethods(name)
-            if name == 'log_message':
-                name = '_' + name
-            setattr(self, name, method)
-
-    def register(self, listeners, library):
-        listeners = ListenerProxy.import_listeners(listeners,
-                                                   self._method_names,
-                                                   prefix='_',
-                                                   raise_on_error=True)
-        for method in self._listener_methods():
-            method.register(listeners, library)
-
-    def _listener_methods(self):
-        return [method for method in self.__dict__.values()
-                if isinstance(method, LibraryListenerMethods)]
-
-    def unregister(self, library, close=False):
-        if close:
-            self.close(library=library)
-        for method in self._listener_methods():
-            method.unregister(library)
-
-    def new_suite_scope(self):
-        for method in self._listener_methods():
-            method.new_suite_scope()
-
-    def discard_suite_scope(self):
-        for method in self._listener_methods():
-            method.discard_suite_scope()
-
-    def set_log_level(self, level):
-        self._is_logged.set_level(level)
-
-    def log_message(self, msg):
-        if self._is_logged(msg.level):
-            self._log_message(msg)
-
-    def imported(self, import_type, name, attrs):
-        pass
-
-    def output_file(self, file_type, path):
-        pass
-
-
-class ListenerProxy(AbstractLoggerProxy):
-    _no_method = None
-
-    def __init__(self, listener, method_names, prefix=None):
-        listener, name = self._import_listener(listener)
-        AbstractLoggerProxy.__init__(self, listener, method_names, prefix)
-        self.name = name
-        self.version = self._get_version(listener)
-        if self.version == 3:
-            self.start_keyword = self.end_keyword = None
-            self.library_import = self.resource_import = self.variables_import = None
-
-    def _import_listener(self, listener):
-        if not is_string(listener):
-            # Modules have `__name__`, with others better to use `type_name`.
-            name = getattr(listener, '__name__', None) or type_name(listener)
-            return listener, name
-        name, args = split_args_from_name_or_path(listener)
-        importer = Importer('listener', logger=LOGGER)
-        listener = importer.import_class_or_module(os.path.normpath(name),
-                                                   instantiate_with_args=args)
-        return listener, name
-
-    def _get_version(self, listener):
-        try:
-            version = int(listener.ROBOT_LISTENER_API_VERSION)
-            if version not in (2, 3):
-                raise ValueError
-        except AttributeError:
-            raise DataError("Listener '%s' does not have mandatory "
-                            "'ROBOT_LISTENER_API_VERSION' attribute."
-                            % self.name)
-        except (ValueError, TypeError):
-            raise DataError("Listener '%s' uses unsupported API version '%s'."
-                            % (self.name, listener.ROBOT_LISTENER_API_VERSION))
-        return version
-
-    @classmethod
-    def import_listeners(cls, listeners, method_names, prefix=None,
-                         raise_on_error=False):
-        imported = []
-        for listener in listeners:
-            try:
-                imported.append(cls(listener, method_names, prefix))
-            except DataError as err:
-                name = listener if is_string(listener) else type_name(listener)
-                msg = "Taking listener '%s' into use failed: %s" % (name, err)
-                if raise_on_error:
-                    raise DataError(msg)
-                LOGGER.error(msg)
-        return imported

robotframework-6.1.1/src/robot/output/output.py

@@ -1,95 +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 . import pyloggingconf
-from .debugfile import DebugFile
-from .listeners import LibraryListeners, Listeners
-from .logger import LOGGER, LoggerProxy
-from .loggerhelper import AbstractLogger
-from .xmllogger import XmlLogger, FlatXmlLogger
-
-
-class Output(AbstractLogger):
-
-    def __init__(self, settings):
-        AbstractLogger.__init__(self)
-        self._xmllogger = XmlLogger(settings.output, settings.log_level,
-                                    settings.rpa)
-        self._flat_xml_logger = None
-        self.listeners = Listeners(settings.listeners, settings.log_level)
-        self.library_listeners = LibraryListeners(settings.log_level)
-        self._register_loggers(DebugFile(settings.debug_file))
-        self._settings = settings
-        self._flatten_level = 0
-
-    @property
-    def flat_xml_logger(self):
-        if self._flat_xml_logger is None:
-            self._flat_xml_logger = FlatXmlLogger(self._xmllogger)
-        return self._flat_xml_logger
-
-    def _register_loggers(self, debug_file):
-        LOGGER.register_xml_logger(self._xmllogger)
-        LOGGER.register_listeners(self.listeners or None, self.library_listeners)
-        if debug_file:
-            LOGGER.register_logger(debug_file)
-
-    def register_error_listener(self, listener):
-        LOGGER.register_error_listener(listener)
-
-    def close(self, result):
-        self._xmllogger.visit_statistics(result.statistics)
-        self._xmllogger.close()
-        LOGGER.unregister_xml_logger()
-        LOGGER.output_file('Output', self._settings['Output'])
-
-    def start_suite(self, suite):
-        LOGGER.start_suite(suite)
-
-    def end_suite(self, suite):
-        LOGGER.end_suite(suite)
-
-    def start_test(self, test):
-        LOGGER.start_test(test)
-
-    def end_test(self, test):
-        LOGGER.end_test(test)
-
-    def start_keyword(self, kw):
-        LOGGER.start_keyword(kw)
-        if kw.tags.robot('flatten'):
-            self._flatten_level += 1
-            if self._flatten_level == 1:
-                LOGGER._xml_logger = LoggerProxy(self.flat_xml_logger)
-
-    def end_keyword(self, kw):
-        if kw.tags.robot('flatten'):
-            self._flatten_level -= 1
-            if not self._flatten_level:
-                LOGGER._xml_logger = LoggerProxy(self._xmllogger)
-        LOGGER.end_keyword(kw)
-
-    def message(self, msg):
-        LOGGER.log_message(msg)
-
-    def trace(self, msg, write_if_flat=True):
-        if write_if_flat or self._flatten_level == 0:
-            self.write(msg, 'TRACE')
-
-    def set_log_level(self, level):
-        pyloggingconf.set_level(level)
-        self.listeners.set_log_level(level)
-        self.library_listeners.set_log_level(level)
-        return self._xmllogger.set_log_level(level)

robotframework-6.1.1/src/robot/parsing/model/visitor.py

@@ -1,67 +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 ast
-
-from .statements import Node
-
-
-class VisitorFinder:
-
-    def _find_visitor(self, cls):
-        if cls is ast.AST:
-            return None
-        method = 'visit_' + cls.__name__
-        if hasattr(self, method):
-            return getattr(self, method)
-        # Forward-compatibility.
-        if method == 'visit_Return' and hasattr(self, 'visit_ReturnSetting'):
-            return getattr(self, 'visit_ReturnSetting')
-        for base in cls.__bases__:
-            visitor = self._find_visitor(base)
-            if visitor:
-                return visitor
-        return None
-
-
-class ModelVisitor(ast.NodeVisitor, VisitorFinder):
-    """NodeVisitor that supports matching nodes based on their base classes.
-
-    In other ways identical to the standard `ast.NodeVisitor
-    <https://docs.python.org/library/ast.html#ast.NodeVisitor>`__,
-    but allows creating ``visit_ClassName`` methods so that the ``ClassName``
-    is one of the base classes of the node. For example, this visitor method
-    matches all ``Statement`` nodes::
-
-        def visit_Statement(self, node):
-            ...
-    """
-
-    def visit(self, node: Node):
-        visitor = self._find_visitor(type(node)) or self.generic_visit
-        visitor(node)
-
-
-class ModelTransformer(ast.NodeTransformer, VisitorFinder):
-    """NodeTransformer that supports matching nodes based on their base classes.
-
-    See :class:`ModelVisitor` for explanation how this is different compared
-    to the standard `ast.NodeTransformer
-    <https://docs.python.org/library/ast.html#ast.NodeTransformer>`__.
-    """
-
-    def visit(self, node: Node):
-        visitor = self._find_visitor(type(node)) or self.generic_visit
-        return visitor(node)

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