robotframework 7.1.1__zip → 7.2b1__zip

{robotframework-7.1.1 → robotframework-7.2b1}/src/robot/output/listeners.py

@@ -16,6 +16,7 @@
 import os.path
 from abc import ABC
 from pathlib import Path
+from typing import Any, Iterable
 
 from robot.errors import DataError, TimeoutError
 from robot.model import BodyItem
@@ -23,15 +24,17 @@ from robot.utils import (get_error_details, Importer, safe_str,
                          split_args_from_name_or_path, type_name)
 
 from .loggerapi import LoggerApi
-from .loggerhelper import IsLogged
 from .logger import LOGGER
+from .loglevel import LogLevel
 
 
 class Listeners:
     _listeners: 'list[ListenerFacade]'
 
-    def __init__(self, listeners=(), log_level='INFO'):
-        self._is_logged = IsLogged(log_level)
+    def __init__(self, listeners: Iterable['str|Any'] = (),
+                 log_level: 'LogLevel|str' = 'INFO'):
+        self._log_level = log_level \
+                if isinstance(log_level, LogLevel) else LogLevel(log_level)
         self._listeners = self._import_listeners(listeners)
 
     # Must be property to allow LibraryListeners to override it.
@@ -67,8 +70,8 @@ class Listeners:
             # 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, self._is_logged, library)
-        return ListenerV3Facade(listener, name, self._is_logged, library)
+            return ListenerV2Facade(listener, name, self._log_level, library)
+        return ListenerV3Facade(listener, name, self._log_level, library)
 
     def _get_version(self, listener):
         version = getattr(listener, 'ROBOT_LISTENER_API_VERSION', 3)
@@ -80,9 +83,6 @@ class Listeners:
             raise DataError(f"Unsupported API version '{version}'.")
         return version
 
-    def set_log_level(self, level):
-        self._is_logged.set_level(level)
-
     def __iter__(self):
         return iter(self.listeners)
 
@@ -93,7 +93,7 @@ class Listeners:
 class LibraryListeners(Listeners):
     _listeners: 'list[list[ListenerFacade]]'
 
-    def __init__(self, log_level='INFO'):
+    def __init__(self, log_level: 'LogLevel|str' = 'INFO'):
         super().__init__(log_level=log_level)
 
     @property
@@ -122,10 +122,10 @@ class LibraryListeners(Listeners):
 
 class ListenerFacade(LoggerApi, ABC):
 
-    def __init__(self, listener, name, is_logged, library=None):
+    def __init__(self, listener, name, log_level, library=None):
         self.listener = listener
         self.name = name
-        self._is_logged = is_logged
+        self._is_logged = log_level.is_logged
         self.library = library
         self.priority = self._get_priority(listener)
 
@@ -141,7 +141,7 @@ class ListenerFacade(LoggerApi, ABC):
             method = getattr(self.listener, method_name, None)
             if method:
                 return ListenerMethod(method, self.name)
-        return ListenerMethod(None, self.name) if fallback is None else fallback
+        return fallback or ListenerMethod(None, self.name)
 
     def _get_method_names(self, name):
         names = [name, self._to_camelCase(name)] if '_' in name else [name]
@@ -156,8 +156,8 @@ class ListenerFacade(LoggerApi, ABC):
 
 class ListenerV3Facade(ListenerFacade):
 
-    def __init__(self, listener, name, is_logged, library=None):
-        super().__init__(listener, name, is_logged, library)
+    def __init__(self, listener, name, log_level, library=None):
+        super().__init__(listener, name, log_level, library)
         get = self._get_method
         # Suite
         self.start_suite = get('start_suite')
@@ -166,8 +166,8 @@ class ListenerV3Facade(ListenerFacade):
         self.start_test = get('start_test')
         self.end_test = get('end_test')
         # Fallbacks for body items
-        start_body_item = self._get_method('start_body_item')
-        end_body_item = self._get_method('end_body_item')
+        start_body_item = get('start_body_item')
+        end_body_item = get('end_body_item')
         # Keywords
         self.start_keyword = get('start_keyword', start_body_item)
         self.end_keyword = get('end_keyword', end_body_item)
@@ -197,6 +197,9 @@ class ListenerV3Facade(ListenerFacade):
         self.end_while = get('end_while', end_body_item)
         self.start_while_iteration = get('start_while_iteration', start_body_item)
         self.end_while_iteration = get('end_while_iteration', end_body_item)
+        # GROUP
+        self.start_group = get('start_group', start_body_item)
+        self.end_group = get('end_group', end_body_item)
         # VAR
         self.start_var = get('start_var', start_body_item)
         self.end_var = get('end_var', end_body_item)
@@ -265,38 +268,39 @@ class ListenerV3Facade(ListenerFacade):
             self.end_keyword(data, result)
 
     def log_message(self, message):
-        if self._is_logged(message.level):
+        if self._is_logged(message):
             self._log_message(message)
 
 
 class ListenerV2Facade(ListenerFacade):
 
-    def __init__(self, listener, name, is_logged, library=None):
-        super().__init__(listener, name, is_logged, library)
+    def __init__(self, listener, name, log_level, library=None):
+        super().__init__(listener, name, log_level, library)
+        get = self._get_method
         # Suite
-        self._start_suite = self._get_method('start_suite')
-        self._end_suite = self._get_method('end_suite')
+        self._start_suite = get('start_suite')
+        self._end_suite = get('end_suite')
         # Test
-        self._start_test = self._get_method('start_test')
-        self._end_test = self._get_method('end_test')
+        self._start_test = get('start_test')
+        self._end_test = get('end_test')
         # Keyword and control structures
-        self._start_kw = self._get_method('start_keyword')
-        self._end_kw = self._get_method('end_keyword')
+        self._start_kw = get('start_keyword')
+        self._end_kw = get('end_keyword')
         # Messages
-        self._log_message = self._get_method('log_message')
-        self._message = self._get_method('message')
+        self._log_message = get('log_message')
+        self._message = get('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')
+        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 = self._get_method('close')
+        self._close = get('close')
 
     def start_suite(self, data, result):
         self._start_suite(result.name, self._suite_attrs(data, result))
@@ -363,6 +367,12 @@ class ListenerV2Facade(ListenerFacade):
     def end_while_iteration(self, data, result):
         self._end_kw(result._log_name, self._attrs(data, result, end=True))
 
+    def start_group(self, data, result):
+        self._start_kw(result._log_name, self._attrs(data, result, name=result.name))
+
+    def end_group(self, data, result):
+        self._end_kw(result._log_name, self._attrs(data, result, name=result.name, end=True))
+
     def start_if_branch(self, data, result):
         extra = {'condition': result.condition} if result.type != result.ELSE else {}
         self._start_kw(result._log_name, self._attrs(data, result, **extra))
@@ -430,7 +440,7 @@ class ListenerV2Facade(ListenerFacade):
         return {'name': result.name, 'value': value, 'scope': result.scope or 'LOCAL'}
 
     def log_message(self, message):
-        if self._is_logged(message.level):
+        if self._is_logged(message):
             self._log_message(self._message_attributes(message))
 
     def message(self, message):
@@ -566,21 +576,15 @@ class ListenerV2Facade(ListenerFacade):
 
 
 class ListenerMethod:
-    # Flag to avoid recursive listener calls.
-    called = False
 
     def __init__(self, method, name):
         self.method = method
         self.listener_name = name
 
     def __call__(self, *args):
-        if self.method is None:
-            return
-        if self.called:
-            return
         try:
-            ListenerMethod.called = True
-            self.method(*args)
+            if self.method is not None:
+                self.method(*args)
         except TimeoutError:
             # Propagate possible timeouts:
             # https://github.com/robotframework/robotframework/issues/2763
@@ -590,8 +594,6 @@ class ListenerMethod:
             LOGGER.error(f"Calling method '{self.method.__name__}' of listener "
                          f"'{self.listener_name}' failed: {message}")
             LOGGER.info(f"Details:\n{details}")
-        finally:
-            ListenerMethod.called = False
 
     def __bool__(self):
         return self.method is not None

{robotframework-7.1.1 → robotframework-7.2b1}/src/robot/output/logger.py

@@ -26,19 +26,15 @@ from .stdoutlogsplitter import StdoutLogSplitter
 
 def start_body_item(method):
     def wrapper(self, *args):
-        # TODO: Could _prev_log_message_handlers be used also here?
-        self._started_keywords += 1
-        self.log_message = self._log_message
+        self._log_message_parents.append(args[-1])
         method(self, *args)
     return wrapper
 
 
 def end_body_item(method):
     def wrapper(self, *args):
-        self._started_keywords -= 1
         method(self, *args)
-        if not self._started_keywords:
-            self.log_message = self.message
+        self._log_message_parents.pop()
     return wrapper
 
 
@@ -55,16 +51,16 @@ class Logger(AbstractLogger):
     def __init__(self, register_console_logger=True):
         self._console_logger = None
         self._syslog = None
-        self._xml_logger = None
+        self._output_file = None
         self._cli_listeners = None
         self._lib_listeners = None
         self._other_loggers = []
         self._message_cache = []
         self._log_message_cache = None
-        self._started_keywords = 0
+        self._log_message_parents = []
+        self._library_import_logging = 0
         self._error_occurred = False
         self._error_listener = None
-        self._prev_log_message_handlers = []
         self._enabled = 0
         self._cache_only = False
         if register_console_logger:
@@ -79,14 +75,14 @@ class Logger(AbstractLogger):
     @property
     def start_loggers(self):
         loggers = (self._other_loggers
-                   + [self._console_logger, self._syslog, self._xml_logger]
+                   + [self._console_logger, self._syslog, self._output_file]
                    + self._listeners)
         return [logger for logger in loggers if logger]
 
     @property
     def end_loggers(self):
         loggers = (self._listeners
-                   + [self._console_logger, self._syslog, self._xml_logger]
+                   + [self._console_logger, self._syslog, self._output_file]
                    + self._other_loggers)
         return [logger for logger in loggers if logger]
 
@@ -133,11 +129,11 @@ class Logger(AbstractLogger):
         else:
             self._syslog = self._wrap_and_relay(syslog)
 
-    def register_xml_logger(self, logger):
-        self._xml_logger = self._wrap_and_relay(logger)
+    def register_output_file(self, logger):
+        self._output_file = self._wrap_and_relay(logger)
 
-    def unregister_xml_logger(self):
-        self._xml_logger = None
+    def unregister_output_file(self):
+        self._output_file = None
 
     def register_listeners(self, listeners, library_listeners):
         self._cli_listeners = listeners
@@ -196,6 +192,12 @@ class Logger(AbstractLogger):
             for msg in messages or ():
                 self._log_message(msg, no_cache=True)
 
+    def log_message(self, msg, no_cache=False):
+        if self._log_message_parents and not self._library_import_logging:
+            self._log_message(msg, no_cache)
+        else:
+            self.message(msg)
+
     def _log_message(self, msg, no_cache=False):
         """Log messages written (mainly) by libraries."""
         if self._log_message_cache is not None and not no_cache:
@@ -204,21 +206,20 @@ class Logger(AbstractLogger):
             return
         for logger in self:
             logger.log_message(msg)
+        if self._log_message_parents and self._output_file.is_logged(msg):
+            self._log_message_parents[-1].body.append(msg)
         if msg.level in ('WARN', 'ERROR'):
             self.message(msg)
 
-    log_message = message
-
     def log_output(self, output):
         for msg in StdoutLogSplitter(output):
             self.log_message(msg)
 
     def enable_library_import_logging(self):
-        self._prev_log_message_handlers.append(self.log_message)
-        self.log_message = self.message
+        self._library_import_logging += 1
 
     def disable_library_import_logging(self):
-        self.log_message = self._prev_log_message_handlers.pop()
+        self._library_import_logging -= 1
 
     def start_suite(self, data, result):
         for logger in self.start_loggers:
@@ -229,12 +230,14 @@ class Logger(AbstractLogger):
             logger.end_suite(data, result)
 
     def start_test(self, data, result):
+        self._log_message_parents.append(result)
         for logger in self.start_loggers:
             logger.start_test(data, result)
 
     def end_test(self, data, result):
         for logger in self.end_loggers:
             logger.end_test(data, result)
+        self._log_message_parents.pop()
 
     @start_body_item
     def start_keyword(self, data, result):
@@ -316,6 +319,16 @@ class Logger(AbstractLogger):
         for logger in self.end_loggers:
             logger.end_while_iteration(data, result)
 
+    @start_body_item
+    def start_group(self, data, result):
+        for logger in self.start_loggers:
+            logger.start_group(data, result)
+
+    @end_body_item
+    def end_group(self, data, result):
+        for logger in self.end_loggers:
+            logger.end_group(data, result)
+
     @start_body_item
     def start_if(self, data, result):
         for logger in self.start_loggers:

{robotframework-7.1.1 → robotframework-7.2b1}/src/robot/output/loggerapi.py

@@ -98,6 +98,12 @@ class LoggerApi:
                             result: 'result.WhileIteration'):
         self.end_body_item(data, result)
 
+    def start_group(self, data: 'running.Group', result: 'result.Group'):
+        self.start_body_item(data, result)
+
+    def end_group(self, data: 'running.Group', result: 'result.Group'):
+        self.end_body_item(data, result)
+
     def start_if(self, data: 'running.If', result: 'result.If'):
         self.start_body_item(data, result)
 

{robotframework-7.1.1 → robotframework-7.2b1}/src/robot/output/loggerhelper.py

@@ -18,20 +18,13 @@ from datetime import datetime
 from typing import Callable, Literal
 
 from robot.errors import DataError
-from robot.model import Message as BaseMessage, MessageLevel
-from robot.utils import console_encode, safe_str
-
-
-LEVELS = {
-  'NONE'  : 7,
-  'SKIP'  : 6,
-  'FAIL'  : 5,
-  'ERROR' : 4,
-  'WARN'  : 3,
-  'INFO'  : 2,
-  'DEBUG' : 1,
-  'TRACE' : 0,
-}
+from robot.model import MessageLevel
+from robot.result import Message as BaseMessage
+from robot.utils import console_encode
+
+from .loglevel import LEVELS
+
+
 PseudoLevel = Literal['HTML', 'CONSOLE']
 
 
@@ -47,12 +40,6 @@ def write_to_console(msg, newline=True, stream='stdout'):
 
 class AbstractLogger:
 
-    def __init__(self, level='TRACE'):
-        self._is_logged = IsLogged(level)
-
-    def set_level(self, level):
-        return self._is_logged.set_level(level)
-
     def trace(self, msg):
         self.write(msg, 'TRACE')
 
@@ -90,9 +77,22 @@ class AbstractLogger:
 
 
 class Message(BaseMessage):
+    """Represents message logged during execution.
+
+    Most messages are logged by libraries. They typically log strings, but
+    possible non-string items have been converted to strings already before
+    they end up here.
+
+    In addition to strings, Robot Framework itself logs also callables to make
+    constructing messages that are not typically needed lazy. Such messages are
+    resolved when they are accessed.
+
+    Listeners can remove messages by setting the `message` attribute to `None`.
+    These messages are not written to the output.xml at all.
+    """
     __slots__ = ['_message']
 
-    def __init__(self, message: 'str|Callable[[], str]',
+    def __init__(self, message: 'str|None|Callable[[], str|None]' = '',
                  level: 'MessageLevel|PseudoLevel' = 'INFO',
                  html: bool = False,
                  timestamp: 'datetime|str|None' = None):
@@ -110,45 +110,16 @@ class Message(BaseMessage):
         raise DataError(f"Invalid log level '{level}'.")
 
     @property
-    def message(self) -> str:
+    def message(self) -> 'str|None':
         self.resolve_delayed_message()
         return self._message
 
     @message.setter
-    def message(self, message: 'str|Callable[[], str]'):
-        if not callable(message):
-            if not isinstance(message, str):
-                message = safe_str(message)
-            if '\r\n' in message:
-                message = message.replace('\r\n', '\n')
+    def message(self, message: 'str|None|Callable[[], str|None]'):
+        if isinstance(message, str) and '\r\n' in message:
+            message = message.replace('\r\n', '\n')
         self._message = message
 
     def resolve_delayed_message(self):
         if callable(self._message):
-            self._message = self._message()
-
-
-class IsLogged:
-
-    def __init__(self, level):
-        self.level = level.upper()
-        self._int_level = self._level_to_int(level)
-
-    def __call__(self, level):
-        return self._level_to_int(level) >= self._int_level
-
-    def set_level(self, level):
-        old = self.level
-        self.__init__(level)
-        return old
-
-    @classmethod
-    def validate_level(cls, level):
-        cls._level_to_int(level)
-
-    @classmethod
-    def _level_to_int(cls, level):
-        try:
-            return LEVELS[level.upper()]
-        except KeyError:
-            raise DataError("Invalid log level '%s'." % level)
+            self.message = self._message()

robotframework-7.2b1/src/robot/output/loglevel.py

@@ -0,0 +1,54 @@
+#  Copyright 2008-2015 Nokia Networks
+#  Copyright 2016-     Robot Framework Foundation
+#
+#  Licensed under the Apache License, Version 2.0 (the "License");
+#  you may not use this file except in compliance with the License.
+#  You may obtain a copy of the License at
+#
+#      http://www.apache.org/licenses/LICENSE-2.0
+#
+#  Unless required by applicable law or agreed to in writing, software
+#  distributed under the License is distributed on an "AS IS" BASIS,
+#  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+#  See the License for the specific language governing permissions and
+#  limitations under the License.
+
+from typing import TYPE_CHECKING
+
+from robot.errors import DataError
+
+if TYPE_CHECKING:
+    from .loggerhelper import Message
+
+
+LEVELS = {
+  'NONE'  : 7,
+  'SKIP'  : 6,
+  'FAIL'  : 5,
+  'ERROR' : 4,
+  'WARN'  : 3,
+  'INFO'  : 2,
+  'DEBUG' : 1,
+  'TRACE' : 0,
+}
+
+
+class LogLevel:
+
+    def __init__(self, level):
+        self.priority = self._get_priority(level)
+        self.level = level.upper()
+
+    def is_logged(self, msg: 'Message'):
+        return LEVELS[msg.level] >= self.priority and msg.message is not None
+
+    def set(self, level):
+        old = self.level
+        self.__init__(level)
+        return old
+
+    def _get_priority(self, level):
+        try:
+            return LEVELS[level.upper()]
+        except KeyError:
+            raise DataError(f"Invalid log level '{level}'.")

{robotframework-7.1.1 → robotframework-7.2b1}/src/robot/output/output.py

@@ -18,19 +18,19 @@ from .debugfile import DebugFile
 from .listeners import Listeners, LibraryListeners
 from .logger import LOGGER
 from .loggerapi import LoggerApi
-from .loggerhelper import AbstractLogger, IsLogged
-from .xmllogger import XmlLoggerAdapter
+from .loggerhelper import AbstractLogger
+from .loglevel import LogLevel
+from .outputfile import OutputFile
 
 
 class Output(AbstractLogger, LoggerApi):
 
     def __init__(self, settings):
-        AbstractLogger.__init__(self)
-        self._xml_logger = XmlLoggerAdapter(settings.output, settings.log_level,
-                                            settings.rpa,
-                                            legacy_output=settings.legacy_output)
-        self.listeners = Listeners(settings.listeners, settings.log_level)
-        self.library_listeners = LibraryListeners(settings.log_level)
+        self.log_level = LogLevel(settings.log_level)
+        self.output_file = OutputFile(settings.output, self.log_level, settings.rpa,
+                                      legacy_output=settings.legacy_output)
+        self.listeners = Listeners(settings.listeners, self.log_level)
+        self.library_listeners = LibraryListeners(self.log_level)
         self._register_loggers(DebugFile(settings.debug_file))
         self._settings = settings
 
@@ -39,7 +39,7 @@ class Output(AbstractLogger, LoggerApi):
         return self._settings.log_level
 
     def _register_loggers(self, debug_file):
-        LOGGER.register_xml_logger(self._xml_logger)
+        LOGGER.register_output_file(self.output_file)
         LOGGER.register_listeners(self.listeners or None, self.library_listeners)
         if debug_file:
             LOGGER.register_logger(debug_file)
@@ -52,9 +52,9 @@ class Output(AbstractLogger, LoggerApi):
         return LOGGER.delayed_logging
 
     def close(self, result):
-        self._xml_logger.logger.visit_statistics(result.statistics)
-        self._xml_logger.close()
-        LOGGER.unregister_xml_logger()
+        self.output_file.statistics(result.statistics)
+        self.output_file.close()
+        LOGGER.unregister_output_file()
         LOGGER.output_file(self._settings['Output'])
 
     def start_suite(self, data, result):
@@ -117,6 +117,12 @@ class Output(AbstractLogger, LoggerApi):
     def end_while_iteration(self, data, result):
         LOGGER.end_while_iteration(data, result)
 
+    def start_group(self, data, result):
+        LOGGER.start_group(data, result)
+
+    def end_group(self, data, result):
+        LOGGER.end_group(data, result)
+
     def start_if(self, data, result):
         LOGGER.start_if(data, result)
 
@@ -175,12 +181,10 @@ class Output(AbstractLogger, LoggerApi):
         LOGGER.log_message(msg)
 
     def trace(self, msg, write_if_flat=True):
-        if write_if_flat or not self._xml_logger.flatten_level:
+        if write_if_flat or not self.output_file.flatten_level:
             self.write(msg, 'TRACE')
 
     def set_log_level(self, level):
-        IsLogged.validate_level(level)
+        old = self.log_level.set(level)
         pyloggingconf.set_level(level)
-        self.listeners.set_log_level(level)
-        self.library_listeners.set_log_level(level)
-        return self._xml_logger.set_log_level(level)
+        return old