PrEditor 1.0.0__py3-none-any.whl

preditor/excepthooks.py

@@ -0,0 +1,131 @@
+from __future__ import absolute_import, print_function
+
+import sys
+import traceback
+
+from Qt import QtCompat
+
+from . import config, plugins
+from .contexts import ErrorReport
+
+
+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.excepthook` is empty when installing this class, it will
+    automatically add the `call_base_excepthook` and `ask_to_show_logger` methods.
+    This enables showing the excepthook in parent streams and prompting the user
+    to show PrEditor when an error happens. You can disable this by adding `None`
+    to the list before this class is initialized.
+    """
+
+    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.append(self.call_base_excepthook)
+            config.excepthooks.append(self.ask_to_show_logger)
+
+    def __call__(self, *exc_info):
+        """Run when an exception is raised and calls all `config.excepthooks`."""
+        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()
+
+    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("")
+        try:
+            self.base_excepthook(*exc_info)
+        except (TypeError, NameError):
+            sys.__excepthook__(*exc_info)
+
+    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.uiAutoPromptACT.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,93 @@
+from __future__ import absolute_import
+
+from functools import partial
+
+from Qt.QtCore import Property
+from Qt.QtWidgets import QStackedWidget
+
+from .dialog import Dialog  # noqa: F401
+from .window import Window  # noqa: F401
+
+
+def QtPropertyInit(name, default, callback=None, typ=None):
+    """Initializes a default Property value with a usable getter and setter.
+
+    You can optionally pass a function that will get called any time the property
+    is set. If using the same callback for multiple properties, you may want to
+    use the preditor.decorators.singleShot decorator to prevent your function getting
+    called multiple times at once. This callback must accept the attribute name and
+    value being set.
+
+    Example:
+        class TestClass(QWidget):
+            def __init__(self, *args, **kwargs):
+                super(TestClass, self).__init__(*args, **kwargs)
+
+            stdoutColor = QtPropertyInit('_stdoutColor', QColor(0, 0, 255))
+            pyForegroundColor = QtPropertyInit('_pyForegroundColor', QColor(0, 0, 255))
+
+    Args:
+        name(str): The name of internal attribute to store to and lookup from.
+        default: The property's default value.  This will also define the Property type
+            if typ is not set.
+        callback(callable): If provided this function is called when the property is
+            set.
+        typ (class, optional): If not None this value is used to specify the type of
+            the Property. This is useful when you need to specify a property as python's
+            object but pass a default value of a given class.
+
+    Returns:
+        Property
+    """
+
+    def _getattrDefault(default, self, attrName):
+        try:
+            value = getattr(self, attrName)
+        except AttributeError:
+            setattr(self, attrName, default)
+            return default
+        return value
+
+    def _setattrCallback(callback, attrName, self, value):
+        setattr(self, attrName, value)
+        if callback:
+            callback(self, attrName, value)
+
+    ga = partial(_getattrDefault, default)
+    sa = partial(_setattrCallback, callback, name)
+    # Use the default value's class if typ is not provided.
+    if typ is None:
+        typ = default.__class__
+    return Property(typ, fget=(lambda s: ga(s, name)), fset=(lambda s, v: sa(s, v)))
+
+
+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,160 @@
+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.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 = []
+                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
+            self.app.exec_()

preditor/gui/codehighlighter.py

@@ -0,0 +1,209 @@
+from __future__ import absolute_import
+
+import json
+import os
+import re
+
+from Qt.QtCore import QRegExp
+from Qt.QtGui import QColor, QSyntaxHighlighter, QTextCharFormat
+
+from .. import resourcePath
+
+
+class CodeHighlighter(QSyntaxHighlighter):
+    def __init__(self, widget):
+        super(CodeHighlighter, self).__init__(widget)
+
+        # setup the search rules
+        self._keywords = []
+        self._strings = []
+        self._comments = []
+        self._consoleMode = False
+        # color storage
+        self._commentColor = QColor(0, 206, 52)
+        self._keywordColor = QColor(17, 154, 255)
+        self._stringColor = QColor(255, 128, 0)
+        self._resultColor = QColor(125, 128, 128)
+
+        # setup the font
+        font = widget.font()
+        font.setFamily('Courier New')
+        widget.setFont(font)
+
+    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 commentFormat(self):
+        """returns the comments QTextCharFormat for this highlighter"""
+        format = QTextCharFormat()
+        format.setForeground(self.commentColor())
+        format.setFontItalic(True)
+
+        return format
+
+    def isConsoleMode(self):
+        """checks to see if this highlighter is in console mode"""
+        return self._consoleMode
+
+    def highlightBlock(self, text):
+        """highlights the inputed text block based on the rules of this code
+        highlighter"""
+        if not self.isConsoleMode() or str(text).startswith('>>>'):
+            # format the result lines
+            format = self.resultFormat()
+            parent = self.parent()
+            if parent and hasattr(parent, 'outputPrompt'):
+                self.highlightText(
+                    text,
+                    QRegExp('%s[^\\n]*' % re.escape(parent.outputPrompt())),
+                    format,
+                )
+
+            # format the keywords
+            format = self.keywordFormat()
+            for kwd in self._keywords:
+                self.highlightText(text, QRegExp(r'\b%s\b' % kwd), format)
+
+            # format the strings
+            format = self.stringFormat()
+            for string in self._strings:
+                self.highlightText(
+                    text,
+                    QRegExp('%s[^%s]*' % (string, string)),
+                    format,
+                    includeLast=True,
+                )
+
+            # format the comments
+            format = self.commentFormat()
+            for comment in self._comments:
+                self.highlightText(text, QRegExp(comment), format)
+
+    def highlightText(self, text, expr, format, offset=0, includeLast=False):
+        """Highlights a text group with an expression and format
+
+        Args:
+            text (str): text to highlight
+            expr (QRegExp): search parameter
+            format (QTextCharFormat): formatting rule
+            offset (int): number of characters to offset by when highlighting
+            includeLast (bool): whether or not the last character should be highlighted
+        """
+        pos = expr.indexIn(text, 0)
+
+        # highlight all the given matches to the expression in the text
+        while pos != -1:
+            pos = expr.pos(offset)
+            length = len(expr.cap(offset))
+
+            # use the last character if desired
+            if includeLast:
+                length += 1
+
+            # set the formatting
+            self.setFormat(pos, length, format)
+
+            matched = expr.matchedLength()
+            if includeLast:
+                matched += 1
+
+            pos = expr.indexIn(text, pos + matched)
+
+    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 keywordFormat(self):
+        """returns the keywords QTextCharFormat for this highlighter"""
+        format = QTextCharFormat()
+        format.setForeground(self.keywordColor())
+
+        return format
+
+    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 resultFormat(self):
+        """returns the result QTextCharFormat for this highlighter"""
+        fmt = QTextCharFormat()
+        fmt.setForeground(self.resultColor())
+        return fmt
+
+    def setConsoleMode(self, state=False):
+        """sets the highlighter to only apply to console strings
+        (lines starting with >>>)
+        """
+        self._consoleMode = 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 = json.load(open(filename))
+            self.setObjectName(data.get('name', ''))
+            self._keywords = data.get('keywords', [])
+            self._comments = data.get('comments', [])
+            self._strings = data.get('strings', [])
+
+            return True
+        return False
+
+    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 stringFormat(self):
+        """returns the keywords QTextCharFormat for this highligter"""
+        format = QTextCharFormat()
+        format.setForeground(self.stringColor())
+        return format