robotframework 7.2.1__tar.gz → 7.3__tar.gz

{robotframework-7.2.1 → robotframework-7.3}/BUILD.rst

@@ -151,6 +151,24 @@ Release notes
 
 __ https://docs.github.com/en/free-pro-team@latest/github/authenticating-to-github/creating-a-personal-access-token
 
+
+Update libdoc generated files
+-----------------------------
+
+Run
+
+    invoke build-libdoc
+
+This step can be skipped if there are no changes to Libdoc. Prerequisites
+are listed in `<src/web/README.md>`_.
+
+This will regenerate the libdoc html template and update libdoc command line
+with the latest supported lagnuages.
+
+Commit & push if there are changes any changes to either
+`src/robot/htmldata/libdoc/libdoc.html` or `src/robot/libdocpkg/languages.py`.
+
+
 Set version
 -----------
 
@@ -189,13 +207,6 @@ Creating distributions
 
       invoke clean
 
-3. Build `libdoc.html`::
-
-      npm run build --prefix src/web/
-
-   This step can be skipped if there are no changes to Libdoc. Prerequisites
-   are listed in `<src/web/README.md>`_.
-
 4. Create and validate source distribution and `wheel <https://pythonwheels.com>`_::
 
       python setup.py sdist bdist_wheel

{robotframework-7.2.1 → robotframework-7.3}/CONTRIBUTING.rst

@@ -133,8 +133,7 @@ new code. An important guideline is that the code should be clear enough that
 comments are generally not needed.
 
 All code, including test code, must be compatible with all supported Python
-interpreters and versions. Most importantly this means that the code must
-support both Python 2 and Python 3.
+interpreters and versions.
 
 Line length
 '''''''''''
@@ -174,6 +173,24 @@ internal code. When docstrings are added, they should follow `PEP-257
 section below for more details about documentation syntax, generating
 API docs, etc.
 
+Type hints / Annotations
+''''''''''''''''''''''''
+
+Keywords and functions / methods in the public api should be annotated with type hints.
+These annotations should follow the Python `Typing Best Practices
+<https://typing.python.org/en/latest/reference/best_practices.html>`_ with the
+following exceptions / restrictions:
+
+- Annotation features are restricted to the minimum Python version supported by
+  Robot Framework.
+- This means that at this time, for example, `TypeAlias` can not yet be used.
+- Annotations should use the stringified format for annotations not natively
+  availabe by the minimum supported Python version. For example `'int | float'`
+  instead of `Union[int, float]` or `'list[int]'` instead of `List[int]`.
+- Due to automatic type conversion by Robot Framework, `'int | float'` should not be
+  annotated as `'float'` since this would convert any `int` argument to a `float`.
+- No `-> None` annotation on functions / method that do not return.
+
 Documentation
 ~~~~~~~~~~~~~
 

robotframework-7.3/PKG-INFO

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

@@ -0,0 +1,85 @@
+#!/usr/bin/env python
+
+from os.path import abspath, dirname, join
+
+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.3"
+with open(join(dirname(abspath(__file__)), "README.rst")) as f:
+    LONG_DESCRIPTION = f.read()
+    base_url = "https://github.com/robotframework/robotframework/blob/master"
+    for text in ("INSTALL", "CONTRIBUTING"):
+        search = f"`<{text}.rst>`__"
+        replace = f"`{text}.rst <{base_url}/{text}.rst>`__"
+        if search not in LONG_DESCRIPTION:
+            raise RuntimeError(f"{search} not found from README.rst")
+        LONG_DESCRIPTION = LONG_DESCRIPTION.replace(search, replace)
+CLASSIFIERS = """
+Development Status :: 5 - Production/Stable
+License :: OSI Approved :: Apache Software License
+Operating System :: OS Independent
+Programming Language :: Python :: 3
+Programming Language :: Python :: 3 :: Only
+Programming Language :: Python :: 3.8
+Programming Language :: Python :: 3.9
+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
+Topic :: Software Development :: Testing :: Acceptance
+Topic :: Software Development :: Testing :: BDD
+Framework :: Robot Framework
+""".strip().splitlines()
+DESCRIPTION = (
+    "Generic automation framework for acceptance testing "
+    "and robotic process automation (RPA)"
+)
+KEYWORDS = (
+    "robotframework automation testautomation rpa testing acceptancetesting atdd bdd"
+)
+PACKAGE_DATA = [
+    join("htmldata", directory, pattern)
+    for directory in ("rebot", "libdoc", "testdoc", "lib", "common")
+    for pattern in ("*.html", "*.css", "*.js")
+] + ["api/py.typed", "logo.png"]
+
+
+setup(
+    name="robotframework",
+    version=VERSION,
+    author="Pekka Klärck",
+    author_email="peke@eliga.fi",
+    url="https://robotframework.org",
+    project_urls={
+        "Source": "https://github.com/robotframework/robotframework",
+        "Issue Tracker": "https://github.com/robotframework/robotframework/issues",
+        "Documentation": "https://robotframework.org/robotframework",
+        "Release Notes": f"https://github.com/robotframework/robotframework/blob/master/doc/releasenotes/rf-{VERSION}.rst",
+        "Slack": "http://slack.robotframework.org",
+    },
+    download_url="https://pypi.org/project/robotframework",
+    license="Apache License 2.0",
+    description=DESCRIPTION,
+    long_description=LONG_DESCRIPTION,
+    long_description_content_type="text/x-rst",
+    keywords=KEYWORDS,
+    platforms="any",
+    python_requires=">=3.8",
+    classifiers=CLASSIFIERS,
+    package_dir={"": "src"},
+    package_data={"robot": PACKAGE_DATA},
+    packages=find_packages("src"),
+    entry_points={
+        "console_scripts": [
+            "robot = robot:run_cli",
+            "rebot = robot:rebot_cli",
+            "libdoc = robot.libdoc:libdoc_cli",
+        ]
+    },
+)

{robotframework-7.2.1 → robotframework-7.3}/src/robot/__init__.py

@@ -40,16 +40,15 @@ this package are for internal usage and may change without prior notice.
 import sys
 import warnings
 
-from robot.rebot import rebot, rebot_cli
-from robot.run import run, run_cli
+from robot.rebot import rebot as rebot, rebot_cli as rebot_cli
+from robot.run import run as run, run_cli as run_cli
 from robot.version import get_version
 
-
 # Avoid warnings when using `python -m robot.run`.
 # https://github.com/robotframework/robotframework/issues/2552
 if not sys.warnoptions:
-    warnings.filterwarnings('ignore', category=RuntimeWarning, module='runpy')
+    warnings.filterwarnings("ignore", category=RuntimeWarning, module="runpy")
 
 
-__all__ = ['run', 'run_cli', 'rebot', 'rebot_cli']
+__all__ = ["rebot", "rebot_cli", "run", "run_cli"]
 __version__ = get_version()

{robotframework-7.2.1 → robotframework-7.3}/src/robot/__main__.py

@@ -17,8 +17,10 @@
 
 import sys
 
-if __name__ == '__main__' and 'robot' not in sys.modules:
-    import pythonpathsetter
+if __name__ == "__main__" and "robot" not in sys.modules:
+    from pythonpathsetter import set_pythonpath
+
+    set_pythonpath()
 
 from robot import run_cli
 

{robotframework-7.2.1 → robotframework-7.3}/src/robot/api/__init__.py

@@ -73,7 +73,7 @@ All of the above classes can be imported like::
     from robot.api import ClassName
 
 The public API intends to follow the `distributing type information specification
-<https://typing.readthedocs.io/en/latest/spec/distributing.html#distributing-type-information>`_ 
+<https://typing.readthedocs.io/en/latest/spec/distributing.html#distributing-type-information>`_
 originally specified in `PEP 484 <https://peps.python.org/pep-0484/>`_.
 
 See documentations of the individual APIs for more details.
@@ -85,29 +85,29 @@ See documentations of the individual APIs for more details.
 from robot.conf.languages import Language as Language, Languages as Languages
 from robot.model import SuiteVisitor as SuiteVisitor
 from robot.parsing import (
-    get_tokens as get_tokens,
-    get_resource_tokens as get_resource_tokens,
+    get_init_model as get_init_model,
     get_init_tokens as get_init_tokens,
     get_model as get_model,
     get_resource_model as get_resource_model,
-    get_init_model as get_init_model,
-    Token as Token
+    get_resource_tokens as get_resource_tokens,
+    get_tokens as get_tokens,
+    Token as Token,
 )
 from robot.reporting import ResultWriter as ResultWriter
 from robot.result import (
     ExecutionResult as ExecutionResult,
-    ResultVisitor as ResultVisitor
+    ResultVisitor as ResultVisitor,
 )
 from robot.running import (
     TestSuite as TestSuite,
     TestSuiteBuilder as TestSuiteBuilder,
-    TypeInfo as TypeInfo
+    TypeInfo as TypeInfo,
 )
 
 from .exceptions import (
     ContinuableFailure as ContinuableFailure,
+    Error as Error,
     Failure as Failure,
     FatalError as FatalError,
-    Error as Error,
-    SkipExecution as SkipExecution
+    SkipExecution as SkipExecution,
 )

{robotframework-7.2.1 → robotframework-7.3}/src/robot/api/deco.py

@@ -13,22 +13,18 @@
 #  See the License for the specific language governing permissions and
 #  limitations under the License.
 
-from typing import Any, Callable, Literal, Sequence, TypeVar, Union, overload
+from typing import Any, Callable, Literal, overload, Sequence, TypeVar, Union
 
 from .interfaces import TypeHints
 
-
-# Current annotations report `attr-defined` errors. This can be solved once Python 3.10
-# becomes the minimum version (error-free conditional typing proved too complex).
-# See: https://discuss.python.org/t/questions-related-to-typing-overload-style/38130
-F = TypeVar('F', bound=Callable[..., Any])    # Any function.
-K = TypeVar('K', bound=Callable[..., Any])    # Keyword function.
-L = TypeVar('L', bound=type)                  # Library class.
+F = TypeVar("F", bound=Callable[..., Any])
+K = TypeVar("K", bound=Callable[..., Any])
+L = TypeVar("L", bound=type)
 KeywordDecorator = Callable[[K], K]
 LibraryDecorator = Callable[[L], L]
-Scope = Literal['GLOBAL', 'SUITE', 'TEST', 'TASK']
+Scope = Literal["GLOBAL", "SUITE", "TEST", "TASK"]
 Converter = Union[Callable[[Any], Any], Callable[[Any, Any], Any]]
-DocFormat = Literal['ROBOT', 'HTML', 'TEXT', 'REST']
+DocFormat = Literal["ROBOT", "HTML", "TEXT", "REST"]
 
 
 def not_keyword(func: F) -> F:
@@ -57,21 +53,23 @@ not_keyword.robot_not_keyword = True
 
 
 @overload
-def keyword(func: K, /) -> K:
-    ...
+def keyword(func: K, /) -> K: ...
 
 
 @overload
-def keyword(name: 'str | None' = None,
-            tags: Sequence[str] = (),
-            types: 'TypeHints | None' = ()) -> KeywordDecorator:
-    ...
+def keyword(
+    name: "str|None" = None,
+    tags: Sequence[str] = (),
+    types: "TypeHints|None" = (),
+) -> KeywordDecorator: ...
 
 
 @not_keyword
-def keyword(name: 'K | str | None' = None,
-            tags: Sequence[str] = (),
-            types: 'TypeHints | None' = ()) -> 'K | KeywordDecorator':
+def keyword(
+    name: "K|str|None" = None,
+    tags: Sequence[str] = (),
+    types: "TypeHints|None" = (),
+) -> "K|KeywordDecorator":
     """Decorator to set custom name, tags and argument types to keywords.
 
     This decorator creates ``robot_name``, ``robot_tags`` and ``robot_types``
@@ -126,27 +124,29 @@ def keyword(name: 'K | str | None' = None,
 
 
 @overload
-def library(cls: L, /) -> L:
-    ...
+def library(cls: L, /) -> L: ...
 
 
 @overload
-def library(scope: 'Scope | None' = None,
-            version: 'str | None' = None,
-            converters: 'dict[type, Converter] | None' = None,
-            doc_format: 'DocFormat | None' = None,
-            listener: 'Any | None' = None,
-            auto_keywords: bool = False) -> LibraryDecorator:
-    ...
+def library(
+    scope: "Scope|None" = None,
+    version: "str|None" = None,
+    converters: "dict[type, Converter]|None" = None,
+    doc_format: "DocFormat|None" = None,
+    listener: "Any|None" = None,
+    auto_keywords: bool = False,
+) -> LibraryDecorator: ...
 
 
 @not_keyword
-def library(scope: 'L | Scope | None' = None,
-            version: 'str | None' = None,
-            converters: 'dict[type, Converter] | None' = None,
-            doc_format: 'DocFormat | None' = None,
-            listener: 'Any | None' = None,
-            auto_keywords: bool = False) -> 'L | LibraryDecorator':
+def library(
+    scope: "L|Scope|None" = None,
+    version: "str|None" = None,
+    converters: "dict[type, Converter]|None" = None,
+    doc_format: "DocFormat|None" = None,
+    listener: "Any|None" = None,
+    auto_keywords: bool = False,
+) -> "L|LibraryDecorator":
     """Class decorator to control keyword discovery and other library settings.
 
     Disables automatic keyword detection by setting class attribute

{robotframework-7.2.1 → robotframework-7.3}/src/robot/api/exceptions.py

@@ -29,6 +29,7 @@ class Failure(AssertionError):
     the standard ``AssertionError``. The main benefits are HTML support and that
     the name of this exception is consistent with other exceptions in this module.
     """
+
     ROBOT_SUPPRESS_NAME = True
 
     def __init__(self, message: str, html: bool = False):
@@ -36,11 +37,12 @@ class Failure(AssertionError):
         :param message: Exception message.
         :param html: When ``True``, message is considered to be HTML and not escaped.
         """
-        super().__init__(message if not html else '*HTML* ' + message)
+        super().__init__(message if not html else "*HTML* " + message)
 
 
 class ContinuableFailure(Failure):
     """Report failed validation but allow continuing execution."""
+
     ROBOT_CONTINUE_ON_FAILURE = True
 
 
@@ -55,6 +57,7 @@ class Error(RuntimeError):
     the standard ``RuntimeError``. The main benefits are HTML support and that
     the name of this exception is consistent with other exceptions in this module.
     """
+
     ROBOT_SUPPRESS_NAME = True
 
     def __init__(self, message: str, html: bool = False):
@@ -62,17 +65,19 @@ class Error(RuntimeError):
         :param message: Exception message.
         :param html: When ``True``, message is considered to be HTML and not escaped.
         """
-        super().__init__(message if not html else '*HTML* ' + message)
+        super().__init__(message if not html else "*HTML* " + message)
 
 
 class FatalError(Error):
     """Report error that stops the whole execution."""
+
     ROBOT_EXIT_ON_FAILURE = True
     ROBOT_SUPPRESS_NAME = False
 
 
 class SkipExecution(Exception):
     """Mark the executed test or task skipped."""
+
     ROBOT_SKIP_EXECUTION = True
     ROBOT_SUPPRESS_NAME = True
 
@@ -81,4 +86,4 @@ class SkipExecution(Exception):
         :param message: Exception message.
         :param html: When ``True``, message is considered to be HTML and not escaped.
         """
-        super().__init__(message if not html else '*HTML* ' + message)
+        super().__init__(message if not html else "*HTML* " + message)