robotframework 7.0rc3__zip → 7.0.1__zip

{robotframework-7.0rc3 → 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.0rc3 → 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
@@ -307,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.0rc3 → 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.0rc3 → 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.0rc3 → 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.0rc3 → 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.

{robotframework-7.0rc3 → robotframework-7.0.1}/src/robot/running/model.py

@@ -36,7 +36,7 @@ __ http://robotframework.org/robotframework/latest/RobotFrameworkUserGuide.html#
 
 import warnings
 from pathlib import Path
-from typing import Literal, Mapping, Sequence, TYPE_CHECKING, TypeVar, Union
+from typing import Any, Literal, Mapping, Sequence, TYPE_CHECKING, TypeVar, Union
 
 from robot import model
 from robot.conf import RobotSettings
@@ -80,6 +80,35 @@ class WithSource:
         return self.parent.source if self.parent is not None else None
 
 
+class Argument:
+    """A temporary API for creating named arguments with non-string values.
+
+    This class was added in RF 7.0.1 (#5031) after a failed attempt to add a public
+    API for this purpose in RF 7.0 (#5000). A better public API is planned for RF 7.1
+    (#5143).
+
+    If you need to support also RF 7.0, you can pass named arguments as two-item tuples
+    like `(name, value)` and positional arguments as one-item tuples like `(value,)`.
+    That approach does not work anymore in RF 7.0.1, though, so the code needs to be
+    conditional depending on Robot Framework version.
+
+    The main limitation of this class is that it is not compatible with the JSON model.
+    The current plan is to remove this in the future, possibly already in RF 8.0, but
+    we can consider preserving it if it turns out to be useful.
+    """
+
+    def __init__(self, name: 'str|None', value: Any):
+        """
+        :param name: Argument name. If ``None``, argument is considered positional.
+        :param value: Argument value.
+        """
+        self.name = name
+        self.value = value
+
+    def __str__(self):
+        return str(self.value) if self.name is None else f'{self.name}={self.value}'
+
+
 @Body.register
 class Keyword(model.Keyword, WithSource):
     """Represents an executable keyword call.
@@ -97,27 +126,11 @@ class Keyword(model.Keyword, WithSource):
     strings in the exact same format as in the data. This means that arguments can
     have variables and escape characters, and that named arguments are specified
     using the ``name=value`` syntax.
-
-    If arguments are set programmatically, it is possible to use also other types
-    than strings. To support non-string values with named arguments, it is possible
-    to use two-item tuples like ``('name', 'value')``. To avoid ambiguity if an
-    argument contains a literal ``=`` character, positional arguments can also be
-    given using one-item tuples like ``('value',)``. In all these cases strings
-    can contain variables, and they must follow the escaping rules used in normal
-    data.
-
-    Arguments can also be given directly as a tuple containing list of positional
-    arguments and a dictionary of named arguments. In this case arguments are
-    used as-is without replacing variables or handling escapes. Argument conversion
-    and validation is done even in this case, though.
-
-    Support for specifying arguments using tuples and giving them directly as
-    positional and named arguments are new in Robot Framework 7.0.
     """
     __slots__ = ['lineno']
 
     def __init__(self, name: str = '',
-                 args: model.Arguments = (),
+                 args: 'Sequence[str|Argument|Any]' = (),
                  assign: Sequence[str] = (),
                  type: str = BodyItem.KEYWORD,
                  parent: BodyItemParent = None,
@@ -125,15 +138,6 @@ class Keyword(model.Keyword, WithSource):
         super().__init__(name, args, assign, type, parent)
         self.lineno = lineno
 
-    @classmethod
-    def from_json(cls, source) -> 'Keyword':
-        kw = super().from_json(source)
-        # Argument tuples have a special meaning during execution.
-        # Tuples are represented as lists in JSON, so we need to convert them.
-        kw.args = tuple([tuple(a) if isinstance(a, list) else a
-                         for a in kw.args])
-        return kw
-
     def to_dict(self) -> DataDict:
         data = super().to_dict()
         if self.lineno:
@@ -663,7 +667,7 @@ class TestSuite(model.TestSuite[Keyword, TestCase]):
 
         Example::
 
-            suite.configure(included_tags=['smoke'],
+            suite.configure(include_tags=['smoke'],
                             doc='Smoke test results.')
 
         Not to be confused with :meth:`config` method that suites, tests,

{robotframework-7.0rc3 → robotframework-7.0.1}/src/robot/running/namespace.py

@@ -215,6 +215,10 @@ class Namespace:
         return library
 
     def get_runner(self, name, recommend_on_failure=True):
+        # TODO: Consider changing the default value of `recommend_on_failure` to False.
+        # Recommendations are not needed in all contexts and collecting them has a
+        # performance effect that has caused issues #4659 and #5051. It is possible to
+        # opt-out from collecting recommendations, but making it opt-in could be safer.
         try:
             return self._kw_store.get_runner(name, recommend_on_failure)
         except DataError as err:

{robotframework-7.0rc3 → robotframework-7.0.1}/src/robot/running/resourcemodel.py

@@ -155,7 +155,7 @@ class ResourceFile(ModelObject):
 
 
 class UserKeyword(KeywordImplementation):
-    """Represents user keywords."""
+    """Represents a user keyword."""
     type = KeywordImplementation.USER_KEYWORD
     fixture_class = Keyword
     __slots__ = ['timeout', '_setup', '_teardown']

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

@@ -21,10 +21,14 @@ from robot.errors import TimeoutError, DataError, FrameworkError
 if WINDOWS:
     from .windows import Timeout
 else:
-    from .posix import Timeout
+    try:
+        from .posix import Timeout
+    except ImportError:
+        from .nosupport import Timeout
 
 
 class _Timeout(Sortable):
+    type: str
 
     def __init__(self, timeout=None, variables=None):
         self.string = timeout or ''
@@ -113,7 +117,7 @@ class TestTimeout(_Timeout):
     def __init__(self, timeout=None, variables=None, rpa=False):
         if rpa:
             self.type = 'Task'
-        _Timeout.__init__(self, timeout, variables)
+        super().__init__(timeout, variables)
 
     def set_keyword_timeout(self, timeout_occurred):
         if timeout_occurred:

robotframework-7.0.1/src/robot/running/timeouts/nosupport.py

@@ -0,0 +1,25 @@
+#  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
+
+
+class Timeout:
+
+    def __init__(self, timeout, error):
+        pass
+
+    def execute(self, runnable):
+        raise DataError('Timeouts are not supported on this platform.')

{robotframework-7.0rc3 → robotframework-7.0.1}/src/robot/running/userkeywordrunner.py

@@ -134,6 +134,8 @@ class UserKeywordRunner:
         args = [f'${{{arg}}}' for arg in spec.positional]
         if spec.var_positional:
             args.append(f'@{{{spec.var_positional}}}')
+        if spec.named_only:
+            args.extend(f'${{{arg}}}' for arg in spec.named_only)
         if spec.var_named:
             args.append(f'&{{{spec.var_named}}}')
         return args

{robotframework-7.0rc3 → robotframework-7.0.1}/src/robot/utils/__init__.py

@@ -54,7 +54,7 @@ from .match import eq, Matcher, MultiMatcher
 from .misc import (classproperty, isatty, parse_re_flags, plural_or_not,
                    printable_name, seq2str, seq2str2, test_or_task)
 from .normalizing import normalize, normalize_whitespace, NormalizedDict
-from .notset import NOT_SET
+from .notset import NOT_SET, NotSet
 from .platform import PY_VERSION, PYPY, UNIXY, WINDOWS, RERAISED_EXCEPTIONS
 from .recommendations import RecommendationFinder
 from .robotenv import get_env_var, set_env_var, del_env_var, get_env_vars

{robotframework-7.0rc3 → robotframework-7.0.1}/src/robot/utils/notset.py

@@ -19,8 +19,8 @@ class NotSet:
     Can be used instead of the standard ``None`` in cases where ``None``
     itself is a valid value.
 
-    Use the constant ``robot.utils.NOT_SET`` instead of creating new instances
-    of the class.
+    ``robot.utils.NOT_SET`` is an instance of this class, but it in same cases
+    it is better to create a separate instance.
 
     New in Robot Framework 7.0.
     """
@@ -30,4 +30,3 @@ class NotSet:
 
 
 NOT_SET = NotSet()
-

{robotframework-7.0rc3 → robotframework-7.0.1}/src/robot/version.py

@@ -18,7 +18,7 @@ import sys
 
 # Version number typically updated by running `invoke set-version <version>`.
 # Run `invoke --help set-version` or see tasks.py for details.
-VERSION = '7.0rc3'
+VERSION = '7.0.1'
 
 
 def get_version(naked=False):

{robotframework-7.0rc3 → robotframework-7.0.1/src/robotframework.egg-info}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: robotframework
-Version: 7.0rc3
+Version: 7.0.1
 Summary: Generic automation framework for acceptance testing and robotic process automation (RPA)
 Home-page: https://robotframework.org
 Author: Pekka Klärck
@@ -10,7 +10,7 @@ Download-URL: https://pypi.org/project/robotframework
 Project-URL: Source, https://github.com/robotframework/robotframework
 Project-URL: Issue Tracker, https://github.com/robotframework/robotframework/issues
 Project-URL: Documentation, https://robotframework.org/robotframework
-Project-URL: Release Notes, https://github.com/robotframework/robotframework/blob/master/doc/releasenotes/rf-7.0rc3.rst
+Project-URL: Release Notes, https://github.com/robotframework/robotframework/blob/master/doc/releasenotes/rf-7.0.1.rst
 Project-URL: Slack, http://slack.robotframework.org
 Description: Robot Framework
         ===============
@@ -63,10 +63,12 @@ Description: Robot Framework
         For more detailed installation instructions, including installing Python, see
         `INSTALL.rst <https://github.com/robotframework/robotframework/blob/master/INSTALL.rst>`__.
         
-        Robot Framework requires Python 3.6 or newer and runs also on `PyPy <http://pypy.org>`_.
+        Robot Framework requires Python 3.8 or newer and runs also on `PyPy <http://pypy.org>`_.
+        The latest version that supports Python 3.6 and 3.7 is `Robot Framework 6.1.1`__.
         If you need to use Python 2, `Jython <http://jython.org>`_ or
         `IronPython <http://ironpython.net>`_, you can use `Robot Framework 4.1.3`__.
         
+        __ https://github.com/robotframework/robotframework/tree/v6.1.1#readme
         __ https://github.com/robotframework/robotframework/tree/v4.1.3#readme
         
         Example

{robotframework-7.0rc3 → robotframework-7.0.1}/src/robotframework.egg-info/SOURCES.txt

@@ -218,6 +218,7 @@ src/robot/running/builder/parsers.py
 src/robot/running/builder/settings.py
 src/robot/running/builder/transformers.py
 src/robot/running/timeouts/__init__.py
+src/robot/running/timeouts/nosupport.py
 src/robot/running/timeouts/posix.py
 src/robot/running/timeouts/windows.py
 src/robot/utils/__init__.py