PrEditor 0.8.0__tar.gz → 0.10.0__tar.gz

{preditor-0.8.0 → preditor-0.10.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: PrEditor
-Version: 0.8.0
+Version: 0.10.0
 Summary: A python REPL and Editor and console based on Qt.
 Home-page: https://github.com/blurstudio/PrEditor.git
 Author: Blur Studio
@@ -208,6 +208,11 @@ added in [setup.cfg](setup.cfg).
 implementing a workbox. See [workbox_mixin.py](preditor/gui/workbox_mixin.py)
 for the full interface to implement all features of an editor.
 
+* `preditor.plug.loggerwindow`: Used to customize the LoggerWindow instance when
+the LoggerWindow is created. For example, this can be used to create extra Toolbars
+or add menu items. When using this plugin, make sure to use the
+`preditor.gui.logger_window_plugin.LoggerWindowPlugin` class for your base class.
+
 * `preditor.plug.logging_handlers`: Used to add custom python logging handlers
 to the LoggingLevelButton's handlers sub-menus. This allows you to install a
 handler instance on a specific logging object.

{preditor-0.8.0 → preditor-0.10.0}/PrEditor.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: PrEditor
-Version: 0.8.0
+Version: 0.10.0
 Summary: A python REPL and Editor and console based on Qt.
 Home-page: https://github.com/blurstudio/PrEditor.git
 Author: Blur Studio
@@ -208,6 +208,11 @@ added in [setup.cfg](setup.cfg).
 implementing a workbox. See [workbox_mixin.py](preditor/gui/workbox_mixin.py)
 for the full interface to implement all features of an editor.
 
+* `preditor.plug.loggerwindow`: Used to customize the LoggerWindow instance when
+the LoggerWindow is created. For example, this can be used to create extra Toolbars
+or add menu items. When using this plugin, make sure to use the
+`preditor.gui.logger_window_plugin.LoggerWindowPlugin` class for your base class.
+
 * `preditor.plug.logging_handlers`: Used to add custom python logging handlers
 to the LoggingLevelButton's handlers sub-menus. This allows you to install a
 handler instance on a specific logging object.

{preditor-0.8.0 → preditor-0.10.0}/PrEditor.egg-info/SOURCES.txt

@@ -57,6 +57,7 @@ preditor/gui/errordialog.py
 preditor/gui/find_files.py
 preditor/gui/level_buttons.py
 preditor/gui/logger_window_handler.py
+preditor/gui/logger_window_plugin.py
 preditor/gui/loggerwindow.py
 preditor/gui/newtabwidget.py
 preditor/gui/redmine_login_dialog.py

{preditor-0.8.0 → preditor-0.10.0}/README.md

@@ -165,6 +165,11 @@ added in [setup.cfg](setup.cfg).
 implementing a workbox. See [workbox_mixin.py](preditor/gui/workbox_mixin.py)
 for the full interface to implement all features of an editor.
 
+* `preditor.plug.loggerwindow`: Used to customize the LoggerWindow instance when
+the LoggerWindow is created. For example, this can be used to create extra Toolbars
+or add menu items. When using this plugin, make sure to use the
+`preditor.gui.logger_window_plugin.LoggerWindowPlugin` class for your base class.
+
 * `preditor.plug.logging_handlers`: Used to add custom python logging handlers
 to the LoggingLevelButton's handlers sub-menus. This allows you to install a
 handler instance on a specific logging object.

{preditor-0.8.0 → preditor-0.10.0}/preditor/__init__.py

@@ -66,51 +66,74 @@ def init():
 
 
 def configure(name, parent_callback=None, excepthook=True, logging=True, streams=True):
-    """Global configuration of PrEditor. Nothing is done if called more than once.
+    """Global configuration of PrEditor. Safe to re-call until the instance is created.
+
+    Configures the instance of PrEditor without creating the GUI. It should be run
+    as early as possible in the applications initialization to allow PrEditor to
+    show as much stdout/err text as possible even the text printed before the
+    application's GUI is created.
+
+    Once `preditor.instance(create=True)` is called this will return without
+    making any changes. Otherwise unless noted with "First call only." each time
+    this function is called it will update any previously set values. This allows
+    you to minimally configure PrEditor and as more of the application comes
+    online enable more advanced features.
 
     Args:
         name (str): The core_name to use for the global instance of PrEditor.
             Once this has been set, you can call `launch` without passing name
-            to access the main instance.
+            to access the main instance. The core_name controls what preferences
+            are loaded and used by PrEditor including the workbox tabs.
         parent_callback (callable, optional): Callback that returns a QWidget
             to use as the parent of the LoggerWindow when its first created.
             This can be used by DCC's to set the parent to their main window.
-        excepthook (bool, optional): Replaces `sys.excepthook` with a interactive
-            exception handler that prompts the user to show PrEditor when an
-            python exception is raised.
-        logging (bool, optional): Restore the python logging configuration that
-            was recorded the last time PrEditor prefs were saved.
-        streams (bool, optional): Install the stream manager to capture any
-            stdout/stderr text written. Later when calling launch, the
+        excepthook (bool, optional): First call only. 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.
+        logging (bool, optional): Restore the python logging configuration settings
+            that were recorded the last time PrEditor prefs were saved. If called
+            multiple times with different core_name's before the instance is
+            created, this will reset the logging configuration from the previous
+            core_name if logging prefs exist.
+        streams (bool, optional): First call only. Install the stream manager to
+            capture any stdout/stderr text written. Later when calling launch, the
             LoggerWindow will show all of the captured text. This lets you only
-            create the LoggerWindow IF you need to, but when you do it will have
-            all of the std stream text written after this call.
+            create the LoggerWindow IF you need to show it, but when you do it
+            will have all of the std stream text written after this call.
     """
-    # Once this has been set, configure should not do anything
-    if 'core_name' in _global_config:
+    # Once the UI instance has been created, configure should not do anything.
+    if instance(create=False):
         return
 
-    # Store the core_name,.
+    # Store the core_name.
+    changed = _global_config.get('core_name') != name
     _global_config['core_name'] = name
     if parent_callback:
         _global_config['parent_callback'] = parent_callback
 
-    if streams:
+    if streams and not _global_config.get('streams_installed'):
         # Install the stream manager to capture output
         from preditor.stream import install_to_std
 
         install_to_std()
+        _global_config['streams_installed'] = True
 
-    if logging:
+    if logging and changed:
+        # Only update the logging config if the core name has changed.
+        # Note: When called repeatedly, this won't remove old logger's added by
+        # the previous calls so you may see some loggers added that were never
+        # actually added by code other than the LoggingConfig.
         from .logging_config import LoggingConfig
 
         cfg = LoggingConfig(core_name=name)
         cfg.load()
 
-    if excepthook:
+    if excepthook and not _global_config.get('excepthook_installed'):
         import preditor.debug
 
         preditor.debug.BlurExcepthook.install()
+        _global_config['excepthook_installed'] = True
 
 
 def get_core_name():
@@ -229,6 +252,16 @@ def root_window():
     return App.root_window()
 
 
+def parent_callback():
+    """Returns the parent_callback or None.
+
+    This is a callback that returns a QWidget to use as the parent of the
+    LoggerWindow when its first created. This can be used by DCC's to set the
+    parent to their main window.
+    """
+    return _global_config.get("parent_callback")
+
+
 def connect_preditor(
     parent, sequence='F2', text='Show PrEditor', obj_name='uiShowPreditorACT', name=None
 ):

{preditor-0.8.0 → preditor-0.10.0}/preditor/cores/core.py

@@ -1,6 +1,6 @@
 from __future__ import absolute_import, print_function
 
-from Qt.QtCore import QObject, Signal
+from Qt.QtCore import QObject
 
 
 class Core(QObject):
@@ -9,17 +9,11 @@ class Core(QObject):
     be distributed between different pacakges.
     """
 
-    # ----------------------------------------------------------------
-    # blurdev signals
-    aboutToClearPaths = Signal()  # Emitted before environment is changed or reloaded
-
-    # ----------------------------------------------------------------
-
     def __init__(self, objectName=None):
-        QObject.__init__(self)
+        super(Core, self).__init__()
         if objectName is None:
-            objectName = 'blurdev'
-        QObject.setObjectName(self, objectName)
+            objectName = 'PrEditor'
+        self.setObjectName(objectName)
 
         # create custom properties
         self._headless = False

{preditor-0.8.0 → preditor-0.10.0}/preditor/gui/__init__.py

@@ -3,6 +3,7 @@ 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
@@ -82,3 +83,11 @@ def loadUi(filename, widget, 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-0.8.0 → preditor-0.10.0}/preditor/gui/dialog.py

@@ -3,7 +3,7 @@ from __future__ import absolute_import
 from Qt.QtCore import Qt
 from Qt.QtWidgets import QDialog
 
-from .. import core, relativePath, root_window
+from .. import relativePath, root_window
 
 
 class Dialog(QDialog):
@@ -25,9 +25,6 @@ class Dialog(QDialog):
             cls._instance = cls(parent=parent)
             # protect the memory
             cls._instance.setAttribute(Qt.WA_DeleteOnClose, False)
-            # but make sure that if we reload the environment, everything gets deleted
-            # properly
-            core.aboutToClearPaths.connect(cls._instance.shutdown)
         return cls._instance
 
     def __init__(
@@ -80,9 +77,6 @@ class Dialog(QDialog):
         # If this value is set to False calling setGeometry on this dialog will not
         # adjust the geometry to ensure the dialog is on a valid screen.
         self.checkScreenGeo = True
-        # If this value is set to True the dialog will listen for
-        # core.aboutToClearPaths and call shutdown on the dialog.
-        self.aboutToClearPathsEnabled = True
         # attempt to set the dialog icon
         import os
         import sys
@@ -128,13 +122,6 @@ class Dialog(QDialog):
 
             WinWidget.uncache(wwidget)
 
-        # only disconnect here if deleting on close
-        if self.aboutToClearPathsEnabled and self.testAttribute(Qt.WA_DeleteOnClose):
-            try:
-                core.aboutToClearPaths.disconnect(self.shutdown)
-            except TypeError:
-                pass
-
     def exec_(self):
         # do not use the DeleteOnClose attribute when executing a dialog as often times
         # a user will be accessing information from the dialog instance after it closes.
@@ -158,13 +145,6 @@ class Dialog(QDialog):
 
             ensureWindowIsVisible(self)
 
-    def showEvent(self, event):
-        # listen for aboutToClearPaths signal if requested
-        # but only connect here if deleting on close
-        if self.aboutToClearPathsEnabled and self.testAttribute(Qt.WA_DeleteOnClose):
-            core.aboutToClearPaths.connect(self.shutdown)
-        super(Dialog, self).showEvent(event)
-
     def shutdown(self):
         # use a @classmethod to make inheritance magically work
         self._shutdown(self)
@@ -178,8 +158,6 @@ class Dialog(QDialog):
         # allow the global instance to be cleared
         if this == cls._instance:
             cls._instance = None
-            if this.aboutToClearPathsEnabled:
-                core.aboutToClearPaths.disconnect(this.shutdown)
             this.setAttribute(Qt.WA_DeleteOnClose, True)
         try:
             this.close()

{preditor-0.8.0 → preditor-0.10.0}/preditor/gui/group_tab_widget/__init__.py

@@ -70,7 +70,7 @@ class GroupTabWidget(OneTabWidget):
         self.uiCornerBTN = corner
         self.setCornerWidget(self.uiCornerBTN, Qt.TopRightCorner)
 
-    def add_new_tab(self, group, title="Workbox"):
+    def add_new_tab(self, group, title="Workbox", group_fmt=None):
         """Adds a new tab to the requested group, creating the group if the group
         doesn't exist.
 
@@ -79,6 +79,11 @@ class GroupTabWidget(OneTabWidget):
                 existing tab, or the name of the group and it will create the group
                 if needed. If None is passed it will add a new tab `Group {last+1}`.
                 If True is passed, then the current group tab is used.
+            title (str, optional): The name to give the newly created tab inside
+                the group.
+            group_fmt(str, optional): If None is passed to group, this string is
+                used to search for existing tabs to calculate the last number
+                and generate the new group tab name.
 
         Returns:
             GroupedTabWidget: The tab group for this group.
@@ -86,12 +91,14 @@ class GroupTabWidget(OneTabWidget):
         """
         parent = None
         if not group:
+            if group_fmt is None:
+                group_fmt = r'Group {}'
             last = 0
             for i in range(self.count()):
-                match = re.match(r'Group (\d+)', self.tabText(i))
+                match = re.match(group_fmt.format(r'(\d+)'), self.tabText(i))
                 if match:
                     last = max(last, int(match.group(1)))
-            group = "Group {}".format(last + 1)
+            group = group_fmt.format(last + 1)
         elif group is True:
             group = self.currentIndex()
         if isinstance(group, int):

{preditor-0.8.0 → preditor-0.10.0}/preditor/gui/level_buttons.py

@@ -212,9 +212,7 @@ class HandlerMenu(LazyMenu):
         self.logger = logger
 
     def install_handler(self, name):
-        for _, cls in plugins.logging_handlers(name):
-            handler = cls()
-            self.logger.addHandler(handler)
+        plugins.add_logging_handler(self.logger, name)
 
     def refresh(self):
         self.clear()
@@ -224,7 +222,7 @@ class HandlerMenu(LazyMenu):
             act = handler_install.addAction(name)
             act.triggered.connect(partial(self.install_handler, name))
             for h in self.logger.handlers:
-                if isinstance(h, cls):
+                if type(h) is cls:
                     act.setEnabled(False)
                     act.setToolTip('Already installed for this logger.')
                     break

{preditor-0.8.0 → preditor-0.10.0}/preditor/gui/logger_window_handler.py

@@ -1,13 +1,12 @@
 from __future__ import absolute_import
 
 import logging
-import weakref
 
 from .. import instance
 
 
 class LoggerWindowHandler(logging.Handler):
-    """A logging handler that writes directly to the Python Logger.
+    """A logging handler that writes directly to the PrEditor instance.
 
     Args:
         error (bool, optional): Write the output as if it were written
@@ -22,7 +21,6 @@ class LoggerWindowHandler(logging.Handler):
 
     def __init__(self, error=True, formatter=default_format):
         super(LoggerWindowHandler, self).__init__()
-        self.console = weakref.ref(instance().console())
         self.error = error
         if formatter is not None:
             if not isinstance(formatter, logging.Formatter):
@@ -30,10 +28,14 @@ class LoggerWindowHandler(logging.Handler):
             self.setFormatter(formatter)
 
     def emit(self, record):
+        _instance = instance(create=False)
+        if _instance is None:
+            # No gui has been created yet, so nothing to do
+            return
         try:
             # If the python logger was closed and garbage collected,
             # there is nothing to do, simply exit the call
-            console = self.console()
+            console = _instance.console()
             if not console:
                 return
 

preditor-0.10.0/preditor/gui/logger_window_plugin.py

@@ -0,0 +1,32 @@
+class LoggerWindowPlugin:
+    """Base class for LoggerWindow plugins.
+
+    These plugins are loaded using the `preditor.plug.loggerwindow` entry point.
+    This entry point is loaded when `LoggerWindow` is initialized. For each entry
+    point defined a single instance of the plugin is created per instance of
+    a LoggerWindow.
+
+    To save preferences override `record_prefs` and `restore_prefs` methods. These
+    are used to save and load preferences any time the PrEditor save/loads prefs.
+    """
+
+    def __init__(self, parent):
+        self.parent = parent
+
+    def record_prefs(self, name):
+        """Returns any prefs to save with the PrEditor's preferences.
+
+        Returns:
+            dict: A dictionary that will be saved using json or None.
+        """
+
+    def restore_prefs(self, name, prefs):
+        """Restore the preferences saved from a previous launch.
+
+        Args:
+            name(str): The name specified by the `preditor.plug.loggerwindow`
+                entry point.
+            prefs(dict or None): The prefs returned by a previous call to
+                `record_prefs()` from the last preference save. None is passed
+                if no prefs were recorded.
+        """

{preditor-0.8.0 → preditor-0.10.0}/preditor/gui/loggerwindow.py

@@ -37,7 +37,7 @@ from .. import (
     resourcePath,
 )
 from ..delayable_engine import DelayableEngine
-from ..gui import Dialog, Window, loadUi
+from ..gui import Dialog, Window, loadUi, tab_widget_for_tab
 from ..gui.fuzzy_search.fuzzy_search import FuzzySearch
 from ..gui.group_tab_widget.grouped_tab_models import GroupTabListItemModel
 from ..logging_config import LoggingConfig
@@ -55,6 +55,31 @@ class WorkboxPages:
     Workboxes = 1
 
 
+class WorkboxName(str):
+    """The joined name of a workbox `group/workbox` with access to its parts.
+
+    This subclass provides properties for the group and workbox values separately.
+    """
+
+    def __new__(cls, group, workbox):
+        txt = "/".join((group, workbox))
+        ret = super().__new__(cls, txt)
+        # Preserve the imitable nature of str's by using properties without setters.
+        ret._group = group
+        ret._workbox = workbox
+        return ret
+
+    @property
+    def group(self):
+        """The tab name of the group tab that contains the workbox."""
+        return self._group
+
+    @property
+    def workbox(self):
+        """The workbox of the tab for this workbox inside of the group."""
+        return self._workbox
+
+
 class LoggerWindow(Window):
     _instance = None
     styleSheetChanged = Signal(str)
@@ -62,7 +87,6 @@ class LoggerWindow(Window):
     def __init__(self, parent, name=None, run_workbox=False, standalone=False):
         super(LoggerWindow, self).__init__(parent=parent)
         self.name = name if name else get_core_name()
-        self.aboutToClearPathsEnabled = False
         self._stylesheet = 'Bright'
 
         # Create timer to autohide status messages
@@ -237,7 +261,6 @@ class LoggerWindow(Window):
         self.uiBackupPreferencesACT.triggered.connect(self.backupPreferences)
         self.uiBrowsePreferencesACT.triggered.connect(self.browsePreferences)
         self.uiAboutPreditorACT.triggered.connect(self.show_about)
-        core.aboutToClearPaths.connect(self.pathsAboutToBeCleared)
         self.uiSetFlashWindowIntervalACT.triggered.connect(self.setFlashWindowInterval)
 
         self.uiSetPreferredTextEditorPathACT.triggered.connect(
@@ -264,6 +287,12 @@ class LoggerWindow(Window):
         self.addAction(self.uiClearLogACT)
 
         self.dont_ask_again = []
+
+        # Load any plugins that modify the LoggerWindow
+        self.plugins = {}
+        for name, plugin in plugins.loggerwindow():
+            self.plugins[name] = plugin(self)
+
         self.restorePrefs()
 
         # add stylesheet menu options.
@@ -335,16 +364,48 @@ class LoggerWindow(Window):
 
     @classmethod
     def name_for_workbox(cls, workbox):
-        """Returns the name for a given workbox.
-        The name is the group tab text and the workbox tab text joined by a `/`"""
-        ret = []
-        logger = cls.instance()
-        index = logger.uiWorkboxTAB.currentIndex()
-        ret.append(logger.uiWorkboxTAB.tabText(index))
-        group_widget = logger.uiWorkboxTAB.currentWidget()
-        index = group_widget.currentIndex()
-        ret.append(group_widget.tabText(index))
-        return "/".join(ret)
+        """Returns the name for a given workbox or None if not valid.
+
+        The name is a `WorkboxName` object showing the group and name joined by
+        a `/`.
+
+        Args:
+            workbox: The workbox to get the name of. If None is passed then it
+                will return the name of the current workbox.
+
+        Returns:
+            The name of the widget as a `WorkboxName` object showing the group
+            and name joined by a `/`. If workbox is not valid for the LoggerWindow
+            instance then None is returned.
+        """
+
+        if workbox is None:
+            # if the workbox was not provided use the current workbox
+            logger = cls.instance()
+            index = logger.uiWorkboxTAB.currentIndex()
+            group = logger.uiWorkboxTAB.tabText(index)
+            group_widget = logger.uiWorkboxTAB.currentWidget()
+            index = group_widget.currentIndex()
+            name = group_widget.tabText(index)
+            return WorkboxName(group, name)
+
+        # Otherwise resolve from the parent widgets.
+        # Get the parent QTabWidget of the workbox
+        workbox_tab_widget = tab_widget_for_tab(workbox)
+        if not workbox_tab_widget:
+            return None
+        # Get the group QTabWidget of the parent QTabWidget of the workbox
+        group_widget = tab_widget_for_tab(workbox_tab_widget)
+        if not group_widget:
+            return None
+
+        # Get the group name
+        index = group_widget.indexOf(workbox_tab_widget)
+        group = group_widget.tabText(index)
+
+        index = workbox_tab_widget.indexOf(workbox)
+        name = workbox_tab_widget.tabText(index)
+        return WorkboxName(group, name)
 
     @classmethod
     def workbox_for_name(cls, name, show=False, visible=False):
@@ -699,10 +760,6 @@ class LoggerWindow(Window):
         else:
             super(LoggerWindow, self).keyPressEvent(event)
 
-    def pathsAboutToBeCleared(self):
-        if self.uiClearLogOnRefreshACT.isChecked():
-            self.clearLog()
-
     def clearExecutionTime(self):
         """Update status text with hyphens to indicate execution has begun."""
         self.setStatusText('Exec: -.- Seconds')
@@ -734,7 +791,6 @@ class LoggerWindow(Window):
                 'spellCheckEnabled': self.uiSpellCheckEnabledACT.isChecked(),
                 'wordWrap': self.uiWordWrapACT.isChecked(),
                 'clearBeforeRunning': self.uiClearBeforeRunningACT.isChecked(),
-                'clearBeforeEnvRefresh': self.uiClearLogOnRefreshACT.isChecked(),
                 'uiSelectTextACT': self.uiSelectTextACT.isChecked(),
                 'toolbarStates': six.text_type(self.saveState().toHex(), 'utf-8'),
                 'consoleFont': self.console().font().toString(),
@@ -773,6 +829,13 @@ class LoggerWindow(Window):
 
         pref['editor_cls'] = self.editor_cls_name
 
+        # Allow any plugins to add their own preferences dictionary
+        pref["plugins"] = {}
+        for name, plugin in self.plugins.items():
+            plugin_pref = plugin.record_prefs(name)
+            if plugin_pref:
+                pref["plugins"][name] = plugin_pref
+
         self.save_prefs(pref)
 
     def load_prefs(self):
@@ -893,7 +956,6 @@ class LoggerWindow(Window):
         self.uiWordWrapACT.setChecked(pref.get('wordWrap', True))
         self.setWordWrap(self.uiWordWrapACT.isChecked())
         self.uiClearBeforeRunningACT.setChecked(pref.get('clearBeforeRunning', False))
-        self.uiClearLogOnRefreshACT.setChecked(pref.get('clearBeforeEnvRefresh', False))
         self.setClearBeforeRunning(self.uiClearBeforeRunningACT.isChecked())
         self.uiSelectTextACT.setChecked(pref.get('uiSelectTextACT', True))
 
@@ -924,6 +986,10 @@ class LoggerWindow(Window):
 
         self.dont_ask_again = pref.get('dont_ask_again', [])
 
+        # Allow any plugins to restore their own preferences
+        for name, plugin in self.plugins.items():
+            plugin.restore_prefs(name, pref.get("plugins", {}).get(name))
+
     def restoreToolbars(self, pref=None):
         if pref is None:
             pref = self.load_prefs()