Better handling of writes to __stderr__/__stdout__

On windows, if using pythonw.exe these streams are set to None. If you try
to print to None it will write to `sys.stdout` which causes recursion.
The intent of these calls is to write to the host shell when errors happen
processing a normal PrEditor write so the problem can be debugged.

If you run into that issue when using pythonw.exe you will need to switch
to python.exe to see the debug output.

Author: MHendricks

preditor/excepthooks.py

@@ -5,7 +5,7 @@
 
 from Qt import QtCompat
 
-from . import config, plugins
+from . import config, plugins, utils
 from .contexts import ErrorReport
 from .weakref import WeakList
 
@@ -49,9 +49,7 @@ def __call__(self, *exc_info):
             # prevent showing the traceback normally. This last ditch method prints
             # the traceback to the original stderr stream so it can be debugged.
             # Without this you might get little to no output to work with.
-            print(" PrEditor excepthooks failed ".center(79, "-"), file=sys.__stderr__)
-            traceback.print_exc(file=sys.__stderr__)
-            print(" PrEditor excepthooks failed ".center(79, "-"), file=sys.__stderr__)
+            utils.ShellPrint(True).print_exc("PrEditor excepthooks failed")
 
     def default_excepthooks(self):
         """Returns default excepthooks handlers.
@@ -90,15 +88,7 @@ def call_callbacks(cls, *exc_info):
             try:
                 callback(*exc_info)
             except Exception:
-                print(
-                    " PrEditor excepthook callback failed ".center(79, "-"),
-                    file=sys.__stderr__,
-                )
-                traceback.print_exc(file=sys.__stderr__)
-                print(
-                    " PrEditor excepthook callback failed ".center(79, "-"),
-                    file=sys.__stderr__,
-                )
+                utils.ShellPrint(True).print_exc("PrEditor excepthook callback failed")
 
     def ask_to_show_logger(self, *exc_info):
         """Show a dialog asking the user how to handle the error."""

preditor/stream/manager.py

@@ -1,9 +1,8 @@
 from __future__ import absolute_import, print_function
 
 import collections
-import sys
-import traceback
 
+from .. import utils
 from ..weakref import WeakList
 
 
@@ -95,6 +94,4 @@ def write(self, msg, state):
             try:
                 callback(msg, state)
             except Exception:
-                print(" PrEditor Console failed ".center(79, "-"), file=sys.__stderr__)
-                traceback.print_exc(file=sys.__stderr__)
-                print(" PrEditor Console failed ".center(79, "-"), file=sys.__stderr__)
+                utils.ShellPrint(True).print_exc("PrEditor Console failed")

preditor/utils/__init__.py

@@ -2,6 +2,7 @@
 import json
 import os
 import sys
+import traceback
 from pathlib import Path
 
 
@@ -99,6 +100,63 @@ def loads_json(cls, json_str, source):
         return cls._load_json(source, json.loads, json_str)
 
 
+class ShellPrint:
+    """Utilities to print to sys.__stdout__/__stderr__ bypassing the PrEditor streams.
+
+    This allows you to write to the host console instead of PrEditor's interface.
+    This helps when developing for the stream or console classes if you cause an
+    exception you might get no traceback printed to debug otherwise.
+
+    On windows if using gui mode app(pythonw.exe) that doesn't have a console
+    the methods will not print anything and just return False. If possible switch
+    to using python.exe or install another file stream like `preditor.debug.FileLogger`,
+    but they will need to be installed on `sys.__stdout__/__stderr__`.
+    """
+
+    def __init__(self, error=False):
+        self.error = error
+
+    def print(self, *args, **kwargs):
+        """Prints to the shell."""
+        if "file" in kwargs:
+            raise KeyError(
+                "file can not be passed to `ShellPrint.print`. Instead use error."
+            )
+        # Check for pythonw.exe's lack of streams and exit
+        kwargs["file"] = self.stream
+        if kwargs["file"] is None:
+            """Note: This protects against errors like this when using pythonw
+              File "preditor/stream/director.py", line 124, in write
+                super().write(msg)
+            RuntimeError: reentrant call inside <_io.BufferedWriter name='nul'>
+            """
+            return False
+
+        # Print to the host stream
+        print(*args, **kwargs)
+        return True
+
+    def print_exc(self, msg, limit=None, chain=True, width=79):
+        """Prints a header line, the current exception and a footer line to shell.
+
+        This must be called from inside of a try/except statement.
+        """
+        stream = self.stream
+        if stream is None:
+            return False
+
+        print(f" {msg} ".center(width, "-"), file=sys.__stderr__)
+        traceback.print_exc(limit=limit, file=stream, chain=chain)
+        print(f" {msg} ".center(width, "-"), file=sys.__stderr__)
+        return True
+
+    @property
+    def stream(self):
+        if self.error:
+            return sys.__stderr__
+        return sys.__stdout__
+
+
 class Truncate:
     def __init__(self, text, sep='...'):
         self.text = text

tests/test_stream.py

@@ -3,9 +3,11 @@
 import io
 import logging
 import sys
+import traceback
 
 import pytest
 
+from preditor import utils
 from preditor.constants import StreamType
 from preditor.stream import Director, Manager, install_to_std
 
@@ -275,3 +277,93 @@ def test_handler_info(input, check):
         # Treat None as the default formatter
         check[3] = HandlerInfo._default_format
     assert hi.formatter._fmt == check[3]
+
+
+class TestShellPrint:
+    def patch(self, monkeypatch, pyw):
+        # Replace all 4 streams with tracking streams
+        new_out = io.StringIO()
+        new_err = io.StringIO()
+        if pyw:
+            # or None if simulating pythonw
+            new_out_ = None
+            new_err_ = None
+        else:
+            # If the console exists a stream is actually used
+            new_out_ = io.StringIO()
+            new_err_ = io.StringIO()
+
+        monkeypatch.setattr(sys, "stdout", new_out)
+        monkeypatch.setattr(sys, "stderr", new_err)
+        monkeypatch.setattr(sys, "__stdout__", new_out_)
+        monkeypatch.setattr(sys, "__stderr__", new_err_)
+
+        return new_out, new_err, new_out_, new_err_
+
+    def test_print_none(self, monkeypatch, capsys):
+        """Verify that the print command works as expected. If `sys.__std*__`
+        is None (pythonw.exe on windows) it will write to `sys.stdout`.
+        """
+        # Simulate pythonw.exe on windows, which uses None for sys.__std*__
+        monkeypatch.setattr(sys, "__stdout__", None)
+        monkeypatch.setattr(sys, "__stderr__", None)
+
+        # Print to the various streams
+        print("stdout")
+        print("stdout: None", file=sys.__stdout__)
+        print("stderr", file=sys.stderr)
+        print("stderr: None", file=sys.__stderr__)
+
+        # Verify the prints were written to the expected stream
+        captured = capsys.readouterr()
+        # sys.stdout and None are sent to sys.stdout
+        assert captured.out == "stdout\nstdout: None\nstderr: None\n"
+        # Only sys.stderr gets written to sys.stderr
+        assert captured.err == "stderr\n"
+
+    @pytest.mark.parametrize("pyw", (True, False))
+    def test_print(self, monkeypatch, pyw):
+        # Replace all 4 streams with tracking streams
+        new_out, new_err, new_out_, new_err_ = self.patch(monkeypatch, pyw)
+
+        # Regular write/print calls go to stdout/stderr
+        print("stdout")
+        print("stderr", file=sys.stderr)
+        # Use ShellPrint to write to `__std*__` and make sure it only returns
+        # True if it should be writting to that stream.
+        assert utils.ShellPrint().print("__stdout__") is not pyw
+        assert utils.ShellPrint(error=True).print("__stderr__") is not pyw
+
+        # Verify the prints were written to the expected stream or discarded
+        assert new_out.getvalue() == "stdout\n"
+        assert new_err.getvalue() == "stderr\n"
+        if not pyw:
+            assert new_out_.getvalue() == "__stdout__\n"
+            assert new_err_.getvalue() == "__stderr__\n"
+
+    @pytest.mark.parametrize("pyw", (True, False))
+    def test_print_exc(self, monkeypatch, pyw):
+        # Replace all 4 streams with tracking streams
+        new_out, new_err, new_out_, new_err_ = self.patch(monkeypatch, pyw)
+
+        # Capture an exception and print it using ShellPrint
+        try:
+            raise RuntimeError("Test exception")
+        except RuntimeError:
+            check = traceback.format_exc()
+            assert utils.ShellPrint(error=True).print_exc("A Test") is not pyw
+
+        # Verify that the text was only written to `sys.__stderr__` unless
+        # that is None
+        assert new_out.getvalue() == ""
+        assert new_err.getvalue() == ""
+        if not pyw:
+            assert new_out_.getvalue() == ""
+            assert new_err_.getvalue() == "\n".join(
+                [
+                    " A Test ".center(79, "-"),
+                    check.rstrip(),
+                    " A Test ".center(79, "-"),
+                    "",
+                ]
+            )