PrEditor 2.1.0__py3-none-any.whl

preditor/excepthooks.py

@@ -0,0 +1,165 @@
+from __future__ import absolute_import, print_function
+
+import sys
+import traceback
+
+from Qt import QtCompat
+
+from . import config, plugins, utils
+from .contexts import ErrorReport
+from .weakref import WeakList
+
+
+class PreditorExceptHook(object):
+    """Replacement for `sys.excepthook` that adds error reporting features.
+
+    This calls each callable in the `preditor.config.excepthooks` list any time
+    `sys.excepthook` is called due to an raised exception.
+
+    If `config.excepthooks` is empty when installing this class, it will
+    automatically add `default_excepthooks`. You can disable this by adding `None`
+    to the list before this class is initialized.
+    """
+
+    callbacks = WeakList()
+    """A list of callback called by `call_callbacks()` if enabled. This can be
+    used to notify other widgets of tracebacks. The callback must accept
+    `*exc_info` arguments.
+    """
+
+    def __init__(self, base_excepthook=None):
+        self.base_excepthook = base_excepthook or sys.__excepthook__
+
+        # Add the default excepthooks
+        if not config.excepthooks and config.excepthooks != [None]:
+            config.excepthooks.extend(self.default_excepthooks())
+
+    def __call__(self, *exc_info):
+        """Run when an exception is raised and calls all `config.excepthooks`."""
+        try:
+            for plugin in config.excepthooks:
+                if plugin is None:
+                    continue
+                plugin(*exc_info)
+
+            # Clear any ErrorReports that were generated by this exception handling
+            ErrorReport.clearReports()
+        except Exception:
+            # When developing for preditor.stream and the console, a exception may
+            # 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.
+            utils.ShellPrint(True).print_exc("PrEditor excepthooks failed")
+
+    def default_excepthooks(self):
+        """Returns default excepthooks handlers.
+
+        This includes the `call_base_excepthook` and `ask_to_show_logger` methods.
+        They enables showing the excepthook in parent streams and prompting the user
+        to show PrEditor when an error happens.
+        """
+        return [
+            self.call_base_excepthook,
+            self.call_callbacks,
+            self.ask_to_show_logger,
+        ]
+
+    def call_base_excepthook(self, *exc_info):
+        """Process `base_excepthook` supplied during object instantiation.
+
+        This is useful for showing the exception in the original excepthook that
+        PrEditor replaced when this class was installed.
+
+        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 received consecutively.
+        """
+        # Print the newline to stderr so it will show up in the same stream as
+        # the traceback will be printed to.
+        print("", file=sys.stderr)
+        try:
+            self.base_excepthook(*exc_info)
+        except (TypeError, NameError):
+            sys.__excepthook__(*exc_info)
+
+    @classmethod
+    def call_callbacks(cls, *exc_info):
+        for callback in cls.callbacks:
+            try:
+                callback(*exc_info)
+            except Exception:
+                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."""
+        if config.error_dialog_class is True:
+            # Default to the base ErrorDialog class
+            from .gui.errordialog import ErrorDialog
+
+            config.error_dialog_class = ErrorDialog
+        elif isinstance(config.error_dialog_class, str):
+            # If passed an EntryPoint string load the EntryPoint
+            config.error_dialog_class = plugins.from_string(config.error_dialog_class)
+
+        # Handle cases where we shouldn't ask to show the logger.
+        if config.error_dialog_class is None:
+            return
+        elif not config.error_dialog_class.show_prompt(*exc_info):
+            return
+
+        from .gui.console import ConsolePrEdit
+        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.")
+                # TODO: This seems incorrect, what should it be printing?
+                print(traceback)
+                return
+
+            # logger is visible and check if it was minimized on windows
+            if instance.isVisible() and not instance.isMinimized():
+                if instance.uiAutoPromptCHK.isChecked():
+                    instance.console().startInputLine()
+                return
+
+        # error already prompted by exception currently being handled
+        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 = config.error_dialog_class(config.root_window())
+            errorDialog.setText(exc_info)
+            errorDialog.exec_()
+
+        # interrupted until dialog closed
+        finally:
+            ConsolePrEdit._errorPrompted = False
+
+    @classmethod
+    def install(cls, force=False):
+        """
+        Install PrEditor excepthook override, returning previously implemented
+        excepthook function.
+
+        Arguments:
+            force (bool): force re-installation 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, cls) or force:
+            sys.excepthook = cls(prev_excepthook)
+
+        return prev_excepthook

preditor/gui/__init__.py

@@ -0,0 +1,56 @@
+import re
+
+from Qt.QtGui import QCursor
+from Qt.QtWidgets import QStackedWidget, QToolTip
+
+from .dialog import Dialog  # noqa: F401
+from .window import Window  # noqa: F401
+
+
+def handleMenuHovered(action):
+    """Actions in QMenus which are not descendants of a QToolBar will not show
+    their toolTips, because... Reasons?
+    """
+    # Don't show if it's just the text of the action
+    text = re.sub(r"(?<!&)&(?!&)", "", action.text())
+    text = text.replace('...', '')
+
+    if text == action.toolTip():
+        text = ''
+    else:
+        text = action.toolTip()
+
+    menu = action.parent()
+    QToolTip.showText(QCursor.pos(), text, menu)
+
+
+def loadUi(filename, widget, uiname=''):
+    """use's Qt's uic loader to load dynamic interafces onto the inputed widget
+
+    Args:
+        filename (str): The python filename. Its basename will be split off, and a
+            ui folder will be added. The file ext will be changed to .ui
+        widget (QWidget): The basewidget the ui file will be loaded onto.
+        uiname (str, optional): Used instead of the basename. This is useful if
+            filename is not the same as the ui file you want to load.
+    """
+    import os.path
+
+    from Qt import QtCompat
+
+    # first, inherit the palette of the parent
+    if widget.parent():
+        widget.setPalette(widget.parent().palette())
+
+    if not uiname:
+        uiname = os.path.basename(filename).split('.')[0]
+
+    QtCompat.loadUi(os.path.split(filename)[0] + '/ui/%s.ui' % uiname, widget)
+
+
+def tab_widget_for_tab(tab_widget):
+    """Returns the `QTabWidget` `tab_widget` is parented to or `None`."""
+    tab_parent = tab_widget.parent()
+    if not isinstance(tab_parent, QStackedWidget):
+        return None
+    return tab_parent.parent()

preditor/gui/app.py

@@ -0,0 +1,163 @@
+from __future__ import absolute_import
+
+import logging
+import os
+
+import Qt
+from Qt.QtGui import QIcon
+from Qt.QtWidgets import QApplication, QDialog, QMainWindow, QSplashScreen
+
+from .. import DEFAULT_CORE_NAME, resourcePath, settings
+
+logger = logging.getLogger(__name__)
+
+
+class App(object):
+    """Used to create and configure the QApplication instance.
+
+    Args:
+        name (str, optional): Set the QApplication application name to this value.
+        args (list, optional): The arguments used to instantiate the QApplication
+            if one isn't already initialized.
+        app (QApplication, optional): An instance of a QApplication to use
+            instead of creating one.
+
+    Raises:
+        RuntimeError: If DISPLAY is not set when running on linux, or the
+            current application isn't a instance of QApplication(ie using a
+            QCoreApplication).
+    """
+
+    def __init__(self, name=None, args=None, app=None):
+        # Used to track if this instance had to create the QApplication or if it
+        # was already created
+        self.app_created = False
+        # If we made the QApplication, did we call exec_ already?
+        self.app_has_exec = False
+
+        if app is None:
+            app = QApplication.instance()
+
+        self.app = app
+
+        if not self.app:
+            # Check for headless environment's
+            if settings.OS_TYPE == 'Linux' and os.environ.get('DISPLAY') is None:
+                raise RuntimeError(
+                    'The PrEditor gui can not run in a headless environment.'
+                )
+
+            if args is None:
+                args = []
+            # create a new application
+            if self.app is None:
+                args.extend(self.dpi_awareness_args())
+                self.app = QApplication(args)
+                self.app_created = True
+                # If we are creating the application, configure it
+                self.configure_standalone()
+
+        if not isinstance(self.app, QApplication):
+            raise RuntimeError(
+                "PrEditor's gui can only be run using a QApplication instance."
+            )
+
+        if self.app and name:
+            # If a application name was passed, update the QApplication's
+            # application name.
+            self.app.setApplicationName(name)
+            self.set_app_id(name)
+
+    def configure_standalone(self):
+        """Update the QApplication for standalone running. Updates the icon and
+        sets its style to default_style_name."""
+        self.app.setWindowIcon(QIcon(resourcePath('img/preditor.png')))
+        self.app.setStyle(self.default_style_name())
+
+    @staticmethod
+    def default_style_name():
+        """The default style name used when setting up the QApplication.
+
+        In Qt4 this is Plastique, in Qt5 this is Fusion.
+        """
+
+        if Qt.IsPyQt4 or Qt.IsPySide:
+            return 'Plastique'
+        return 'Fusion'
+
+    @classmethod
+    def dpi_awareness_args(cls):
+        """On windows sets dpiawareness platform flag to 0 to enable
+        per-monitor scaling support in Qt.
+
+        Returns:
+            args: Extend the arguments used to intialize the QApplication.
+        """
+        if settings.OS_TYPE == "Windows" and (Qt.IsPyQt6 or Qt.IsPyQt5):
+            # Make Qt automatically scale based on the monitor the window is
+            # currently located.
+            return ["--platform", "windows:dpiawareness=0"]
+        return []
+
+    @classmethod
+    def root_window(cls):
+        """Returns the currently active window. Attempts to find the top level
+        QMainWindow or QDialog for the current Qt application.
+        """
+        inst = QApplication.instance()
+        root_window = None
+        if inst:
+            root_window = inst.activeWindow()
+            # Ignore QSplashScreen's, they should never be considered the root window.
+            if isinstance(root_window, QSplashScreen):
+                root_window = None
+
+            # If the application does not have focus try to find A top level widget
+            # that doesn't have a parent and is a QMainWindow or QDialog
+            if root_window is None:
+                windows = []
+                dialogs = []
+
+                hasTopLevelWidgets = hasattr(QApplication.instance(), "topLevelWidgets")
+                if hasTopLevelWidgets:
+                    for w in inst.topLevelWidgets():
+                        if w.parent() is None:
+                            if isinstance(w, QMainWindow):
+                                windows.append(w)
+                            elif isinstance(w, QDialog):
+                                dialogs.append(w)
+                if windows:
+                    root_window = windows[0]
+                elif dialogs:
+                    root_window = dialogs[0]
+
+            # grab the root window
+            if root_window:
+                while root_window.parent():
+                    parent = root_window.parent()
+                    if isinstance(parent, QSplashScreen):
+                        return root_window
+                    else:
+                        root_window = parent
+        return root_window
+
+    @classmethod
+    def set_app_id(cls, app_id=DEFAULT_CORE_NAME):
+        if settings.OS_TYPE == "Windows":
+            # Set the app user model id here not in the window class so it doesn't
+            # try to set the app id for applications that already set the app id.
+            try:
+                from casement.app_id import AppId
+            except ImportError:
+                logger.debug(
+                    "Unable to configure taskbar grouping, use `pip install "
+                    "casement` to enable this."
+                )
+            else:
+                AppId.set_for_application(app_id)
+
+    def start(self):
+        """Exec's the QApplication if it hasn't already been started."""
+        if self.app_created and self.app and not self.app_has_exec:
+            self.app_has_exec = True
+            Qt.QtCompat.QApplication.exec_()

preditor/gui/codehighlighter.py

@@ -0,0 +1,289 @@
+from __future__ import absolute_import
+
+import keyword
+import os
+import re
+
+from Qt.QtGui import QColor, QSyntaxHighlighter, QTextCharFormat
+
+from .. import resourcePath, utils
+
+
+class CodeHighlighter(QSyntaxHighlighter):
+    def __init__(self, widget, language):
+        super(CodeHighlighter, self).__init__(widget)
+        self._consoleMode = False
+
+        self.initHighlightVariables()
+        self.setLanguage(language)
+
+        self.defineHighlightVariables()
+
+    def initHighlightVariables(self):
+        """Initialize the variables which will be used in code highlighting"""
+
+        # For each call of highlightBlock, keep track of the spans of each highlight, so
+        # we can prevent overlapping spans (ie if a string is found, but it's within a
+        # comment, do not highlight it).
+        self.spans = []
+
+        self._enabled = True
+
+        # Language specific lists
+        self._comments = []
+        self._keywords = []
+        self._strings = []
+
+        # Patterns
+        self._commentPattern = None
+        self._keywordPattern = None
+        self._resultPattern = None
+        self._stringsPattern = None
+
+        # Formats
+        self._commentFormat = None
+        self._keywordFormat = None
+        self._resultFormat = None
+        self._stringFormat = None
+
+        # Colors. These may be overriden by parent colors, which themselves my be
+        # overridden by stylesheets (ie Bright.css)
+        self._commentColor = QColor(0, 206, 52)
+        self._keywordColor = QColor(255, 0, 255)
+        self._resultColor = QColor(125, 128, 128)
+        self._stringColor = QColor(255, 128, 0)
+
+    def enabled(self):
+        return self._enabled
+
+    def setEnabled(self, state):
+        self._enabled = state
+
+    def setLanguage(self, lang):
+        """Sets the language of the highlighter by loading the json definition"""
+        filename = resourcePath('lang/%s.json' % lang.lower())
+        if os.path.exists(filename):
+            data = utils.Json(filename).load()
+            self.setObjectName(data.get('name', ''))
+
+            self._comments = data.get('comments', [])
+            self._strings = data.get('strings', [])
+
+            # If using python, we can get keywords dynamically, otherwise get them from
+            # the language json data.
+            if lang.lower() == "python":
+                self._keywords = keyword.kwlist
+            else:
+                self._keywords = data.get('keywords', [])
+
+            return True
+        return False
+
+    def defineHighlightVariables(self):
+        """Define the formats and regex patterns which will be used to highlight
+        code."""
+        # Define highlight formats
+        self.defineCommentFormat()
+        self.defineKeywordFormat()
+        self.defineResultFormat()
+        self.defineStringFormat()
+
+        # Define highlight regex patterns
+        self.defineCommentPattern()
+        self.defineKeywordPattern()
+        self.defineResultPattern()
+        self.defineStringPattern()
+
+    def highlightBlock(self, text):
+        """Highlights the inputed text block based on the rules of this code
+        highlighter"""
+
+        if not self.enabled():
+            return
+
+        # Reset the highlight spans for this text block
+        self.spans = []
+
+        if not self.isConsoleMode() or str(text).startswith('>>>'):
+
+            # We only have a result pattern if the parent has an attr "outputPrompt", so
+            # only proceed if we have been able to define self._resultPattern.
+            if self._resultPattern:
+                self.highlightText(
+                    text,
+                    self._resultPattern,
+                    self._resultFormat,
+                )
+
+            # Format the strings
+            self.highlightText(
+                text,
+                self._stringPattern,
+                self._stringFormat,
+            )
+
+            # format the comments
+            self.highlightText(
+                text,
+                self._commentPattern,
+                self._commentFormat,
+            )
+
+            # Format the keywords
+            self.highlightText(
+                text,
+                self._keywordPattern,
+                self._keywordFormat,
+            )
+
+    def highlightText(self, text, expr, format):
+        """Highlights a text group with an expression and format
+
+        Args:
+            text (str): text to highlight
+            expr (re.compile): search parameter
+            format (QTextCharFormat): formatting rule
+        """
+        if expr is None or not text:
+            return
+
+        # highlight all the given matches to the expression in the text
+        for match in expr.finditer(text):
+            match_span = match.span()
+            start, end = match_span
+            length = end - start
+
+            # Determine if the current highlight is within an already determined
+            # highlight, if so, let's block it.
+            blocked = False
+            for span in self.spans:
+                if start > span[0] and start < span[-1]:
+                    blocked = True
+                    break
+
+            if not blocked:
+                self.setFormat(start, length, format)
+
+                # Append the current span to self.spans, so we can later block
+                # new highlights which should be blocked
+                self.spans.append(match_span)
+
+    def isConsoleMode(self):
+        """checks to see if this highlighter is in console mode"""
+        return self._consoleMode
+
+    def setConsoleMode(self, state=False):
+        """sets the highlighter to only apply to console strings
+        (lines starting with >>>)
+        """
+        self._consoleMode = state
+
+    def commentColor(self):
+        # Pull the color from the parent if possible because this doesn't support
+        # stylesheets
+        parent = self.parent()
+        if parent and hasattr(parent, 'commentColor'):
+            return parent.commentColor
+        return self._commentColor
+
+    def setCommentColor(self, color):
+        # set the color for the parent if possible because this doesn't support
+        # stylesheets
+        parent = self.parent()
+        if parent and hasattr(parent, 'commentColor'):
+            parent.commentColor = color
+        self._commentColor = color
+
+    def keywordColor(self):
+        # pull the color from the parent if possible because this doesn't support
+        # stylesheets
+        parent = self.parent()
+        if parent and hasattr(parent, 'keywordColor'):
+            return parent.keywordColor
+        return self._keywordColor
+
+    def setKeywordColor(self, color):
+        # set the color for the parent if possible because this doesn't support
+        # stylesheets
+        parent = self.parent()
+        if parent and hasattr(parent, 'keywordColor'):
+            parent.keywordColor = color
+        self._keywordColor = color
+
+    def resultColor(self):
+        # pull the color from the parent if possible because this doesn't support
+        # stylesheets
+        parent = self.parent()
+        if parent and hasattr(parent, 'resultColor'):
+            return parent.resultColor
+        return self._resultColor
+
+    def setResultColor(self, color):
+        # set the color for the parent if possible because this doesn't support
+        # stylesheets
+        parent = self.parent()
+        if parent and hasattr(parent, 'resultColor'):
+            parent.resultColor = color
+        self._resultColor = color
+
+    def stringColor(self):
+        # pull the color from the parent if possible because this doesn't support
+        # stylesheets
+        parent = self.parent()
+        if parent and hasattr(parent, 'stringColor'):
+            return parent.stringColor
+        return self._stringColor
+
+    def setStringColor(self, color):
+        # set the color for the parent if possible because this doesn't support
+        # stylesheets
+        parent = self.parent()
+        if parent and hasattr(parent, 'stringColor'):
+            parent.stringColor = color
+        self._stringColor = color
+
+    def defineCommentFormat(self):
+        """Define the comment format based on the comment color"""
+        self._commentFormat = QTextCharFormat()
+        self._commentFormat.setForeground(self.commentColor())
+        self._commentFormat.setFontItalic(True)
+
+    def defineKeywordFormat(self):
+        """Define the keyword format based on the keyword color"""
+        self._keywordFormat = QTextCharFormat()
+        self._keywordFormat.setForeground(self.keywordColor())
+
+    def defineResultFormat(self):
+        """Define the result format based on the result color"""
+        self._resultFormat = QTextCharFormat()
+        self._resultFormat.setForeground(self.resultColor())
+
+    def defineStringFormat(self):
+        """Define the string format based on the string color"""
+        self._stringFormat = QTextCharFormat()
+        self._stringFormat.setForeground(self.stringColor())
+
+    def defineCommentPattern(self):
+        """Define the regex pattern to use for comment"""
+        pattern = "|".join(self._comments)
+        self._commentPattern = re.compile(pattern)
+
+    def defineKeywordPattern(self):
+        """Define the regex pattern to use for keyword"""
+        keywords = [r"\b{}\b".format(word) for word in self._keywords]
+        pattern = "|".join(keywords)
+        self._keywordPattern = re.compile(pattern)
+
+    def defineResultPattern(self):
+        """Define the regex pattern to use for results"""
+        parent = self.parent()
+        if parent and hasattr(parent, 'outputPrompt'):
+            prompt = parent.outputPrompt()
+            pattern = '{}[^\n]*'.format(prompt)
+            self._resultPattern = re.compile(pattern)
+
+    def defineStringPattern(self):
+        """Define the regex pattern to use for strings."""
+        lst = ["""{0}[^{0}\n]*{0}""".format(st) for st in self._strings]
+        pattern = "|".join(lst)
+        self._stringPattern = re.compile(pattern)