PrEditor 0.0.0.dev1__py2.py3-none-any.whl → 0.1.0__py2.py3-none-any.whl

preditor/gui/group_tab_widget/grouped_tab_menu.py

@@ -0,0 +1,35 @@
+from __future__ import absolute_import
+
+from preditor.gui.level_buttons import LazyMenu
+
+
+class GroupTabMenu(LazyMenu):
+    """A menu listing all tabs of GroupTabWidget and their child GroupedTabWidget
+    tabs. When selecting one of the GroupedTabWidget tab, it will make that tab
+    the current tab and give it focus.
+    """
+
+    def __init__(self, manager, parent=None):
+        super(GroupTabMenu, self).__init__(parent=parent)
+        self.manager = manager
+        self.triggered.connect(self.focus_tab)
+
+    def refresh(self):
+        self.clear()
+        for group in range(self.manager.count()):
+            # Create a "header" for the group tabs
+            self.addSeparator()
+            act = self.addAction(self.manager.tabText(group))
+            act.setEnabled(False)
+            self.addSeparator()
+
+            # Add all of this group tab's tabs
+            tab_widget = self.manager.widget(group)
+            for index in range(tab_widget.count()):
+                act = self.addAction('  {}'.format(tab_widget.tabText(index)))
+                act.setProperty('info', (group, index))
+
+    def focus_tab(self, action):
+        group, editor = action.property('info')
+        widget = self.manager.set_current_groups_from_index(group, editor)
+        widget.setFocus()

preditor/gui/group_tab_widget/grouped_tab_models.py

@@ -0,0 +1,108 @@
+from __future__ import absolute_import
+
+import re
+
+from Qt.QtCore import QSortFilterProxyModel, Qt
+from Qt.QtGui import QStandardItem, QStandardItemModel
+
+
+class GroupTabItemModel(QStandardItemModel):
+    GroupIndexRole = Qt.UserRole + 1
+    TabIndexRole = GroupIndexRole + 1
+
+    def __init__(self, manager, *args, **kwargs):
+        super(GroupTabItemModel, self).__init__(*args, **kwargs)
+        self.manager = manager
+
+    def workbox_indexes_from_model_index(self, index):
+        """Returns the group_index and tab_index for the provided QModelIndex"""
+        return (
+            index.data(self.GroupIndexRole),
+            index.data(self.TabIndexRole),
+        )
+
+    def pathFromIndex(self, index):
+        parts = [""]
+        while index.isValid():
+            parts.append(self.data(index, Qt.DisplayRole))
+            index = index.parent()
+        if len(parts) == 1:
+            return ""
+        return "/".join([x for x in parts[::-1] if x])
+
+
+class GroupTabTreeItemModel(GroupTabItemModel):
+    def process(self):
+        root = self.invisibleRootItem()
+        current_group = self.manager.currentIndex()
+        current_tab = self.manager.currentWidget().currentIndex()
+
+        prev_group = -1
+        all_widgets = self.manager.all_widgets()
+        for _, group_name, tab_name, group_index, tab_index in all_widgets:
+            if prev_group != group_index:
+                group_item = QStandardItem(group_name)
+                group_item.setData(group_index, self.GroupIndexRole)
+                root.appendRow(group_item)
+                prev_group = group_index
+
+            tab_item = QStandardItem(tab_name)
+            tab_item.setData(group_index, self.GroupIndexRole)
+            tab_item.setData(tab_index, self.TabIndexRole)
+            group_item.appendRow(tab_item)
+            if group_index == current_group and tab_index == current_tab:
+                self.original_model_index = self.indexFromItem(tab_item)
+
+
+class GroupTabListItemModel(GroupTabItemModel):
+    def flags(self, index):
+        return Qt.ItemIsEnabled | Qt.ItemIsSelectable
+
+    def process(self):
+        root = self.invisibleRootItem()
+        current_group = self.manager.currentIndex()
+        current_tab = self.manager.currentWidget().currentIndex()
+
+        all_widgets = self.manager.all_widgets()
+        for _, group_name, tab_name, group_index, tab_index in all_widgets:
+            tab_item = QStandardItem('/'.join((group_name, tab_name)))
+            tab_item.setData(group_index, self.GroupIndexRole)
+            tab_item.setData(tab_index, self.TabIndexRole)
+            root.appendRow(tab_item)
+            if group_index == current_group and tab_index == current_tab:
+                self.original_model_index = self.indexFromItem(tab_item)
+
+
+class GroupTabFuzzyFilterProxyModel(QSortFilterProxyModel):
+    """Implements a fuzzy search filter proxy model."""
+
+    def __init__(self, parent=None):
+        super(GroupTabFuzzyFilterProxyModel, self).__init__(parent=parent)
+        self._fuzzy_regex = None
+
+    def setFuzzySearch(self, search):
+        search = '.*'.join(search)
+        # search = '.*{}.*'.format(search)
+        self._fuzzy_regex = re.compile(search, re.I)
+        self.invalidateFilter()
+
+    def filterAcceptsRow(self, sourceRow, sourceParent):
+        if self.filterKeyColumn() == 0 and self._fuzzy_regex:
+
+            index = self.sourceModel().index(sourceRow, 0, sourceParent)
+            data = self.sourceModel().data(index)
+            ret = bool(self._fuzzy_regex.search(data))
+            return ret
+
+        return super(GroupTabFuzzyFilterProxyModel, self).filterAcceptsRow(
+            sourceRow, sourceParent
+        )
+
+    def pathFromIndex(self, index):
+        parts = [""]
+        while index.isValid():
+            parts.append(self.data(index, Qt.DisplayRole))
+            index = index.parent()
+        if len(parts) == 1:
+            return ""
+        return "/".join([x for x in parts[::-1] if x])

preditor/gui/group_tab_widget/grouped_tab_widget.py

@@ -0,0 +1,75 @@
+from __future__ import absolute_import
+
+from Qt.QtCore import Qt
+from Qt.QtGui import QIcon
+from Qt.QtWidgets import QMessageBox, QToolButton
+
+from ... import resourcePath
+from ..drag_tab_bar import DragTabBar
+from ..workbox_text_edit import WorkboxTextEdit
+from .one_tab_widget import OneTabWidget
+
+
+class GroupedTabWidget(OneTabWidget):
+    def __init__(self, editor_kwargs, editor_cls=None, core_name=None, *args, **kwargs):
+        super(GroupedTabWidget, self).__init__(*args, **kwargs)
+        DragTabBar.install_tab_widget(self, 'grouped_tab_widget')
+        self.editor_kwargs = editor_kwargs
+        if editor_cls is None:
+            editor_cls = WorkboxTextEdit
+        self.editor_cls = editor_cls
+        self.core_name = core_name
+        self.currentChanged.connect(self.tab_shown)
+
+        self.uiCornerBTN = QToolButton(self)
+        self.uiCornerBTN.setText('+')
+        self.uiCornerBTN.setIcon(QIcon(resourcePath('img/file-plus.png')))
+        self.uiCornerBTN.released.connect(lambda: self.add_new_editor())
+        self.setCornerWidget(self.uiCornerBTN, Qt.TopRightCorner)
+
+    def add_new_editor(self, title="Workbox"):
+        editor, title = self.default_tab(title)
+        index = self.addTab(editor, title)
+        self.setCurrentIndex(index)
+        return editor
+
+    def addTab(self, *args, **kwargs):  # noqa: N802
+        ret = super(GroupedTabWidget, self).addTab(*args, **kwargs)
+        self.update_closable_tabs()
+        return ret
+
+    def close_tab(self, index):
+        if self.count() == 1:
+            msg = "You have to leave at least one tab open."
+            QMessageBox.critical(self, 'Tab can not be closed.', msg, QMessageBox.Ok)
+            return
+        ret = QMessageBox.question(
+            self,
+            'Donate to the cause?',
+            "Would you like to donate this tabs contents to the /dev/null fund "
+            "for wayward code?",
+            QMessageBox.Yes | QMessageBox.Cancel,
+        )
+        if ret == QMessageBox.Yes:
+            # If the tab was saved to a temp file, remove it from disk
+            editor = self.widget(index)
+            editor.__remove_tempfile__()
+
+            super(GroupedTabWidget, self).close_tab(index)
+
+    def default_tab(self, title='Workbox'):
+        kwargs = self.editor_kwargs if self.editor_kwargs else {}
+        editor = self.editor_cls(parent=self, core_name=self.core_name, **kwargs)
+        return editor, title
+
+    def showEvent(self, event):  # noqa: N802
+        super(GroupedTabWidget, self).showEvent(event)
+        self.tab_shown(self.currentIndex())
+
+    def tab_shown(self, index):
+        editor = self.widget(index)
+        if editor and editor.isVisible():
+            editor.__show__()
+
+    def update_closable_tabs(self):
+        self.setTabsClosable(self.count() != 1)

preditor/gui/group_tab_widget/one_tab_widget.py

@@ -0,0 +1,54 @@
+from __future__ import absolute_import
+
+from Qt.QtWidgets import QTabWidget
+
+
+class OneTabWidget(QTabWidget):
+    """A QTabWidget that shows the close button only if there is more than one
+    tab. If something removes the last tab, it will add a default tab if the
+    default_tab method is implemented on a subclass. This is also used to create
+    the first tab on showEvent.
+
+    Subclasses can implement a `default_tab()` method. This should return the
+    widget to add and the title of the tab to create if implemented.
+    """
+
+    def __init__(self, *args, **kwargs):
+        super(OneTabWidget, self).__init__(*args, **kwargs)
+        self.tabCloseRequested.connect(self.close_tab)
+
+    def addTab(self, *args, **kwargs):  # noqa: N802
+        ret = super(OneTabWidget, self).addTab(*args, **kwargs)
+        self.update_closable_tabs()
+        return ret
+
+    def close_tab(self, index):
+        self.removeTab(index)
+        self.update_closable_tabs()
+
+    def index_for_text(self, text):
+        """Return the index of the tab with this text. Returns -1 if not found"""
+        for i in range(self.count()):
+            if self.tabText(i) == text:
+                return i
+        return -1
+
+    def insertTab(self, *args, **kwargs):  # noqa: N802
+        ret = super(OneTabWidget, self).insertTab(*args, **kwargs)
+        self.update_closable_tabs()
+        return ret
+
+    def removeTab(self, index):  # noqa: N802
+        super(OneTabWidget, self).removeTab(index)
+        if hasattr(self, 'default_tab') and not self.count():
+            self.addTab(*self.default_tab())
+        self.update_closable_tabs()
+
+    def showEvent(self, event):  # noqa: N802
+        super(OneTabWidget, self).showEvent(event)
+        # Force the creation of a default tab if defined
+        if hasattr(self, 'default_tab') and not self.count():
+            self.addTab(*self.default_tab())
+
+    def update_closable_tabs(self):
+        self.setTabsClosable(self.count() != 1)

preditor/gui/level_buttons.py

@@ -0,0 +1,349 @@
+from __future__ import absolute_import
+
+import logging
+import types
+from functools import partial
+
+import six
+from Qt.QtGui import QIcon
+from Qt.QtWidgets import QAction, QMenu, QToolButton
+
+from .. import plugins, resourcePath
+from ..enum import Enum, EnumGroup
+
+
+class Level(Enum):
+
+    """
+    Custom `Enum` representing an information level.
+
+    Attributes:
+        cached_icon(None): Used to cache the created icon from `get_icon` for
+            future use.
+        icon_name(str): Name of source icon file to use when creating icon via
+            `get_icon`.
+    """
+
+    cached_icon = None
+    icon_name = "dot"
+
+    @property
+    def name(self):
+        """
+        Override of `name` property allowing for the return of a "friendly
+        name" to be used in place of the inferred name from the `Enum` instance
+        name.
+
+        Returns:
+            str: Name of `Enum` instance.
+        """
+        return getattr(self, "friendly_name", super(Level, self).name)
+
+    @property
+    def icon(self):
+        """
+        Icon representing the level. On first access, the icon is created via
+        the `get_icon`-method and cached for later use.
+
+        Returns:
+            QIcon:
+        """
+        if not self.cached_icon:
+            self.cached_icon = self.get_icon(self.icon_name, self.level)
+        return self.cached_icon
+
+    def get_icon(self, name, level):
+        """
+        Retrieves the icon of `name` and level.
+
+        Args:
+            name (str): Icon to retrieve QIcon for.
+            level (str): Level name to apply.
+
+        Returns:
+            QIcon: Correct instantiated QIcon.
+        """
+        return QIcon(
+            resourcePath('img/{name}_{level}.png'.format(name=name, level=level))
+        )
+
+
+class LoggerLevel(Level):
+    """A Logger level `Enum` using the 'format_align_left' icon."""
+
+    icon_name = "logging"
+
+    def is_current(self, logger):
+        """Returns if the current logging level matches this label."""
+        return logging.getLevelName(logger.level) == self.label
+
+
+class LoggerLevels(EnumGroup):
+    """
+    Logger levels with their implementation level name and number & custom
+    icon level.
+    """
+
+    Disabled = LoggerLevel(
+        friendly_name="Not Set / Inherited", label="NOTSET", number=0, level="not_set"
+    )
+    Critical = LoggerLevel(label="CRITICAL", number=50, level="critical")
+    Error = LoggerLevel(label="ERROR", number=40, level="error")
+    Warning = LoggerLevel(label="WARNING", number=30, level="warning")
+    Info = LoggerLevel(label="INFO", number=20, level="info")
+    Debug = LoggerLevel(label="DEBUG", number=10, level="debug")
+
+    @classmethod
+    def fromLabel(cls, label, default=None, logger=None):
+        try:
+            return super(LoggerLevels, cls).fromLabel(label, default=default)
+        except ValueError:
+            # This is not be a standard level, generate a custom level to use
+            if logger is None:
+                logger = logging.getLogger()
+            effective_level = logger.getEffectiveLevel()
+            effective_level_name = logging.getLevelName(effective_level)
+
+            enum = LoggerLevel(
+                label=effective_level_name,
+                number=effective_level,
+                level=effective_level_name,
+            )
+            # Force the custom icon as this enum's name won't match
+            enum.cached_icon = enum.get_icon(enum.icon_name, "custom")
+            # Add it to the enum
+            LoggerLevels.append(enum)
+            return enum
+
+
+class LoggingLevelButton(QToolButton):
+
+    """
+    A drop down button to set logger levels for all loggers known to Python's
+    native logging implementation.
+
+    The logger menus present in the tool bar button have level-changing actions
+    as well a sub-menus for any descendant loggers.
+    """
+
+    def __init__(self, parent=None):
+        """
+        Creates the root logger menu this button displays when clicked.
+        Additionally, any pre-existing loggers and their menus are added.
+
+        Args:
+            parent (QWidget, optional): The parent widget for this button.
+        """
+        super(LoggingLevelButton, self).__init__(parent=parent)
+        self.setPopupMode(QToolButton.InstantPopup)
+
+        # create root logger menu
+        root = logging.getLogger("")
+        root_menu = LoggingLevelMenu(name="root", logger=root, parent=self)
+        self.setMenu(root_menu)
+
+        # TODO: Hook refresh up to a root logger signal
+        # Monkey patch root.setLogger to emit signal we connect to
+        root = self.patched_root_logger().level_changed.connect(self.refresh)
+
+    @staticmethod
+    def patched_root_logger():
+        """Returns `logging.getLogger("")`. This will have the level_changed
+        signal added if it wasn't already.
+
+        The level_changed signal is emitted any time something changes the
+        root logger level. PrEditor uses this to update the logging level button
+        icon any time the root logger's level is changed. The rest of the loggers
+        don't need this as the menu is built on demand with the correct icons indicated.
+        """
+        root = logging.getLogger("")
+        if hasattr(root, "level_changed"):
+            # Already patched, nothing to do
+            return root
+
+        # Need to patch the root logger
+        from signalslot import Signal
+
+        root.level_changed = Signal(args=["level"], name="level_changed")
+
+        # Store the current setLevel, so we can call it in our method
+        root._setLevel = root.setLevel
+
+        def setLevel(self, level):
+            """
+            Sets the threshold for this logger to `level`. Also emits the
+            instance's `level_changed`-signal with the level number as its payload.
+
+            Args:
+                level (int): Numeric level value.
+            """
+            # Call the original setLevel method
+            self._setLevel(level)
+            # Emit our signal
+            self.level_changed.emit(level=level)
+
+        if six.PY3:
+            root.setLevel = types.MethodType(setLevel, root)
+        else:
+            root.setLevel = types.MethodType(setLevel, root, type(root))
+
+        return root
+
+    def refresh(self, **kwargs):
+        effective_level = logging.getLogger("").getEffectiveLevel()
+        effective_level_name = logging.getLevelName(effective_level)
+        level_enum = LoggerLevels.fromLabel(effective_level_name)
+
+        self.setIcon(level_enum.icon)
+        self.setToolTip("Logger 'root' current level: {}".format(level_enum.name))
+
+
+class LazyMenu(QMenu):
+    """A menu class that only calls self.refresh when it is about to be shown."""
+
+    def __init__(self, *args, **kwargs):
+        super(LazyMenu, self).__init__(*args, **kwargs)
+        self.aboutToShow.connect(self.refresh)
+
+
+class HandlerMenu(LazyMenu):
+    def __init__(self, logger, parent=None):
+        super(HandlerMenu, self).__init__(title="Handlers", parent=parent)
+        self.logger = logger
+
+    def install_handler(self, name):
+        for _, cls in plugins.logging_handlers(name):
+            handler = cls()
+            self.logger.addHandler(handler)
+
+    def refresh(self):
+        self.clear()
+        # Add the Install sub menu showing all logging_handler plugins
+        handler_install = self.addMenu('Install')
+        for name, cls in plugins.logging_handlers():
+            act = handler_install.addAction(name)
+            act.triggered.connect(partial(self.install_handler, name))
+            for h in self.logger.handlers:
+                if isinstance(h, cls):
+                    act.setEnabled(False)
+                    act.setToolTip('Already installed for this logger.')
+                    break
+
+        # Add a visual indication of all of the existing handlers
+        # TODO: Add ability to modify the formatters and auto-creation on startup
+        self.addSeparator()
+        for handler in self.logger.handlers:
+            act = self.addAction(repr(handler))
+            act.setEnabled(False)
+
+
+class LoggingLevelMenu(LazyMenu):
+
+    """
+    Custom menu for Python Loggers.
+
+    Provides an interface for changing logger levels via menu actions. Also
+    displays the presently set level by highlighting the relevant menu action
+    and via the menu's icon (which displays the logger's effective level,
+    potentially inherited from its ancestor).
+    """
+
+    def __init__(self, name, logger, parent=None):
+        """
+        Creates the default level menu actions for updating the logger's level.
+
+        Args:
+            name (str): Name of Logger this menu will represent.
+            logger (logging.Logger): Logger this menu will represent and control
+                via actions that modify the logger's set level.
+            parent (QToolButton/QMenu): `QMenu` or `QToolButton` this menu will
+                be parented to.
+
+        Note: If the logger is merely a placeholder it will be initialized so
+            it can be added to the menu hierarchy. This ensures all ancestors
+            exist for appropriate parenting when descendants are added.
+        """
+        super(LoggingLevelMenu, self).__init__(title=name.split(".")[-1], parent=parent)
+
+        if isinstance(logger, logging.PlaceHolder):
+            logger = logging.getLogger(name)
+
+        self.logger = logger
+        self.name = name
+        self.update_ui()
+
+    def children(self):
+        """The direct sub-loggers of this logging object."""
+        parent = self.name
+        if parent == "root":
+            parent = ""
+        for name, logger in sorted(
+            logging.root.manager.loggerDict.items(), key=lambda x: x[0].lower()
+        ):
+            if name.startswith(parent):
+                remaining = name.lstrip(parent).lstrip(".")
+                if remaining and "." not in remaining:
+                    yield name, logger
+
+    def level(self):
+        """Returns the current effective LoggerLevel for self.logger."""
+        effective_level = self.logger.getEffectiveLevel()
+        effective_level_name = logging.getLevelName(effective_level)
+        return LoggerLevels.fromLabel(effective_level_name, logger=self.logger)
+
+    def refresh(self):
+        self.clear()
+
+        self.addMenu(HandlerMenu(self.logger, self))
+        self.addSeparator()
+
+        for logger_level in LoggerLevels:
+            is_current = logger_level.is_current(self.logger)
+
+            action = QAction(logger_level.icon, logger_level.name, self)
+            action.setCheckable(True)
+            action.setChecked(is_current)
+
+            # tooltip example: "Set 'preditor.debug' to level Warning")
+            action.setToolTip(
+                "Set '{}' to level {}".format(self.name, logger_level.name)
+            )
+
+            # when clicked/activated set associated loggers level
+            action.triggered.connect(partial(self.setLevel, logger_level.number))
+            self.addAction(action)
+
+        self.addSeparator()
+
+        for name, child in self.children():
+            self.addMenu(LoggingLevelMenu(name, child, self))
+
+    def setLevel(self, level):
+        """
+        Sets the logger this menu object represents to the level supplied.
+
+        Args:
+            level (str): Logging level to set logger to.
+        """
+        self.logger.setLevel(level)
+        self.update_ui()
+
+    def update_ui(self):
+        """Set the menu icon to this LoggerLevel's icon.
+
+        If the updated logger is the root logger, the logging level toolbar
+        button's icon is updated instead.
+
+        Args:
+            level (LoggerLevel): Logging level to change icon to represent.
+        """
+
+        level_enum = self.level()
+        act = self.menuAction()
+        act.setIcon(level_enum.icon)
+        act.setToolTip(
+            "Logger '{}' current level: {}".format(self.logger.name, level_enum.name)
+        )
+
+        if self.name == "root":
+            self.parent().refresh()