robotframework 7.3rc1__tar.gz → 7.3rc3__tar.gz

robotframework-7.3rc3/PKG-INFO

@@ -0,0 +1,190 @@
+Metadata-Version: 2.1
+Name: robotframework
+Version: 7.3rc3
+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.3rc3.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.3rc3/pyproject.toml

@@ -0,0 +1,33 @@
+[tool.black]
+line_length = 88
+# When we add [project] with requires-python, remove this and Ruff's target-version
+target-version = ["py38", "py39", "py310", "py311", "py312", "py313"]
+
+[tool.ruff]
+target-version = "py38"
+
+[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"]
+combine_as_imports = true
+order_by_type = false
+line_length = 88

{robotframework-7.3rc1 → robotframework-7.3rc3}/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.3rc3"
 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
@@ -76,8 +77,8 @@ setup(
     packages=find_packages("src"),
     entry_points={
         "console_scripts": [
-            "robot = robot.run:run_cli",
-            "rebot = robot.rebot:rebot_cli",
+            "robot = robot:run_cli",
+            "rebot = robot:rebot_cli",
             "libdoc = robot.libdoc:libdoc_cli",
         ]
     },

{robotframework-7.3rc1 → robotframework-7.3rc3}/src/robot/libdocpkg/standardtypes.py

@@ -81,7 +81,7 @@ Examples: ``good``, ``hyvä`` (same as ``hyv\\xE4``), ``\\x00`` (the null byte)
 """,
     bytearray: "Set below to same value as `bytes`.",
     datetime: """\
-Strings are expected to be a timestamp in
+String timestamps are expected to be in
 [https://en.wikipedia.org/wiki/ISO_8601|ISO 8601] like
 format ``YYYY-MM-DD hh:mm:ss.mmmmmm``, where any non-digit
 character can be used as a separator or separators can be
@@ -89,20 +89,26 @@ omitted altogether. Additionally, only the date part is
 mandatory, all possibly missing time components are considered
 to be zeros.
 
+A special value ``NOW`` (case-insensitive) can be used to get the
+current local date and time. This is new in Robot Framework 7.3.
+
 Integers and floats are considered to represent seconds since
 the [https://en.wikipedia.org/wiki/Unix_time|Unix epoch].
 
-Examples: ``2022-02-09T16:39:43.632269``, ``2022-02-09 16:39``,
-``${1644417583.632269}`` (Epoch time)
+Examples: ``2022-02-09T16:39:43.632269``, ``20220209 16:39``,
+``now``, ``${1644417583.632269}`` (Epoch time)
 """,
     date: """\
-Strings are expected to be a timestamp in
+String timestamps are expected to be in
 [https://en.wikipedia.org/wiki/ISO_8601|ISO 8601] like date format
 ``YYYY-MM-DD``, where any non-digit character can be used as a separator
 or separators can be omitted altogether. Possible time components are
 only allowed if they are zeros.
 
-Examples: ``2022-02-09``, ``2022-02-09 00:00``
+A special value ``TODAY`` (case-insensitive) can be used to get
+the current local date. This is new in Robot Framework 7.3.
+
+Examples: ``2022-02-09``, ``2022-02-09 00:00``, ``today``
 """,
     timedelta: """\
 Strings are expected to represent a time interval in one of

{robotframework-7.3rc1 → robotframework-7.3rc3}/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.3rc3}/src/robot/libraries/Process.py

@@ -279,6 +279,11 @@ class Process:
     | `Should Be Equal`      | ${stdout}             | ${result.stdout}      |
     | `File Should Be Empty` | ${result.stderr_path} |                       |
 
+    Notice that in ``stdout`` and ``stderr`` content possible trailing newline
+    is removed and ``\\r\\n`` converted to ``\\n`` automatically. If you
+    need to see the original process output, redirect it to a file using
+    `process configuration` and read it from there.
+
     = Boolean arguments =
 
     Some keywords accept arguments that are handled as Boolean values true or

{robotframework-7.3rc1 → robotframework-7.3rc3}/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.3rc3}/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.3rc3}/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.3rc3}/src/robot/output/outputfile.py

@@ -77,7 +77,7 @@ class OutputFile(LoggerApi):
             self._delayed_messages = []
 
     def _release_delayed_messages(self):
-        for msg in self._delayed_messages:
+        for msg in self._delayed_messages or ():
             self.log_message(msg, no_delay=True)
 
     def start_suite(self, data, result):

{robotframework-7.3rc1 → robotframework-7.3rc3}/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.3rc3}/src/robot/running/arguments/embedded.py

@@ -14,7 +14,8 @@
 #  limitations under the License.
 
 import re
-from typing import Any, Mapping, Sequence
+import warnings
+from typing import Mapping, Sequence
 
 from robot.errors import DataError
 from robot.utils import get_error_message
@@ -44,11 +45,24 @@ class EmbeddedArguments:
     def from_name(cls, name: str) -> "EmbeddedArguments|None":
         return EmbeddedArgumentParser().parse(name) if "${" in name else None
 
+    def match(self, name: str) -> 're.Match|None':
+        """Deprecated since Robot Framework 7.3."""
+        warnings.warn(
+            "'EmbeddedArguments.match()' is deprecated since Robot Framework 7.3. Use "
+            "new 'EmbeddedArguments.matches()' or 'EmbeddedArguments.parse_args()' "
+            "instead. Alternatively, use 'EmbeddedArguments.name.fullmatch()' to "
+            "preserve the old behavior and to be compatible with earlier Robot "
+            "Framework versions."
+        )
+        return self.name.fullmatch(name)
+
     def matches(self, name: str) -> bool:
+        """Return ``True`` if ``name`` matches these embedded arguments."""
         args, _ = self._parse_args(name)
         return bool(args)
 
     def parse_args(self, name: str) -> "tuple[str, ...]":
+        """Parse arguments matching these embedded arguments from ``name``."""
         args, placeholders = self._parse_args(name)
         if not placeholders:
             return args
@@ -72,12 +86,12 @@ class EmbeddedArguments:
                 arg = arg.replace(ph, placeholders[ph])
         return arg
 
-    def map(self, args: Sequence[Any]) -> "list[tuple[str, Any]]":
-        args = [i.convert(a) if i else a for a, i in zip(args, self.types)]
+    def map(self, args: Sequence[object]) -> "list[tuple[str, object]]":
+        args = [t.convert(a) if t else a for a, t in zip(args, self.types)]
         self.validate(args)
         return list(zip(self.args, args))
 
-    def validate(self, args: Sequence[Any]):
+    def validate(self, args: Sequence[object]):
         """Validate that embedded args match custom regexps.
 
         Initial validation is done already when matching keywords, but this