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

preditor/stream/director.py

@@ -0,0 +1,56 @@
+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
+
+        if old_stream is False:
+            old_stream = None
+        elif old_stream is None:
+            if state == STDOUT:
+                old_stream = sys.stdout
+            elif state == STDERR:
+                old_stream = sys.stderr
+        self.old_stream = old_stream
+
+    def close(self):
+        if self.old_stream:
+            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]

{blurdev → preditor}/version.py

@@ -1,5 +1,5 @@
-# coding: utf-8
-# file generated by setuptools_scm
-# don't change, don't track in version control
-version = '0.0.0.dev1'
-version_tuple = (0, 0, 0, 'dev1')
+# coding: utf-8
+# file generated by setuptools_scm
+# don't change, don't track in version control
+version = '0.1.0'
+version_tuple = (0, 1, 0)

preditor/weakref.py

@@ -0,0 +1,363 @@
+# coding: utf-8
+# /*##########################################################################
+#
+# Copyright (c) 2016-2018 European Synchrotron Radiation Facility
+#
+# Permission is hereby granted, free of charge, to any person obtaining a copy
+# of this software and associated documentation files (the "Software"), to deal
+# in the Software without restriction, including without limitation the rights
+# to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+# copies of the Software, and to permit persons to whom the Software is
+# furnished to do so, subject to the following conditions:
+#
+# The above copyright notice and this permission notice shall be included in
+# all copies or substantial portions of the Software.
+#
+# THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+# IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+# FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+# AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+# LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+# OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+# THE SOFTWARE.
+#
+# ###########################################################################*/
+# Code pulled from the silx codebase
+# https://github.com/silx-kit/silx/blob/master/src/silx/utils/weakref.py
+"""Weakref utils for compatibility between Python 2 and Python 3 or for
+extended features.
+"""
+from __future__ import absolute_import
+
+__authors__ = ["V. Valls"]
+__license__ = "MIT"
+__date__ = "15/09/2016"
+
+
+import inspect
+import types
+import weakref
+
+
+def ref(object, callback=None):
+    """Returns a weak reference to object. The original object can be retrieved
+    by calling the reference object if the referent is still alive. If the
+    referent is no longer alive, calling the reference object will cause None
+    to be returned.
+
+    The signature is the same as the standard `weakref` library, but it returns
+    `WeakMethod` if the object is a bound method.
+
+    :param object: An object
+    :param func callback: If provided, and the returned weakref object is
+        still alive, the callback will be called when the object is about to
+        be finalized. The weak reference object will be passed as the only
+        parameter to the callback. Then the referent will no longer be
+        available.
+    :return: A weak reference to the object
+    """
+    if inspect.ismethod(object):
+        return WeakMethod(object, callback)
+    else:
+        return weakref.ref(object, callback)
+
+
+def proxy(object, callback=None):
+    """Return a proxy to object which uses a weak reference. This supports use
+    of the proxy in most contexts instead of requiring the explicit
+    dereferencing used with weak reference objects.
+
+    The signature is the same as the standard `weakref` library, but it returns
+    `WeakMethodProxy` if the object is a bound method.
+
+    :param object: An object
+    :param func callback: If provided, and the returned weakref object is
+        still alive, the callback will be called when the object is about to
+        be finalized. The weak reference object will be passed as the only
+        parameter to the callback. Then the referent will no longer be
+        available.
+    :return: A proxy to a weak reference of the object
+    """
+    if inspect.ismethod(object):
+        return WeakMethodProxy(object, callback)
+    else:
+        return weakref.proxy(object, callback)
+
+
+class WeakMethod(object):
+    """Wraps a callable object like a function or a bound method.
+    Feature callback when the object is about to be finalized.
+    Provids the same interface as a normal weak reference.
+    """
+
+    def __init__(self, function, callback=None):
+        """
+        Constructor
+        :param function: Function/method to be called
+        :param callback: If callback is provided and not None,
+            and the returned weakref object is still alive, the
+            callback will be called when the object is about to
+            be finalized; the weak reference object will be passed
+            as the only parameter to the callback; the referent will
+            no longer be available
+        """
+        self.__callback = callback
+
+        if inspect.ismethod(function):
+            # it is a bound method
+            self.__obj = weakref.ref(function.__self__, self.__call_callback)
+            self.__method = weakref.ref(function.__func__, self.__call_callback)
+        else:
+            self.__obj = None
+            self.__method = weakref.ref(function, self.__call_callback)
+
+    def __call_callback(self, ref):
+        """Called when the object is about to be finalized"""
+        if not self.is_alive():
+            return
+        self.__obj = None
+        self.__method = None
+        if self.__callback is not None:
+            self.__callback(self)
+
+    def __call__(self):
+        """Return a callable function or None if the WeakMethod is dead."""
+        if self.__obj is not None:
+            method = self.__method()
+            obj = self.__obj()
+            if method is None or obj is None:
+                return None
+            return types.MethodType(method, obj)
+        elif self.__method is not None:
+            return self.__method()
+        else:
+            return None
+
+    def is_alive(self):
+        """True if the WeakMethod is still alive"""
+        return self.__method is not None
+
+    def __eq__(self, other):
+        """Check it another obect is equal to this.
+
+        :param object other: Object to compare with
+        """
+        if isinstance(other, WeakMethod):
+            if not self.is_alive():
+                return False
+            return self.__obj == other.__obj and self.__method == other.__method
+        return False
+
+    def __ne__(self, other):
+        """Check it another obect is not equal to this.
+
+        :param object other: Object to compare with
+        """
+        if isinstance(other, WeakMethod):
+            if not self.is_alive():
+                return False
+            return self.__obj != other.__obj or self.__method != other.__method
+        return True
+
+    def __hash__(self):
+        """Returns the hash for the object."""
+        return self.__obj.__hash__() ^ self.__method.__hash__()
+
+
+class WeakMethodProxy(WeakMethod):
+    """Wraps a callable object like a function or a bound method
+    with a weakref proxy.
+    """
+
+    def __call__(self, *args, **kwargs):
+        """Dereference the method and call it if the method is still alive.
+        Else raises an ReferenceError.
+
+        :raises: ReferenceError, if the method is not alive
+        """
+        fn = super(WeakMethodProxy, self).__call__()
+        if fn is None:
+            raise ReferenceError("weakly-referenced object no longer exists")
+        return fn(*args, **kwargs)
+
+
+class WeakList(list):
+    """Manage a list of weaked references.
+    When an object is dead, the list is flaged as invalid.
+    If expected the list is cleaned up to remove dead objects.
+    """
+
+    def __init__(self, enumerator=()):
+        """Create a WeakList
+
+        :param iterator enumerator: A list of object to initialize the
+            list
+        """
+        list.__init__(self)
+        self.__list = []
+        self.__is_valid = True
+        for obj in enumerator:
+            self.append(obj)
+
+    def __invalidate(self, ref):
+        """Flag the list as invalidated. The list contains dead references."""
+        self.__is_valid = False
+
+    def __create_ref(self, obj):
+        """Create a weakref from an object. It uses the `ref` module function."""
+        return ref(obj, self.__invalidate)
+
+    def __clean(self):
+        """Clean the list from dead references"""
+        if self.__is_valid:
+            return
+        self.__list = [ref for ref in self.__list if ref() is not None]
+        self.__is_valid = True
+
+    def __iter__(self):
+        """Iterate over objects of the list"""
+        for ref in self.__list:
+            obj = ref()
+            if obj is not None:
+                yield obj
+
+    def __len__(self):
+        """Count item on the list"""
+        self.__clean()
+        return len(self.__list)
+
+    def __getitem__(self, key):
+        """Returns the object at the requested index
+
+        :param key: Indexes to get
+        :type key: int or slice
+        """
+        self.__clean()
+        data = self.__list[key]
+        if isinstance(data, list):
+            result = [ref() for ref in data]
+        else:
+            result = data()
+        return result
+
+    def __setitem__(self, key, obj):
+        """Set an item at an index
+
+        :param key: Indexes to set
+        :type key: int or slice
+        """
+        self.__clean()
+        if isinstance(key, slice):
+            objs = [self.__create_ref(o) for o in obj]
+            self.__list[key] = objs
+        else:
+            obj_ref = self.__create_ref(obj)
+            self.__list[key] = obj_ref
+
+    def __delitem__(self, key):
+        """Delete an Indexes item of this list
+
+        :param key: Index to delete
+        :type key: int or slice
+        """
+        self.__clean()
+        del self.__list[key]
+
+    def __delslice__(self, i, j):
+        """Looks to be used in Python 2.7"""
+        self.__delitem__(slice(i, j, None))
+
+    def __setslice__(self, i, j, sequence):
+        """Looks to be used in Python 2.7"""
+        self.__setitem__(slice(i, j, None), sequence)
+
+    def __getslice__(self, i, j):
+        """Looks to be used in Python 2.7"""
+        return self.__getitem__(slice(i, j, None))
+
+    def __reversed__(self):
+        """Returns a copy of the reverted list"""
+        reversed_list = reversed(list(self))
+        return WeakList(reversed_list)
+
+    def __contains__(self, obj):
+        """Returns true if the object is in the list"""
+        ref = self.__create_ref(obj)
+        return ref in self.__list
+
+    def __add__(self, other):
+        """Returns a WeakList containing this list an the other"""
+        l = WeakList(self)  # noqa: E741
+        l.extend(other)
+        return l
+
+    def __iadd__(self, other):
+        """Add objects to this list inplace"""
+        self.extend(other)
+        return self
+
+    def __mul__(self, n):
+        """Returns a WeakList containing n-duplication object of this list"""
+        return WeakList(list(self) * n)
+
+    def __imul__(self, n):
+        """N-duplication of the objects to this list inplace"""
+        self.__list *= n
+        return self
+
+    def append(self, obj):
+        """Add an object at the end of the list"""
+        ref = self.__create_ref(obj)
+        self.__list.append(ref)
+
+    def count(self, obj):
+        """Returns the number of occurencies of an object"""
+        ref = self.__create_ref(obj)
+        return self.__list.count(ref)
+
+    def extend(self, other):
+        """Append the list with all objects from another list"""
+        for obj in other:
+            self.append(obj)
+
+    def index(self, obj):
+        """Returns the index of an object"""
+        ref = self.__create_ref(obj)
+        return self.__list.index(ref)
+
+    def insert(self, index, obj):
+        """Insert an object at the requested index"""
+        ref = self.__create_ref(obj)
+        self.__list.insert(index, ref)
+
+    def pop(self, index=-1):
+        """Remove and return an object at the requested index"""
+        self.__clean()
+        obj = self.__list.pop(index)()
+        return obj
+
+    def remove(self, obj):
+        """Remove an object from the list"""
+        ref = self.__create_ref(obj)
+        self.__list.remove(ref)
+
+    def reverse(self):
+        """Reverse the list inplace"""
+        self.__list.reverse()
+
+    def sort(self, key=None, reverse=False):
+        """Sort the list inplace.
+        Not very efficient.
+        """
+        sorted_list = list(self)
+        sorted_list.sort(key=key, reverse=reverse)
+        self.__list = []
+        self.extend(sorted_list)
+
+    def __str__(self):
+        unref_list = list(self)
+        return "WeakList(%s)" % str(unref_list)
+
+    def __repr__(self):
+        unref_list = list(self)
+        return "WeakList(%s)" % repr(unref_list)

PrEditor-0.0.0.dev1.dist-info/METADATA

@@ -1,51 +0,0 @@
-Metadata-Version: 2.1
-Name: PrEditor
-Version: 0.0.0.dev1
-Summary: PrEditor
-Home-page: https://gitlab.blur.com/pipeline/blurdev.git
-Author: Blur Studio
-Author-email: opensource@blur.com
-License: GNU LGPLv3
-Platform: any
-Classifier: Development Status :: 5 - Production/Stable
-Classifier: Intended Audience :: Developers
-Classifier: Programming Language :: Python
-Classifier: Programming Language :: Python :: 2
-Classifier: Programming Language :: Python :: 2.7
-Classifier: Programming Language :: Python :: 3
-Classifier: Programming Language :: Python :: 3.7
-Classifier: Programming Language :: Python :: Implementation :: CPython
-Classifier: Programming Language :: Python :: Implementation :: PyPy
-Classifier: Operating System :: OS Independent
-Classifier: License :: OSI Approved :: GNU Lesser General Public License v3 (LGPLv3)
-Requires-Python: !=3.0.*,!=3.1.*,!=3.2.*,!=3.3.*,!=3.4.*,!=3.5.*,>=2.7
-Description-Content-Type: text/markdown
-Requires-Dist: blur-cute (>=0.25.0)
-Requires-Dist: blur-pillar (>=0.40.0)
-Requires-Dist: blur-sentry-bootstrap (>=1.1.0)
-Requires-Dist: certifi (>=2019.9.11)
-Requires-Dist: click (>=7.1.2)
-Requires-Dist: configparser (>=4.0.2)
-Requires-Dist: Deprecated (>=1.2.7)
-Requires-Dist: future (>=0.18.2)
-Requires-Dist: Jinja2 (>=2.10.3)
-Requires-Dist: MarkupSafe (>=1.1.1)
-Requires-Dist: Pygments (>=2.4.2)
-Requires-Dist: python-redmine (>=2.1.1)
-Requires-Dist: signalslot (>=0.1.2)
-Requires-Dist: tabulate (>=0.8.7)
-Requires-Dist: urllib3 (>=1.25.7)
-Requires-Dist: winshell (>=0.6) ; platform_system == "Windows"
-Requires-Dist: QScintilla (>=2.11.4) ; python_version >= "3.5" and platform_system == "Windows"
-Provides-Extra: dev
-Requires-Dist: black ; extra == 'dev'
-Requires-Dist: covdefaults ; extra == 'dev'
-Requires-Dist: coverage ; extra == 'dev'
-Requires-Dist: flake8 ; extra == 'dev'
-Requires-Dist: flake8-bugbear ; extra == 'dev'
-Requires-Dist: pep8-naming ; extra == 'dev'
-Requires-Dist: pytest ; extra == 'dev'
-Requires-Dist: tox ; extra == 'dev'
-
-UNKNOWN
-