robotframework 7.1rc1__zip → 7.1.1__zip

{robotframework-7.1rc1 → robotframework-7.1.1}/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``).

{robotframework-7.1rc1 → robotframework-7.1.1}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: robotframework
-Version: 7.1rc1
+Version: 7.1.1
 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.1rc1.rst
+Project-URL: Release Notes, https://github.com/robotframework/robotframework/blob/master/doc/releasenotes/rf-7.1.1.rst
 Project-URL: Slack, http://slack.robotframework.org
 Description: Robot Framework
         ===============

{robotframework-7.1rc1 → robotframework-7.1.1}/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.1rc1'
+VERSION = '7.1.1'
 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.1rc1 → robotframework-7.1.1}/src/robot/api/interfaces.py

@@ -478,20 +478,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.
@@ -915,23 +932,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.1rc1 → robotframework-7.1.1}/src/robot/conf/settings.py

@@ -68,6 +68,7 @@ class _BaseSettings:
                  'PreRebotModifiers': ('prerebotmodifier', []),
                  'StatusRC'         : ('statusrc', True),
                  'ConsoleColors'    : ('consolecolors', 'AUTO'),
+                 'ConsoleLinks'     : ('consolelinks', 'AUTO'),
                  'PythonPath'       : ('pythonpath', []),
                  'StdOut'           : ('stdout', None),
                  'StdErr'           : ('stderr', None)}
@@ -454,6 +455,10 @@ class _BaseSettings:
     def console_colors(self):
         return self['ConsoleColors']
 
+    @property
+    def console_links(self):
+        return self['ConsoleLinks']
+
     @property
     def rpa(self):
         return self['RPA']
@@ -613,6 +618,7 @@ class RobotSettings(_BaseSettings):
             'type':    self.console_type,
             'width':   self.console_width,
             'colors':  self.console_colors,
+            'links': self.console_links,
             'markers': self.console_markers,
             'stdout':  self['StdOut'],
             'stderr':  self['StdErr']
@@ -736,6 +742,7 @@ class RebotSettings(_BaseSettings):
     def console_output_config(self):
         return {
             'colors':  self.console_colors,
+            'links': self.console_links,
             'stdout':  self['StdOut'],
             'stderr':  self['StdErr']
         }

{robotframework-7.1rc1 → robotframework-7.1.1}/src/robot/errors.py

@@ -148,8 +148,6 @@ class ExecutionStatus(RobotError):
         if templated:
             return context.continue_on_failure(default=True)
         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.1rc1 → robotframework-7.1.1}/src/robot/htmldata/template.py

@@ -20,8 +20,6 @@ from pathlib import Path
 
 
 if sys.version_info < (3, 9) and not Path(__file__).exists():    # zipsafe
-    # `importlib.resources.files` is new in Python 3.9, but that version does
-    # not seem to be compatible with zipapp.
     try:
         from importlib_resources import files
     except ImportError:

{robotframework-7.1rc1 → robotframework-7.1.1}/src/robot/libraries/BuiltIn.py

@@ -2415,6 +2415,7 @@ class _RunKeyword(_BuiltInBase):
             try:
                 return self.run_keyword(name, *args)
             except ExecutionFailed as err:
+                self._reset_keyword_timeout_in_teardown(err, self._context)
                 if err.dont_continue or err.skip:
                     raise
                 count -= 1
@@ -2434,6 +2435,17 @@ class _RunKeyword(_BuiltInBase):
                         )
             self._sleep_in_parts(sleep_time)
 
+    def _reset_keyword_timeout_in_teardown(self, err, context):
+        # Keyword timeouts in teardowns have been converted to normal failures
+        # to allow execution to continue on higher level:
+        # https://github.com/robotframework/robotframework/issues/3398
+        # We need to reset it here to not continue unnecessarily:
+        # https://github.com/robotframework/robotframework/issues/5237
+        if context.in_teardown:
+            timeouts = [t for t in context.timeouts if t.type == 'Keyword']
+            if timeouts and min(timeouts).timed_out():
+                err.keyword_timeout = True
+
     @run_keyword_variant(resolve=1)
     def set_variable_if(self, condition, *values):
         """Sets variable based on the given condition.

{robotframework-7.1rc1 → robotframework-7.1.1}/src/robot/libraries/Collections.py

@@ -455,9 +455,8 @@ class _List:
         normalize = Normalizer(ignore_case).normalize
         list1 = normalize(list1)
         list2 = normalize(list2)
-        diffs = ', '.join(str(item) for item in list2 if item not in list1)
-        _verify_condition(not diffs,
-                          f'Following values were not found from first list: {diffs}',
+        diffs = [item for item in list2 if item not in list1]
+        _verify_condition(not diffs, f'Following values are missing: {seq2str(diffs)}',
                           msg, values)
 
     def log_list(self, list_, level='INFO'):

{robotframework-7.1rc1 → robotframework-7.1.1}/src/robot/output/console/__init__.py

@@ -20,13 +20,13 @@ from .quiet import NoOutput, QuietOutput
 from .verbose import VerboseOutput
 
 
-def ConsoleOutput(type='verbose', width=78, colors='AUTO', markers='AUTO',
+def ConsoleOutput(type='verbose', width=78, colors='AUTO', links='AUTO', markers='AUTO',
                   stdout=None, stderr=None):
     upper = type.upper()
     if upper == 'VERBOSE':
-        return VerboseOutput(width, colors, markers, stdout, stderr)
+        return VerboseOutput(width, colors, links, markers, stdout, stderr)
     if upper == 'DOTTED':
-        return DottedOutput(width, colors, stdout, stderr)
+        return DottedOutput(width, colors, links, stdout, stderr)
     if upper == 'QUIET':
         return QuietOutput(colors, stderr)
     if upper == 'NONE':

{robotframework-7.1rc1 → robotframework-7.1.1}/src/robot/output/console/dotted.py

@@ -25,10 +25,10 @@ from ..loggerapi import LoggerApi
 
 class DottedOutput(LoggerApi):
 
-    def __init__(self, width=78, colors='AUTO', stdout=None, stderr=None):
+    def __init__(self, width=78, colors='AUTO', links='AUTO', stdout=None, stderr=None):
         self.width = width
-        self.stdout = HighlightingStream(stdout or sys.__stdout__, colors)
-        self.stderr = HighlightingStream(stderr or sys.__stderr__, colors)
+        self.stdout = HighlightingStream(stdout or sys.__stdout__, colors, links)
+        self.stderr = HighlightingStream(stderr or sys.__stderr__, colors, links)
         self.markers_on_row = 0
 
     def start_suite(self, data, result):

{robotframework-7.1rc1 → robotframework-7.1.1}/src/robot/output/console/highlighting.py

@@ -42,11 +42,13 @@ from robot.utils import console_encode, isatty, WINDOWS
 
 class HighlightingStream:
 
-    def __init__(self, stream, colors='AUTO'):
-        self.stream = stream
-        self._highlighter = self._get_highlighter(stream, colors)
+    def __init__(self, stream, colors='AUTO', links='AUTO'):
+        self.stream = stream or NullStream()
+        self._highlighter = self._get_highlighter(stream, colors, links)
 
-    def _get_highlighter(self, stream, colors):
+    def _get_highlighter(self, stream, colors, links):
+        if not stream:
+            return NoHighlighting()
         options = {'AUTO': Highlighter if isatty(stream) else NoHighlighting,
                    'ON': Highlighter,
                    'OFF': NoHighlighting,
@@ -54,9 +56,12 @@ class HighlightingStream:
         try:
             highlighter = options[colors.upper()]
         except KeyError:
-            raise DataError("Invalid console color value '%s'. Available "
-                            "'AUTO', 'ON', 'OFF' and 'ANSI'." % colors)
-        return highlighter(stream)
+            raise DataError(f"Invalid console color value '{colors}'. "
+                            f"Available 'AUTO', 'ON', 'OFF' and 'ANSI'.")
+        if links.upper() not in ('AUTO', 'OFF'):
+            raise DataError(f"Invalid console link value '{links}. "
+                            f"Available 'AUTO' and 'OFF'.")
+        return highlighter(stream, links.upper() == 'AUTO')
 
     def write(self, text, flush=True):
         self._write(console_encode(text, stream=self.stream))
@@ -99,7 +104,7 @@ class HighlightingStream:
     def error(self, message, level):
         self.write('[ ', flush=False)
         self.highlight(level, flush=False)
-        self.write(' ] %s\n' % message)
+        self.write(f' ] {message}\n')
 
     @contextmanager
     def _highlighting(self, status):
@@ -116,17 +121,26 @@ class HighlightingStream:
             highlighter.reset()
 
     def result_file(self, kind, path):
-        path = self._highlighter.link(path)
+        path = self._highlighter.link(path) if path else 'NONE'
         self.write(f"{kind + ':':8} {path}\n")
 
 
-def Highlighter(stream):
+class NullStream:
+
+    def write(self, text):
+        pass
+
+    def flush(self):
+        pass
+
+
+def Highlighter(stream, links=True):
     if os.sep == '/':
-        return AnsiHighlighter(stream)
+        return AnsiHighlighter(stream, links)
     if not windll:
         return NoHighlighting(stream)
     if virtual_terminal_enabled(stream):
-        return AnsiHighlighter(stream)
+        return AnsiHighlighter(stream, links)
     return DosHighlighter(stream)
 
 
@@ -136,8 +150,9 @@ class AnsiHighlighter:
     YELLOW = '\033[33m'
     RESET = '\033[0m'
 
-    def __init__(self, stream):
+    def __init__(self, stream, links=True):
         self._stream = stream
+        self._links = links
 
     def green(self):
         self._set_color(self.GREEN)
@@ -152,7 +167,15 @@ class AnsiHighlighter:
         self._set_color(self.RESET)
 
     def link(self, path):
-        return f'\033]8;;file:///{path}\033\\{path}\033]8;;\033\\'
+        if not self._links:
+            return path
+        try:
+            uri = path.as_uri()
+        except ValueError:
+            return path
+        # Terminal hyperlink syntax is documented here:
+        # https://gist.github.com/egmontkob/eb114294efbcd5adb1944c9f3cb5feda
+        return f'\033]8;;{uri}\033\\{path}\033]8;;\033\\'
 
     def _set_color(self, color):
         self._stream.write(color)
@@ -160,6 +183,9 @@ class AnsiHighlighter:
 
 class NoHighlighting(AnsiHighlighter):
 
+    def __init__(self, stream=None, links=True):
+        super().__init__(stream, links)
+
     def link(self, path):
         return path
 

{robotframework-7.1rc1 → robotframework-7.1.1}/src/robot/output/console/verbose.py

@@ -24,9 +24,9 @@ from ..loggerapi import LoggerApi
 
 class VerboseOutput(LoggerApi):
 
-    def __init__(self, width=78, colors='AUTO', markers='AUTO', stdout=None,
-                 stderr=None):
-        self.writer = VerboseWriter(width, colors, markers, stdout, stderr)
+    def __init__(self, width=78, colors='AUTO', links='AUTO', markers='AUTO',
+                 stdout=None, stderr=None):
+        self.writer = VerboseWriter(width, colors, links, markers, stdout, stderr)
         self.started = False
         self.started_keywords = 0
         self.running_test = False
@@ -73,11 +73,11 @@ class VerboseOutput(LoggerApi):
 class VerboseWriter:
     _status_length = len('| PASS |')
 
-    def __init__(self, width=78, colors='AUTO', markers='AUTO', stdout=None,
-                 stderr=None):
+    def __init__(self, width=78, colors='AUTO', links='AUTO', markers='AUTO',
+                 stdout=None, stderr=None):
         self.width = width
-        self.stdout = HighlightingStream(stdout or sys.__stdout__, colors)
-        self.stderr = HighlightingStream(stderr or sys.__stderr__, colors)
+        self.stdout = HighlightingStream(stdout or sys.__stdout__, colors, links)
+        self.stderr = HighlightingStream(stderr or sys.__stderr__, colors, links)
         self._keyword_marker = KeywordMarker(self.stdout, markers)
         self._last_info = None
 

{robotframework-7.1rc1 → robotframework-7.1.1}/src/robot/output/logger.py

@@ -104,8 +104,8 @@ class Logger(AbstractLogger):
             self.close()
 
     def register_console_logger(self, type='verbose', width=78, colors='AUTO',
-                                markers='AUTO', stdout=None, stderr=None):
-        logger = ConsoleOutput(type, width, colors, markers, stdout, stderr)
+                                links='AUTO', markers='AUTO', stdout=None, stderr=None):
+        logger = ConsoleOutput(type, width, colors, links, markers, stdout, stderr)
         self._console_logger = self._wrap_and_relay(logger)
 
     def _wrap_and_relay(self, logger):

{robotframework-7.1rc1 → robotframework-7.1.1}/src/robot/output/loggerhelper.py

@@ -40,8 +40,9 @@ def write_to_console(msg, newline=True, stream='stdout'):
     if newline:
         msg += '\n'
     stream = sys.__stdout__ if stream.lower() != 'stderr' else sys.__stderr__
-    stream.write(console_encode(msg, stream=stream))
-    stream.flush()
+    if stream:
+        stream.write(console_encode(msg, stream=stream))
+        stream.flush()
 
 
 class AbstractLogger:

{robotframework-7.1rc1 → robotframework-7.1.1}/src/robot/rebot.py

@@ -262,6 +262,9 @@ Options
                           on:   always use colors
                           ansi: like `on` but use ANSI colors also on Windows
                           off:  disable colors altogether
+    --consolelinks auto|off  Control making paths to results files hyperlinks.
+                          auto: use links when colors are enabled (default)
+                          off: disable links unconditionally
  -P --pythonpath path *   Additional locations to add to the module search path
                           that is used when importing Python based extensions.
  -A --argumentfile path *  Text file to read more arguments from. File can have

{robotframework-7.1rc1 → robotframework-7.1.1}/src/robot/run.py

@@ -341,6 +341,9 @@ Options
                           on:   always use colors
                           ansi: like `on` but use ANSI colors also on Windows
                           off:  disable colors altogether
+    --consolelinks auto|off  Control making paths to results files hyperlinks.
+                          auto: use links when colors are enabled (default)
+                          off: disable links unconditionally
  -K --consolemarkers auto|on|off  Show markers on the console when top level
                           keywords in a test case end. Values have same
                           semantics as with --consolecolors.

{robotframework-7.1rc1 → robotframework-7.1.1}/src/robot/running/arguments/typeinfo.py

@@ -175,8 +175,7 @@ class TypeInfo(metaclass=SetterAwareType):
         - a sequence of supported type hints to create a union from such as
           ``[int, float]`` or ``('int', 'list[int]')``
 
-        In special cases, for example with dictionaries or sequences, using the
-        more specialized methods like :meth:`from_dict` or :meth:`from_sequence`
+        In special cases using a more specialized method like :meth:`from_sequence`
         may be more appropriate than using this generic method.
         """
         if hint is NOT_SET:

{robotframework-7.1rc1 → robotframework-7.1.1}/src/robot/running/bodyrunner.py

@@ -383,7 +383,6 @@ class WhileRunner:
         ctx = self._context
         error = None
         run = False
-        limit = None
         result.start_time = datetime.now()
         iter_result = result.body.create_iteration(start_time=datetime.now())
         if self._run:
@@ -391,15 +390,17 @@ class WhileRunner:
                 error = DataError(data.error, syntax=True)
             elif not ctx.dry_run:
                 try:
-                    limit = WhileLimit.create(data.limit,
-                                              data.on_limit,
-                                              data.on_limit_message,
-                                              ctx.variables)
                     run = self._should_run(data.condition, ctx.variables)
                 except DataError as err:
                     error = err
         with StatusReporter(data, result, self._context, run):
             iter_data = data.get_iteration()
+            if run:
+                try:
+                    limit = WhileLimit.create(data, ctx.variables)
+                except DataError as err:
+                    error = err
+                    run = False
             if ctx.dry_run or not run:
                 self._run_iteration(iter_data, iter_result, run)
                 if error:
@@ -651,29 +652,34 @@ class WhileLimit:
         self.on_limit_message = on_limit_message
 
     @classmethod
-    def create(cls, limit, on_limit, on_limit_message, variables):
-        if on_limit_message:
-            try:
-                on_limit_message = variables.replace_string(on_limit_message)
-            except DataError as err:
-                raise DataError(f"Invalid WHILE loop 'on_limit_message': '{err}")
-        on_limit = cls._parse_on_limit(variables, on_limit)
+    def create(cls, data, variables):
+        limit = cls._parse_limit(data.limit, variables)
+        on_limit = cls._parse_on_limit(data.on_limit, variables)
+        on_limit_msg = cls._parse_on_limit_message(data.on_limit_message, variables)
         if not limit:
-            return IterationCountLimit(DEFAULT_WHILE_LIMIT, on_limit, on_limit_message)
-        limit = variables.replace_string(limit)
+            return IterationCountLimit(DEFAULT_WHILE_LIMIT, on_limit, on_limit_msg)
         if limit.upper() == 'NONE':
             return NoLimit()
         try:
             count = cls._parse_limit_as_count(limit)
         except ValueError:
             seconds = cls._parse_limit_as_timestr(limit)
-            return DurationLimit(seconds, on_limit, on_limit_message)
+            return DurationLimit(seconds, on_limit, on_limit_msg)
         else:
-            return IterationCountLimit(count, on_limit, on_limit_message)
+            return IterationCountLimit(count, on_limit, on_limit_msg)
 
     @classmethod
-    def _parse_on_limit(cls, variables, on_limit):
-        if on_limit is None:
+    def _parse_limit(cls, limit, variables):
+        if not limit:
+            return None
+        try:
+            return variables.replace_string(limit)
+        except DataError as err:
+            raise DataError(f"Invalid WHILE loop limit: {err}")
+
+    @classmethod
+    def _parse_on_limit(cls, on_limit, variables):
+        if not on_limit:
             return None
         try:
             on_limit = variables.replace_string(on_limit)
@@ -682,7 +688,16 @@ class WhileLimit:
             raise DataError(f"Value '{on_limit}' is not accepted. Valid values "
                             f"are 'PASS' and 'FAIL'.")
         except DataError as err:
-            raise DataError(f"Invalid WHILE loop 'on_limit' value: {err}")
+            raise DataError(f"Invalid WHILE loop 'on_limit': {err}")
+
+    @classmethod
+    def _parse_on_limit_message(cls, on_limit_message, variables):
+        if not on_limit_message:
+            return None
+        try:
+            return variables.replace_string(on_limit_message)
+        except DataError as err:
+            raise DataError(f"Invalid WHILE loop 'on_limit_message': '{err}")
 
     @classmethod
     def _parse_limit_as_count(cls, limit):

{robotframework-7.1rc1 → robotframework-7.1.1}/src/robot/running/outputcapture.py

@@ -52,7 +52,8 @@ class OutputCapturer:
             LOGGER.log_output(stdout)
         if stderr:
             LOGGER.log_output(stderr)
-            sys.__stderr__.write(console_encode(stderr, stream=sys.__stderr__))
+            if sys.__stderr__:
+                sys.__stderr__.write(console_encode(stderr, stream=sys.__stderr__))
 
     def _release(self):
         stdout = self.stdout.release()

{robotframework-7.1rc1 → robotframework-7.1.1}/src/robot/running/signalhandler.py

@@ -31,14 +31,18 @@ class _StopSignalMonitor:
 
     def __call__(self, signum, frame):
         self._signal_count += 1
-        LOGGER.info('Received signal: %s.' % signum)
+        LOGGER.info(f'Received signal: {signum}.')
         if self._signal_count > 1:
-            sys.__stderr__.write('Execution forcefully stopped.\n')
+            self._write_to_stderr('Execution forcefully stopped.')
             raise SystemExit()
-        sys.__stderr__.write('Second signal will force exit.\n')
+        self._write_to_stderr('Second signal will force exit.')
         if self._running_keyword:
             self._stop_execution_gracefully()
 
+    def _write_to_stderr(self, message):
+        if sys.__stderr__:
+            sys.__stderr__.write(message + '\n')
+
     def _stop_execution_gracefully(self):
         raise ExecutionFailed('Execution terminated by signal', exit=True)
 

{robotframework-7.1rc1 → robotframework-7.1.1}/src/robot/running/status.py

@@ -29,9 +29,13 @@ class Failure:
         self.teardown_skipped = None
 
     def __bool__(self):
-        return bool(
-            self.setup or self.test or self.teardown or
-            self.setup_skipped or self.test_skipped or self.teardown_skipped
+        return (
+            self.setup is not None
+            or self.test is not None
+            or self.teardown is not None
+            or self.setup_skipped is not None
+            or self.test_skipped is not None
+            or self.teardown_skipped is not None
         )
 
 

{robotframework-7.1rc1 → robotframework-7.1.1}/src/robot/running/userkeywordrunner.py

@@ -85,6 +85,10 @@ class UserKeywordRunner:
             with context.timeout(timeout):
                 exception, return_value = self._execute(kw, result, context)
                 if exception and not exception.can_continue(context):
+                    if context.in_teardown and exception.keyword_timeout:
+                        # Allow execution to continue on teardowns after timeout.
+                        # https://github.com/robotframework/robotframework/issues/3398
+                        exception.keyword_timeout = False
                     raise exception
                 return_value = self._handle_return_value(return_value, variables)
                 if exception:

{robotframework-7.1rc1 → robotframework-7.1.1}/src/robot/variables/scopes.py

@@ -192,7 +192,8 @@ class GlobalVariables(Variables):
                                 'include': Tags(settings.include),
                                 'exclude': Tags(settings.exclude),
                                 'skip': Tags(settings.skip),
-                                'skip_on_failure': Tags(settings.skip_on_failure)
+                                'skip_on_failure': Tags(settings.skip_on_failure),
+                                'console_width': settings.console_width
                             })),
                             ('${/}', os.sep),
                             ('${:}', os.pathsep),