PrEditor 1.0.0__py3-none-any.whl

preditor/gui/level_buttons.py

@@ -0,0 +1,343 @@
+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.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()
+
+        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()

preditor/gui/logger_window_handler.py

@@ -0,0 +1,48 @@
+from __future__ import absolute_import
+
+import logging
+
+from .. import instance
+
+
+class LoggerWindowHandler(logging.Handler):
+    """A logging handler that writes directly to the PrEditor instance.
+
+    Args:
+        error (bool, optional): Write the output as if it were written
+            to sys.stderr and not sys.stdout. Ie in red text.
+        formatter (str or logging.Formatter, optional): If specified,
+            this is passed to setFormatter.
+    """
+
+    default_format = (
+        '%(levelname)s %(module)s.%(funcName)s line:%(lineno)d - %(message)s'
+    )
+
+    def __init__(self, error=True, formatter=default_format):
+        super(LoggerWindowHandler, self).__init__()
+        self.error = error
+        if formatter is not None:
+            if not isinstance(formatter, logging.Formatter):
+                formatter = logging.Formatter(formatter)
+            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 = _instance.console()
+            if not console:
+                return
+
+            msg = self.format(record)
+            msg = u'{}\n'.format(msg)
+            console.write(msg, self.error)
+        except (KeyboardInterrupt, SystemExit):
+            raise
+        except Exception:
+            self.handleError(record)

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.
+        """