PrEditor 2.1.0__py3-none-any.whl

preditor/settings.py

@@ -0,0 +1,71 @@
+#!/usr/bin/env python
+from __future__ import absolute_import, print_function
+
+import os
+import sys
+
+try:
+    import configparser
+except Exception:
+    import ConfigParser as configparser  # noqa: N813
+
+# define the default environment variables
+OS_TYPE = ''
+if os.name == 'posix':
+    OS_TYPE = 'Linux'
+elif os.name == 'nt':
+    OS_TYPE = 'Windows'
+elif os.name == 'osx':
+    OS_TYPE = 'MacOS'
+
+# The sections to add from settings.ini
+# The order matters. Add from most specific to least specific.
+# Example: Add Windows Offline, then Windows, then Default.
+# Environment variables that exist in os.environ will not be added.
+_SECTIONS_TO_ADD = []
+if os.getenv('BDEV_OFFLINE') == '1':
+    _SECTIONS_TO_ADD.append('{} Offline'.format(OS_TYPE))
+_SECTIONS_TO_ADD += [OS_TYPE, 'Default']
+
+_currentEnv = ''
+defaults = {}
+
+
+def environStr(value):
+    if sys.version_info[0] > 2:
+        # Python 3 requires a unicode value. aka str(), which these values already are
+        return value
+    # Python 2 requires str object, not unicode
+    return value.encode('utf8')
+
+
+def addConfigSection(config_parser, section):
+    """
+    Add a config section to os.environ for a section.
+
+    Does not add options that already exist in os.environ.
+
+    Args:
+        config_parser (configparser.RawConfigParser): The parser to read from.
+            Must already be read.
+        section (str): The section name to add.
+    """
+
+    for option in config_parser.options(section):
+        if option.upper() not in os.environ:
+            value = config_parser.get(section, option)
+            if value == 'None':
+                value = ''
+            # In python2.7 on windows you can't pass unicode values to
+            # subprocess.Popen's env argument. This is the reason we are calling str()
+            os.environ[environStr(option.upper())] = environStr(value)
+
+
+# load the default environment from the settings INI
+config = configparser.RawConfigParser()
+config.read(os.path.join(os.path.dirname(__file__), 'resource', 'settings.ini'))
+for section in _SECTIONS_TO_ADD:
+    addConfigSection(config, section)
+
+# store the blurdev path in the environment
+os.environ['BDEV_PATH'] = environStr(os.path.dirname(__file__))

preditor/stream/__init__.py

@@ -0,0 +1,72 @@
+""" A system for capturing stream output and later inserting the captured output into a
+gui, and allowing that GUI to directly capture any new output written to the streams.
+
+A use case for this is to attach a Manager's as early as possible to ``sys.stdout``
+and ``sys.stderr`` process, before any GUI's are created. Then later you initialize a
+GUI python console that should show all python output that has already been written.
+Any future writes are delivered directly to the gui using a callback mechanism.
+
+Example::
+
+    # Startup script or plugin for DCC runs this as early as possible.
+    from preditor.stream import install_to_std
+
+    manager = install_to_std()
+    # Startup script exits and DCC continues to load eventually creating the main gui.
+
+    # From a menu a user chooses to show a custom console(A gui that replicates a
+    # python interactive console inside the DCC).
+    console = PythonConsole()
+
+    # We will want to see all the previous writes made by python, so replay them
+    # in the console so it can properly handle stdout and stderr writes.
+    for msg, state in manager:
+        console.write(msg, state)
+
+    # Make it so any future writes are automatically added to the console.
+    manager.add_callback(console.write)
+
+    # Optionally, disable storing data in the buffer. buffer.write calls will now
+    # directly write to console so there is no reason to duplicate the data to the
+    # buffer.
+    manager.append_writes = False
+"""
+import sys
+
+from ..constants import StreamType
+from ..streamhandler_helper import StreamHandlerHelper  # noqa: E402
+from .director import Director  # noqa: E402
+from .manager import Manager  # noqa: E402
+
+"""Set when :py:attr:``install_to_std`` is called. This stores the installed Manager
+so it can be accessed to install callbacks.
+"""
+active = None
+
+__all__ = ["active", "Director", "install_to_std", "Manager"]
+
+
+def install_to_std(out=True, err=True):
+    """Replaces ``sys.stdout`` and ``sys.stderr`` with :py:class:`Director`'s
+    using the returned :py:class:`Manager`. This manager is stored as the ``active``
+    variable and can be accessed later. This can be called more than once, and it will
+    simply return the already installed Manager.
+
+    Args:
+        out (bool, optional): Enables replacement of ``sys.stdout`` on first call.
+        err (bool, optional): Enables replacement of ``sys.stderr`` on first call.
+    """
+    global active
+
+    if active is None:
+        active = Manager()
+        if out:
+            sys.stdout = Director(active, StreamType.STDOUT)
+            # Update any StreamHandler's that were setup using the old stdout
+            StreamHandlerHelper.replace_stream(sys.stdout.old_stream, sys.stdout)
+        if err:
+            sys.stderr = Director(active, StreamType.STDERR)
+            # Update any StreamHandler's that were setup using the old stderr
+            StreamHandlerHelper.replace_stream(sys.stderr.old_stream, sys.stderr)
+
+    return active

preditor/stream/console_handler.py

@@ -0,0 +1,169 @@
+from __future__ import absolute_import
+
+import logging
+import re
+from dataclasses import dataclass
+from typing import Optional
+
+from .. import plugins
+from ..constants import StreamType
+from . import Manager
+
+logger = logging.getLogger(__name__)
+
+
+class DefaultDescriptor:
+    def __init__(self, *, ident=None, default=None):
+        self._default = default
+        self._ident = ident
+
+    def __set_name__(self, owner, name):
+        self._name = "_" + name
+
+    def __get__(self, obj, type):
+        if obj is None:
+            return self._default
+
+        return getattr(obj, self._name, self._default)
+
+
+class LoggingLevelDescriptor(DefaultDescriptor):
+    """Converts a string into a logging level or None.
+
+    When set, the string will be converted to an int if possible otherwise the
+    provided value is stored.
+    """
+
+    _level_conversion = logging.Handler()
+
+    def __set__(self, obj, value):
+        if value is None:
+            value = logging.NOTSET
+        else:
+            try:
+                value = int(value)
+            except ValueError:
+                # convert logging level strings to their int values if possible.
+                try:
+                    self._level_conversion.setLevel(value)
+                    value = self._level_conversion.level
+                except Exception:
+                    logger.warning(f"Unable to convert {value} to an int logging level")
+                    value = 0
+        setattr(obj, self._name, value)
+
+
+class FormatterDescriptor(DefaultDescriptor):
+    """Stores a logging.Formatter object.
+
+    If a string is passed it will be cast into a Formatter instance.
+    """
+
+    def __init__(self, *, ident=None, default=None):
+        if isinstance(default, str):
+            default = logging.Formatter(default)
+        super().__init__(ident=ident, default=default)
+
+    def __set__(self, obj, value):
+        if isinstance(value, str):
+            value = logging.Formatter(value)
+        setattr(obj, self._name, value)
+
+
+@dataclass
+class HandlerInfo:
+    name: str
+    level: LoggingLevelDescriptor = LoggingLevelDescriptor()
+    plugin: Optional[str] = "Console"
+    formatter: FormatterDescriptor = FormatterDescriptor()
+
+    _attr_names = {"plug": "plugin", "fmt": "formatter", "lvl": "level"}
+
+    def __post_init__(self):
+        # Clear self.name so you can define omit name to define a root logger
+        # For example passing "level=INFO" would set the root logger to info.
+        name = self.name
+        self.name = ""
+
+        parts = self.__to_parts__(name)
+        for i, value in enumerate(parts):
+            key, _value = self.__parse_setting__(value, i)
+            setattr(self, key, _value)
+
+    @classmethod
+    def __to_parts__(cls, value):
+        """Returns a list of args and kwargs. Kwargs are 2 item tuples."""
+        sp = re.split(r'(\w+(?<!\\)=)', value)
+        args = [i for i in sp[0].split(',') if i]
+        for i in range(1, len(sp), 2):
+            value = sp[i + 1].replace("\\=", "=")
+            if value.endswith(","):
+                value = value[:-1]
+            args.append((sp[i][:-1], value))
+        return args
+
+    @classmethod
+    def __parse_setting__(cls, value, index):
+        """Converts a value into its name and value.
+
+        Examples:
+            ("preditor", 0) returns ("name", "preditor")
+            ("lvl=DEBUG", 0) returns ("level", "INFO")
+        """
+        if isinstance(value, tuple):
+            # The string specified the key so expand it to the property name.
+            attr_name = cls._attr_names.get(value[0], value[0])
+            value = value[1]
+        else:
+            # If there is no key defined, map the index to the property name
+            i = list(cls.__dataclass_fields__)[index]
+            field = cls.__dataclass_fields__[i]
+            attr_name = field.name
+
+        return attr_name, value
+
+    def install(self, callback=None, replay=False, disable_writes=False, clear=False):
+        """Add the required logging handler if needed and connect callback to it."""
+        _logger = logging.getLogger(self.name)
+        handler, _ = plugins.add_logging_handler(_logger, self.plugin)
+        if handler and callback:
+            handler.manager.add_callback(
+                callback, replay=replay, disable_writes=disable_writes, clear=clear
+            )
+        return handler
+
+    def uninstall(self, callback):
+        """Remove the callback added via install, doesn't remove the logging handler."""
+        _logger = logging.getLogger(self.name)
+        handler, _ = plugins.add_logging_handler(_logger, self.plugin)
+        if handler:
+            handler.manager.remove_callback(callback)
+
+
+class ConsoleHandler(logging.Handler):
+    """A logging handler that writes directly to the PrEditor instance.
+
+    Args:
+        formatter (str or logging.Formatter, optional): If specified,
+            this is passed to setFormatter.
+        stream (optional): If provided write to this stream instead of the
+            main preditor instance's console.
+        stream_type (StreamType, optional): If not None, pass this value to the
+            write call's force kwarg.
+    """
+
+    def __init__(self):
+        super().__init__()
+        self.manager = Manager()
+
+    def emit(self, record):
+        try:
+            # If no gui has been created yet, or the `preditor.instance()` was
+            # closed and garbage collected, there is nothing to do, simply exit
+            # msg = self.format(record)
+            # self.manager.write(f'{msg}\n', StreamType.CONSOLE)
+            self.manager.write((self, record), StreamType.CONSOLE)
+        except (KeyboardInterrupt, SystemExit):
+            raise
+        except Exception:
+            self.handleError(record)

preditor/stream/director.py

@@ -0,0 +1,144 @@
+from __future__ import absolute_import, print_function
+
+import io
+import sys
+
+from ..constants import StreamType
+
+
+class _DirectorBuffer(io.RawIOBase):
+    """Binary buffer that forwards text writes to the manager.
+
+    This makes the stream more compatible including if enabled when running tox.
+
+    Args:
+        manager (Manager): The manager that writes are stored in.
+        state: The state passed to the manager. This is often``StreamType.STDOUT``
+            or ``StreamType.STDERR``.
+        old_stream: A second stream that will be written to every time this stream
+            is written to. This allows this object to replace sys.stdout and still
+            send that output to the original stdout, which is useful for not breaking
+            DCC's script editors. Pass False to disable this feature. If you pass None
+            and state is set to ``StreamType.STDOUT`` or ``StreamType.STDERR``
+            this will automatically be set to the current sys.stdout or sys.stderr.
+        name (str, optional): Stored on self.name.
+    """
+
+    def __init__(self, manager, state, old_stream=None, name='nul'):
+        super().__init__()
+        self.manager = manager
+        self.state = state
+        self.old_stream = old_stream
+        self.name = name
+
+    def flush(self):
+        if self.old_stream:
+            self.old_stream.flush()
+        super().flush()
+
+    def writable(self):
+        return True
+
+    def write(self, b):
+        if isinstance(b, memoryview):
+            b = b.tobytes()
+
+        # Decode incoming bytes (TextIOWrapper encodes before sending here)
+        msg = b.decode("utf-8", errors="replace")
+        self.manager.write(msg, self.state)
+
+        if self.old_stream:
+            self.old_stream.write(msg)
+
+        return len(b)
+
+
+class Director(io.TextIOWrapper):
+    """A file like object that stores the text written to it in a manager.
+    This manager can be shared between multiple Directors to build a single
+    continuous history of all writes.
+
+    While this uses a buffer under the hood, buffering is disabled and any calls
+    to write will automatically flush the buffer.
+
+    Args:
+        manager (Manager): The manager that writes are stored in.
+        state: The state passed to the manager. This is often ``StreamType.STDOUT``
+            or ``StreamType.STDERR``.
+        old_stream: A second stream that will be written to every time this stream
+            is written to. This allows this object to replace sys.stdout and still
+            send that output to the original stdout, which is useful for not breaking
+            DCC's script editors. Pass False to disable this feature. If you pass None
+            and state is set to ``StreamType.STDOUT`` or ``StreamType.STDERR``
+            this will automatically be set to the current sys.stdout or sys.stderr.
+    """
+
+    def __init__(self, manager, state, old_stream=None, *args, **kwargs):
+        # Keep track of whether we wrapped a std stream
+        # that way we don't .close() any streams that we don't control
+        self.std_stream_wrapped = False
+
+        name = 'nul'
+        if old_stream is False:
+            old_stream = None
+        elif old_stream is None:
+            if state == StreamType.STDOUT:
+                # On Windows if we're in pythonw.exe, then sys.stdout is named "nul"
+                # And it uses cp1252 encoding (which breaks with unicode)
+                # So if we find this nul TextIOWrapper, it's safe to just skip it
+                name = getattr(sys.stdout, 'name', '')
+                if name != 'nul':
+                    self.std_stream_wrapped = True
+                    old_stream = sys.stdout
+            elif state == StreamType.STDERR:
+                name = getattr(sys.stderr, 'name', '')
+                if name != 'nul':
+                    self.std_stream_wrapped = True
+                    old_stream = sys.stderr
+
+        self.old_stream = old_stream
+        self.manager = manager
+        self.state = state
+
+        # Build the buffer. This provides the expected interface for tox, etc.
+        raw = _DirectorBuffer(manager, state, old_stream, name)
+        buffer = io.BufferedWriter(raw)
+
+        super().__init__(buffer, encoding="utf-8", write_through=True, *args, **kwargs)
+
+    def __repr__(self):
+        return f"<Director state={self.state} old_stream={self.old_stream!r}>"
+
+    def close(self):
+        if (
+            self.old_stream
+            and not self.std_stream_wrapped
+            and self.old_stream is not sys.__stdout__
+            and self.old_stream is not sys.__stderr__
+        ):
+            self.old_stream.close()
+
+        super().close()
+
+    def write(self, msg):
+        super().write(msg)
+        # Force a write of any buffered data
+        self.flush()
+
+    # These methods enable terminal features like color coding etc.
+    def isatty(self):
+        if self.old_stream is not None:
+            return self.old_stream.isatty()
+        return False
+
+    @property
+    def encoding(self):
+        if self.old_stream is not None:
+            return self.old_stream.encoding
+        return super().encoding
+
+    @property
+    def errors(self):
+        if self.old_stream is not None:
+            return self.old_stream.errors
+        return super().errors

preditor/stream/manager.py

@@ -0,0 +1,97 @@
+from __future__ import absolute_import, print_function
+
+import collections
+
+from .. import utils
+from ..weakref import WeakList
+
+
+class Manager(collections.deque):
+    """Stores all of the data from the stdout/stderr writes. You can iterate over this
+    object to see all of the (msg, state) calls that have been written to it up to the
+    maxlen specified when constructing it.
+
+    Args:
+        maxlen (int, optional): The maximum number of raw writes to store. If this is
+            exceeded, the oldest writes are discarded.
+
+    Properties:
+        store_writes (bool): Set this to False if you no longer want write calls to
+            store on the manager.
+    """
+
+    def __init__(self, maxlen=10000):
+        super(Manager, self).__init__(maxlen=maxlen)
+        self.callbacks = WeakList()
+        self.store_writes = True
+
+    def add_callback(self, callback, replay=False, disable_writes=False, clear=False):
+        """Add a callable that will be called every time write is called.
+
+        Args:
+            callback (callable): A callable object that takes two arguments. It must
+                take two arguments (msg, state). See write for more details.
+            replay (bool, optional): If True, calls replay on callback.
+            disable_writes (bool, optional): Set store_writes to False if this is True.
+            clear (bool, optional): Clear the stored history on this object.
+
+        Returns:
+            bool: True if the callback was added. If the callback has already been
+                already, this method does nothing and returns False.
+        """
+        if callback in self.callbacks:
+            return False
+
+        self.callbacks.append(callback)
+
+        if replay:
+            self.replay(callback)
+
+        if disable_writes:
+            # Disable storing data in the buffer. buffer.write calls will now
+            # directly write to console so there is no reason to duplicate the
+            # data to the buffer.
+            self.store_writes = False
+
+        if clear:
+            self.clear()
+
+        return True
+
+    def remove_callback(self, callback) -> bool:
+        """Remove callback from manager and return if it was removed."""
+        if callback not in self.callbacks:
+            return False
+        self.callbacks.remove(callback)
+        return True
+
+    def replay(self, callback):
+        """Replay the existing writes for the given callback.
+
+        This iterates over all the stored writes and pass them to callback. This
+        is useful for when you are initializing a gui and want to include all
+        previous prints.
+        """
+        for msg, state in self:
+            callback(msg, state)
+
+    def get_value(self, fmt="[{state}:{msg}]"):
+        return ''.join([fmt.format(msg=d[0], state=d[1]) for d in self])
+
+    def write(self, msg, state):
+        """Adds the written text to the manager and passes it to any attached callbacks.
+
+        Args:
+            msg (str): The text to be written.
+            state: A identifier for how the text is to be written. For example if this
+                write is coming from sys.stderr this will likely be set to
+                ``preditor.constants.StreamType.STDERR``.
+        """
+        if self.store_writes:
+            self.append((msg, state))
+
+        for callback in self.callbacks:
+            try:
+                callback(msg, state)
+            except Exception:
+                utils.ShellPrint(True).print_exc("PrEditor Console failed")

preditor/streamhandler_helper.py

@@ -0,0 +1,46 @@
+from __future__ import absolute_import
+
+import logging
+import sys
+
+
+class StreamHandlerHelper(object):
+    """A collection of functions for manipulating ``logging.StreamHandler`` objects."""
+
+    @classmethod
+    def set_stream(cls, handler, stream):
+        """For the given StreamHandler, set its stream. This works around
+        python 2's lack of StreamHandler.setStream by replicating python 3.
+        """
+        # TODO: once python 2 is no longer supported, replace any uses of this
+        # function with `handler.setStream(stream)`
+        if sys.version_info[0] > 2:
+            handler.setStream(stream)
+        else:
+            # Copied from python 3's logging's setStream to work in python 2
+            handler.acquire()
+            try:
+                handler.flush()
+                handler.stream = stream
+            finally:
+                handler.release()
+
+    @classmethod
+    def replace_stream(cls, old, new, logger=None):
+        """Replaces the stream of StreamHandlers by checking all
+        `logging.StreamHandler`'s attached to the provided logger. If any of them are
+        using old for their stream, update that stream to new.
+
+        Args:
+            old (stream): Only StreamHandlers using this stream will be updated to new.
+            new (stream): A file stream object like `sys.stderr` that will replace old.
+            logger (logging.Logger, optional): The logger to update streams for. If
+                None, the root logger(`logging.getLogger()`) will be used.
+        """
+        if logger is None:
+            logger = logging.getLogger()
+
+        for handler in logger.handlers:
+            if isinstance(handler, logging.StreamHandler):
+                if handler.stream == old:
+                    cls.set_stream(handler, new)