robotframework 7.1rc2__zip → 7.2b1__zip

{robotframework-7.1rc2 → robotframework-7.2b1}/BUILD.rst

@@ -76,7 +76,7 @@ __ https://github.com/robotframework/robotframework/tree/master/atest#schema-val
 Preparation
 -----------
 
-1. Check that you are on the master branch and have nothing left to commit,
+1. Check that you are on the right branch and have nothing left to commit,
    pull, or push::
 
       git branch
@@ -93,13 +93,13 @@ Preparation
 
       VERSION=<version>
 
-   For example, ``VERSION=3.0.1`` or ``VERSION=3.1a2``.
+   For example, ``VERSION=7.1.1`` or ``VERSION=7.2a2``. No ``v`` prefix!
 
 Release notes
 -------------
 
-1. Create personal `GitHub access token`__ to be able to access issue tracker
-   programmatically. The token needs only the `repo/public_repo` scope.
+1. Create a personal `GitHub access token`__ to be able to access issue tracker
+   programmatically. The token needs only the ``repo/public_repo`` scope.
 
 2. Set GitHub user information into shell variables to ease running the
    ``invoke release-notes`` command in the next step::
@@ -119,7 +119,7 @@ Release notes
    <Set version_>`__. Omit the ``-w`` option if you just want to get release
    notes printed to the console, not written to a file.
 
-   When generating release notes for a preview release like ``3.0.2rc1``,
+   When generating release notes for a preview release like ``7.2rc1``,
    the list of issues is only going to contain issues with that label
    (e.g. ``rc1``) or with a label of an earlier preview release (e.g.
    ``alpha1``, ``beta2``).
@@ -229,14 +229,14 @@ Creating distributions
 
         git checkout gh-pages
         invoke add-docs $VERSION --push
-        git checkout master
+        git checkout master    # replace master with v*-maintenance if needed!
 
 Post actions
 ------------
 
 1. Back to master if needed::
 
-      git checkout master
+      git checkout master    # replace master with v*-maintenance if needed!
 
 2. Set dev version based on the previous version::
 

{robotframework-7.1rc2 → robotframework-7.2b1}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: robotframework
-Version: 7.1rc2
+Version: 7.2b1
 Summary: Generic automation framework for acceptance testing and robotic process automation (RPA)
 Home-page: https://robotframework.org
 Author: Pekka Klärck
@@ -10,7 +10,7 @@ Download-URL: https://pypi.org/project/robotframework
 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.1rc2.rst
+Project-URL: Release Notes, https://github.com/robotframework/robotframework/blob/master/doc/releasenotes/rf-7.2b1.rst
 Project-URL: Slack, http://slack.robotframework.org
 Description: Robot Framework
         ===============

{robotframework-7.1rc2 → robotframework-7.2b1}/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.1rc2'
+VERSION = '7.2b1'
 with open(join(dirname(abspath(__file__)), 'README.rst')) as f:
     LONG_DESCRIPTION = f.read()
     base_url = 'https://github.com/robotframework/robotframework/blob/master'

{robotframework-7.1rc2 → robotframework-7.2b1}/src/robot/api/__init__.py

@@ -72,18 +72,42 @@ 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>`_ 
+originally specified in `PEP 484 <https://peps.python.org/pep-0484/>`_.
+
 See documentations of the individual APIs for more details.
 
 .. tip:: APIs related to the command line entry points are exposed directly
         via the :mod:`robot` root package.
 """
 
-from robot.conf.languages import Language, Languages
-from robot.model import SuiteVisitor
-from robot.parsing import (get_tokens, get_resource_tokens, get_init_tokens,
-                           get_model, get_resource_model, get_init_model, Token)
-from robot.reporting import ResultWriter
-from robot.result import ExecutionResult, ResultVisitor
-from robot.running import TestSuite, TestSuiteBuilder, TypeInfo
-
-from .exceptions import ContinuableFailure, Failure, FatalError, Error, SkipExecution
+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_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
+)
+from robot.reporting import ResultWriter as ResultWriter
+from robot.result import (
+    ExecutionResult as ExecutionResult,
+    ResultVisitor as ResultVisitor
+)
+from robot.running import (
+    TestSuite as TestSuite,
+    TestSuiteBuilder as TestSuiteBuilder,
+    TypeInfo as TypeInfo
+)
+
+from .exceptions import (
+    ContinuableFailure as ContinuableFailure,
+    Failure as Failure,
+    FatalError as FatalError,
+    Error as Error,
+    SkipExecution as SkipExecution
+)

{robotframework-7.1rc2 → robotframework-7.2b1}/src/robot/api/deco.py

@@ -13,7 +13,7 @@
 #  See the License for the specific language governing permissions and
 #  limitations under the License.
 
-from typing import Any, Callable, Sequence, TypeVar, Union, overload
+from typing import Any, Callable, Literal, Sequence, TypeVar, Union, overload
 
 from .interfaces import TypeHints
 
@@ -26,7 +26,9 @@ K = TypeVar('K', bound=Callable[..., Any])    # Keyword function.
 L = TypeVar('L', bound=type)                  # Library class.
 KeywordDecorator = Callable[[K], K]
 LibraryDecorator = Callable[[L], L]
+Scope = Literal['GLOBAL', 'SUITE', 'TEST', 'TASK']
 Converter = Union[Callable[[Any], Any], Callable[[Any, Any], Any]]
+DocFormat = Literal['ROBOT', 'HTML', 'TEXT', 'REST']
 
 
 def not_keyword(func: F) -> F:
@@ -107,7 +109,7 @@ def keyword(name: 'K | str | None' = None,
         def types_as_list(length, case_insensitive):
             # ...
 
-        @keyword(types=None])
+        @keyword(types=None)
         def no_conversion(length, case_insensitive=False):
             # ...
     """
@@ -129,20 +131,20 @@ def library(cls: L, /) -> L:
 
 
 @overload
-def library(scope: 'str | None' = None,
+def library(scope: 'Scope | None' = None,
             version: 'str | None' = None,
             converters: 'dict[type, Converter] | None' = None,
-            doc_format: 'str | None' = None,
+            doc_format: 'DocFormat | None' = None,
             listener: 'Any | None' = None,
             auto_keywords: bool = False) -> LibraryDecorator:
     ...
 
 
 @not_keyword
-def library(scope: 'L | str | None' = None,
+def library(scope: 'L | Scope | None' = None,
             version: 'str | None' = None,
             converters: 'dict[type, Converter] | None' = None,
-            doc_format: 'str | 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.

{robotframework-7.1rc2 → robotframework-7.2b1}/src/robot/api/interfaces.py

@@ -53,7 +53,6 @@ else:
     UnionType = type
 
 from robot import result, running
-from robot.model import Message
 from robot.running import TestDefaults, TestSuite
 
 
@@ -366,7 +365,7 @@ class StartKeywordAttributes(OptionalKeywordAttributes):
     assign: 'list[str]'
     tags: 'list[str]'
     source: str
-    lineno: int
+    lineno: 'int|None'
     status: str
     starttime: str
 
@@ -478,20 +477,37 @@ class ListenerV2:
     def output_file(self, path: str):
         """Called after the output file has been created.
 
-        At this point the file is guaranteed to be closed.
+        ``path`` is an absolute path to the output file or
+        a string ``None`` if creating the output file is disabled.
         """
 
     def log_file(self, path: str):
-        """Called after the log file has been created."""
+        """Called after the log file has been created.
+
+        ``path`` is an absolute path to the log file.
+        Not called if creating the log file is disabled.
+        """
 
     def report_file(self, path: str):
-        """Called after the report file has been created."""
+        """Called after the report file has been created.
+
+        ``path`` is an absolute path to the report file.
+        Not called if creating the report file is disabled.
+        """
 
     def xunit_file(self, path: str):
-        """Called after the xunit compatible output file has been created."""
+        """Called after the xunit compatible output file has been created.
+
+        ``path`` is an absolute path to the xunit file.
+        Only called if creating the xunit file is enabled.
+        """
 
     def debug_file(self, path: str):
-        """Called after the debug file has been created."""
+        """Called after the debug file has been created.
+
+        ``path`` is an absolute path to the debug file.
+        Only called if creating the debug file is enabled.
+        """
 
     def close(self):
         """Called when the whole execution ends.
@@ -692,6 +708,24 @@ class ListenerV3:
         """
         self.end_body_item(data, result)
 
+    def start_group(self, data: running.Group, result: result.Group):
+        """Called when a GROUP starts.
+
+        The default implementation calls :meth:`start_body_item`.
+
+        New in Robot Framework 7.2.
+        """
+        self.start_body_item(data, result)
+
+    def end_group(self, data: running.Group, result: result.Group):
+        """Called when a GROUP ends.
+
+        The default implementation calls :meth:`end_body_item`.
+
+        New in Robot Framework 7.2.
+        """
+        self.end_body_item(data, result)
+
     def start_if(self, data: running.If, result: result.If):
         """Called when an IF/ELSE structure starts.
 
@@ -868,7 +902,7 @@ class ListenerV3:
         """
         pass
 
-    def log_message(self, message: Message):
+    def log_message(self, message: result.Message):
         """Called when a normal log message are emitted.
 
         The messages are typically logged by keywords, but also the framework
@@ -876,7 +910,7 @@ class ListenerV3:
         log.html.
         """
 
-    def message(self, message: Message):
+    def message(self, message: result.Message):
         """Called when framework's internal messages are emitted.
 
         Only logged by the framework itself. These messages end up to the syslog
@@ -915,23 +949,40 @@ class ListenerV3:
         the imported variable file.
         """
 
-    def output_file(self, path: Path):
+    def output_file(self, path: 'Path | None'):
         """Called after the output file has been created.
 
-        At this point the file is guaranteed to be closed.
+        ``path`` is an absolute path to the output file or
+        ``None`` if creating the output file is disabled.
         """
 
     def log_file(self, path: Path):
-        """Called after the log file has been created."""
+        """Called after the log file has been created.
+
+        ``path`` is an absolute path to the log file.
+        Not called if creating the log file is disabled.
+        """
 
     def report_file(self, path: Path):
-        """Called after the report file has been created."""
+        """Called after the report file has been created.
+
+        ``path`` is an absolute path to the report file.
+        Not called if creating the report file is disabled.
+        """
 
     def xunit_file(self, path: Path):
-        """Called after the xunit compatible output file has been created."""
+        """Called after the xunit compatible output file has been created.
+
+        ``path`` is an absolute path to the xunit file.
+        Only called if creating the xunit file is enabled.
+        """
 
     def debug_file(self, path: Path):
-        """Called after the debug file has been created."""
+        """Called after the debug file has been created.
+
+        ``path`` is an absolute path to the debug file.
+        Only called if creating the debug file is enabled.
+        """
 
     def close(self):
         """Called when the whole execution ends.

{robotframework-7.1rc2 → robotframework-7.2b1}/src/robot/api/parsing.py

@@ -196,6 +196,7 @@ Blocks:
 - :class:`~robot.parsing.model.blocks.Try`
 - :class:`~robot.parsing.model.blocks.For`
 - :class:`~robot.parsing.model.blocks.While`
+- :class:`~robot.parsing.model.blocks.Group` (new in RF 7.2)
 
 Statements:
 
@@ -236,6 +237,7 @@ Statements:
 - :class:`~robot.parsing.model.statements.FinallyHeader`
 - :class:`~robot.parsing.model.statements.ForHeader`
 - :class:`~robot.parsing.model.statements.WhileHeader`
+- :class:`~robot.parsing.model.statements.GroupHeader` (new in RF 7.2)
 - :class:`~robot.parsing.model.statements.Var` (new in RF 7.0)
 - :class:`~robot.parsing.model.statements.End`
 - :class:`~robot.parsing.model.statements.ReturnStatement`
@@ -484,78 +486,80 @@ get the executable suite by using the
 """
 
 from robot.parsing import (
-    get_tokens,
-    get_resource_tokens,
-    get_init_tokens,
-    get_model,
-    get_resource_model,
-    get_init_model,
-    Token
+    get_tokens as get_tokens,
+    get_resource_tokens as get_resource_tokens,
+    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
 )
 from robot.parsing.model.blocks import (
-    File,
-    SettingSection,
-    VariableSection,
-    TestCaseSection,
-    KeywordSection,
-    CommentSection,
-    TestCase,
-    Keyword,
-    If,
-    Try,
-    For,
-    While
+    File as File,
+    SettingSection as SettingSection,
+    VariableSection as VariableSection,
+    TestCaseSection as TestCaseSection,
+    KeywordSection as KeywordSection,
+    CommentSection as CommentSection,
+    TestCase as TestCase,
+    Keyword as Keyword,
+    If as If,
+    Try as Try,
+    For as For,
+    While as While,
+    Group as Group
 )
 from robot.parsing.model.statements import (
-    SectionHeader,
-    LibraryImport,
-    ResourceImport,
-    VariablesImport,
-    Documentation,
-    Metadata,
-    SuiteName,
-    SuiteSetup,
-    SuiteTeardown,
-    TestSetup,
-    TestTeardown,
-    TestTemplate,
-    TestTimeout,
-    TestTags,
-    DefaultTags,
-    KeywordTags,
-    Variable,
-    TestCaseName,
-    KeywordName,
-    Setup,
-    Teardown,
-    Tags,
-    Template,
-    Timeout,
-    Arguments,
-    Return,
-    ReturnSetting,
-    KeywordCall,
-    TemplateArguments,
-    IfHeader,
-    InlineIfHeader,
-    ElseIfHeader,
-    ElseHeader,
-    TryHeader,
-    ExceptHeader,
-    FinallyHeader,
-    ForHeader,
-    WhileHeader,
-    End,
-    Var,
-    ReturnStatement,
-    Continue,
-    Break,
-    Comment,
-    Config,
-    Error,
-    EmptyLine
+    SectionHeader as SectionHeader,
+    LibraryImport as LibraryImport,
+    ResourceImport as ResourceImport,
+    VariablesImport as VariablesImport,
+    Documentation as Documentation,
+    Metadata as Metadata,
+    SuiteName as SuiteName,
+    SuiteSetup as SuiteSetup,
+    SuiteTeardown as SuiteTeardown,
+    TestSetup as TestSetup,
+    TestTeardown as TestTeardown,
+    TestTemplate as TestTemplate,
+    TestTimeout as TestTimeout,
+    TestTags as TestTags,
+    DefaultTags as DefaultTags,
+    KeywordTags as KeywordTags,
+    Variable as Variable,
+    TestCaseName as TestCaseName,
+    KeywordName as KeywordName,
+    Setup as Setup,
+    Teardown as Teardown,
+    Tags as Tags,
+    Template as Template,
+    Timeout as Timeout,
+    Arguments as Arguments,
+    Return as Return,
+    ReturnSetting as ReturnSetting,
+    KeywordCall as KeywordCall,
+    TemplateArguments as TemplateArguments,
+    IfHeader as IfHeader,
+    InlineIfHeader as InlineIfHeader,
+    ElseIfHeader as ElseIfHeader,
+    ElseHeader as ElseHeader,
+    TryHeader as TryHeader,
+    ExceptHeader as ExceptHeader,
+    FinallyHeader as FinallyHeader,
+    ForHeader as ForHeader,
+    WhileHeader as WhileHeader,
+    GroupHeader as GroupHeader,
+    End as End,
+    Var as Var,
+    ReturnStatement as ReturnStatement,
+    Continue as Continue,
+    Break as Break,
+    Comment as Comment,
+    Config as Config,
+    Error as Error,
+    EmptyLine as EmptyLine
 )
 from robot.parsing.model.visitor import (
-    ModelTransformer,
-    ModelVisitor
+    ModelTransformer as ModelTransformer,
+    ModelVisitor as ModelVisitor
 )

{robotframework-7.1rc2 → robotframework-7.2b1}/src/robot/conf/languages.py

@@ -115,8 +115,7 @@ class Languages:
         self.false_strings |= {s.title() for s in lang.false_strings}
 
     def _get_languages(self, languages, add_english=True) -> 'list[Language]':
-        languages = self._resolve_languages(languages, add_english)
-        available = self._get_available_languages()
+        languages, available = self._resolve_languages(languages, add_english)
         returned: 'list[Language]' = []
         for lang in languages:
             if isinstance(lang, Language):
@@ -138,9 +137,11 @@ class Languages:
             languages = list(languages)
         else:
             languages = [languages]
+        # Get available languages only if custom languages are used to save time.
+        available = self._get_available_languages() if languages else {}
         if add_english:
             languages.append(En())
-        return languages
+        return languages, available
 
     def _get_available_languages(self) -> 'dict[str, type[Language]]':
         available = {}

{robotframework-7.1rc2 → robotframework-7.2b1}/src/robot/conf/settings.py

@@ -23,7 +23,7 @@ from datetime import datetime
 from pathlib import Path
 
 from robot.errors import DataError, FrameworkError
-from robot.output import LOGGER, loggerhelper
+from robot.output import LOGGER, LogLevel
 from robot.result.keywordremover import KeywordRemover
 from robot.result.flattenkeywordmatcher import validate_flatten_keyword
 from robot.utils import (abspath, create_destination_directory, escape,
@@ -163,16 +163,17 @@ class _BaseSettings:
 
     def _split_log_level(self, level):
         if ':' in level:
-            log_level, visible_level = level.split(':', 1)
+            collect, show = level.split(':', 1)
         else:
-            log_level = visible_level = level
-        for level in log_level, visible_level:
-            if level not in loggerhelper.LEVELS:
-                self._raise_invalid('LogLevel', f"Invalid level '{level}'.")
-        if not loggerhelper.IsLogged(log_level)(visible_level):
-            self._raise_invalid('LogLevel', f"Level in log '{visible_level}' is lower "
-                                            f"than execution level '{log_level}'.")
-        return log_level, visible_level
+            collect = show = level
+        try:
+            collect,  show = LogLevel(collect), LogLevel(show)
+        except DataError as err:
+            self._raise_invalid('LogLevel', str(err))
+        if collect.priority > show.priority:
+            self._raise_invalid('LogLevel', f"Level in log '{show.level}' is lower "
+                                            f"than execution level '{collect.level}'.")
+        return collect.level, show.level
 
     def _process_max_error_lines(self, value):
         if not value or value.upper() == 'NONE':

{robotframework-7.1rc2 → robotframework-7.2b1}/src/robot/errors.py

@@ -143,13 +143,13 @@ class ExecutionStatus(RobotError):
     def can_continue(self, context, templated=False):
         if context.dry_run:
             return True
-        if self.syntax or self.exit or self.skip or self.test_timeout:
+        if self.syntax or self.exit or self.test_timeout:
             return False
         if templated:
             return context.continue_on_failure(default=True)
+        if self.skip:
+            return False
         if self.keyword_timeout:
-            if context.in_teardown:
-                self.keyword_timeout = False
             return False
         return self.continue_on_failure or context.continue_on_failure()
 

{robotframework-7.1rc2 → robotframework-7.2b1}/src/robot/htmldata/htmlfilewriter.py

@@ -63,6 +63,9 @@ class Writer(ABC):
 class ModelWriter(Writer, ABC):
     handles_line = '<!-- JS MODEL -->'
 
+    def handles(self, line: str):
+        return line.strip().startswith(self.handles_line)
+
 
 class LineWriter(Writer):