robotframework 6.1rc1__zip → 7.0__zip

robotframework-6.1rc1/src/robot/running/handlers.py

@@ -1,321 +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 copy import copy
-import inspect
-
-from robot.utils import (getdoc, getshortdoc, is_list_like, normpath, printable_name,
-                         split_tags_from_doc, type_name)
-from robot.errors import DataError
-from robot.model import Tags
-
-from .arguments import ArgumentSpec, DynamicArgumentParser, PythonArgumentParser
-from .dynamicmethods import GetKeywordSource, GetKeywordTypes
-from .librarykeywordrunner import (EmbeddedArgumentsRunner,
-                                   LibraryKeywordRunner, RunKeywordRunner)
-from .runkwregister import RUN_KW_REGISTER
-
-
-def Handler(library, name, method):
-    if RUN_KW_REGISTER.is_run_keyword(library.orig_name, name):
-        return _RunKeywordHandler(library, name, method)
-    return _PythonHandler(library, name, method)
-
-
-def DynamicHandler(library, name, method, doc, argspec, tags=None):
-    if RUN_KW_REGISTER.is_run_keyword(library.orig_name, name):
-        return _DynamicRunKeywordHandler(library, name, method, doc, argspec, tags)
-    return _DynamicHandler(library, name, method, doc, argspec, tags)
-
-
-def InitHandler(library, method=None, docgetter=None):
-    return _PythonInitHandler(library, '__init__', method, docgetter)
-
-
-class _RunnableHandler:
-    supports_embedded_args = False
-
-    def __init__(self, library, handler_name, handler_method, doc='', tags=None):
-        self.library = library
-        self._handler_name = handler_name
-        self.name = self._get_name(handler_name, handler_method)
-        self.arguments = self._parse_arguments(handler_method)
-        self._method = self._get_initial_handler(library, handler_name,
-                                                 handler_method)
-        doc, tags_from_doc = split_tags_from_doc(doc or '')
-        tags_from_attr = self._get_tags_from_attribute(handler_method)
-        self._doc = doc
-        self.tags = Tags(tuple(tags_from_doc) +
-                         tuple(tags_from_attr) +
-                         tuple(tags or ()))
-
-    def _get_name(self, handler_name, handler_method):
-        robot_name = getattr(handler_method, 'robot_name', None)
-        name = robot_name or printable_name(handler_name, code_style=True)
-        if not name:
-            raise DataError('Keyword name cannot be empty.')
-        return name
-
-    def _parse_arguments(self, handler_method):
-        raise NotImplementedError
-
-    def _get_tags_from_attribute(self, handler_method):
-        tags = getattr(handler_method, 'robot_tags', ())
-        if not is_list_like(tags):
-            raise DataError(f"Expected tags to be list-like, got {type_name(tags)}.")
-        return tags
-
-    def _get_initial_handler(self, library, name, method):
-        if library.scope.is_global:
-            return self._get_global_handler(method, name)
-        return None
-
-    def resolve_arguments(self, args, variables=None, languages=None):
-        return self.arguments.resolve(args, variables, self.library.converters,
-                                      languages=languages)
-
-    @property
-    def doc(self):
-        return self._doc
-
-    @property
-    def longname(self):
-        return f'{self.library.name}.{self.name}'
-
-    @property
-    def shortdoc(self):
-        return getshortdoc(self.doc)
-
-    @property
-    def libname(self):
-        return self.library.name
-
-    @property
-    def source(self):
-        return self.library.source
-
-    @property
-    def lineno(self):
-        return -1
-
-    def create_runner(self, name, languages=None):
-        return LibraryKeywordRunner(self, languages=languages)
-
-    def current_handler(self):
-        if self._method:
-            return self._method
-        return self._get_handler(self.library.get_instance(), self._handler_name)
-
-    def _get_global_handler(self, method, name):
-        return method
-
-    def _get_handler(self, lib_instance, handler_name):
-        try:
-            return getattr(lib_instance, handler_name)
-        except AttributeError:
-            # Occurs with old-style classes.
-            if handler_name == '__init__':
-                return None
-            raise
-
-
-class _PythonHandler(_RunnableHandler):
-
-    def __init__(self, library, handler_name, handler_method):
-        super().__init__(library, handler_name, handler_method, getdoc(handler_method))
-
-    def _parse_arguments(self, handler_method):
-        return PythonArgumentParser().parse(handler_method, self.longname)
-
-    @property
-    def source(self):
-        handler = self.current_handler()
-        # `getsourcefile` can return None and raise TypeError.
-        try:
-            source = inspect.getsourcefile(inspect.unwrap(handler))
-        except TypeError:
-            source = None
-        return normpath(source) if source else self.library.source
-
-    @property
-    def lineno(self):
-        handler = self.current_handler()
-        try:
-            lines, start_lineno = inspect.getsourcelines(inspect.unwrap(handler))
-        except (TypeError, OSError, IOError):
-            return -1
-        for increment, line in enumerate(lines):
-            if line.strip().startswith('def '):
-                return start_lineno + increment
-        return start_lineno
-
-
-class _DynamicHandler(_RunnableHandler):
-
-    def __init__(self, library, handler_name, dynamic_method, doc='', argspec=None,
-                 tags=None):
-        self._argspec = argspec
-        self._run_keyword_method_name = dynamic_method.name
-        self._supports_kwargs = dynamic_method.supports_kwargs
-        # Cannot use super() here due to multi-inheritance in _DynamicRunKeywordHandler
-        _RunnableHandler.__init__(self, library, handler_name, dynamic_method.method,
-                                  doc, tags)
-        self._source_info = None
-
-    def _parse_arguments(self, handler_method):
-        spec = DynamicArgumentParser().parse(self._argspec, self.longname)
-        if not self._supports_kwargs:
-            name = self._run_keyword_method_name
-            if spec.var_named:
-                raise DataError(f"Too few '{name}' method parameters for "
-                                f"**kwargs support.")
-            if spec.named_only:
-                raise DataError(f"Too few '{name}' method parameters for "
-                                f"keyword-only arguments support.")
-        get_keyword_types = GetKeywordTypes(self.library.get_instance())
-        spec.types = get_keyword_types(self._handler_name)
-        return spec
-
-    @property
-    def source(self):
-        if self._source_info is None:
-            self._source_info = self._get_source_info()
-        return self._source_info[0]
-
-    def _get_source_info(self):
-        get_keyword_source = GetKeywordSource(self.library.get_instance())
-        try:
-            source = get_keyword_source(self._handler_name)
-        except DataError as err:
-            self.library.report_error(
-                f"Getting source information for keyword '{self.name}' failed: {err}",
-                err.details
-            )
-            source = None
-        if source and ':' in source and source.rsplit(':', 1)[1].isdigit():
-            source, lineno = source.rsplit(':', 1)
-            lineno = int(lineno)
-        else:
-            lineno = -1
-        return normpath(source) if source else self.library.source, lineno
-
-    @property
-    def lineno(self):
-        if self._source_info is None:
-            self._source_info = self._get_source_info()
-        return self._source_info[1]
-
-    def resolve_arguments(self, arguments, variables=None, languages=None):
-        positional, named = super().resolve_arguments(arguments, variables, languages)
-        if not self._supports_kwargs:
-            positional, named = self.arguments.map(positional, named)
-        return positional, named
-
-    def _get_handler(self, lib_instance, handler_name):
-        runner = getattr(lib_instance, self._run_keyword_method_name)
-        return self._get_dynamic_handler(runner, handler_name)
-
-    def _get_global_handler(self, method, name):
-        return self._get_dynamic_handler(method, name)
-
-    def _get_dynamic_handler(self, runner, name):
-        def handler(*positional, **kwargs):
-            if self._supports_kwargs:
-                return runner(name, positional, kwargs)
-            else:
-                return runner(name, positional)
-        return handler
-
-
-class _RunKeywordHandler(_PythonHandler):
-
-    def create_runner(self, name, languages=None):
-        dry_run = RUN_KW_REGISTER.get_dry_run(self.library.orig_name, self.name)
-        return RunKeywordRunner(self, execute_in_dry_run=dry_run)
-
-    @property
-    def _args_to_process(self):
-        return RUN_KW_REGISTER.get_args_to_process(self.library.orig_name, self.name)
-
-    def resolve_arguments(self, args, variables=None, languages=None):
-        return self.arguments.resolve(args, variables, self.library.converters,
-                                      resolve_named=False,
-                                      resolve_variables_until=self._args_to_process)
-
-
-class _DynamicRunKeywordHandler(_DynamicHandler, _RunKeywordHandler):
-    _parse_arguments = _RunKeywordHandler._parse_arguments
-    resolve_arguments = _RunKeywordHandler.resolve_arguments
-
-
-class _PythonInitHandler(_PythonHandler):
-
-    def __init__(self, library, handler_name, handler_method, docgetter):
-        super().__init__(library, handler_name, handler_method)
-        self._docgetter = docgetter
-
-    def _get_name(self, handler_name, handler_method):
-        return '__init__'
-
-    @property
-    def doc(self):
-        if self._docgetter:
-            self._doc = self._docgetter() or self._doc
-            self._docgetter = None
-        return self._doc
-
-    def _parse_arguments(self, init_method):
-        parser = PythonArgumentParser(type='Library')
-        return parser.parse(init_method or (lambda: None), self.library.name)
-
-
-class EmbeddedArgumentsHandler:
-    supports_embedded_args = True
-
-    def __init__(self, embedded, orig_handler):
-        self.arguments = ArgumentSpec()  # Show empty argument spec for Libdoc
-        self.embedded = embedded
-        self._orig_handler = orig_handler
-
-    def __getattr__(self, item):
-        return getattr(self._orig_handler, item)
-
-    @property
-    def library(self):
-        return self._orig_handler.library
-
-    @library.setter
-    def library(self, library):
-        self._orig_handler.library = library
-
-    def matches(self, name):
-        return self.embedded.match(name) is not None
-
-    def create_runner(self, name, languages=None):
-        return EmbeddedArgumentsRunner(self, name)
-
-    def resolve_arguments(self, args, variables=None, languages=None):
-        argspec = self._orig_handler.arguments
-        if variables:
-            if argspec.var_positional:
-                args = variables.replace_list(args)
-            else:
-                args = [variables.replace_scalar(a) for a in args]
-            self.embedded.validate(args)
-        return argspec.convert(args, named={}, converters=self.library.converters,
-                               dry_run=not variables)
-
-    def __copy__(self):
-        return EmbeddedArgumentsHandler(self.embedded, copy(self._orig_handler))

robotframework-6.1rc1/src/robot/running/handlerstore.py

@@ -1,66 +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 itertools import chain
-
-from robot.errors import DataError
-from robot.utils import NormalizedDict, seq2str
-
-from .usererrorhandler import UserErrorHandler
-
-
-class HandlerStore:
-
-    def __init__(self):
-        self._normal = NormalizedDict(ignore='_')
-        self._embedded = []
-
-    def add(self, handler, embedded=False):
-        if embedded:
-            self._embedded.append(handler)
-        elif handler.name not in self._normal:
-            self._normal[handler.name] = handler
-        else:
-            error = DataError('Keyword with same name defined multiple times.')
-            self._normal[handler.name] = UserErrorHandler(error, handler.name,
-                                                          handler.libname)
-            raise error
-
-    def __iter__(self):
-        return chain(self._normal.values(), self._embedded)
-
-    def __len__(self):
-        return len(self._normal) + len(self._embedded)
-
-    def __contains__(self, name):
-        if name in self._normal:
-            return True
-        if not self._embedded:
-            return False
-        return any(template.matches(name) for template in self._embedded)
-
-    def __getitem__(self, name):
-        handlers = self.get_handlers(name)
-        if len(handlers) == 1:
-            return handlers[0]
-        if not handlers:
-            raise ValueError(f"No handler with name '{name}' found.")
-        names = seq2str([handler.name for handler in handlers])
-        raise ValueError(f"Multiple handlers matching name '{name}' found: {names}")
-
-    def get_handlers(self, name):
-        if name in self._normal:
-            return [self._normal[name]]
-        return [template for template in self._embedded if template.matches(name)]

robotframework-6.1rc1/src/robot/running/librarykeywordrunner.py

@@ -1,238 +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.output import LOGGER
-from robot.result import Keyword as KeywordResult
-from robot.utils import prepr, safe_str
-from robot.variables import contains_variable, is_list_variable, VariableAssignment
-
-from .bodyrunner import BodyRunner
-from .model import Keyword
-from .outputcapture import OutputCapturer
-from .signalhandler import STOP_SIGNAL_MONITOR
-from .statusreporter import StatusReporter
-
-
-class LibraryKeywordRunner:
-
-    def __init__(self, handler, name=None, languages=None):
-        self._handler = handler
-        self.name = name or handler.name
-        self.pre_run_messages = ()
-        self.languages = languages
-
-    @property
-    def library(self):
-        return self._handler.library
-
-    @property
-    def libname(self):
-        return self._handler.library.name
-
-    @property
-    def longname(self):
-        return '%s.%s' % (self.library.name, self.name)
-
-    def run(self, kw, context, run=True):
-        assignment = VariableAssignment(kw.assign)
-        result = self._get_result(kw, assignment)
-        with StatusReporter(kw, result, context, run):
-            if run:
-                with assignment.assigner(context) as assigner:
-                    return_value = self._run(context, kw.args)
-                    assigner.assign(return_value)
-                    return return_value
-
-    def _get_result(self, kw, assignment):
-        handler = self._handler
-        return KeywordResult(kwname=self.name,
-                             libname=handler.libname,
-                             doc=handler.shortdoc,
-                             args=kw.args,
-                             assign=tuple(assignment),
-                             tags=handler.tags,
-                             type=kw.type)
-
-    def _run(self, context, args):
-        if self.pre_run_messages:
-            for message in self.pre_run_messages:
-                context.output.message(message)
-        variables = context.variables if not context.dry_run else None
-        positional, named = self._handler.resolve_arguments(args, variables,
-                                                            self.languages)
-        context.output.trace(lambda: self._trace_log_args(positional, named),
-                             write_if_flat=False)
-        runner = self._runner_for(context, self._handler.current_handler(),
-                                  positional, dict(named))
-        return self._run_with_output_captured_and_signal_monitor(runner, context)
-
-    def _trace_log_args(self, positional, named):
-        args = [prepr(arg) for arg in positional]
-        args += ['%s=%s' % (safe_str(n), prepr(v)) for n, v in named]
-        return 'Arguments: [ %s ]' % ' | '.join(args)
-
-    def _runner_for(self, context, handler, positional, named):
-        timeout = self._get_timeout(context)
-        if timeout and timeout.active:
-            def runner():
-                with LOGGER.delayed_logging:
-                    context.output.debug(timeout.get_message)
-                    return timeout.run(handler, args=positional, kwargs=named)
-            return runner
-        return lambda: handler(*positional, **named)
-
-    def _get_timeout(self, context):
-        return min(context.timeouts) if context.timeouts else None
-
-    def _run_with_output_captured_and_signal_monitor(self, runner, context):
-        with OutputCapturer():
-            return self._run_with_signal_monitoring(runner, context)
-
-    def _run_with_signal_monitoring(self, runner, context):
-        try:
-            STOP_SIGNAL_MONITOR.start_running_keyword(context.in_teardown)
-            runner_result = runner()
-            if context.asynchronous.is_loop_required(runner_result):
-                return context.asynchronous.run_until_complete(runner_result)
-            return runner_result
-        finally:
-            STOP_SIGNAL_MONITOR.stop_running_keyword()
-
-    def dry_run(self, kw, context):
-        assignment = VariableAssignment(kw.assign)
-        result = self._get_result(kw, assignment)
-        with StatusReporter(kw, result, context, run=False):
-            assignment.validate_assignment()
-            self._dry_run(context, kw.args)
-
-    def _dry_run(self, context, args):
-        if self._executed_in_dry_run(self._handler):
-            self._run(context, args)
-        else:
-            self._handler.resolve_arguments(args, languages=self.languages)
-
-    def _executed_in_dry_run(self, handler):
-        keywords_to_execute = ('BuiltIn.Import Library',
-                               'BuiltIn.Set Library Search Order',
-                               'BuiltIn.Set Tags',
-                               'BuiltIn.Remove Tags')
-        return (handler.libname == 'Reserved' or
-                handler.longname in keywords_to_execute)
-
-
-class EmbeddedArgumentsRunner(LibraryKeywordRunner):
-
-    def __init__(self, handler, name):
-        super().__init__(handler, name)
-        self.embedded_args = handler.embedded.match(name).groups()
-
-    def _run(self, context, args):
-        if args:
-            raise DataError("Positional arguments are not allowed when using "
-                            "embedded arguments.")
-        return super()._run(context, self.embedded_args)
-
-    def _dry_run(self, context, args):
-        return super()._dry_run(context, self.embedded_args)
-
-    def _get_result(self, kw, assignment):
-        result = super()._get_result(kw, assignment)
-        result.sourcename = self._handler.name
-        return result
-
-
-class RunKeywordRunner(LibraryKeywordRunner):
-
-    def __init__(self, handler, execute_in_dry_run=False):
-        super().__init__(handler)
-        self.execute_in_dry_run = execute_in_dry_run
-
-    def _get_timeout(self, context):
-        # These keywords are not affected by timeouts. Keywords they execute are.
-        return None
-
-    def _run_with_output_captured_and_signal_monitor(self, runner, context):
-        return self._run_with_signal_monitoring(runner, context)
-
-    def _dry_run(self, context, args):
-        super()._dry_run(context, args)
-        keywords = [kw for kw in self._get_dry_run_keywords(args)
-                    if not contains_variable(kw.name)]
-        BodyRunner(context).run(keywords)
-
-    def _get_dry_run_keywords(self, args):
-        if not self.execute_in_dry_run:
-            return []
-        name = self._handler.name
-        if name == 'Run Keyword If':
-            return self._get_dry_run_keywords_for_run_keyword_if(args)
-        if name == 'Run Keywords':
-            return self._get_dry_run_keywords_for_run_keyword(args)
-        return self._get_dry_run_keywords_based_on_name_argument(args)
-
-    def _get_dry_run_keywords_for_run_keyword_if(self, given_args):
-        for kw_call in self._get_run_kw_if_calls(given_args):
-            if kw_call:
-                yield Keyword(name=kw_call[0], args=kw_call[1:])
-
-    def _get_run_kw_if_calls(self, given_args):
-        while 'ELSE IF' in given_args:
-            kw_call, given_args = self._split_run_kw_if_args(given_args, 'ELSE IF', 2)
-            yield kw_call
-        if 'ELSE' in given_args:
-            kw_call, else_call = self._split_run_kw_if_args(given_args, 'ELSE', 1)
-            yield kw_call
-            yield else_call
-        elif self._validate_kw_call(given_args):
-            expr, kw_call = given_args[0], given_args[1:]
-            if not is_list_variable(expr):
-                yield kw_call
-
-    def _split_run_kw_if_args(self, given_args, control_word, required_after):
-        index = list(given_args).index(control_word)
-        expr_and_call = given_args[:index]
-        remaining = given_args[index+1:]
-        if not (self._validate_kw_call(expr_and_call) and
-                self._validate_kw_call(remaining, required_after)):
-            raise DataError("Invalid 'Run Keyword If' usage.")
-        if is_list_variable(expr_and_call[0]):
-            return (), remaining
-        return expr_and_call[1:], remaining
-
-    def _validate_kw_call(self, kw_call, min_length=2):
-        if len(kw_call) >= min_length:
-            return True
-        return any(is_list_variable(item) for item in kw_call)
-
-    def _get_dry_run_keywords_for_run_keyword(self, given_args):
-        for kw_call in self._get_run_kws_calls(given_args):
-            yield Keyword(name=kw_call[0], args=kw_call[1:])
-
-    def _get_run_kws_calls(self, given_args):
-        if 'AND' not in given_args:
-            for kw_call in given_args:
-                yield [kw_call,]
-        else:
-            while 'AND' in given_args:
-                index = list(given_args).index('AND')
-                kw_call, given_args = given_args[:index], given_args[index + 1:]
-                yield kw_call
-            if given_args:
-                yield given_args
-
-    def _get_dry_run_keywords_based_on_name_argument(self, given_args):
-        index = list(self._handler.arguments.positional).index('name')
-        return [Keyword(name=given_args[index], args=given_args[index+1:])]