Refactor the Error Reporting system

- Move original `preditor.debug.BlurExcepthook` class to `preditor.excepthooks.PreditorExceptHook`
and refactor removing most of the legacy blur specific customization.
- You can now configure the excepthook system using `preditor.configure`
- Removed blur specific code from `ErrorDialog`.
- Named all widgets in `ErrorDialog` so subclasses can easily customize it.

Author: MHendricks

examples/add_to_app.py

@@ -41,9 +41,9 @@ def raise_error():
         # specific to this application.
         'add_to_app',
     )
-    import preditor.debug
+    import preditor.excepthooks
 
-    preditor.debug.BlurExcepthook.install()
+    preditor.excepthooks.PreditorExceptHook.install()
 
     # Create a Gui Application allowing the user to show PrEditor
     app = QApplication(sys.argv)

preditor/config.py

@@ -49,13 +49,17 @@ def __init__(self):
         self._logging = False
         self._headless_callback = None
         self._parent_callback = None
+        self._error_dialog_class = True
+        self._excepthooks = []
 
     def dump(self, indent=0):
         """A convenient way to inspect the current configuration."""
         ret = [
             f"{' ' * indent}name: {self.name}",
             f"{' ' * indent}streams: {self.streams}",
             f"{' ' * indent}excepthook: {self.excepthook!r}",
+            f"{' ' * indent}excepthooks: {self.excepthooks!r}",
+            f"{' ' * indent}error_dialog_class: {self.error_dialog_class!r}",
             f"{' ' * indent}logging: {self.logging}",
             f"{' ' * indent}headless_callback: {self.headless_callback!r}",
             f"{' ' * indent}parent_callback: {self.parent_callback!r}",
@@ -83,14 +87,37 @@ def is_locked(self, value, track_state=False):
             return self._locks.get(value, False)
         return False
 
+    @property
+    def error_dialog_class(self):
+        """Dialog class shown if PrEditor isn't visible and a error happens.
+
+        This dialog is used to prompt the user to show PrEditor and can be
+        sub-classed to add extra functionality. This is called by
+        `PreditorExceptHook.ask_to_show_logger` method when added to
+        `preditor.config.excepthooks`.
+
+        If set to `True` then `blurdev.gui.errordialog.ErrorDialog` is used. When
+        replacing this, it should be a sub-class of that class or re-implement
+        its api.
+
+        You can use an EntryPoint string like `preditor.gui.errordialog:ErrorDialog`
+        instead of passing the actual class object. This lets you delay the import
+        until actually needed.
+        """
+        return self._error_dialog_class
+
+    @error_dialog_class.setter
+    def error_dialog_class(self, cls):
+        self._error_dialog_class = cls
+
     @property
     def excepthook(self):
         """Installs a `sys.excepthook` handler when first set to True.
 
         Replaces `sys.excepthook` with a interactive exception handler that
         prompts the user to show PrEditor when an python exception is raised.
         It is recommended that you only add the excepthook once the Qt UI is
-        initialized. See: :py:class:`preditor.debug.BlurExcepthook`.
+        initialized. See: :py:class:`preditor.excepthooks.PreditorExceptHook`.
         """
         return self._locks.get("excepthook", False)
 
@@ -100,19 +127,30 @@ def excepthook(self, value):
         if not value:
             return
 
-        # Install the excepthook
-        import preditor.debug
+        # Install the excepthook:
+        import preditor.excepthooks
 
         # Note: install checks if the current excepthook is a instance of this
         # class and prevents installing a second time.
-        preditor.debug.BlurExcepthook.install()
+        preditor.excepthooks.PreditorExceptHook.install()
 
-        # Disable future setting via `set_if_unlocked`, the BlurExcepthook is a
-        # chaining except hook that calls the previous excepthook when called. We
-        # don't want to install multiple automatically, the user can define that
+        # Disable future setting via `set_if_unlocked`, the `PreditorExceptHook`
+        # is a chaining except hook that calls the previous excepthook when called.
+        # We don't want to install multiple automatically, the user can define that
         # logic if required.
         self._locks["excepthook"] = True
 
+    @property
+    def excepthooks(self):
+        """A list of callables that are called when an exception is handled.
+
+        If `excepthook` is enabled installing `PreditorExceptHook` then it will
+        call each item in this list. The signature of the function should be
+        `callable(*args)`. If not configured it will automatically install default
+        callables. You can add `None` to disable this.
+        """
+        return self._excepthooks
+
     @property
     def headless_callback(self):
         """A pointer to a method that is called by `is_headless`.

preditor/cores/core.py

@@ -2,8 +2,6 @@
 
 from Qt.QtCore import QObject
 
-from .. import config
-
 
 class Core(QObject):
     """
@@ -20,32 +18,3 @@ def __init__(self, objectName=None):
         # Paths in this variable will be removed in
         # preditor.osystem.subprocessEnvironment
         self._removeFromPATHEnv = set()
-
-    def shouldReportException(self, exc_type, exc_value, exc_traceback, actions=None):
-        """
-        Allow core to control how exceptions are handled. Currently being used
-        by `BlurExcepthook`, informing which excepthooks should or should not
-        be executed.
-
-        Args:
-            exc_type (type): exception type class object
-            exc_value (Exception): class instance of exception parameter
-            exc_traceback (traceback): encapsulation of call stack for exception
-            actions (dict, optional): default values for the returned dict. A copy
-                of this dict is returned with standard defaults applied.
-
-        Returns:
-            dict: Boolean values representing whether to perform excepthook
-                action, keyed to the name of the excepthook
-        """
-        if actions is None:
-            actions = {}
-        # Create a shallow copy so we don't modify the passed in dict and don't
-        # need to use a default value of None
-        actions = actions.copy()
-
-        # provide the expected default values
-        actions.setdefault('email', True)
-        # If blurdev is running headless, there is no way to show a gui prompt
-        actions.setdefault('prompt', not config.is_headless())
-        return actions

preditor/debug.py

@@ -4,12 +4,6 @@
 import inspect
 import logging
 import sys
-import traceback
-
-from Qt import QtCompat
-
-from . import config, core
-from .contexts import ErrorReport
 
 logger = logging.getLogger(__name__)
 
@@ -77,150 +71,6 @@ def logToFile(path, stdout=True, stderr=True, useOldStd=True, clearLog=True):
         StreamHandlerHelper.replace_stream(sys.stderr._stdhandle, sys.stderr)
 
 
-# --------------------------------------------------------------------------------
-
-
-class BlurExcepthook(object):
-    """
-    Blur's excepthook override allowing for granular error handling
-    customization.
-
-    Stacked atop the standard library excepthook (by default), catches any
-    unhandled exceptions and conditionally passes them to the following custom
-    excepthooks:
-
-        - *`call_base_excepthook`*
-            excepthook callable supplied at initialization; if not supplied or
-            invalid, executes standard library excepthook.
-
-        - *`send_exception_email`*
-            email notification.
-
-        - *`send_logger_error`*
-            logger console.
-
-    Arguments:
-        ehook (callable): An excepthook callable compatible with signature of
-            sys.excepthook; defaults to original startup excepthook
-    """
-
-    def __init__(self, base_excepthook=None):
-        self.base_excepthook = base_excepthook or sys.__excepthook__
-        # We can't show the prompt if running headless.
-        self.actions = dict(email=True, prompt=not config.is_headless())
-
-    def __call__(self, *exc_info):
-        """
-        Executes overriden execpthook.
-
-        Checks the results from the core's `shouldReportException` function as
-        to if the current exception should be reported. (Why? Nuke, for
-        example, uses exceptions to signal tradionally non-exception worthy
-        events, such as when a user cancels an Open File dialog window.)
-        """
-        self.actions = core.shouldReportException(*exc_info, actions=self.actions)
-
-        self.call_base_excepthook(exc_info)
-        self.send_exception_email(exc_info)
-        self.send_logger_error(exc_info)
-
-        ErrorReport.clearReports()
-
-    def call_base_excepthook(self, exc_info):
-        """
-        Process base excepthook supplied during object instantiation.
-
-        A newline is printed pre-traceback to ensure the first line of output
-        is not printed in-line with the prompt. This also provides visual
-        separation between tracebacks, when recieved consecutively.
-        """
-        print("")
-        try:
-            self.base_excepthook(*exc_info)
-        except (TypeError, NameError):
-            sys.__excepthook__(*exc_info)
-
-    def send_exception_email(self, exc_info):
-        """
-        Conditionally sends an exception email.
-        """
-        if not self.actions.get("email", False):
-            return
-
-        # email_addresses = os.getenv('BDEV_ERROR_EMAIL')
-        # if email_addresses:
-        #     from .utils.error import ErrorEmail
-        #     mailer = ErrorEmail(*exc_info)
-        #     mailer.send(email_addresses)
-
-    def send_logger_error(self, exc_info):
-        """
-        Shows logger prompt.
-        """
-        if not self.actions.get("prompt", False):
-            return
-
-        from .gui.console import ConsolePrEdit
-        from .gui.errordialog import ErrorDialog
-        from .gui.loggerwindow import LoggerWindow
-
-        instance = LoggerWindow.instance(create=False)
-
-        if instance:
-            # logger reference deleted, fallback and print to console
-            if not QtCompat.isValid(instance):
-                print("[LoggerWindow] LoggerWindow object has been deleted.")
-                print(traceback)
-                return
-
-            # logger is visible and check if it was minimized on windows
-            if instance.isVisible() and not instance.isMinimized():
-                if instance.uiAutoPromptACT.isChecked():
-                    instance.console().startInputLine()
-                return
-
-        # error already prompted
-        if ConsolePrEdit._errorPrompted:
-            return
-
-        # Preemptively marking error as "prompted" (handled) to avoid errors
-        # from being raised multiple times due to C++ and/or threading error
-        # processing.
-        try:
-            ConsolePrEdit._errorPrompted = True
-            errorDialog = ErrorDialog(config.root_window())
-            errorDialog.setText(exc_info)
-            errorDialog.exec_()
-
-        # interruptted until dialog closed
-        finally:
-            ConsolePrEdit._errorPrompted = False
-
-    @classmethod
-    def install(cls, force=False):
-        """
-        Install Blur excepthook override, returing previously implemented
-        excepthook function.
-
-        Arguments:
-            force (bool): force reinstallation of excepthook override when
-                already previously implemented.
-
-        Returns:
-            func: pre-override excepthook function
-        """
-        ErrorReport.enabled = True
-        prev_excepthook = sys.excepthook
-
-        if not isinstance(prev_excepthook, BlurExcepthook) or force:
-            sys.excepthook = cls(prev_excepthook)
-
-        return prev_excepthook
-
-
-# --------------------------------------------------------------------------------
-
-
 def printCallingFunction(compact=False):
     """Prints and returns info about the calling function