robotframework 7.3rc1__tar.gz → 7.3rc2__tar.gz

robotframework-7.3rc2/PKG-INFO

@@ -0,0 +1,190 @@
+Metadata-Version: 2.1
+Name: robotframework
+Version: 7.3rc2
+Summary: Generic automation framework for acceptance testing and robotic process automation (RPA)
+Home-page: https://robotframework.org
+Download-URL: https://pypi.org/project/robotframework
+Author: Pekka Klärck
+Author-email: peke@eliga.fi
+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.3rc2.rst
+Project-URL: Slack, http://slack.robotframework.org
+Keywords: robotframework automation testautomation rpa testing acceptancetesting atdd bdd
+Platform: any
+Classifier: Development Status :: 5 - Production/Stable
+Classifier: License :: OSI Approved :: Apache Software License
+Classifier: Operating System :: OS Independent
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3 :: Only
+Classifier: Programming Language :: Python :: 3.8
+Classifier: Programming Language :: Python :: 3.9
+Classifier: Programming Language :: Python :: 3.10
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
+Classifier: Programming Language :: Python :: 3.13
+Classifier: Programming Language :: Python :: 3.14
+Classifier: Programming Language :: Python :: Implementation :: CPython
+Classifier: Programming Language :: Python :: Implementation :: PyPy
+Classifier: Topic :: Software Development :: Testing
+Classifier: Topic :: Software Development :: Testing :: Acceptance
+Classifier: Topic :: Software Development :: Testing :: BDD
+Classifier: Framework :: Robot Framework
+Requires-Python: >=3.8
+Description-Content-Type: text/x-rst
+License-File: LICENSE.txt
+License-File: AUTHORS.rst
+
+Robot Framework
+===============
+
+.. contents::
+   :local:
+
+Introduction
+------------
+
+`Robot Framework <http://robotframework.org>`_ |r| is a generic open source
+automation framework for acceptance testing, acceptance test driven
+development (ATDD), and robotic process automation (RPA). It has simple plain
+text syntax and it can be extended easily with generic and custom libraries.
+
+Robot Framework is operating system and application independent. It is
+implemented using `Python <http://python.org>`_ which is also the primary
+language to extend it. The framework has a rich ecosystem around it consisting
+of various generic libraries and tools that are developed as separate projects.
+For more information about Robot Framework and the ecosystem, see
+http://robotframework.org.
+
+Robot Framework project is hosted on GitHub_ where you can find source code,
+an issue tracker, and some further documentation. Downloads are hosted on PyPI_.
+
+Robot Framework development is sponsored by non-profit `Robot Framework Foundation
+<http://robotframework.org/foundation>`_. If you are using the framework
+and benefiting from it, consider joining the foundation to help maintaining
+the framework and developing it further.
+
+.. _GitHub: https://github.com/robotframework/robotframework
+.. _PyPI: https://pypi.python.org/pypi/robotframework
+
+.. image:: https://img.shields.io/pypi/v/robotframework.svg?label=version
+   :target: https://pypi.python.org/pypi/robotframework
+   :alt: Latest version
+
+.. image:: https://img.shields.io/pypi/l/robotframework.svg
+   :target: http://www.apache.org/licenses/LICENSE-2.0.html
+   :alt: License
+
+Installation
+------------
+
+If you already have Python_ with `pip <https://pip.pypa.io>`_ installed,
+you can simply run::
+
+    pip install robotframework
+
+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.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
+-------
+
+Below is a simple example test case for testing login to some system.
+You can find more examples with links to related demo projects from
+http://robotframework.org.
+
+.. code:: robotframework
+
+    *** Settings ***
+    Documentation     A test suite with a single test for valid login.
+    ...
+    ...               This test has a workflow that is created using keywords in
+    ...               the imported resource file.
+    Resource          login.resource
+
+    *** Test Cases ***
+    Valid Login
+        Open Browser To Login Page
+        Input Username    demo
+        Input Password    mode
+        Submit Credentials
+        Welcome Page Should Be Open
+        [Teardown]    Close Browser
+
+Usage
+-----
+
+Tests (or tasks) are executed from the command line using the ``robot``
+command or by executing the ``robot`` module directly like ``python -m robot`` .
+
+The basic usage is giving a path to a test (or task) file or directory as an
+argument with possible command line options before the path::
+
+    robot tests.robot
+    robot --variable BROWSER:Firefox --outputdir results path/to/tests/
+
+Additionally, there is the ``rebot`` tool for combining results and otherwise
+post-processing outputs::
+
+    rebot --name Example output1.xml output2.xml
+
+Run ``robot --help`` and ``rebot --help`` for more information about the command
+line usage. For a complete reference manual see `Robot Framework User Guide`_.
+
+Documentation
+-------------
+
+- `Robot Framework User Guide
+  <http://robotframework.org/robotframework/#user-guide>`_
+- `Standard libraries
+  <http://robotframework.org/robotframework/#standard-libraries>`_
+- `API documentation <http://robot-framework.readthedocs.org>`_
+- `General documentation <http://robotframework.org/>`_
+
+Support and Contact
+-------------------
+
+- `Slack <http://slack.robotframework.org/>`_
+- `Forum <https://forum.robotframework.org/>`_
+- `robotframework-users
+  <https://groups.google.com/group/robotframework-users/>`_ mailing list
+
+Contributing
+------------
+
+Interested to contribute to Robot Framework? Great! In that case it is a good
+start by looking at the `CONTRIBUTING.rst <https://github.com/robotframework/robotframework/blob/master/CONTRIBUTING.rst>`__. If you
+do not already have an issue you would like to work on, you can check
+issues with `good new issue`__ and `help wanted`__ labels.
+
+Remember also that there are many other tools and libraries in the wider
+`Robot Framework ecosystem <http://robotframework.org>`_ that you can
+contribute to!
+
+__ https://github.com/robotframework/robotframework/issues?q=is%3Aissue+is%3Aopen+label%3A%22good+first+issue%22
+__ https://github.com/robotframework/robotframework/issues?q=is%3Aissue+is%3Aopen+label%3A%22help+wanted%22
+
+License and Trademark
+---------------------
+
+Robot Framework is open source software provided under the `Apache License 2.0`__.
+Robot Framework documentation and other similar content use the
+`Creative Commons Attribution 3.0 Unported`__ license. Most libraries and tools
+in the ecosystem are also open source, but they may use different licenses.
+
+Robot Framework trademark is owned by `Robot Framework Foundation`_.
+
+__ http://apache.org/licenses/LICENSE-2.0
+__ http://creativecommons.org/licenses/by/3.0
+
+.. |r| unicode:: U+00AE

robotframework-7.3rc2/pyproject.toml

@@ -0,0 +1,39 @@
+[project]
+requires-python = ">=3.8"
+
+[tool.black]
+line_length = 88
+extend-exclude = "atest/result/"
+
+[tool.ruff]
+extend-exclude = ["atest/result/"]
+
+[tool.ruff.format]
+quote-style = "double"
+
+[tool.ruff.lint]
+extend-select = ["I"]  # imports
+ignore = ["E731"]  # lambda assignment
+
+[tool.ruff.lint.pyflakes]
+# Needed due to https://github.com/astral-sh/ruff/issues/9298
+extend-generics = ["robot.model.body.BaseBranches"]
+
+[tool.ruff.lint.isort]
+# Ruff is used to sort and fix imports first. Multiline imports are organized so
+# that each item is on its own line. This is same as the Vertical Hanging Indent
+# mode with isort.
+combine-as-imports = true
+order-by-type = false
+
+[tool.isort]
+# isort is used after Ruff to sort "normal" imports so that multiline imports use
+# the Hanging Grid Grouped mode. Files contained redundant import aliases denoting
+# module/package API are excluded. For details about multiline modes see:
+# https://pycqa.github.io/isort/docs/configuration/multi_line_output_modes.html
+multi_line_output = 5
+extend_skip = ["__init__.py", "src/robot/api/parsing.py"]
+skip_glob = ["atest/result/*"]
+combine_as_imports = true
+order_by_type = false
+line_length = 88

{robotframework-7.3rc1 → robotframework-7.3rc2}/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.3rc1"
+VERSION = "7.3rc2"
 with open(join(dirname(abspath(__file__)), "README.rst")) as f:
     LONG_DESCRIPTION = f.read()
     base_url = "https://github.com/robotframework/robotframework/blob/master"
@@ -28,6 +28,7 @@ Programming Language :: Python :: 3.10
 Programming Language :: Python :: 3.11
 Programming Language :: Python :: 3.12
 Programming Language :: Python :: 3.13
+Programming Language :: Python :: 3.14
 Programming Language :: Python :: Implementation :: CPython
 Programming Language :: Python :: Implementation :: PyPy
 Topic :: Software Development :: Testing

{robotframework-7.3rc1 → robotframework-7.3rc2}/src/robot/libraries/BuiltIn.py

@@ -4382,7 +4382,10 @@ def register_run_keyword(library, keyword, args_to_process=0, deprecation_warnin
     - Their arguments are not resolved normally (use ``args_to_process``
       to control that). This basically means not replacing variables or
       handling escapes.
-    - They are not stopped by timeouts.
+    - They are not stopped by timeouts. Prior to Robot Framework 7.3, timeouts
+      occurring when these keywords were executing other keywords could corrupt
+      output files. That bug has been fixed, so this use case why to register
+      keywords as run keyword variants is not relevant anymore.
     - If there are conflicts with keyword names, these keywords have
       *lower* precedence than other keywords.
 

{robotframework-7.3rc1 → robotframework-7.3rc2}/src/robot/model/itemlist.py

@@ -18,9 +18,9 @@ from typing import (
     Any, Iterable, Iterator, MutableSequence, overload, Type, TYPE_CHECKING, TypeVar
 )
 
-from robot.utils import copy_signature, KnownAtRuntime, type_name
+from robot.utils import copy_signature, KnownAtRuntime
 
-from .modelobject import DataDict
+from .modelobject import DataDict, full_name, ModelObject
 
 if TYPE_CHECKING:
     from .visitor import SuiteVisitor
@@ -77,14 +77,18 @@ class ItemList(MutableSequence[T]):
                 item = self._item_from_dict(item)
             else:
                 raise TypeError(
-                    f"Only {type_name(self._item_class)} objects "
-                    f"accepted, got {type_name(item)}."
+                    f"Only '{self._type_name(self._item_class)}' objects accepted, "
+                    f"got '{self._type_name(item)}'."
                 )
         if self._common_attrs:
             for attr, value in self._common_attrs.items():
                 setattr(item, attr, value)
         return item
 
+    def _type_name(self, item: "type|object") -> str:
+        typ = item if isinstance(item, type) else type(item)
+        return full_name(typ) if issubclass(typ, ModelObject) else typ.__name__
+
     def _item_from_dict(self, data: DataDict) -> T:
         if hasattr(self._item_class, "from_dict"):
             return self._item_class.from_dict(data)  # type: ignore
@@ -193,21 +197,21 @@ class ItemList(MutableSequence[T]):
 
     def __lt__(self, other: "ItemList[T]") -> bool:
         if not isinstance(other, ItemList):
-            raise TypeError(f"Cannot order ItemList and {type_name(other)}.")
+            raise TypeError(f"Cannot order 'ItemList' and '{self._type_name(other)}'.")
         if not self._is_compatible(other):
-            raise TypeError("Cannot order incompatible ItemLists.")
+            raise TypeError("Cannot order incompatible 'ItemList' objects.")
         return self._items < other._items
 
     def __add__(self: Self, other: "ItemList[T]") -> Self:
         if not isinstance(other, ItemList):
-            raise TypeError(f"Cannot add ItemList and {type_name(other)}.")
+            raise TypeError(f"Cannot add 'ItemList' and '{self._type_name(other)}'.")
         if not self._is_compatible(other):
-            raise TypeError("Cannot add incompatible ItemLists.")
+            raise TypeError("Cannot add incompatible 'ItemList' objects.")
         return self._create_new_from(self._items + other._items)
 
     def __iadd__(self: Self, other: Iterable[T]) -> Self:
         if isinstance(other, ItemList) and not self._is_compatible(other):
-            raise TypeError("Cannot add incompatible ItemLists.")
+            raise TypeError("Cannot add incompatible 'ItemList' objects.")
         self.extend(other)
         return self
 

{robotframework-7.3rc1 → robotframework-7.3rc2}/src/robot/model/modelobject.py

@@ -241,7 +241,7 @@ class ModelObject(metaclass=SetterAwareType):
 
 
 def full_name(obj_or_cls):
-    cls = type(obj_or_cls) if not isinstance(obj_or_cls, type) else obj_or_cls
+    cls = obj_or_cls if isinstance(obj_or_cls, type) else type(obj_or_cls)
     parts = [*cls.__module__.split("."), cls.__name__]
     if len(parts) > 1 and parts[0] == "robot":
         parts[2:-1] = []

{robotframework-7.3rc1 → robotframework-7.3rc2}/src/robot/output/listeners.py

@@ -174,15 +174,34 @@ class ListenerV3Facade(ListenerFacade):
         # Fallbacks for body items
         start_body_item = get("start_body_item")
         end_body_item = get("end_body_item")
+        # Fallbacks for keywords
+        start_keyword = get("start_keyword", start_body_item)
+        end_keyword = get("end_keyword", end_body_item)
         # Keywords
-        self.start_keyword = get("start_keyword", start_body_item)
-        self.end_keyword = get("end_keyword", end_body_item)
-        self._start_user_keyword = get("start_user_keyword")
-        self._end_user_keyword = get("end_user_keyword")
-        self._start_library_keyword = get("start_library_keyword")
-        self._end_library_keyword = get("end_library_keyword")
-        self._start_invalid_keyword = get("start_invalid_keyword")
-        self._end_invalid_keyword = get("end_invalid_keyword")
+        self.start_user_keyword = get(
+            "start_user_keyword",
+            lambda data, implementation, result: start_keyword(data, result),
+        )
+        self.end_user_keyword = get(
+            "end_user_keyword",
+            lambda data, implementation, result: end_keyword(data, result),
+        )
+        self.start_library_keyword = get(
+            "start_library_keyword",
+            lambda data, implementation, result: start_keyword(data, result),
+        )
+        self.end_library_keyword = get(
+            "end_library_keyword",
+            lambda data, implementation, result: end_keyword(data, result),
+        )
+        self.start_invalid_keyword = get(
+            "start_invalid_keyword",
+            lambda data, implementation, result: start_keyword(data, result),
+        )
+        self.end_invalid_keyword = get(
+            "end_invalid_keyword",
+            lambda data, implementation, result: end_keyword(data, result),
+        )
         # IF
         self.start_if = get("start_if", start_body_item)
         self.end_if = get("end_if", end_body_item)
@@ -237,42 +256,6 @@ class ListenerV3Facade(ListenerFacade):
         # Close
         self.close = get("close")
 
-    def start_user_keyword(self, data, implementation, result):
-        if self._start_user_keyword:
-            self._start_user_keyword(data, implementation, result)
-        else:
-            self.start_keyword(data, result)
-
-    def end_user_keyword(self, data, implementation, result):
-        if self._end_user_keyword:
-            self._end_user_keyword(data, implementation, result)
-        else:
-            self.end_keyword(data, result)
-
-    def start_library_keyword(self, data, implementation, result):
-        if self._start_library_keyword:
-            self._start_library_keyword(data, implementation, result)
-        else:
-            self.start_keyword(data, result)
-
-    def end_library_keyword(self, data, implementation, result):
-        if self._end_library_keyword:
-            self._end_library_keyword(data, implementation, result)
-        else:
-            self.end_keyword(data, result)
-
-    def start_invalid_keyword(self, data, implementation, result):
-        if self._start_invalid_keyword:
-            self._start_invalid_keyword(data, implementation, result)
-        else:
-            self.start_keyword(data, result)
-
-    def end_invalid_keyword(self, data, implementation, result):
-        if self._end_invalid_keyword:
-            self._end_invalid_keyword(data, implementation, result)
-        else:
-            self.end_keyword(data, result)
-
     def log_message(self, message):
         if self._is_logged(message):
             self._log_message(message)

{robotframework-7.3rc1 → robotframework-7.3rc2}/src/robot/parsing/model/statements.py

@@ -1077,14 +1077,7 @@ class KeywordCall(Statement):
         return self.get_values(Token.ASSIGN)
 
     def validate(self, ctx: "ValidationContext"):
-        assignment = VariableAssignment(self.assign)
-        if assignment.error:
-            self.errors += (assignment.error.message,)
-        for variable in assignment:
-            try:
-                TypeInfo.from_variable(variable)
-            except DataError as err:
-                self.errors += (str(err),)
+        AssignmentValidator().validate(self)
 
 
 @Statement.register
@@ -1182,20 +1175,23 @@ class ForHeader(Statement):
 
     def validate(self, ctx: "ValidationContext"):
         if not self.assign:
-            self._add_error("no loop variables")
+            self.errors += ("FOR loop has no variables.",)
         if not self.flavor:
-            self._add_error("no 'IN' or other valid separator")
+            self.errors += ("FOR loop has no 'IN' or other valid separator.",)
         else:
             for var in self.assign:
-                if not is_scalar_assign(var):
-                    self._add_error(f"invalid loop variable '{var}'")
+                match = search_variable(var, ignore_errors=True, parse_type=True)
+                if not match.is_scalar_assign():
+                    self.errors += (f"Invalid FOR loop variable '{var}'.",)
+                elif match.type:
+                    try:
+                        TypeInfo.from_variable(match)
+                    except DataError as err:
+                        self.errors += (f"Invalid FOR loop variable '{var}': {err}",)
             if not self.values:
-                self._add_error("no loop values")
+                self.errors += ("FOR loop has no values.",)
         self._validate_options()
 
-    def _add_error(self, error: str):
-        self.errors += (f"FOR loop has {error}.",)
-
 
 class IfElseHeader(Statement, ABC):
 
@@ -1266,6 +1262,10 @@ class InlineIfHeader(IfElseHeader):
         ]
         return cls(tokens)
 
+    def validate(self, ctx: "ValidationContext"):
+        super().validate(ctx)
+        AssignmentValidator().validate(self)
+
 
 @Statement.register
 class ElseIfHeader(IfElseHeader):
@@ -1754,7 +1754,7 @@ class VariableValidator:
         try:
             TypeInfo.from_variable(match)
         except DataError as err:
-            statement.errors += (str(err),)
+            statement.errors += (f"Invalid variable '{name}': {err}",)
 
     def _validate_dict_items(self, statement: Statement):
         for item in statement.get_values(Token.ARGUMENT):
@@ -1767,3 +1767,17 @@ class VariableValidator:
     def _is_valid_dict_item(self, item: str) -> bool:
         name, value = split_from_equals(item)
         return value is not None or is_dict_variable(item)
+
+
+class AssignmentValidator:
+
+    def validate(self, statement: Statement):
+        assignment = statement.get_values(Token.ASSIGN)
+        if assignment:
+            assignment = VariableAssignment(assignment)
+            statement.errors += assignment.errors
+            for variable in assignment:
+                try:
+                    TypeInfo.from_variable(variable)
+                except DataError as err:
+                    statement.errors += (f"Invalid variable '{variable}': {err}",)

{robotframework-7.3rc1 → robotframework-7.3rc2}/src/robot/running/arguments/typeconverters.py

@@ -146,6 +146,7 @@ class TypeConverter:
             return False
 
     def validate(self):
+        """Validate converter. Raise ``TypeError`` for unrecognized types."""
         if self.nested:
             self._validate(self.nested)
 
@@ -163,17 +164,15 @@ class TypeConverter:
         raise NotImplementedError
 
     def _handle_error(self, value, name, kind, error=None):
-        value_type = "" if isinstance(value, str) else f" ({type_name(value)})"
+        typ = "" if isinstance(value, str) else f" ({type_name(value)})"
         value = safe_str(value)
+        kind = kind.capitalize() if kind.islower() else kind
         ending = f": {error}" if (error and error.args) else "."
+        cannot_be_converted = f"cannot be converted to {self.type_name}{ending}"
         if name is None:
-            raise ValueError(
-                f"{kind.capitalize()} '{value}'{value_type} "
-                f"cannot be converted to {self.type_name}{ending}"
-            )
+            raise ValueError(f"{kind} '{value}'{typ} {cannot_be_converted}")
         raise ValueError(
-            f"{kind.capitalize()} '{name}' got value '{value}'{value_type} that "
-            f"cannot be converted to {self.type_name}{ending}"
+            f"{kind} '{name}' got value '{value}'{typ} that {cannot_be_converted}"
         )
 
     def _literal_eval(self, value, expected):

{robotframework-7.3rc1 → robotframework-7.3rc2}/src/robot/running/arguments/typeinfo.py

@@ -300,11 +300,20 @@ class TypeInfo(metaclass=SetterAwareType):
         cls,
         variable: "str|VariableMatch",
         handle_list_and_dict: bool = True,
-    ) -> "TypeInfo|None":
+    ) -> "TypeInfo":
         """Construct a ``TypeInfo`` based on a variable.
 
-        Type can be specified using syntax like `${x: int}`. Supports both
-        strings and already parsed `VariableMatch` objects.
+        Type can be specified using syntax like ``${x: int}``.
+
+        :param variable: Variable as a string or as an already parsed
+            ``VariableMatch`` object.
+        :param handle_list_and_dict: When ``True``, types in list and dictionary
+            variables get ``list[]`` and ``dict[]`` decoration implicitly.
+            For example, ``@{x: int}``, ``&{x: int}`` and ``&{x: str=int}``
+            yield types ``list[int]``, ``dict[Any, int]`` and ``dict[str, int]``,
+            respectively.
+        :raises: ``DataError`` if variable has an unrecognized type. Variable
+            not having a type is not an error.
 
         New in Robot Framework 7.3.
         """
@@ -342,7 +351,7 @@ class TypeInfo(metaclass=SetterAwareType):
         languages: "LanguagesLike" = None,
         kind: str = "Argument",
         allow_unknown: bool = False,
-    ):
+    ) -> object:
         """Convert ``value`` based on type information this ``TypeInfo`` contains.
 
         :param value: Value to convert.
@@ -356,8 +365,8 @@ class TypeInfo(metaclass=SetterAwareType):
         :param allow_unknown: If ``False``, a ``TypeError`` is raised if there
             is no converter for this type or to its nested types. If ``True``,
             conversion returns the original value instead.
-        :raises: ``ValueError`` is conversion fails and ``TypeError`` if there
-            is no converter and unknown converters are not accepted.
+        :raises: ``ValueError`` if conversion fails and ``TypeError`` if there is
+            no converter for this type and unknown converters are not accepted.
         :return: Converted value.
         """
         converter = self.get_converter(custom_converters, languages, allow_unknown)