PrEditor 2.1.0__py3-none-any.whl

preditor/gui/group_tab_widget/grouped_tab_widget.py

@@ -0,0 +1,223 @@
+from __future__ import absolute_import
+
+from Qt.QtCore import Qt
+from Qt.QtWidgets import QMessageBox, QToolButton
+
+from ...prefs import VersionTypes
+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.released.connect(lambda: self.add_new_editor())
+        self.setCornerWidget(self.uiCornerBTN, Qt.Corner.TopRightCorner)
+
+        self.default_title = "Workbox01"
+
+    def __tab_widget__(self):
+        """Return the tab widget which contains this group
+
+        Returns:
+            GroupTabWidget: The tab widget which contains this group
+        """
+        return self.parent().parent()
+
+    def __changed_by_instance__(self):
+        """Returns if any of this groups editors have been changed by another
+        PrEditor instance's prefs save.
+
+        Returns:
+            changed (bool)
+        """
+        changed = False
+        for workbox_idx in range(self.count()):
+            workbox = self.widget(workbox_idx)
+            if workbox.__changed_by_instance__():
+                changed = True
+                break
+        return changed
+
+    def __orphaned_by_instance__(self):
+        """Returns if any of this groups editors have been orphaned by another
+        PrEditor instance's prefs save.
+
+        Returns:
+            orphaned (bool)
+        """
+        orphaned = False
+        for workbox_idx in range(self.count()):
+            workbox = self.widget(workbox_idx)
+            if workbox.__orphaned_by_instance__():
+                orphaned = True
+                break
+        return orphaned
+
+    def __is_dirty__(self):
+        """Returns if any of this groups editors are dirty.
+
+        Returns:
+            is_dirty (bool)
+        """
+        is_dirty = False
+        for workbox_idx in range(self.count()):
+            workbox = self.widget(workbox_idx)
+            if workbox.__is_dirty__():
+                is_dirty = True
+                break
+        return is_dirty
+
+    def __is_missing_linked_file__(self):
+        """Determine if any of the workboxes are linked to file which is missing
+        on disk.
+
+        Returns:
+            bool: Whether any of this group's workboxes define a linked file
+                which is missing on disk.
+        """
+        is_missing_linked_file = False
+        for workbox_idx in range(self.count()):
+            workbox = self.widget(workbox_idx)
+            if workbox.__is_missing_linked_file__():
+                is_missing_linked_file = True
+                break
+        return is_missing_linked_file
+
+    def add_new_editor(self, title=None, prefs=None):
+        title = title or self.default_title
+
+        title = self.get_next_available_tab_name(title)
+        editor, title = self.default_tab(title, prefs=prefs)
+        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, ask=True):
+        if self.count() == 1:
+            msg = "You have to leave at least one tab open."
+            QMessageBox.critical(
+                self, 'Tab can not be closed.', msg, QMessageBox.StandardButton.Ok
+            )
+            return
+
+        workbox = self.widget(index)
+        name = workbox.__workbox_name__()
+        msg = (
+            f"Would you like to donate the contents of tab\n{name}\nto the "
+            "/dev/null fund for wayward code?"
+        )
+
+        if ask:
+            ret = QMessageBox.question(
+                self,
+                'Donate to the cause?',
+                msg,
+                QMessageBox.StandardButton.Yes | QMessageBox.StandardButton.Cancel,
+            )
+        else:
+            ret = QMessageBox.StandardButton.Yes
+
+        if ret == QMessageBox.StandardButton.Yes:
+            editor = self.widget(index)
+            editor.__set_file_monitoring_enabled__(False)
+            self.store_closed_workbox(index)
+            super(GroupedTabWidget, self).close_tab(index)
+
+    def store_closed_workbox(self, index):
+        """Store the name of the workbox being closed.
+
+        Args:
+            index (int): The index of the workbox being closed
+        """
+        workbox = self.widget(index)
+
+        # Save the workbox first, so we can possibly restore it later.
+        workbox.__save_prefs__(saveLinkedFile=False)
+
+        self.parent().window().addRecentlyClosedWorkbox(workbox)
+
+    def default_tab(self, title=None, prefs=None):
+        title = title or self.default_title
+        kwargs = self.editor_kwargs if self.editor_kwargs else {}
+        editor = None
+        orphaned_by_instance = False
+        if prefs:
+            editor_info = prefs.pop("existing_editor_info", None)
+            if editor_info:
+                editor = editor_info[0]
+            orphaned_by_instance = prefs.pop("orphaned_by_instance", False)
+        else:
+            prefs = {}
+
+        if editor:
+            editor.__load_workbox_version_text__(VersionTypes.Last)
+
+            editor.__set_last_saved_text__(editor.__text__())
+            editor.__set_last_workbox_name__(editor.__workbox_name__())
+
+            filename = prefs.get("filename", None)
+            editor.__set_filename__(filename)
+
+            editor.__determine_been_changed_by_instance__()
+            self.window().setWorkboxFontBasedOnConsole(editor)
+        else:
+            editor = self.editor_cls(
+                parent=self, core_name=self.core_name, **prefs, **kwargs
+            )
+        editor.__set_orphaned_by_instance__(orphaned_by_instance)
+        return editor, title
+
+    def get_next_available_tab_name(self, name=None):
+        """Get the next available tab name, providing a default if needed.
+
+        Args:
+            name (str, optional): The name for which to get the next available
+                name.
+
+        Returns:
+            str: The determined next available tab name
+        """
+        if name is None:
+            name = self.default_title
+        return super().get_next_available_tab_name(name)
+
+    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__()
+
+        if hasattr(self.window(), "setWorkboxFontBasedOnConsole"):
+            self.window().setWorkboxFontBasedOnConsole()
+
+    def tab_widget(self):
+        """Return the tab widget which contains this group tab
+
+        Returns:
+            self._tab_widget (GroupTabWidget): The tab widget which contains
+                this workbox
+        """
+        return self.parent().parent()
+
+    def update_closable_tabs(self):
+        self.setTabsClosable(self.count() != 1)

preditor/gui/group_tab_widget/one_tab_widget.py

@@ -0,0 +1,96 @@
+from __future__ import absolute_import
+
+import re
+
+from Qt.QtWidgets import QTabWidget
+
+TAB_ITERATION_PATTERN = re.compile(r"(\d+)(?!.*\d)")
+
+
+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 get_next_available_tab_name(self, name):
+        """Get the next available tab name, incrementing an iteration if needed.
+
+        Args:
+            name (str): The desired name
+
+        Returns:
+            name (str): The name, or updated name if needed
+        """
+        existing_names = [self.tabText(i) for i in range(self.count())]
+
+        # Use regex to find the last set of digits. If found, the base name is
+        # a slice of name minus the digits string. Otherwise, the base name is
+        # the full name and iteration is zero.
+        match = TAB_ITERATION_PATTERN.search(name)
+        if match:
+            # We found trailing digits, so slice to get base name, and convert
+            # iteration to int
+            iter_str = match.group()
+            base = name[: -len(iter_str)]
+            iteration = int(iter_str)
+        else:
+            # No trailing digits found, so base name is full name and iteration
+            # is zero.
+            base = name
+            iteration = 0
+
+        if name in existing_names:
+            for _ in range(99):
+                iteration += 1
+                new_iter_str = str(iteration).zfill(2)
+                name = base + new_iter_str
+                if name not in existing_names:
+                    break
+        return name
+
+    def addTab(self, *args, **kwargs):  # noqa: N802
+        ret = super(OneTabWidget, self).addTab(*args, **kwargs)
+        self.update_closable_tabs()
+        self.tabBar().setFont(self.window().font())
+        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()
+        self.window().updateTabColorsAndToolTips()
+
+    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,358 @@
+from __future__ import absolute_import
+
+import logging
+import types
+from functools import partial
+
+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.ToolButtonPopupMode.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)
+
+        root.setLevel = types.MethodType(setLevel, 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):
+        plugins.add_logging_handler(self.logger, name)
+
+    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 type(h) is 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()
+
+        if self.logger.disabled:
+            # Warn the user that this logger has been disabled. The documentation
+            # says to consider this property as read only so this is just info
+            # and does not implement a way to re-enable this logger. It's not
+            # disabled because that would prevent the tooltip from showing.
+            action = self.addAction("Logger is disabled")
+            action.setToolTip(
+                'This <b>logger has been disabled</b> and does not handle events '
+                "so you likely won't see events from it or its children. "
+                'This normally happens when using logging.config with '
+                '"disable_existing_loggers" defaulted to True.'
+            )
+            action.setIcon(QIcon(resourcePath('img/warning-big.png')))
+            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()