PrEditor 1.0.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,80 @@
+""" 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
+"""
+from __future__ import absolute_import, print_function
+
+import sys
+
+STDERR = 1
+STDIN = 2
+STDOUT = 3
+
+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",
+    "STDERR",
+    "STDIN",
+    "STDOUT",
+]
+
+
+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, STDOUT)
+        if err:
+            sys.stderr = Director(active, STDERR)
+
+    return active

preditor/stream/director.py

@@ -0,0 +1,73 @@
+from __future__ import absolute_import, print_function
+
+import io
+import sys
+
+from . import STDERR, STDOUT
+
+
+class Director(io.TextIOBase):
+    """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.
+
+    Args:
+        manager (Manager): The manager that writes are stored in.
+        state: The state passed to the manager. This is often ``preditor.stream.STDOUT``
+            or ``preditor.stream.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 ``preditor.stream.STDOUT`` or ``preditor.stream.STDERR``
+            this will automatically be set to the current sys.stdout or sys.stderr.
+    """
+
+    def __init__(self, manager, state, old_stream=None, *args, **kwargs):
+        super(Director, self).__init__(*args, **kwargs)
+        self.manager = manager
+        self.state = state
+
+        # 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
+
+        if old_stream is False:
+            old_stream = None
+        elif old_stream is None:
+            if state == 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
+                if getattr(sys.stdout, 'name', '') != 'nul':
+                    self.std_stream_wrapped = True
+                    old_stream = sys.stdout
+            elif state == STDERR:
+                if getattr(sys.stderr, 'name', '') != 'nul':
+                    self.std_stream_wrapped = True
+                    old_stream = sys.stderr
+
+        self.old_stream = old_stream
+
+    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(Director, self).close()
+
+    def flush(self):
+        if self.old_stream:
+            self.old_stream.flush()
+
+        super(Director, self).flush()
+
+    def write(self, msg):
+        self.manager.write(msg, self.state)
+
+        if self.old_stream:
+            self.old_stream.write(msg)

preditor/stream/manager.py

@@ -0,0 +1,74 @@
+from __future__ import absolute_import, print_function
+
+import collections
+
+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, then iterate 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.
+            disable_writes (bool, optional): Set store_writes to False if this is True.
+            clear (bool, optional): Clear the stored history on this object.
+        """
+        self.callbacks.append(callback)
+
+        if replay:
+            # Replay the existing prints into the console.
+            for msg, state in self:
+                callback(msg, state)
+
+        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()
+
+    def remove_callback(self, callback):
+        self.callbacks.remove(callback)
+
+    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.stream.STDERR``.
+        """
+        if self.store_writes:
+            self.append((msg, state))
+
+        for callback in self.callbacks:
+            callback(msg, state)

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)

preditor/utils/cute.py

@@ -0,0 +1,30 @@
+from __future__ import absolute_import
+
+__all__ = ["ensureWindowIsVisible"]
+from Qt.QtWidgets import QApplication
+
+
+def ensureWindowIsVisible(widget):
+    """
+    Checks the widget's geometry against all of the system's screens. If it does
+    not intersect it will reposition it to the top left corner of the highest
+    numbered desktop.  Returns a boolean indicating if it had to move the
+    widget.
+    """
+    desktop = QApplication.desktop()
+    geo = widget.geometry()
+    for screen in range(desktop.screenCount()):
+        monGeo = desktop.screenGeometry(screen)
+        if monGeo.intersects(geo):
+            break
+    else:
+        geo.moveTo(monGeo.x() + 7, monGeo.y() + 30)
+        # setting the geometry may trigger a second check if setGeometry is overridden
+        disable = hasattr(widget, 'checkScreenGeo') and widget.checkScreenGeo
+        if disable:
+            widget.checkScreenGeo = False
+        widget.setGeometry(geo)
+        if disable:
+            widget.checkScreenGeo = True
+        return True
+    return False

preditor/utils/stylesheets.py

@@ -0,0 +1,54 @@
+from __future__ import absolute_import
+
+import glob
+import os
+
+
+def read_stylesheet(stylesheet='', path=None):
+    """Returns the contents of the requested stylesheet.
+
+    Args:
+
+        stylesheet (str): the name of the stylesheet. Attempt to load stylesheet.css
+            shipped with preditor. Ignored if path is provided.
+
+        path (str): Return the contents of this file path.
+
+    Returns:
+        str: The contents of stylesheet or blank if stylesheet was not found.
+        valid: A stylesheet was found and loaded.
+    """
+    if path is None:
+        path = os.path.join(
+            os.path.dirname(os.path.dirname(os.path.abspath(__file__))),
+            'resource',
+            'stylesheet',
+            '{}.css'.format(stylesheet),
+        )
+    if os.path.isfile(path):
+        with open(path) as f:
+            return f.read(), True
+    return '', False
+
+
+def stylesheets(subFolder=None):
+    """Returns a list of installed stylesheet names.
+
+    Args:
+        subFolder (str or None, optional): Use this to access sub-folders of
+            the stylesheet resource directory.
+
+    Returns:
+        list: A list .css file paths in the target directory.
+    """
+    components = [
+        os.path.dirname(os.path.dirname(os.path.abspath(__file__))),
+        'resource',
+        'stylesheet',
+    ]
+    if subFolder is not None:
+        components.append(subFolder)
+    cssdir = os.path.join(*components)
+    cssfiles = sorted(glob.glob(os.path.join(cssdir, '*.css')))
+    # Only return the filename without the .css extension
+    return [os.path.splitext(os.path.basename(fp))[0] for fp in cssfiles]