robotframework 7.0rc2__zip → 7.0.1__zip

{robotframework-7.0rc2 → robotframework-7.0.1}/src/robot/model/keyword.py

@@ -13,7 +13,7 @@
 #  See the License for the specific language governing permissions and
 #  limitations under the License.
 
-from typing import Any, Dict, List, Sequence, Tuple, TYPE_CHECKING, Union
+from typing import Sequence, TYPE_CHECKING
 
 from .body import Body, BodyItem, BodyItemParent
 from .modelobject import DataDict
@@ -22,25 +22,18 @@ if TYPE_CHECKING:
     from .visitor import SuiteVisitor
 
 
-Arguments = Union[Sequence[Union[Any, Tuple[Any], Tuple[str, Any]]],
-                  Tuple[List[Any], Dict[str, Any]]]
-
-
 @Body.register
 class Keyword(BodyItem):
     """Base model for a single keyword.
 
     Extended by :class:`robot.running.model.Keyword` and
     :class:`robot.result.model.Keyword`.
-
-    Arguments from normal data are always strings, but other types are possible in
-    programmatic usage. See the docstrings of the extending classes for more details.
     """
     repr_args = ('name', 'args', 'assign')
     __slots__ = ['name', 'args', 'assign', 'type']
 
     def __init__(self, name: 'str|None' = '',
-                 args: Arguments = (),
+                 args: Sequence[str] = (),
                  assign: Sequence[str] = (),
                  type: str = BodyItem.KEYWORD,
                  parent: BodyItemParent = None):

{robotframework-7.0rc2 → robotframework-7.0.1}/src/robot/output/xmllogger.py

@@ -217,7 +217,7 @@ class XmlLogger(ResultVisitor):
             if self.flatten_level == 0:
                 self._writer = self._xml_writer
         self._write_list('var', kw.assign)
-        self._write_list('arg', kw.args)
+        self._write_list('arg', [str(a) for a in kw.args])
         self._write_list('tag', kw.tags)
         self._writer.element('doc', kw.doc)
         if kw.timeout:
@@ -429,6 +429,8 @@ class LegacyXmlLogger(XmlLogger):
                 'schemaversion': '4'}
 
     def _datetime_to_timestamp(self, dt):
+        if dt is None:
+            return None
         return dt.isoformat(' ', timespec='milliseconds').replace('-', '')
 
     def _get_start_keyword_attrs(self, kw):

{robotframework-7.0rc2 → robotframework-7.0.1}/src/robot/reporting/logreportwriters.py

@@ -56,7 +56,7 @@ class LogWriter(_LogReportWriter):
     def _write_split_log(self, index, keywords, strings, path: Path):
         with file_writer(path, usage=self.usage) as outfile:
             writer = SplitLogWriter(outfile)
-            writer.write(keywords, strings, index, path.stem)
+            writer.write(keywords, strings, index, path.name)
 
 
 class ReportWriter(_LogReportWriter):

{robotframework-7.0rc2 → robotframework-7.0.1}/src/robot/result/model.py

@@ -43,7 +43,7 @@ from typing import Literal, Mapping, overload, Sequence, Union, TextIO, TypeVar
 from robot import model
 from robot.model import (BodyItem, create_fixture, DataDict, Tags, TestSuites,
                          TotalStatistics, TotalStatisticsBuilder)
-from robot.utils import is_dict_like, is_list_like, setter
+from robot.utils import setter
 
 from .configurer import SuiteConfigurer
 from .messagefilter import MessageFilter
@@ -91,7 +91,6 @@ class Message(model.Message):
         return data
 
 
-
 class StatusMixin:
     PASS = 'PASS'
     FAIL = 'FAIL'
@@ -711,7 +710,7 @@ class Keyword(model.Keyword, StatusMixin):
                  owner: 'str|None' = None,
                  source_name: 'str|None' = None,
                  doc: str = '',
-                 args: model.Arguments = (),
+                 args: Sequence[str] = (),
                  assign: Sequence[str] = (),
                  tags: Sequence[str] = (),
                  timeout: 'str|None' = None,
@@ -739,30 +738,6 @@ class Keyword(model.Keyword, StatusMixin):
         self._teardown = None
         self.body = ()
 
-    @setter
-    def args(self, args: model.Arguments) -> 'tuple[str, ...]':
-        """Keyword arguments.
-
-        Arguments originating from normal data are given as a list of strings.
-        Programmatically it is possible to use also other types and named arguments
-        can be specified using name-value tuples. Additionally, it is possible
-        o give arguments directly as a list of positional arguments and a dictionary
-        of named arguments. In all these cases arguments are stored as strings.
-        """
-        if len(args) == 2 and is_list_like(args[0]) and is_dict_like(args[1]):
-            positional = [str(a) for a in args[0]]
-            named = [f'{n}={v}' for n, v in args[1].items()]
-            return tuple(positional + named)
-        return tuple([a if isinstance(a, str) else self._arg_to_str(a) for a in args])
-
-    def _arg_to_str(self, arg):
-        if isinstance(arg, tuple):
-            if len(arg) == 2:
-                return f'{arg[0]}={arg[1]}'
-            if len(arg) == 1:
-                return str(arg[0])
-        return str(arg)
-
     @setter
     def body(self, body: 'Sequence[BodyItem|DataDict]') -> Body:
         """Possible keyword body as a :class:`~.Body` object.

{robotframework-7.0rc2 → robotframework-7.0.1}/src/robot/running/__init__.py

@@ -32,6 +32,12 @@ The public API of this module consists of the following objects:
   :mod:`robot.running.model` module. These classes are typically only needed
   in type hints.
 
+* Keyword implementation related classes :class:`~robot.running.resourcemodel.UserKeyword`,
+  :class:`~robot.running.librarykeyword.LibraryKeyword`,
+  :class:`~robot.running.invalidkeyword.InvalidKeyword` and their common base class
+  :class:`~robot.running.keywordimplementation.KeywordImplementation`. Also these
+  classes are mainly needed in type hints.
+
 * :class:`~robot.running.builder.settings.TestDefaults` that is part of the
   `external parsing API`__ and also typically needed only in type hints.
 
@@ -43,6 +49,7 @@ the :mod:`robot.api` package.
 
 .. note:: Prior to Robot Framework 6.1, only some classes in
           :mod:`robot.running.model` were exposed via :mod:`robot.running`.
+          Keyword implementation related classes are new in Robot Framework 7.0.
 
 Examples
 --------

{robotframework-7.0rc2 → robotframework-7.0.1}/src/robot/running/arguments/argumentresolver.py

@@ -16,10 +16,11 @@
 from typing import TYPE_CHECKING
 
 from robot.errors import DataError
-from robot.utils import is_dict_like, is_list_like, split_from_equals
+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
@@ -38,13 +39,9 @@ class ArgumentResolver:
         self.argument_validator = ArgumentValidator(spec)
 
     def resolve(self, arguments, variables=None):
-        if len(arguments) == 2 and is_list_like(arguments[0]) and is_dict_like(arguments[1]):
-            positional = list(arguments[0])
-            named = list(arguments[1].items())
-        else:
-            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)
+        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
 
@@ -72,13 +69,8 @@ class NamedArgumentResolver:
         return positional, named
 
     def _split_named(self, arg, previous_named, variables, spec):
-        if isinstance(arg, tuple):
-            if len(arg) == 2 and isinstance(arg[0], str):
-                return arg
-            elif len(arg) == 1:
-                return None, arg[0]
-            else:
-                return None, arg
+        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):
             return None, arg

{robotframework-7.0rc2 → robotframework-7.0.1}/src/robot/running/arguments/typeconverters.py

@@ -526,7 +526,17 @@ class TypedDictConverter(TypeConverter):
         return type_info.is_typed_dict
 
     def no_conversion_needed(self, value):
-        return False
+        if not isinstance(value, Mapping):
+            return False
+        for key in value:
+            try:
+                converter = self.converters[key]
+            except KeyError:
+                return False
+            else:
+                if not converter.no_conversion_needed(value[key]):
+                    return False
+        return set(value).issuperset(self.type_info.required)
 
     def _non_string_convert(self, value):
         return self._convert_items(value)

{robotframework-7.0rc2 → robotframework-7.0.1}/src/robot/running/arguments/typeinfo.py

@@ -13,12 +13,20 @@
 #  See the License for the specific language governing permissions and
 #  limitations under the License.
 
+import sys
 from collections.abc import Mapping, Sequence, Set
 from datetime import date, datetime, timedelta
 from decimal import Decimal
 from enum import Enum
 from pathlib import Path
-from typing import Any, ForwardRef, get_type_hints, Literal, Union
+from typing import Any, ForwardRef, get_type_hints, get_origin, Literal, Union
+if sys.version_info >= (3, 11):
+    from typing import NotRequired, Required
+else:
+    try:
+        from typing_extensions import NotRequired, Required
+    except ImportError:
+        NotRequired = Required = object()
 
 from robot.conf import Languages, LanguagesLike
 from robot.errors import DataError
@@ -84,7 +92,7 @@ class TypeInfo(metaclass=SetterAwareType):
 
     def __init__(self, name: 'str|None' = None,
                  type: Any = NOT_SET,
-                 nested: 'Sequence[TypeInfo]' = ()):
+                 nested: 'Sequence[TypeInfo]|None' = None):
         if type is NOT_SET:
             type = TYPE_NAMES.get(name.lower()) if name else None
         self.name = name
@@ -92,7 +100,7 @@ class TypeInfo(metaclass=SetterAwareType):
         self.nested = nested
 
     @setter
-    def nested(self, nested: 'Sequence[TypeInfo]') -> 'tuple[TypeInfo, ...]':
+    def nested(self, nested: 'Sequence[TypeInfo]') -> 'tuple[TypeInfo, ...]|None':
         """Nested types as a tuple of ``TypeInfo`` objects.
 
         Used with parameterized types and unions.
@@ -100,8 +108,10 @@ class TypeInfo(metaclass=SetterAwareType):
         typ = self.type
         if self.is_union:
             self._validate_union(nested)
-        elif typ is None or not nested:
-            pass
+        elif nested is None:
+            return None
+        elif typ is None:
+            return tuple(nested)
         elif typ is Literal:
             self._validate_literal(nested)
         elif not isinstance(typ, type):
@@ -124,6 +134,8 @@ class TypeInfo(metaclass=SetterAwareType):
             raise DataError('Union cannot be empty.')
 
     def _validate_literal(self, nested):
+        if not nested:
+            raise DataError('Literal cannot be empty.')
         for info in nested:
             if not isinstance(info.type, LITERAL_TYPES):
                 raise DataError(f'Literal supports only integers, strings, bytes, '
@@ -183,7 +195,7 @@ class TypeInfo(metaclass=SetterAwareType):
             elif has_args(hint):
                 nested = [cls.from_type_hint(a) for a in hint.__args__]
             else:
-                nested = []
+                nested = None
             return cls(type_repr(hint, nested=False), hint.__origin__, nested)
         if isinstance(hint, str):
             return cls.from_string(hint)
@@ -285,10 +297,11 @@ class TypeInfo(metaclass=SetterAwareType):
     def __str__(self):
         if self.is_union:
             return ' | '.join(str(n) for n in self.nested)
-        if self.nested:
-            nested = ', '.join(str(n) for n in self.nested)
-            return f'{self.name}[{nested}]'
-        return self.name or ''
+        name = self.name or ''
+        if self.nested is None:
+            return name
+        nested = ', '.join(str(n) for n in self.nested)
+        return f'{name}[{nested}]'
 
     def __bool__(self):
         return self.name is not None
@@ -302,11 +315,30 @@ class TypedDictInfo(TypeInfo):
 
     def __init__(self, name: str, type: type):
         super().__init__(name, type)
-        try:
-            type_hints = get_type_hints(type)
-        except Exception:
-            type_hints = type.__annotations__
-        self.annotations = {name: TypeInfo.from_type_hint(hint)
-                            for name, hint in type_hints.items()}
+        type_hints = self._get_type_hints(type)
         # __required_keys__ is new in Python 3.9.
         self.required = getattr(type, '__required_keys__', frozenset())
+        if sys.version_info < (3, 11):
+            self._handle_typing_extensions_required_and_not_required(type_hints)
+        self.annotations = {name: TypeInfo.from_type_hint(hint)
+                            for name, hint in type_hints.items()}
+
+    def _get_type_hints(self, type) -> 'dict[str, Any]':
+        try:
+            return get_type_hints(type)
+        except Exception:
+            return type.__annotations__
+
+    def _handle_typing_extensions_required_and_not_required(self, type_hints):
+        # NotRequired and Required are handled automatically by Python 3.11 and newer,
+        # but with older they appear in type hints and need to be handled separately.
+        required = set(self.required)
+        for key, hint in type_hints.items():
+            origin = get_origin(hint)
+            if origin is Required:
+                required.add(key)
+                type_hints[key] = hint.__args__[0]
+            elif origin is NotRequired:
+                required.discard(key)
+                type_hints[key] = hint.__args__[0]
+        self.required = frozenset(required)

{robotframework-7.0rc2 → robotframework-7.0.1}/src/robot/running/arguments/typeinfoparser.py

@@ -21,7 +21,7 @@ from typing import Literal
 from .typeinfo import LITERAL_TYPES, TypeInfo
 
 
-class TypeInfoTokenType(Enum):
+class TokenType(Enum):
     NAME = auto()
     LEFT_SQUARE = auto()
     RIGHT_SQUARE = auto()
@@ -33,23 +33,23 @@ class TypeInfoTokenType(Enum):
 
 
 @dataclass
-class TypeInfoToken:
-    type: TypeInfoTokenType
+class Token:
+    type: TokenType
     value: str
     position: int = -1
 
 
 class TypeInfoTokenizer:
     markers = {
-        '[': TypeInfoTokenType.LEFT_SQUARE,
-        ']': TypeInfoTokenType.RIGHT_SQUARE,
-        '|': TypeInfoTokenType.PIPE,
-        ',': TypeInfoTokenType.COMMA,
+        '[': TokenType.LEFT_SQUARE,
+        ']': TokenType.RIGHT_SQUARE,
+        '|': TokenType.PIPE,
+        ',': TokenType.COMMA,
     }
 
     def __init__(self, source: str):
         self.source = source
-        self.tokens: 'list[TypeInfoToken]' = []
+        self.tokens: 'list[Token]' = []
         self.start = 0
         self.current = 0
 
@@ -57,7 +57,7 @@ class TypeInfoTokenizer:
     def at_end(self) -> bool:
         return self.current >= len(self.source)
 
-    def tokenize(self) -> 'list[TypeInfoToken]':
+    def tokenize(self) -> 'list[Token]':
         while not self.at_end:
             self.start = self.current
             char = self.advance()
@@ -95,18 +95,18 @@ class TypeInfoTokenizer:
             self.current += 1
             if char == closing_quote:
                 break
-        self.add_token(TypeInfoTokenType.NAME)
+        self.add_token(TokenType.NAME)
 
-    def add_token(self, type: TypeInfoTokenType):
+    def add_token(self, type: TokenType):
         value = self.source[self.start:self.current].strip()
-        self.tokens.append(TypeInfoToken(type, value, self.start))
+        self.tokens.append(Token(type, value, self.start))
 
 
 class TypeInfoParser:
 
     def __init__(self, source: str):
         self.source = source
-        self.tokens: 'list[TypeInfoToken]' = []
+        self.tokens: 'list[Token]' = []
         self.current = 0
 
     @property
@@ -121,29 +121,50 @@ class TypeInfoParser:
         return info
 
     def type(self) -> TypeInfo:
-        if not self.check(TypeInfoTokenType.NAME):
+        if not self.check(TokenType.NAME):
             self.error('Type name missing.')
         info = TypeInfo(self.advance().value)
-        if self.match(TypeInfoTokenType.LEFT_SQUARE):
+        if self.match(TokenType.LEFT_SQUARE):
             info.nested = self.params(literal=info.type is Literal)
-        if self.match(TypeInfoTokenType.PIPE):
+        if self.match(TokenType.PIPE):
             nested = [info] + self.union()
             info = TypeInfo('Union', nested=nested)
         return info
 
     def params(self, literal: bool = False) -> 'list[TypeInfo]':
         params = []
-        while not params or self.match(TypeInfoTokenType.COMMA):
-            param = self.type()
+        prev = None
+        while True:
+            token = self.peek()
+            if not token:
+                self.error("Closing ']' missing.")
+            if token.type is TokenType.RIGHT_SQUARE:
+                self.advance()
+                break
+            if token.type is TokenType.COMMA:
+                if not prev or prev.type is TokenType.COMMA:
+                    self.error("Type missing before ','.")
+                self.advance()
+                prev = token
+                continue
+            if token.type is TokenType.NAME:
+                param = self.type()
+            elif token.type is TokenType.LEFT_SQUARE:
+                self.advance()
+                param = TypeInfo()
+                param.nested = self.params()
             if literal:
                 param = self._literal_param(param)
             params.append(param)
-        if not self.match(TypeInfoTokenType.RIGHT_SQUARE):
-            self.error("Closing ']' missing.")
+            prev = token
+        if literal and not params:
+            self.error('Literal cannot be empty.')
         return params
 
     def _literal_param(self, param: TypeInfo) -> TypeInfo:
         try:
+            if param.name is None:
+                raise ValueError
             try:
                 value = literal_eval(param.name)
             except ValueError:
@@ -153,14 +174,13 @@ class TypeInfoParser:
             if not isinstance(value, LITERAL_TYPES):
                 raise ValueError
         except (ValueError, SyntaxError):
-            token = self.tokens[self.current-1]
-            self.error(f"Invalid literal value {param.name!r}.", token)
+            self.error(f"Invalid literal value {str(param)!r}.")
         else:
             return TypeInfo(repr(value), value)
 
     def union(self) -> 'list[TypeInfo]':
         types = []
-        while not types or self.match(TypeInfoTokenType.PIPE):
+        while not types or self.match(TokenType.PIPE):
             info = self.type()
             if info.is_union:
                 types.extend(info.nested)
@@ -168,30 +188,30 @@ class TypeInfoParser:
                 types.append(info)
         return types
 
-    def match(self, *types: TypeInfoTokenType) -> bool:
+    def match(self, *types: TokenType) -> bool:
         for typ in types:
             if self.check(typ):
                 self.advance()
                 return True
         return False
 
-    def check(self, expected: TypeInfoTokenType) -> bool:
+    def check(self, expected: TokenType) -> bool:
         peeked = self.peek()
         return peeked and peeked.type == expected
 
-    def advance(self) -> 'TypeInfoToken|None':
+    def advance(self) -> 'Token|None':
         token = self.peek()
         if token:
             self.current += 1
         return token
 
-    def peek(self) -> 'TypeInfoToken|None':
+    def peek(self) -> 'Token|None':
         try:
             return self.tokens[self.current]
         except IndexError:
             return None
 
-    def error(self, message: str, token: 'TypeInfoToken|None' = None):
+    def error(self, message: str, token: 'Token|None' = None):
         if not token:
             token = self.peek()
         position = f'index {token.position}' if token else 'end'

{robotframework-7.0rc2 → robotframework-7.0.1}/src/robot/running/bodyrunner.py

@@ -68,7 +68,7 @@ class KeywordRunner:
 
     def run(self, data, result, name=None):
         context = self._context
-        runner = context.get_runner(name or data.name)
+        runner = context.get_runner(name or data.name, recommend_on_failure=self._run)
         if context.dry_run:
             return runner.dry_run(data, result, context)
         return runner.run(data, result, context, self._run)

{robotframework-7.0rc2 → robotframework-7.0.1}/src/robot/running/builder/transformers.py

@@ -370,9 +370,9 @@ class ForBuilder(BodyBuilder):
 
     def build(self, node):
         error = format_error(self._get_errors(node))
-        self.model.config(assign=node.assign, flavor=node.flavor, values=node.values,
-                          start=node.start, mode=node.mode, fill=node.fill,
-                          lineno=node.lineno, error=error)
+        self.model.config(assign=node.assign, flavor=node.flavor or 'IN',
+                          values=node.values, start=node.start, mode=node.mode,
+                          fill=node.fill, lineno=node.lineno, error=error)
         for step in node.body:
             self.visit(step)
         return self.model

{robotframework-7.0rc2 → robotframework-7.0.1}/src/robot/running/invalidkeyword.py

@@ -24,6 +24,11 @@ from .keywordimplementation import KeywordImplementation
 
 
 class InvalidKeyword(KeywordImplementation):
+    """Represents an invalid keyword call.
+
+    Keyword may not have been found, there could have been multiple matches,
+    or the keyword call itself could have been invalid.
+    """
     type = KeywordImplementation.INVALID_KEYWORD
 
     def _get_embedded(self, name) -> 'EmbeddedArguments|None':

{robotframework-7.0rc2 → robotframework-7.0.1}/src/robot/running/librarykeyword.py

@@ -100,7 +100,7 @@ class LibraryKeyword(KeywordImplementation):
 
 
 class StaticKeyword(LibraryKeyword):
-    """Represents keywords in static libraries."""
+    """Represents a keyword in a static library."""
     __slots__ = ['method_name']
 
     def __init__(self, method_name: str,
@@ -142,7 +142,7 @@ class StaticKeyword(LibraryKeyword):
 
 
 class DynamicKeyword(LibraryKeyword):
-    """Represents keywords in dynamic libraries."""
+    """Represents a keyword in a dynamic library."""
     owner: 'DynamicLibrary'
     __slots__ = ['run_keyword', '_orig_name', '__source_info']
 
@@ -212,7 +212,7 @@ class DynamicKeyword(LibraryKeyword):
 
 
 class LibraryInit(LibraryKeyword):
-    """Represents library initializer.
+    """Represents a library initializer.
 
     :attr:`positional` and :attr:`named` contain arguments used for initializing
     the library.