robotframework 7.0.1rc1__zip → 7.1__zip

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

@@ -17,14 +17,24 @@
 # Andre Burgaud, licensed under the MIT License, and available here:
 # http://www.burgaud.com/bring-colors-to-the-windows-console-with-python/
 
-from contextlib import contextmanager
 import errno
 import os
 import sys
+from contextlib import contextmanager
 try:
-    from ctypes import windll, Structure, c_short, c_ushort, byref
+    from ctypes import windll
 except ImportError:  # Not on Windows
     windll = None
+else:
+    from ctypes import byref, c_ushort, Structure
+    from ctypes.wintypes import _COORD, DWORD, SMALL_RECT
+
+    class ConsoleScreenBufferInfo(Structure):
+        _fields_ = [('dwSize', _COORD),
+                    ('dwCursorPosition', _COORD),
+                    ('wAttributes', c_ushort),
+                    ('srWindow', SMALL_RECT),
+                    ('dwMaximumWindowSize', _COORD)]
 
 from robot.errors import DataError
 from robot.utils import console_encode, isatty, WINDOWS
@@ -32,11 +42,11 @@ from robot.utils import console_encode, isatty, WINDOWS
 
 class HighlightingStream:
 
-    def __init__(self, stream, colors='AUTO'):
+    def __init__(self, stream, colors='AUTO', links='AUTO'):
         self.stream = stream
-        self._highlighter = self._get_highlighter(stream, colors)
+        self._highlighter = self._get_highlighter(stream, colors, links)
 
-    def _get_highlighter(self, stream, colors):
+    def _get_highlighter(self, stream, colors, links):
         options = {'AUTO': Highlighter if isatty(stream) else NoHighlighting,
                    'ON': Highlighter,
                    'OFF': NoHighlighting,
@@ -44,9 +54,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))
@@ -78,18 +91,14 @@ class HighlightingStream:
             self.stream.flush()
 
     def highlight(self, text, status=None, flush=True):
-        if self._must_flush_before_and_after_highlighting():
+        # Must flush before and after highlighting when using Windows APIs to make
+        # sure colors only affects the actual highlighted text.
+        if isinstance(self._highlighter, DosHighlighter):
             self.flush()
             flush = True
         with self._highlighting(status or text):
             self.write(text, flush)
 
-    def _must_flush_before_and_after_highlighting(self):
-        # Must flush on Windows before and after highlighting to make sure set
-        # console colors only affect the actual highlighted text. Problems
-        # only encountered with Python 3, but better to be safe than sorry.
-        return WINDOWS and not isinstance(self._highlighter, NoHighlighting)
-
     def error(self, message, level):
         self.write('[ ', flush=False)
         self.highlight(level, flush=False)
@@ -109,33 +118,53 @@ class HighlightingStream:
         finally:
             highlighter.reset()
 
+    def result_file(self, kind, path):
+        path = self._highlighter.link(path)
+        self.write(f"{kind + ':':8} {path}\n")
+
 
-def Highlighter(stream):
+def Highlighter(stream, links=True):
     if os.sep == '/':
-        return AnsiHighlighter(stream)
-    return DosHighlighter(stream) if windll else NoHighlighting(stream)
+        return AnsiHighlighter(stream, links)
+    if not windll:
+        return NoHighlighting(stream)
+    if virtual_terminal_enabled(stream):
+        return AnsiHighlighter(stream, links)
+    return DosHighlighter(stream)
 
 
 class AnsiHighlighter:
-    _ANSI_GREEN = '\033[32m'
-    _ANSI_RED = '\033[31m'
-    _ANSI_YELLOW = '\033[33m'
-    _ANSI_RESET = '\033[0m'
+    GREEN = '\033[32m'
+    RED = '\033[31m'
+    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._ANSI_GREEN)
+        self._set_color(self.GREEN)
 
     def red(self):
-        self._set_color(self._ANSI_RED)
+        self._set_color(self.RED)
 
     def yellow(self):
-        self._set_color(self._ANSI_YELLOW)
+        self._set_color(self.YELLOW)
 
     def reset(self):
-        self._set_color(self._ANSI_RESET)
+        self._set_color(self.RESET)
+
+    def link(self, path):
+        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)
@@ -143,71 +172,67 @@ class AnsiHighlighter:
 
 class NoHighlighting(AnsiHighlighter):
 
+    def link(self, path):
+        return path
+
     def _set_color(self, color):
         pass
 
 
 class DosHighlighter:
-    _FOREGROUND_GREEN = 0x2
-    _FOREGROUND_RED = 0x4
-    _FOREGROUND_YELLOW = 0x6
-    _FOREGROUND_GREY = 0x7
-    _FOREGROUND_INTENSITY = 0x8
-    _BACKGROUND_MASK = 0xF0
-    _STDOUT_HANDLE = -11
-    _STDERR_HANDLE = -12
+    FOREGROUND_GREEN = 0x2
+    FOREGROUND_RED = 0x4
+    FOREGROUND_YELLOW = 0x6
+    FOREGROUND_GREY = 0x7
+    FOREGROUND_INTENSITY = 0x8
+    BACKGROUND_MASK = 0xF0
 
     def __init__(self, stream):
-        self._handle = self._get_std_handle(stream)
+        self._handle = get_std_handle(stream)
         self._orig_colors = self._get_colors()
-        self._background = self._orig_colors & self._BACKGROUND_MASK
+        self._background = self._orig_colors & self.BACKGROUND_MASK
 
     def green(self):
-        self._set_foreground_colors(self._FOREGROUND_GREEN)
+        self._set_foreground_colors(self.FOREGROUND_GREEN)
 
     def red(self):
-        self._set_foreground_colors(self._FOREGROUND_RED)
+        self._set_foreground_colors(self.FOREGROUND_RED)
 
     def yellow(self):
-        self._set_foreground_colors(self._FOREGROUND_YELLOW)
+        self._set_foreground_colors(self.FOREGROUND_YELLOW)
 
     def reset(self):
         self._set_colors(self._orig_colors)
 
-    def _get_std_handle(self, stream):
-        handle = self._STDOUT_HANDLE \
-            if stream is sys.__stdout__ else self._STDERR_HANDLE
-        return windll.kernel32.GetStdHandle(handle)
+    def link(self, path):
+        return path
 
     def _get_colors(self):
-        csbi = _CONSOLE_SCREEN_BUFFER_INFO()
-        ok = windll.kernel32.GetConsoleScreenBufferInfo(self._handle, byref(csbi))
+        info = ConsoleScreenBufferInfo()
+        ok = windll.kernel32.GetConsoleScreenBufferInfo(self._handle, byref(info))
         if not ok:  # Call failed, return default console colors (gray on black)
-            return self._FOREGROUND_GREY
-        return csbi.wAttributes
+            return self.FOREGROUND_GREY
+        return info.wAttributes
 
     def _set_foreground_colors(self, colors):
-        self._set_colors(colors | self._FOREGROUND_INTENSITY | self._background)
+        self._set_colors(colors | self.FOREGROUND_INTENSITY | self._background)
 
     def _set_colors(self, colors):
         windll.kernel32.SetConsoleTextAttribute(self._handle, colors)
 
 
-if windll:
-
-    class _COORD(Structure):
-        _fields_ = [("X", c_short),
-                    ("Y", c_short)]
+def get_std_handle(stream):
+    handle = -11 if stream is sys.__stdout__ else -12
+    return windll.kernel32.GetStdHandle(handle)
 
-    class _SMALL_RECT(Structure):
-        _fields_ = [("Left", c_short),
-                    ("Top", c_short),
-                    ("Right", c_short),
-                    ("Bottom", c_short)]
 
-    class _CONSOLE_SCREEN_BUFFER_INFO(Structure):
-        _fields_ = [("dwSize", _COORD),
-                    ("dwCursorPosition", _COORD),
-                    ("wAttributes", c_ushort),
-                    ("srWindow", _SMALL_RECT),
-                    ("dwMaximumWindowSize", _COORD)]
+def virtual_terminal_enabled(stream):
+    handle = get_std_handle(stream)
+    enable_vt = 0x0004
+    mode = DWORD()
+    if not windll.kernel32.GetConsoleMode(handle, byref(mode)):
+        return False    # Calling GetConsoleMode failed.
+    if mode.value & enable_vt:
+        return True     # VT already enabled.
+    # Try to enable VT.
+    return windll.kernel32.SetConsoleMode(handle, mode.value | enable_vt) != 0

{robotframework-7.0.1rc1 → robotframework-7.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
@@ -67,17 +67,17 @@ class VerboseOutput(LoggerApi):
             self.writer.error(msg.message, msg.level, clear=self.running_test)
 
     def result_file(self, kind, path):
-        self.writer.output(kind, path)
+        self.writer.result_file(kind, path)
 
 
 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
 
@@ -146,8 +146,8 @@ class VerboseWriter:
         if self._should_clear_markers(clear):
             self._write_info()
 
-    def output(self, name, path):
-        self.stdout.write(f"{name+':':8} {path}\n")
+    def result_file(self, kind, path):
+        self.stdout.result_file(kind, path)
 
 
 class KeywordMarker:

{robotframework-7.0.1rc1 → robotframework-7.1}/src/robot/output/listeners.py

@@ -27,13 +27,18 @@ from .loggerhelper import IsLogged
 from .logger import LOGGER
 
 
-class Listeners(LoggerApi):
+class Listeners:
     _listeners: 'list[ListenerFacade]'
 
     def __init__(self, listeners=(), log_level='INFO'):
         self._is_logged = IsLogged(log_level)
         self._listeners = self._import_listeners(listeners)
 
+    # Must be property to allow LibraryListeners to override it.
+    @property
+    def listeners(self):
+        return self._listeners
+
     def _import_listeners(self, listeners, library=None) -> 'list[ListenerFacade]':
         imported = []
         for listener_source in listeners:
@@ -62,8 +67,8 @@ class Listeners(LoggerApi):
             # Modules have `__name__`, with others better to use `type_name`.
             name = getattr(listener, '__name__', None) or type_name(listener)
         if self._get_version(listener) == 2:
-            return ListenerV2Facade(listener, name, library)
-        return ListenerV3Facade(listener, name, library)
+            return ListenerV2Facade(listener, name, self._is_logged, library)
+        return ListenerV3Facade(listener, name, self._is_logged, library)
 
     def _get_version(self, listener):
         version = getattr(listener, 'ROBOT_LISTENER_API_VERSION', 3)
@@ -75,205 +80,14 @@ class Listeners(LoggerApi):
             raise DataError(f"Unsupported API version '{version}'.")
         return version
 
-    # Must be property to allow LibraryListeners to override it.
-    @property
-    def listeners(self):
-        return self._listeners
-
-    def start_suite(self, data, result):
-        for listener in self.listeners:
-            listener.start_suite(data, result)
-
-    def end_suite(self, data, result):
-        for listener in self.listeners:
-            listener.end_suite(data, result)
-
-    def start_test(self, data, result):
-        for listener in self.listeners:
-            listener.start_test(data, result)
-
-    def end_test(self, data, result):
-        for listener in self.listeners:
-            listener.end_test(data, result)
-
-    def start_keyword(self, data, result):
-        for listener in self.listeners:
-            listener.start_keyword(data, result)
-
-    def end_keyword(self, data, result):
-        for listener in self.listeners:
-            listener.end_keyword(data, result)
-
-    def start_user_keyword(self, data, implementation, result):
-        for listener in self.listeners:
-            listener.start_user_keyword(data, implementation, result)
-
-    def end_user_keyword(self, data, implementation, result):
-        for listener in self.listeners:
-            listener.end_user_keyword(data, implementation, result)
-
-    def start_library_keyword(self, data, implementation, result):
-        for listener in self.listeners:
-            listener.start_library_keyword(data, implementation, result)
-
-    def end_library_keyword(self, data, implementation, result):
-        for listener in self.listeners:
-            listener.end_library_keyword(data, implementation, result)
-
-    def start_invalid_keyword(self, data, implementation, result):
-        for listener in self.listeners:
-            listener.start_invalid_keyword(data, implementation, result)
-
-    def end_invalid_keyword(self, data, implementation, result):
-        for listener in self.listeners:
-            listener.end_invalid_keyword(data, implementation, result)
-
-    def start_for(self, data, result):
-        for listener in self.listeners:
-            listener.start_for(data, result)
-
-    def end_for(self, data, result):
-        for listener in self.listeners:
-            listener.end_for(data, result)
-
-    def start_for_iteration(self, data, result):
-        for listener in self.listeners:
-            listener.start_for_iteration(data, result)
-
-    def end_for_iteration(self, data, result):
-        for listener in self.listeners:
-            listener.end_for_iteration(data, result)
-
-    def start_while(self, data, result):
-        for listener in self.listeners:
-            listener.start_while(data, result)
-
-    def end_while(self, data, result):
-        for listener in self.listeners:
-            listener.end_while(data, result)
-
-    def start_while_iteration(self, data, result):
-        for listener in self.listeners:
-            listener.start_while_iteration(data, result)
-
-    def end_while_iteration(self, data, result):
-        for listener in self.listeners:
-            listener.end_while_iteration(data, result)
-
-    def start_if(self, data, result):
-        for listener in self.listeners:
-            listener.start_if(data, result)
-
-    def end_if(self, data, result):
-        for listener in self.listeners:
-            listener.end_if(data, result)
-
-    def start_if_branch(self, data, result):
-        for listener in self.listeners:
-            listener.start_if_branch(data, result)
-
-    def end_if_branch(self, data, result):
-        for listener in self.listeners:
-            listener.end_if_branch(data, result)
-
-    def start_try(self, data, result):
-        for listener in self.listeners:
-            listener.start_try(data, result)
-
-    def end_try(self, data, result):
-        for listener in self.listeners:
-            listener.end_try(data, result)
-
-    def start_try_branch(self, data, result):
-        for listener in self.listeners:
-            listener.start_try_branch(data, result)
-
-    def end_try_branch(self, data, result):
-        for listener in self.listeners:
-            listener.end_try_branch(data, result)
-
-    def start_return(self, data, result):
-        for listener in self.listeners:
-            listener.start_return(data, result)
-
-    def end_return(self, data, result):
-        for listener in self.listeners:
-            listener.end_return(data, result)
-
-    def start_continue(self, data, result):
-        for listener in self.listeners:
-            listener.start_continue(data, result)
-
-    def end_continue(self, data, result):
-        for listener in self.listeners:
-            listener.end_continue(data, result)
-
-    def start_break(self, data, result):
-        for listener in self.listeners:
-            listener.start_break(data, result)
-
-    def end_break(self, data, result):
-        for listener in self.listeners:
-            listener.end_break(data, result)
-
-    def start_error(self, data, result):
-        for listener in self.listeners:
-            listener.start_error(data, result)
-
-    def end_error(self, data, result):
-        for listener in self.listeners:
-            listener.end_error(data, result)
-
-    def start_var(self, data, result):
-        for listener in self.listeners:
-            listener.start_var(data, result)
-
-    def end_var(self, data, result):
-        for listener in self.listeners:
-            listener.end_var(data, result)
-
     def set_log_level(self, level):
         self._is_logged.set_level(level)
 
-    def log_message(self, message):
-        if self._is_logged(message.level):
-            for listener in self.listeners:
-                listener.log_message(message)
-
-    def message(self, message):
-        for listener in self.listeners:
-            listener.message(message)
-
-    def imported(self, import_type, name, attrs):
-        for listener in self.listeners:
-            listener.imported(import_type, name, attrs)
-
-    def output_file(self, path):
-        for listener in self.listeners:
-            listener.output_file(path)
+    def __iter__(self):
+        return iter(self.listeners)
 
-    def report_file(self, path):
-        for listener in self.listeners:
-            listener.report_file(path)
-
-    def log_file(self, path):
-        for listener in self.listeners:
-            listener.log_file(path)
-
-    def xunit_file(self, path):
-        for listener in self.listeners:
-            listener.xunit_file(path)
-
-    def debug_file(self, path):
-        for listener in self.listeners:
-            listener.debug_file(path)
-
-    def close(self):
-        for listener in self.listeners:
-            listener.close()
-
-    def __bool__(self):
-        return bool(self.listeners)
+    def __len__(self):
+        return len(self.listeners)
 
 
 class LibraryListeners(Listeners):
@@ -296,9 +110,6 @@ class LibraryListeners(Listeners):
         listeners = self._import_listeners(library.listeners, library=library)
         self._listeners[-1].extend(listeners)
 
-    def close(self):
-        pass
-
     def unregister(self, library, close=False):
         remaining = []
         for listener in self._listeners[-1]:
@@ -311,10 +122,19 @@ class LibraryListeners(Listeners):
 
 class ListenerFacade(LoggerApi, ABC):
 
-    def __init__(self, listener, name, library=None):
+    def __init__(self, listener, name, is_logged, library=None):
         self.listener = listener
         self.name = name
+        self._is_logged = is_logged
         self.library = library
+        self.priority = self._get_priority(listener)
+
+    def _get_priority(self, listener):
+        priority = getattr(listener, 'ROBOT_LISTENER_PRIORITY', 0)
+        try:
+            return float(priority)
+        except (ValueError, TypeError):
+            raise DataError(f"Invalid listener priority '{priority}'.")
 
     def _get_method(self, name, fallback=None):
         for method_name in self._get_method_names(name):
@@ -336,8 +156,8 @@ class ListenerFacade(LoggerApi, ABC):
 
 class ListenerV3Facade(ListenerFacade):
 
-    def __init__(self, listener, name, library=None):
-        super().__init__(listener, name, library)
+    def __init__(self, listener, name, is_logged, library=None):
+        super().__init__(listener, name, is_logged, library)
         get = self._get_method
         # Suite
         self.start_suite = get('start_suite')
@@ -393,14 +213,18 @@ class ListenerV3Facade(ListenerFacade):
         self.start_error = get('start_error', start_body_item)
         self.end_error = get('end_error', end_body_item)
         # Messages
-        self.log_message = get('log_message')
+        self._log_message = get('log_message')
         self.message = get('message')
+        # Imports
+        self.library_import = get('library_import')
+        self.resource_import = get('resource_import')
+        self.variables_import = get('variables_import')
         # Result files
-        self.output_file = self._get_method('output_file')
-        self.report_file = self._get_method('report_file')
-        self.log_file = self._get_method('log_file')
-        self.xunit_file = self._get_method('xunit_file')
-        self.debug_file = self._get_method('debug_file')
+        self.output_file = get('output_file')
+        self.report_file = get('report_file')
+        self.log_file = get('log_file')
+        self.xunit_file = get('xunit_file')
+        self.debug_file = get('debug_file')
         # Close
         self.close = get('close')
 
@@ -440,11 +264,15 @@ class ListenerV3Facade(ListenerFacade):
         else:
             self.end_keyword(data, result)
 
+    def log_message(self, message):
+        if self._is_logged(message.level):
+            self._log_message(message)
+
 
 class ListenerV2Facade(ListenerFacade):
 
-    def __init__(self, listener, name, library=None):
-        super().__init__(listener, name, library)
+    def __init__(self, listener, name, is_logged, library=None):
+        super().__init__(listener, name, is_logged, library)
         # Suite
         self._start_suite = self._get_method('start_suite')
         self._end_suite = self._get_method('end_suite')
@@ -457,6 +285,10 @@ class ListenerV2Facade(ListenerFacade):
         # Messages
         self._log_message = self._get_method('log_message')
         self._message = self._get_method('message')
+        # Imports
+        self._library_import = self._get_method('library_import')
+        self._resource_import = self._get_method('resource_import')
+        self._variables_import = self._get_method('variables_import')
         # Result files
         self._output_file = self._get_method('output_file')
         self._report_file = self._get_method('report_file')
@@ -466,10 +298,6 @@ class ListenerV2Facade(ListenerFacade):
         # Close
         self._close = self._get_method('close')
 
-    def imported(self, import_type: str, name: str, attrs):
-        method = self._get_method(f'{import_type.lower()}_import')
-        method(name, attrs)
-
     def start_suite(self, data, result):
         self._start_suite(result.name, self._suite_attrs(data, result))
 
@@ -602,11 +430,27 @@ class ListenerV2Facade(ListenerFacade):
         return {'name': result.name, 'value': value, 'scope': result.scope or 'LOCAL'}
 
     def log_message(self, message):
-        self._log_message(self._message_attributes(message))
+        if self._is_logged(message.level):
+            self._log_message(self._message_attributes(message))
 
     def message(self, message):
         self._message(self._message_attributes(message))
 
+    def library_import(self, library, importer):
+        self._library_import(library.name, {'args': list(importer.args),
+                                            'originalname': library.real_name,
+                                            'source': str(library.source or ''),
+                                            'importer': str(importer.source)})
+
+    def resource_import(self, resource, importer):
+        self._resource_import(resource.name, {'source': str(resource.source),
+                                              'importer': str(importer.source)})
+
+    def variables_import(self, attrs: dict, importer):
+        self._variables_import(attrs['name'], {'args': list(attrs['args']),
+                                               'source': str(attrs['source']),
+                                               'importer': str(importer.source)})
+
     def output_file(self, path: Path):
         self._output_file(str(path))