robotframework 7.2.2__tar.gz → 7.3rc2__tar.gz

{robotframework-7.2.2 → robotframework-7.3rc2}/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.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.3rc2/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.3rc2"
+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:run_cli",
+            "rebot = robot.rebot:rebot_cli",
+            "libdoc = robot.libdoc:libdoc_cli",
+        ]
+    },
+)

{robotframework-7.2.2 → robotframework-7.3rc2}/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.2 → robotframework-7.3rc2}/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.2 → robotframework-7.3rc2}/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.2 → robotframework-7.3rc2}/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.2 → robotframework-7.3rc2}/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)