robotframework 7.0.1rc1__zip → 7.1__zip

{robotframework-7.0.1rc1 → robotframework-7.1}/src/robot/output/logger.py

@@ -56,8 +56,8 @@ class Logger(AbstractLogger):
         self._console_logger = None
         self._syslog = None
         self._xml_logger = None
-        self._listeners = None
-        self._library_listeners = None
+        self._cli_listeners = None
+        self._lib_listeners = None
         self._other_loggers = []
         self._message_cache = []
         self._log_message_cache = None
@@ -70,17 +70,25 @@ class Logger(AbstractLogger):
         if register_console_logger:
             self.register_console_logger()
 
+    @property
+    def _listeners(self):
+        cli_listeners = list(self._cli_listeners or [])
+        lib_listeners = list(self._lib_listeners or [])
+        return sorted(cli_listeners + lib_listeners, key=lambda li: -li.priority)
+
     @property
     def start_loggers(self):
-        loggers = [self._console_logger, self._syslog, self._xml_logger,
-                   self._listeners, self._library_listeners]
-        return [logger for logger in self._other_loggers + loggers if logger]
+        loggers = (self._other_loggers
+                   + [self._console_logger, self._syslog, self._xml_logger]
+                   + self._listeners)
+        return [logger for logger in loggers if logger]
 
     @property
     def end_loggers(self):
-        loggers = [self._listeners, self._library_listeners,
-                   self._console_logger, self._syslog, self._xml_logger]
-        return [logger for logger in loggers + self._other_loggers if logger]
+        loggers = (self._listeners
+                   + [self._console_logger, self._syslog, self._xml_logger]
+                   + self._other_loggers)
+        return [logger for logger in loggers if logger]
 
     def __iter__(self):
         return iter(self.end_loggers)
@@ -96,8 +104,8 @@ class Logger(AbstractLogger):
             self.close()
 
     def register_console_logger(self, type='verbose', width=78, colors='AUTO',
-                                markers='AUTO', stdout=None, stderr=None):
-        logger = ConsoleOutput(type, width, colors, markers, stdout, stderr)
+                                links='AUTO', markers='AUTO', stdout=None, stderr=None):
+        logger = ConsoleOutput(type, width, colors, links, markers, stdout, stderr)
         self._console_logger = self._wrap_and_relay(logger)
 
     def _wrap_and_relay(self, logger):
@@ -132,10 +140,10 @@ class Logger(AbstractLogger):
         self._xml_logger = None
 
     def register_listeners(self, listeners, library_listeners):
-        self._listeners = listeners
-        self._library_listeners = library_listeners
-        if listeners:
-            self._relay_cached_messages(listeners)
+        self._cli_listeners = listeners
+        self._lib_listeners = library_listeners
+        for listener in listeners or ():
+            self._relay_cached_messages(listener)
 
     def register_logger(self, *loggers):
         for logger in loggers:
@@ -398,9 +406,17 @@ class Logger(AbstractLogger):
         for logger in self.end_loggers:
             logger.end_error(data, result)
 
-    def imported(self, import_type, name, **attrs):
+    def library_import(self, library, importer):
+        for logger in self:
+            logger.library_import(library, importer)
+
+    def resource_import(self, resource, importer):
+        for logger in self:
+            logger.resource_import(resource, importer)
+
+    def variables_import(self, variables, importer):
         for logger in self:
-            logger.imported(import_type, name, attrs)
+            logger.variables_import(variables, importer)
 
     def output_file(self, path):
         for logger in self:

{robotframework-7.0.1rc1 → robotframework-7.1}/src/robot/output/loggerapi.py

@@ -211,5 +211,16 @@ class LoggerApi:
     def imported(self, import_type: str, name: str, attrs):
         pass
 
+    def library_import(self, library: 'running.TestLibrary',
+                       importer: 'running.Import'):
+        pass
+
+    def resource_import(self, resource: 'running.ResourceFile',
+                        importer: 'running.Import'):
+        pass
+
+    def variables_import(self, attrs: dict, importer: 'running.Import'):
+        pass
+
     def close(self):
         pass

{robotframework-7.0.1rc1 → robotframework-7.1}/src/robot/output/loggerhelper.py

@@ -141,7 +141,12 @@ class IsLogged:
         self.__init__(level)
         return old
 
-    def _level_to_int(self, level):
+    @classmethod
+    def validate_level(cls, level):
+        cls._level_to_int(level)
+
+    @classmethod
+    def _level_to_int(cls, level):
         try:
             return LEVELS[level.upper()]
         except KeyError:

{robotframework-7.0.1rc1 → robotframework-7.1}/src/robot/output/output.py

@@ -18,7 +18,7 @@ from .debugfile import DebugFile
 from .listeners import Listeners, LibraryListeners
 from .logger import LOGGER
 from .loggerapi import LoggerApi
-from .loggerhelper import AbstractLogger
+from .loggerhelper import AbstractLogger, IsLogged
 from .xmllogger import XmlLoggerAdapter
 
 
@@ -179,6 +179,7 @@ class Output(AbstractLogger, LoggerApi):
             self.write(msg, 'TRACE')
 
     def set_log_level(self, level):
+        IsLogged.validate_level(level)
         pyloggingconf.set_level(level)
         self.listeners.set_log_level(level)
         self.library_listeners.set_log_level(level)

{robotframework-7.0.1rc1 → robotframework-7.1}/src/robot/parsing/model/statements.py

@@ -1208,7 +1208,7 @@ class WhileHeader(Statement):
 class Var(Statement):
     type = Token.VAR
     options = {
-        'scope': ('GLOBAL', 'SUITE', 'TEST', 'TASK', 'LOCAL'),
+        'scope': ('LOCAL', 'TEST', 'TASK', 'SUITE', 'SUITES', 'GLOBAL'),
         'separator': None
     }
 

{robotframework-7.0.1rc1 → robotframework-7.1}/src/robot/rebot.py

@@ -262,6 +262,9 @@ Options
                           on:   always use colors
                           ansi: like `on` but use ANSI colors also on Windows
                           off:  disable colors altogether
+    --consolelinks auto|off  Control making paths to results files hyperlinks.
+                          auto: use links when colors are enabled (default)
+                          off: disable links unconditionally
  -P --pythonpath path *   Additional locations to add to the module search path
                           that is used when importing Python based extensions.
  -A --argumentfile path *  Text file to read more arguments from. File can have

{robotframework-7.0.1rc1 → robotframework-7.1}/src/robot/result/executionresult.py

@@ -64,6 +64,7 @@ class Result:
         #: :class:`~.executionerrors.ExecutionErrors` object.
         self.errors = errors or ExecutionErrors()
         self.generated_by_robot = True
+        self.generation_time = None
         self._status_rc = True
         self._stat_config = {}
         self.rpa = rpa

{robotframework-7.0.1rc1 → robotframework-7.1}/src/robot/result/model.py

@@ -1133,7 +1133,7 @@ class TestSuite(model.TestSuite[Keyword, TestCase], StatusMixin):
         if output is None:
             output = StringIO()
         elif isinstance(output, (Path, str)):
-            output = open(output, 'w')
+            output = open(output, 'w', encoding='UTF-8')
             close = True
         return output, close
 

{robotframework-7.0.1rc1 → robotframework-7.1}/src/robot/result/resultbuilder.py

@@ -13,8 +13,6 @@
 #  See the License for the specific language governing permissions and
 #  limitations under the License.
 
-from pathlib import Path
-
 from robot.errors import DataError
 from robot.model import SuiteVisitor
 from robot.utils import ET, ETSource, get_error_message
@@ -82,9 +80,13 @@ def _single_result(source, options):
 def _json_result(source, options):
     try:
         suite = TestSuite.from_json(source)
+    except IOError as err:
+        error = err.strerror
     except Exception:
-        raise DataError(f"Reading JSON source '{source}' failed: {get_error_message()}")
-    return Result(source, suite, rpa=options.pop('rpa', None))
+        error = get_error_message()
+    else:
+        return Result(source, suite, rpa=options.pop('rpa', None))
+    raise DataError(f"Reading JSON source '{source}' failed: {error}")
 
 
 def _xml_result(source, options):
@@ -150,27 +152,27 @@ class ExecutionResultBuilder:
                 elem.clear()
 
     def _omit_keywords(self, context):
-        omitted_kws = 0
+        omitted_elements = {'kw', 'for', 'while', 'if', 'try'}
+        omitted = 0
         for event, elem in context:
             # Teardowns aren't omitted yet to allow checking suite teardown status.
             # They'll be removed later when not needed in `build()`.
-            omit = elem.tag in ('kw', 'for', 'if') and elem.get('type') != 'TEARDOWN'
+            omit = elem.tag in omitted_elements and elem.get('type') != 'TEARDOWN'
             start = event == 'start'
             if omit and start:
-                omitted_kws += 1
-            if not omitted_kws:
+                omitted += 1
+            if not omitted:
                 yield event, elem
             elif not start:
                 elem.clear()
             if omit and not start:
-                omitted_kws -= 1
+                omitted -= 1
 
     def _flatten_keywords(self, context, flattened):
         # Performance optimized. Do not change without profiling!
         name_match, by_name = self._get_matcher(FlattenByNameMatcher, flattened)
         type_match, by_type = self._get_matcher(FlattenByTypeMatcher, flattened)
         started = -1    # if 0 or more, we are flattening
-        tags = []
         containers = {'kw', 'for', 'while', 'iter', 'if', 'try'}
         inside = 0    # to make sure we don't read tags from a test
         for event, elem in context:
@@ -185,7 +187,6 @@ class ExecutionResultBuilder:
                         started = 0
                     elif by_type and type_match(tag):
                         started = 0
-                    tags = []
             else:
                 if tag in containers:
                     inside -= 1

{robotframework-7.0.1rc1 → robotframework-7.1}/src/robot/result/xmlelementhandlers.py

@@ -60,6 +60,9 @@ class ElementHandler:
 
     def _legacy_timestamp(self, elem, attr_name):
         ts = elem.get(attr_name)
+        return self._parse_legacy_timestamp(ts)
+
+    def _parse_legacy_timestamp(self, ts):
         if ts == 'N/A' or not ts:
             return None
         ts = ts.ljust(24, '0')
@@ -85,10 +88,19 @@ class RobotHandler(ElementHandler):
     def start(self, elem, result):
         generator = elem.get('generator', 'unknown').split()[0].upper()
         result.generated_by_robot = generator == 'ROBOT'
+        result.generation_time = self._parse_generation_time(elem.get('generated'))
         if result.rpa is None:
             result.rpa = elem.get('rpa', 'false') == 'true'
         return result
 
+    def _parse_generation_time(self, generated):
+        if not generated:
+            return None
+        try:
+            return datetime.fromisoformat(generated)
+        except ValueError:
+            return self._parse_legacy_timestamp(generated)
+
 
 @ElementHandler.register
 class SuiteHandler(ElementHandler):

{robotframework-7.0.1rc1 → robotframework-7.1}/src/robot/run.py

@@ -341,6 +341,9 @@ Options
                           on:   always use colors
                           ansi: like `on` but use ANSI colors also on Windows
                           off:  disable colors altogether
+    --consolelinks auto|off  Control making paths to results files hyperlinks.
+                          auto: use links when colors are enabled (default)
+                          off: disable links unconditionally
  -K --consolemarkers auto|on|off  Show markers on the console when top level
                           keywords in a test case end. Values have same
                           semantics as with --consolecolors.

{robotframework-7.0.1rc1 → robotframework-7.1}/src/robot/running/__init__.py

@@ -123,6 +123,6 @@ from .librarykeyword import LibraryKeyword
 from .model import (Break, Continue, Error, For, ForIteration, If, IfBranch, Keyword,
                     Return, TestCase, TestSuite, Try, TryBranch, Var, While,
                     WhileIteration)
-from .resourcemodel import ResourceFile, UserKeyword
+from .resourcemodel import Import, ResourceFile, UserKeyword, Variable
 from .runkwregister import RUN_KW_REGISTER
 from .testlibraries import TestLibrary

{robotframework-7.0.1rc1 → robotframework-7.1}/src/robot/running/arguments/argumentresolver.py

@@ -20,6 +20,7 @@ from robot.utils import is_dict_like, split_from_equals
 from robot.variables import is_dict_variable
 
 from .argumentvalidator import ArgumentValidator
+from ..model import Argument
 
 if TYPE_CHECKING:
     from .argumentspec import ArgumentSpec
@@ -37,8 +38,11 @@ class ArgumentResolver:
         self.dict_to_kwargs = DictToKwargs(spec, dict_to_kwargs)
         self.argument_validator = ArgumentValidator(spec)
 
-    def resolve(self, arguments, variables=None):
-        positional, named = self.named_resolver.resolve(arguments, variables)
+    def resolve(self, args, named_args=None, variables=None):
+        if named_args is None:
+            positional, named = self.named_resolver.resolve(args, variables)
+        else:
+            positional, named = args, list(named_args.items())
         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)
@@ -51,14 +55,15 @@ class NamedArgumentResolver:
         self.spec = spec
 
     def resolve(self, arguments, variables=None):
-        spec = self.spec
-        positional = list(arguments[:len(spec.embedded)])
+        known_positional_count = max(len(self.spec.positional_only),
+                                     len(self.spec.embedded))
+        positional = list(arguments[:known_positional_count])
         named = []
-        for arg in arguments[len(spec.embedded):]:
+        for arg in arguments[known_positional_count:]:
             if is_dict_variable(arg):
                 named.append(arg)
             else:
-                name, value = self._split_named(arg, named, variables, spec)
+                name, value = self._split_named(arg, named, variables)
                 if name is not None:
                     named.append((name, value))
                 elif named:
@@ -67,21 +72,23 @@ class NamedArgumentResolver:
                     positional.append(value)
         return positional, named
 
-    def _split_named(self, arg, previous_named, variables, spec):
+    def _split_named(self, arg, previous_named, variables):
+        if isinstance(arg, Argument):
+            return arg.name, arg.value
         name, value = split_from_equals(arg)
-        if value is None or not self._is_named(name, previous_named, variables, spec):
+        if value is None or not self._is_named(name, previous_named, variables):
             return None, arg
         return name, value
 
-    def _is_named(self, name, previous_named, variables, spec):
-        if previous_named or spec.var_named:
+    def _is_named(self, name, previous_named, variables):
+        if previous_named or self.spec.var_named:
             return True
         if variables:
             try:
                 name = variables.replace_scalar(name)
             except DataError:
                 return False
-        return name in spec.named
+        return name in self.spec.named
 
     def _raise_positional_after_named(self):
         raise DataError(f"{self.spec.type.capitalize()} '{self.spec.name}' "

{robotframework-7.0.1rc1 → robotframework-7.1}/src/robot/running/arguments/argumentspec.py

@@ -96,12 +96,12 @@ class ArgumentSpec(metaclass=SetterAwareType):
         return (self.positional_only + self.positional_or_named + var_positional +
                 self.named_only + var_named)
 
-    def resolve(self, arguments, variables=None, converters=None,
+    def resolve(self, args, named_args=None, variables=None, converters=None,
                 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)
+        positional, named = resolver.resolve(args, named_args, variables)
         return self.convert(positional, named, converters, dry_run=not variables,
                             languages=languages)
 

{robotframework-7.0.1rc1 → robotframework-7.1}/src/robot/running/arguments/argumentvalidator.py

@@ -34,7 +34,6 @@ class ArgumentValidator:
                        any(is_dict_variable(arg) for arg in named)):
             return
         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)
@@ -49,13 +48,6 @@ class ArgumentValidator:
         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(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)
         if not spec.minargs <= count <= spec.maxargs:

{robotframework-7.0.1rc1 → robotframework-7.1}/src/robot/running/arguments/embedded.py

@@ -80,7 +80,7 @@ class EmbeddedArgumentParser:
         args = []
         custom_patterns = {}
         after = string
-        for match in VariableMatches(string, identifiers='$'):
+        for match in VariableMatches(' '.join(string.split()), identifiers='$'):
             arg, pattern, is_custom = self._get_name_and_pattern(match.base)
             args.append(arg)
             if is_custom:
@@ -139,7 +139,7 @@ class EmbeddedArgumentParser:
 
     def _compile_regexp(self, pattern: str) -> re.Pattern:
         try:
-            return re.compile(''.join(pattern), re.IGNORECASE)
+            return re.compile(pattern.replace(r'\ ', r'\s'), re.IGNORECASE)
         except Exception:
             raise DataError(f"Compiling embedded arguments regexp failed: "
                             f"{get_error_message()}")

{robotframework-7.0.1rc1 → robotframework-7.1}/src/robot/running/bodyrunner.py

@@ -383,7 +383,6 @@ class WhileRunner:
         ctx = self._context
         error = None
         run = False
-        limit = None
         result.start_time = datetime.now()
         iter_result = result.body.create_iteration(start_time=datetime.now())
         if self._run:
@@ -391,15 +390,17 @@ class WhileRunner:
                 error = DataError(data.error, syntax=True)
             elif not ctx.dry_run:
                 try:
-                    limit = WhileLimit.create(data.limit,
-                                              data.on_limit,
-                                              data.on_limit_message,
-                                              ctx.variables)
                     run = self._should_run(data.condition, ctx.variables)
                 except DataError as err:
                     error = err
         with StatusReporter(data, result, self._context, run):
             iter_data = data.get_iteration()
+            if run:
+                try:
+                    limit = WhileLimit.create(data, ctx.variables)
+                except DataError as err:
+                    error = err
+                    run = False
             if ctx.dry_run or not run:
                 self._run_iteration(iter_data, iter_result, run)
                 if error:
@@ -651,29 +652,34 @@ class WhileLimit:
         self.on_limit_message = on_limit_message
 
     @classmethod
-    def create(cls, limit, on_limit, on_limit_message, variables):
-        if on_limit_message:
-            try:
-                on_limit_message = variables.replace_string(on_limit_message)
-            except DataError as err:
-                raise DataError(f"Invalid WHILE loop 'on_limit_message': '{err}")
-        on_limit = cls._parse_on_limit(variables, on_limit)
+    def create(cls, data, variables):
+        limit = cls._parse_limit(data.limit, variables)
+        on_limit = cls._parse_on_limit(data.on_limit, variables)
+        on_limit_msg = cls._parse_on_limit_message(data.on_limit_message, variables)
         if not limit:
-            return IterationCountLimit(DEFAULT_WHILE_LIMIT, on_limit, on_limit_message)
-        limit = variables.replace_string(limit)
+            return IterationCountLimit(DEFAULT_WHILE_LIMIT, on_limit, on_limit_msg)
         if limit.upper() == 'NONE':
             return NoLimit()
         try:
             count = cls._parse_limit_as_count(limit)
         except ValueError:
             seconds = cls._parse_limit_as_timestr(limit)
-            return DurationLimit(seconds, on_limit, on_limit_message)
+            return DurationLimit(seconds, on_limit, on_limit_msg)
         else:
-            return IterationCountLimit(count, on_limit, on_limit_message)
+            return IterationCountLimit(count, on_limit, on_limit_msg)
 
     @classmethod
-    def _parse_on_limit(cls, variables, on_limit):
-        if on_limit is None:
+    def _parse_limit(cls, limit, variables):
+        if not limit:
+            return None
+        try:
+            return variables.replace_string(limit)
+        except DataError as err:
+            raise DataError(f"Invalid WHILE loop limit: {err}")
+
+    @classmethod
+    def _parse_on_limit(cls, on_limit, variables):
+        if not on_limit:
             return None
         try:
             on_limit = variables.replace_string(on_limit)
@@ -682,7 +688,16 @@ class WhileLimit:
             raise DataError(f"Value '{on_limit}' is not accepted. Valid values "
                             f"are 'PASS' and 'FAIL'.")
         except DataError as err:
-            raise DataError(f"Invalid WHILE loop 'on_limit' value: {err}")
+            raise DataError(f"Invalid WHILE loop 'on_limit': {err}")
+
+    @classmethod
+    def _parse_on_limit_message(cls, on_limit_message, variables):
+        if not on_limit_message:
+            return None
+        try:
+            return variables.replace_string(on_limit_message)
+        except DataError as err:
+            raise DataError(f"Invalid WHILE loop 'on_limit_message': '{err}")
 
     @classmethod
     def _parse_limit_as_count(cls, limit):

{robotframework-7.0.1rc1 → robotframework-7.1}/src/robot/running/invalidkeyword.py

@@ -54,9 +54,12 @@ class InvalidKeywordRunner:
 
     def run(self, data: KeywordData, result: KeywordResult, context, run=True):
         kw = self.keyword.bind(data)
+        args = tuple(data.args)
+        if data.named_args:
+            args += tuple(f'{n}={v}' for n, v in data.named_args.items())
         result.config(name=self.name,
                       owner=kw.owner.name if kw.owner else None,
-                      args=data.args,
+                      args=args,
                       assign=tuple(VariableAssignment(data.assign)),
                       type=data.type)
         with StatusReporter(data, result, context, run, implementation=kw):

{robotframework-7.0.1rc1 → robotframework-7.1}/src/robot/running/keywordimplementation.py

@@ -14,7 +14,7 @@
 #  limitations under the License.
 
 from pathlib import Path
-from typing import Any, Literal, Sequence, TYPE_CHECKING
+from typing import Any, Literal, Mapping, Sequence, TYPE_CHECKING
 
 from robot.model import ModelObject, Tags
 from robot.utils import eq, getshortdoc, setter
@@ -23,6 +23,8 @@ from .arguments import ArgInfo, ArgumentSpec, EmbeddedArguments
 from .model import BodyItemParent, Keyword
 
 if TYPE_CHECKING:
+    from robot.conf import LanguagesLike
+
     from .librarykeywordrunner import LibraryKeywordRunner
     from .resourcemodel import ResourceFile
     from .testlibraries import TestLibrary
@@ -141,11 +143,13 @@ class KeywordImplementation(ModelObject):
             return self.embedded.match(name) is not None
         return eq(self.name, name, ignore='_')
 
-    def resolve_arguments(self, args: Sequence[str], variables=None,
-                          languages=None) -> 'tuple[list, list]':
-        return self.args.resolve(args, variables, languages=languages)
+    def resolve_arguments(self, args: 'Sequence[str|Any]',
+                          named_args: 'Mapping[str, Any]|None' = None,
+                          variables=None,
+                          languages: 'LanguagesLike' = None) -> 'tuple[list, list]':
+        return self.args.resolve(args, named_args, variables, languages=languages)
 
-    def create_runner(self, name: 'str|None', languages=None) \
+    def create_runner(self, name: 'str|None', languages: 'LanguagesLike' = None) \
             -> 'LibraryKeywordRunner|UserKeywordRunner':
         raise NotImplementedError
 

{robotframework-7.0.1rc1 → robotframework-7.1}/src/robot/running/librarykeyword.py

@@ -16,7 +16,7 @@
 import inspect
 from os.path import normpath
 from pathlib import Path
-from typing import Any, Callable, Generic, Sequence, TypeVar, TYPE_CHECKING
+from typing import Any, Callable, Generic, Mapping, Sequence, TypeVar, TYPE_CHECKING
 
 from robot.model import Tags
 from robot.errors import DataError
@@ -29,10 +29,13 @@ from .dynamicmethods import (GetKeywordArguments, GetKeywordDocumentation,
                              RunKeyword)
 from .model import BodyItemParent, Keyword
 from .keywordimplementation import KeywordImplementation
-from .librarykeywordrunner import EmbeddedArgumentsRunner, LibraryKeywordRunner, RunKeywordRunner
+from .librarykeywordrunner import (EmbeddedArgumentsRunner, LibraryKeywordRunner,
+                                   RunKeywordRunner)
 from .runkwregister import RUN_KW_REGISTER
 
 if TYPE_CHECKING:
+    from robot.conf import LanguagesLike
+
     from .testlibraries import DynamicLibrary, TestLibrary
 
 
@@ -73,7 +76,8 @@ class LibraryKeyword(KeywordImplementation):
                 return start_lineno + increment
         return start_lineno
 
-    def create_runner(self, name: 'str|None', languages=None) -> LibraryKeywordRunner:
+    def create_runner(self, name: 'str|None',
+                      languages: 'LanguagesLike' = None) -> LibraryKeywordRunner:
         if self.embedded:
             return EmbeddedArgumentsRunner(self, name)
         if self._resolve_args_until is not None:
@@ -81,10 +85,13 @@ class LibraryKeyword(KeywordImplementation):
             return RunKeywordRunner(self, execute_in_dry_run=dry_run)
         return LibraryKeywordRunner(self, languages=languages)
 
-    def resolve_arguments(self, args: Sequence[str], variables=None,
-                          languages=None) -> 'tuple[list, list]':
+    def resolve_arguments(self, args: 'Sequence[str|Any]',
+                          named_args: 'Mapping[str, Any]|None' = None,
+                          variables=None,
+                          languages: 'LanguagesLike' = None) -> 'tuple[list, list]':
         resolve_args_until = self._resolve_args_until
-        positional, named = self.args.resolve(args, variables, self.owner.converters,
+        positional, named = self.args.resolve(args, named_args, variables,
+                                              self.owner.converters,
                                               resolve_named=resolve_args_until is None,
                                               resolve_args_until=resolve_args_until,
                                               languages=languages)
@@ -198,9 +205,12 @@ class DynamicKeyword(LibraryKeyword):
     def from_name(cls, name: str, owner: 'DynamicLibrary') -> 'DynamicKeyword':
         return DynamicKeywordCreator(name, owner).create()
 
-    def resolve_arguments(self, arguments, variables=None,
-                          languages=None) -> 'tuple[list, list]':
-        positional, named = super().resolve_arguments(arguments, variables, languages)
+    def resolve_arguments(self, args: 'Sequence[str|Any]',
+                          named_args: 'Mapping[str, Any]|None' = None,
+                          variables=None,
+                          languages: 'LanguagesLike' = None) -> 'tuple[list, list]':
+        positional, named = super().resolve_arguments(args, named_args, variables,
+                                                      languages)
         if not self.owner.supports_named_args:
             positional, named = self.args.map(positional, named)
         return positional, named