robotframework 7.4rc1__tar.gz → 7.4.1__tar.gz

{robotframework-7.4rc1 → robotframework-7.4.1}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: robotframework
-Version: 7.4rc1
+Version: 7.4.1
 Summary: Generic automation framework for acceptance testing and robotic process automation (RPA)
 Home-page: https://robotframework.org
 Download-URL: https://pypi.org/project/robotframework
@@ -10,7 +10,7 @@ License: Apache License 2.0
 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.4rc1.rst
+Project-URL: Release Notes, https://github.com/robotframework/robotframework/blob/master/doc/releasenotes/rf-7.4.1.rst
 Project-URL: Slack, http://slack.robotframework.org
 Keywords: robotframework automation testautomation rpa testing acceptancetesting atdd bdd
 Platform: any

{robotframework-7.4rc1 → robotframework-7.4.1}/setup.py

@@ -6,7 +6,7 @@ from setuptools import find_packages, setup
 
 # Version number typically updated by running `invoke set-version <version>`.
 # Run `invoke --help set-version` or see tasks.py for details.
-VERSION = "7.4rc1"
+VERSION = "7.4.1"
 with open(join(dirname(abspath(__file__)), "README.rst")) as f:
     LONG_DESCRIPTION = f.read()
     base_url = "https://github.com/robotframework/robotframework/blob/master"

{robotframework-7.4rc1 → robotframework-7.4.1}/src/robot/api/types.py

@@ -13,11 +13,24 @@
 #  See the License for the specific language governing permissions and
 #  limitations under the License.
 
-"""Types for libraries and other extensions.
+"""Types that libraries and other extensions can utilize.
 
-Currently only exposes the :class:`~robot.utils.secret.Secret` type.
+- The :class:`~robot.utils.secret.Secret` class is used for encapsulating
+  passwords, tokens and other such secret information.
+
+- :class:`KeywordName` and :class:`KeywordArguments` are used in type hints
+  with keywords executing other keywords. External tools can recognize special
+  arguments using these types and handle them adequately.
 
 New in Robot Framework 7.4.
 """
 
 from robot.utils.secret import Secret as Secret
+
+
+class KeywordName(str):
+    """Name of a keyword executed by another keyword."""
+
+
+class KeywordArgument:
+    """Argument of a keyword executed by another keyword."""

{robotframework-7.4rc1 → robotframework-7.4.1}/src/robot/libraries/BuiltIn.py

@@ -21,6 +21,8 @@ from datetime import datetime, timedelta
 from typing import Any, Callable, Iterator, Literal, NoReturn
 
 from robot.api import logger, SkipExecution
+from robot.api.deco import library
+from robot.api.types import KeywordArgument, KeywordName
 from robot.errors import (
     BreakLoop, ContinueLoop, DataError, ExecutionFailed, ExecutionFailures,
     ExecutionPassed, PassExecution, ReturnFromKeyword, VariableError
@@ -43,14 +45,49 @@ from robot.version import get_version
 
 from .normalizer import Normalizer, StripSpaces
 
-# Type aliases representing names and arguments of keywords executed dynamically
-# by `Run Keyword` and other similar keywords. We may want to replace these with
-# concrete types in the future.
-KeywordName = str
-KeywordArgument = object
-# Type alias for expressions that are evaluated in Python. We may want to replace
-# this with a concrete type with custom type documentation later.
-Expression = object
+
+class Expression:
+    """An expression evaluated in Python.
+
+    Expressions are evaluated using Python's
+    [http://docs.python.org/library/functions.html#eval|eval] function so
+    that all Python built-ins like ``len()`` and ``int()`` are available.
+    In addition to that, all unrecognized variables are considered to be
+    modules that are automatically imported. It is possible to use all
+    available Python modules, including the standard modules and the installed
+    third party modules.
+
+    Examples:
+    | `Should Be True`    len('${result}') > 3
+    | `Run Keyword If`    os.sep == '/'    Non-Windows Keyword
+    | ${version} =      `Evaluate`    robot.__version__
+
+    When a variable is used in the expressing using the normal ``${variable}``
+    syntax, its value is replaced before the expression is evaluated. This
+    means that the value used in the expression will be the string
+    representation of the variable value, not the variable value itself.
+    This is not a problem with numbers and other objects that have a string
+    representation that can be evaluated directly, but with other objects
+    the behavior depends on the string representation. Most importantly,
+    strings must always be quoted, and if they can contain newlines, they must
+    be triple quoted.
+
+    Examples:
+    | `Should Be True`    ${rc} < 10                   Return code greater than 10
+    | `Run Keyword If`    '${status}' == 'PASS'        `Log`    Passed
+    | `Run Keyword If`    'FAIL' in '''${output}'''    `Log`    Output contains FAIL
+
+    Actual variables values are also available in the evaluation namespace.
+    They can be accessed using special variable syntax without the curly
+    braces like ``$variable``. These variables should never be quoted.
+
+    Examples:
+    | `Should Be True`    $rc < 10             Return code greater than 10
+    | `Run Keyword If`    $status == 'PASS'    `Log`    Passed
+    | `Run Keyword If`    'FAIL' in $output    `Log`    Output contains FAIL
+    | `Should Be True`    len($result) > 1 and $result[1] == 'OK'
+    | `Should Be True`    $result is not None
+    """
 
 
 def run_keyword_variant(resolve, dry_run=False):
@@ -657,8 +694,9 @@ class _Verify(_BuiltInBase):
         formatter: Literal["str", "repr", "ascii"] = "str",
         strip_spaces: StripSpaces = False,
         collapse_spaces: bool = False,
-        type: "type | str | Literal['AUTO'] | Any | None" = None,
-        types: "type | str | Any | None" = None,
+        type: "Literal['AUTO'] | Any | None" = None,
+        types: "Any | None" = None,
+        # TODO: 'Any' -> 'TypeForm' with 'type' and 'types' once PEP 747 lands.
     ):
         r"""Fails if the given objects are unequal.
 
@@ -1777,7 +1815,7 @@ class _Variables(_BuiltInBase):
         return self._variables.as_dict(decoration=not no_decoration)
 
     @run_keyword_variant(resolve=0)
-    def get_variable_value(self, name: str, default: object = None, /) -> object:
+    def get_variable_value(self, name: str, default: object = None) -> object:
         r"""Returns variable value or ``default`` if the variable does not exist.
 
         The name of the variable can be given either as a normal variable name
@@ -1828,7 +1866,7 @@ class _Variables(_BuiltInBase):
         return name, value
 
     @run_keyword_variant(resolve=0)
-    def variable_should_exist(self, name: str, message: "str | None" = None, /):
+    def variable_should_exist(self, name: str, message: "str | None" = None):
         r"""Fails unless the given variable exists within the current scope.
 
         The name of the variable can be given either as a normal variable name
@@ -1853,7 +1891,7 @@ class _Variables(_BuiltInBase):
             )
 
     @run_keyword_variant(resolve=0)
-    def variable_should_not_exist(self, name: str, message: "str | None" = None, /):
+    def variable_should_not_exist(self, name: str, message: "str | None" = None):
         r"""Fails if the given variable exists within the current scope.
 
         The name of the variable can be given either as a normal variable name
@@ -3352,7 +3390,7 @@ class _Control(_BuiltInBase):
         raise PassExecution(message)
 
     @run_keyword_variant(resolve=1)
-    def pass_execution_if(self, condition: Expression, message: str, /, *tags: str):
+    def pass_execution_if(self, condition: Expression, message: str, *tags: str):
         """Conditionally skips rest of the current test, setup, or teardown with PASS status.
 
         A wrapper for `Pass Execution` to skip rest of the current test,
@@ -3642,7 +3680,7 @@ class _Misc(_BuiltInBase):
         logger.info(f"Reloaded library {lib.name} with {len(lib.keywords)} keywords.")
 
     @run_keyword_variant(resolve=0)
-    def import_library(self, name: str, /, *args: object):
+    def import_library(self, name: str, *args: object):
         """Imports a library with the given name and optional arguments.
 
         This functionality allows dynamic importing of libraries while tests
@@ -3678,7 +3716,7 @@ class _Misc(_BuiltInBase):
         return args, None
 
     @run_keyword_variant(resolve=0)
-    def import_variables(self, path: str, /, *args: object):
+    def import_variables(self, path: str, *args: object):
         """Imports a variable file with the given path and optional arguments.
 
         Variables imported with this keyword are set into the test suite scope
@@ -3703,7 +3741,7 @@ class _Misc(_BuiltInBase):
             raise RuntimeError(str(err))
 
     @run_keyword_variant(resolve=0)
-    def import_resource(self, path: str, /):
+    def import_resource(self, path: str):
         """Imports a resource file with the given path.
 
         Resources imported with this keyword are set into the test suite scope
@@ -4248,6 +4286,14 @@ class _Misc(_BuiltInBase):
             raise RuntimeError(str(err))
 
 
+@library(
+    converters={
+        KeywordName: lambda value: str(value),
+        KeywordArgument: lambda value: value,
+        Expression: lambda value: value,
+    },
+    auto_keywords=True,
+)
 class BuiltIn(_Verify, _Converter, _Variables, _RunKeyword, _Control, _Misc):
     r"""An always available standard library with often needed keywords.
 
@@ -4397,7 +4443,7 @@ class BuiltIn(_Verify, _Converter, _Variables, _RunKeyword, _Control, _Misc):
     Examples:
     | `Should Be True`    len('${result}') > 3
     | `Run Keyword If`    os.sep == '/'    Non-Windows Keyword
-    | ${version} =    `Evaluate`    robot.__version__
+    | ${version} =      `Evaluate`    robot.__version__
 
     `Evaluate` also allows configuring the execution namespace with a custom
     namespace and with custom modules to be imported. The latter functionality
@@ -4420,8 +4466,8 @@ class BuiltIn(_Verify, _Converter, _Variables, _RunKeyword, _Control, _Misc):
 
     Examples:
     | `Should Be True`    ${rc} < 10                   Return code greater than 10
-    | `Run Keyword If`    '${status}' == 'PASS'        Log    Passed
-    | `Run Keyword If`    'FAIL' in '''${output}'''    Log    Output contains FAIL
+    | `Run Keyword If`    '${status}' == 'PASS'        `Log`    Passed
+    | `Run Keyword If`    'FAIL' in '''${output}'''    `Log`    Output contains FAIL
 
     Actual variables values are also available in the evaluation namespace.
     They can be accessed using special variable syntax without the curly