Add context to temporarily enable/disable showing stream data in console

MHendricks · MHendricks · commit 5ce632529fcc · 2025-12-11T17:04:59.000-08:00
The `preditor.contexts.OverrideConsoleStreams` context manager can enable
or disable echoing tracebacks, stdout, stderr, results for consoles.
diff --git a/examples/output_console.py b/examples/output_console.py
@@ -12,12 +12,18 @@
 from Qt.QtWidgets import QApplication, QMainWindow
 
 import preditor
+from preditor.contexts import OverrideConsoleStreams
 
 logger_a = logging.getLogger("logger_a")
 logger_a_child = logging.getLogger("logger_a.child")
 logger_b = logging.getLogger("logger_b")
 logger_c = logging.getLogger("logger_c")
 
+# Define a custom logging level name. This should be discouraged but logging
+# supports it so PrEditor should as well.
+SUPER_INFO_LEVEL = logging.INFO - 5
+logging.addLevelName(SUPER_INFO_LEVEL, "SUPER_INFO")
+
 
 class ExampleApp(QMainWindow):
     def __init__(self, parent=None):
@@ -29,6 +35,11 @@ def __init__(self, parent=None):
         self.uiClearBTN.released.connect(self.clear_all)
         self.uiAllLoggingDebugBTN.released.connect(self.all_logging_level_debug)
         self.uiAllLoggingWarningBTN.released.connect(self.all_logging_level_warning)
+        self.uiAllLoggingPrintBTN.released.connect(self.all_logging_print)
+        self.uiAllLoggingRaiseBTN.released.connect(self.all_logging_raise)
+        self.uiAllLoggingChangeHandlersBTN.released.connect(
+            self.all_logging_change_handlers
+        )
         self.uiLoggingCriticalBTN.released.connect(self.level_critical)
         self.uiLoggingErrorBTN.released.connect(self.level_error)
         self.uiLoggingWarningBTN.released.connect(self.level_warning)
@@ -76,6 +87,24 @@ def __init__(self, parent=None):
         # Configure uiStderr to only show stderr text
         self.uiStderr.stream_echo_stderr = True
 
+    def all_logging_change_handlers(self):
+        """Demonstrate temporarily changing logging_handlers for uiAllLog.
+
+        This changes uiAllLog to only show a subset of loggers not all of them.
+        It sends the same logging messages as the "Send Logging Message" Button,
+        but due to the updated filtering it shows very different results.
+        """
+        handlers = [
+            # Only show logger_a warnings
+            "logger_a_child,level=WARNING",
+            # And enable showing a custom logging level message. This is normally
+            # hidden unless the logging level is set to debug or SUPER_INFO.
+            # Note that we can pass SUPER_INFO because of the `addLevelName` call.
+            "logger_c,level=SUPER_INFO",
+        ]
+        with OverrideConsoleStreams(self.uiAllLog, logging_handlers=handlers):
+            self.send_logging()
+
     def all_logging_level_debug(self):
         """Update this widget to show up to debug messages for all loggers.
         Hide the PyQt loggers as they just clutter the output for this demo.
@@ -101,6 +130,18 @@ def all_logging_level_warning(self):
             "logger_b,fmt=[%(levelname)s:%(name)s] %(message)s",
         ]
 
+    def all_logging_print(self):
+        """Show temporarily enabling showing prints inside multiple consoles."""
+        with OverrideConsoleStreams([self.uiAllLog, self.uiSelectLog], stdout=True):
+            print("This print is also shown in All logging and Select Logging.")
+        print("This print is NOT shown in All logging and Select Logging.")
+
+    def all_logging_raise(self):
+        """Show temporarily enabling showing tracebacks in uiAllLog."""
+        with OverrideConsoleStreams(self.uiAllLog, tracebacks=True):
+            print("This print is NOT shown in All logging.")
+            raise RuntimeError("This Exception is also shown in All logging.")
+
     def clear_all(self):
         """Clear the text from all consoles"""
         self.uiAllLog.clear()
@@ -147,6 +188,11 @@ def send_logging(self):
         logger_b.debug("A debug msg for logger_b")
         logger_c.warning("A warning msg for logger_c")
         logger_c.debug("A debug msg for logger_c")
+        logger_c.log(
+            SUPER_INFO_LEVEL,
+            "A custom logging level msg for logger_c that is normally hidden "
+            "unless using debug or the custom level.",
+        )
         logging.root.warning("A warning msg for logging.root")
         logging.root.debug("A debug msg for logging.root")
 
diff --git a/examples/output_console.ui b/examples/output_console.ui
@@ -6,7 +6,7 @@
    <rect>
     <x>0</x>
     <y>0</y>
-    <width>667</width>
+    <width>861</width>
     <height>941</height>
    </rect>
   </property>
@@ -29,22 +29,39 @@
          <widget class="OutputConsole" name="uiAllLog"/>
         </item>
         <item>
-         <layout class="QVBoxLayout" name="verticalLayout">
-          <item>
+         <layout class="QGridLayout" name="gridLayout">
+          <item row="0" column="0">
            <widget class="QPushButton" name="uiAllLoggingWarningBTN">
             <property name="text">
              <string>Warning</string>
             </property>
            </widget>
           </item>
-          <item>
+          <item row="0" column="1">
            <widget class="QPushButton" name="uiAllLoggingDebugBTN">
             <property name="text">
              <string>Debug</string>
             </property>
            </widget>
           </item>
-          <item>
+          <item row="2" column="0" colspan="2">
+           <widget class="Line" name="line">
+            <property name="orientation">
+             <enum>Qt::Horizontal</enum>
+            </property>
+           </widget>
+          </item>
+          <item row="3" column="0" colspan="2">
+           <widget class="QPushButton" name="uiAllLoggingRaiseBTN">
+            <property name="toolTip">
+             <string>&lt;html&gt;&lt;head/&gt;&lt;body&gt;&lt;p&gt;Uses preditor.contexts.OverrideConsoleStreams to temporarily enable showing tracebacks in all logging and raises an exception. This enables showing errors in that console but errors raised elsewhere won't be shown in that console.&lt;/p&gt;&lt;/body&gt;&lt;/html&gt;</string>
+            </property>
+            <property name="text">
+             <string>Raise and show Exception</string>
+            </property>
+           </widget>
+          </item>
+          <item row="1" column="0" colspan="2">
            <widget class="QLabel" name="label_2">
             <property name="text">
              <string>Set the logging level filter for this widget. This is affected by the global logging levels set at the bottom of this UI, so to see debug output you must set both to debug.</string>
@@ -54,15 +71,35 @@
             </property>
            </widget>
           </item>
-          <item>
+          <item row="4" column="0">
+           <widget class="QPushButton" name="uiAllLoggingPrintBTN">
+            <property name="toolTip">
+             <string>&lt;html&gt;&lt;head/&gt;&lt;body&gt;&lt;p&gt;Uses preditor.contexts.OverrideConsoleStreams to temporarily enable showing stdout(prints). It also shows the print in Select Logging.&lt;/p&gt;&lt;/body&gt;&lt;/html&gt;</string>
+            </property>
+            <property name="text">
+             <string>Show print</string>
+            </property>
+           </widget>
+          </item>
+          <item row="4" column="1">
+           <widget class="QPushButton" name="uiAllLoggingChangeHandlersBTN">
+            <property name="toolTip">
+             <string>&lt;html&gt;&lt;head/&gt;&lt;body&gt;&lt;p&gt;Sends the same logging messages as the &amp;quot;Send Logging Messages&amp;quot; button.&lt;/p&gt;&lt;p&gt;However it uses preditor.contexts.OverrideConsoleStreams to temporarily replace logging handlers for uiAllLog. This results in very different output being shown.&lt;/p&gt;&lt;p&gt;If you use the bottom Debug button to set the global logging level to debug you will also see the SUPER_INFO log message.&lt;/p&gt;&lt;/body&gt;&lt;/html&gt;</string>
+            </property>
+            <property name="text">
+             <string>Logging Handlers</string>
+            </property>
+           </widget>
+          </item>
+          <item row="5" column="1">
            <spacer name="verticalSpacer">
             <property name="orientation">
              <enum>Qt::Vertical</enum>
             </property>
             <property name="sizeHint" stdset="0">
              <size>
               <width>20</width>
-              <height>40</height>
+              <height>0</height>
              </size>
             </property>
            </spacer>
diff --git a/preditor/contexts.py b/preditor/contexts.py
@@ -1,6 +1,8 @@
-from __future__ import absolute_import, print_function
+from __future__ import absolute_import
 
 import logging
+from contextlib import contextmanager
+from typing import List, Tuple
 
 _LOGGER = logging.getLogger(__name__)
 
@@ -60,7 +62,7 @@ def doMoreStuff(self):
             memory if there isn't a excepthook calling clearReports.
     """
 
-    __reports__ = []
+    __reports__: List[Tuple[str, str]] = []
     enabled = False
 
     def __init__(self, callback, title=''):
@@ -117,3 +119,92 @@ def generateReport(cls, fmt='{result}'):
             result = callback()
             ret.append((title, fmt.format(result=result)))
         return ret
+
+
+@contextmanager
+def OverrideConsoleStreams(
+    consoles,
+    tracebacks=None,
+    stdout=None,
+    stderr=None,
+    result=None,
+    logging_handlers=None,
+):
+    """Override a Console's stream and logging_handlers settings.
+
+    This is useful if you don't want to show tracebacks or output for un-related code.
+
+    Example:
+
+        console = OutputConsole()
+        with OverrideConsoleStreams(console, tracebacks=True)
+            # A traceback raised here would show in console
+            do_work_you_only_want_to_show_tracebacks_in_console()
+        raise RuntimeError("This traceback will not be shown in console")
+    """
+    # If a single console was passed, convert it into a list
+    try:
+        iter(consoles)
+    except TypeError:
+        consoles = [consoles]
+
+    # Store the current state and apply changes to the consoles
+    current = []
+    for console in consoles:
+        current.append(
+            (
+                console,
+                None if tracebacks is None else console.stream_echo_tracebacks,
+                None if stdout is None else console.stream_echo_stdout,
+                None if stderr is None else console.stream_echo_stderr,
+                None if result is None else console.stream_echo_result,
+                None if logging_handlers is None else console.logging_handlers,
+            )
+        )
+
+        if tracebacks is not None:
+            # Enable/disable traceback display override
+            console.stream_echo_tracebacks = tracebacks
+            if tracebacks:
+                # traceback display is enabled, make it automatically remove
+                # itself if an exception is raised by the sys.excepthook handler.
+                console._write_error_self_destruct = True
+        if stdout is not None:
+            console.stream_echo_stdout = stdout
+        if stderr is not None:
+            console.stream_echo_stderr = stderr
+        if result is not None:
+            console.stream_echo_result = result
+        if logging_handlers is not None:
+            console.logging_handlers = logging_handlers
+
+    # NOTE: This code is a horrible abomination of necessity.
+    try:
+        yield
+    except Exception:
+        # This is syntactically needed, we don't need to capture the exception,
+        # but the else requires it. We need raise any un-handled exceptions
+        # encountered to allow sys.excepthook to process normally.
+        # This prevents the else code from removing the traceback print overriding
+        # because the else/finally are processed before sys.excepthook is.
+        raise
+    else:
+        # Only called when exception was not raised. Restore the original traceback
+        # and disable the self destructing flag its not needed anymore.
+        for item in current:
+            if tracebacks is not None:
+                item[0].stream_echo_tracebacks = item[1]
+                if tracebacks:
+                    item[0]._write_error_self_destruct = False
+    finally:
+        # Always remove non-traceback options. This is handled before excepthook
+        # so we can just use the simplicity of a normal try/finally statement.
+        for item in current:
+            if stdout is not None:
+                item[0].stream_echo_stdout = item[2]
+            if stderr is not None:
+                item[0].stream_echo_stderr = item[3]
+            if result is not None:
+                item[0].stream_echo_result = item[4]
+            if logging_handlers is not None:
+                item[0].logging_handlers = item[5]
diff --git a/preditor/gui/console_base.py b/preditor/gui/console_base.py
@@ -48,6 +48,10 @@ def __init__(self, parent: QWidget, controller: Optional[LoggerWindow] = None):
         # Optionally used to prevent the app from being marked as not responding
         # while processing blocking code and ensure _last_repaint_time processes.
         self._last_process_events_time = 0
+        self._write_error_self_destruct = False
+        """If enabling tracebacks using `OverrideConsoleStreams`, this is set to True
+        so only if write_error is called by sys.excepthook it will remove itself.
+        """
 
         # Create the highlighter
         highlight = CodeHighlighter(self, 'Python')
@@ -56,6 +60,7 @@ def __init__(self, parent: QWidget, controller: Optional[LoggerWindow] = None):
         self.addSepNewline = False
         self.consoleLine = None
         self.mousePressPos = None
+        self.logging_info = {}
 
         self.init_actions()
 
@@ -315,6 +320,13 @@ def init_actions(self):
         self.uiAddBreakACT.triggered.connect(self.add_separator)
 
     def init_logging_handlers(self, attrName=None, value=None):
+        # Ensure the old callbacks are removed so they don't keep writing.
+        # The stream Manager will deal with if this widget is closed, but not
+        # in the case of temporarily disabling a handler.
+        for hi in self.logging_info.values():
+            hi.uninstall(self.write_log)
+
+        # Reset and add new handlers to handle log statements
         self.logging_info = {}
         for h in self.logging_handlers:
             hi = HandlerInfo(h)
@@ -588,6 +600,15 @@ def write_error(self, *exc_info):
         for line in text:
             self.write(line, stream_type=StreamType.CONSOLE | StreamType.STDERR)
 
+        if self._write_error_self_destruct:
+            # This should only be enabled by `OverrideConsoleStreams`. This callback
+            # was installed temporarily and once its called by sys.excepthook it
+            # should be removed so it doesn't get called again.
+            from preditor.excepthooks import PreditorExceptHook
+
+            self._write_error_self_destruct = False
+            PreditorExceptHook.callbacks.remove(self.write_error)
+
     def write_log(self, log_data, stream_type=StreamType.CONSOLE):
         """Write a logging message to the console depending on filters."""
         handler, record = log_data
diff --git a/preditor/stream/console_handler.py b/preditor/stream/console_handler.py
@@ -123,14 +123,22 @@ def __parse_setting__(cls, value, index):
         return attr_name, value
 
     def install(self, callback=None, replay=False, disable_writes=False, clear=False):
-        logger = logging.getLogger(self.name)
-        handler, _ = plugins.add_logging_handler(logger, self.plugin)
+        """Add the required logging handler if needed and connect callback to it."""
+        _logger = logging.getLogger(self.name)
+        handler, _ = plugins.add_logging_handler(_logger, self.plugin)
         if handler and callback:
             handler.manager.add_callback(
                 callback, replay=replay, disable_writes=disable_writes, clear=clear
             )
         return handler
 
+    def uninstall(self, callback):
+        """Remove the callback added via install, doesn't remove the logging handler."""
+        _logger = logging.getLogger(self.name)
+        handler, _ = plugins.add_logging_handler(_logger, self.plugin)
+        if handler:
+            handler.manager.remove_callback(callback)
+
 
 class ConsoleHandler(logging.Handler):
     """A logging handler that writes directly to the PrEditor instance.
