robotframework 7.0rc2__zip → 7.0.1__zip

{robotframework-7.0rc2 → 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.0rc2 → 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.0rc2 → 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.0rc2 → 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.0rc2 → 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.0rc2 → 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.0rc2 → robotframework-7.0.1}/src/robot/utils/misc.py

@@ -15,7 +15,6 @@
 
 import re
 
-from .robottypes import is_integer
 from .unic import safe_str
 
 
@@ -71,7 +70,7 @@ def _is_camel_case_boundary(prev, char, next):
 
 
 def plural_or_not(item):
-    count = item if is_integer(item) else len(item)
+    count = item if isinstance(item, int) else len(item)
     return '' if count in (1, -1) else 's'
 
 

{robotframework-7.0rc2 → 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.0rc2 → 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.0rc2'
+VERSION = '7.0.1'
 
 
 def get_version(naked=False):

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: robotframework
-Version: 7.0rc2
+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.0rc2.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.0rc2 → 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