PrEditor 2.1.0__py3-none-any.whl

preditor/dccs/maya/plug-ins/PrEditor_maya.py

@@ -0,0 +1,141 @@
+from __future__ import absolute_import
+
+import os
+import site
+from pathlib import Path
+
+import maya.mel
+from maya import OpenMayaUI, cmds
+
+preditor_menu = None
+
+
+def headless():
+    """If true, no Qt gui elements should be used because python is running a
+    QCoreApplication."""
+    return bool(cmds.about(batch=True))
+
+    # TODO: This is the old method for detecting batch mode. Remove this once
+    # the above about command is vetted as working.
+    # basename = os.path.splitext(os.path.basename(sys.executable).lower())[0]
+    # return basename in ('mayabatch', 'mayapy')
+
+
+def root_window():
+    """Returns the main window of Maya as a Qt object to be used for parenting."""
+    from Qt import QtCompat
+
+    ptr = OpenMayaUI.MQtUtil.mainWindow()
+    if ptr is not None:
+        pointer = int(ptr)
+        return QtCompat.wrapInstance(pointer)
+
+
+def launch(ignored):
+    """Show the PrEditor GUI and bring it into focus if it was minimized."""
+    import preditor
+
+    widget = preditor.launch()
+    return widget
+
+
+def update_site():
+    """Adds a site dir to python. This makes its contents importable to python.
+
+    This includes making any editable installs located in that site-packages folder
+    accessible to this python instance. This does not activate the virtualenv.
+
+    If the env var `PREDITOR_SITE` is set, this path is used. Otherwise the
+    parent directory of preditor is used.
+
+    - `PREDITOR_SITE` is useful if you want to use an editable install of preditor
+    for development. This should point to a virtualenv's site-packages folder.
+    - Otherwise if the virtualenv has a regular pip install of preditor you can
+    skip setting the env var.
+    """
+    venv_path = os.getenv("PREDITOR_SITE")
+    # If the env var is not defined then use the parent dir of this preditor package.
+    if venv_path is None:
+        venv_path = cmds.moduleInfo(moduleName="PrEditor", path=True)
+        venv_path = Path(venv_path).parent.parent.parent
+        venv_path = str(venv_path)
+
+    print(f"Preditor is adding python site: {venv_path}")
+    site.addsitedir(venv_path)
+
+
+def initializePlugin(mobject):  # noqa: N802
+    """Initialize the script plug-in"""
+    global preditor_menu
+
+    # If running headless, there is no need to build a gui and create the python logger
+    if not headless():
+        update_site()
+
+        from Qt.QtWidgets import QApplication
+
+        import preditor
+
+        maya_ver = cmds.about(version=True).split(" ")[0]
+
+        # Capture all stderr/out after the plugin is loaded. This makes it so
+        # if the PrEditor GUI is shown, it will include all of the output. Also
+        # tells PrEditor how to parent itself to the main window and save prefs.
+        preditor.configure(
+            # Set the core_name so preferences are saved per-maya version.
+            "Maya-{}".format(maya_ver),
+            # Tell PrEditor how to find the maya root window for parenting
+            parent_callback=root_window,
+            # Tell it how to check if running in batch mode
+            headless_callback=headless,
+        )
+
+        # Detect Maya shutting down and ensure PrEditor's prefs are saved
+        if QApplication.instance():
+            QApplication.instance().aboutToQuit.connect(preditor.shutdown)
+
+        # Add a new PrEditor menu with an item that launches PrEditor
+        gmainwindow = maya.mel.eval("$temp1=$gMainWindow")
+        preditor_menu = cmds.menu(label="PrEditor", parent=gmainwindow, tearOff=True)
+        cmds.menuItem(
+            label="PrEditor",
+            command=launch,
+            sourceType="python",
+            image=preditor.resourcePath('img/preditor.png'),
+            parent=preditor_menu,
+        )
+
+        # TODO: Alternatively figure out how to add the launcher menuItem to a
+        # pre-existing maya menu like next to the "Script Editor" in
+        # "Windows -> General Editors"
+        # https://github.com/chadmv/cvwrap/blob/master/scripts/cvwrap/menu.py#L18
+
+        # menu = 'mainWindowMenu'
+        # # Make sure the menu widgets exist first.
+        # maya.mel.eval('ChaDeformationsMenu MayaWindow|{0};'.format(menu))
+        # items = cmds.menu(menu, q=True, ia=True)
+        # # print(items)
+        # for item in items:
+        #     menu_label = cmds.menuItem(item, q=True, label=True)
+        #     # print(menu_label)
+        #     if menu_label == "General Editors":
+        #         # cmds.menuItem(parent=item, divider=True, dividerLabel='PrEditor' )
+        #         cmds.menuItem(
+        #             label="PrEditor",
+        #             command=launch,
+        #             sourceType='python',
+        #             image=preditor.resourcePath('img/preditor.png'),
+        #             parent=item,
+        #         )
+
+
+def uninitializePlugin(mobject):  # noqa: N802
+    """Uninitialize the script plug-in"""
+    import preditor
+
+    # Remove the PrEditor Menu if it exists
+    if preditor_menu and cmds.menu(preditor_menu, exists=True):
+        cmds.deleteUI(preditor_menu, menu=True)
+
+    # Close PrEditor making sure to save prefs
+    preditor.core.shutdown()

preditor/dccs/studiomax/PackageContents.xml

@@ -0,0 +1,32 @@
+<?xml version="1.0" encoding="utf-8"?>
+<ApplicationPackage
+    SchemaVersion="1.0"
+    AutodeskProduct="3ds Max"
+    ProductType="Application"
+    Name="PrEditor"
+    Description="Initialize PrEditor inside 3ds Max."
+    AppVersion="0.0.1"
+    ProductCode="{7b1e4ece-9a30-4afb-99ed-b9fb7c23e2f9}"
+    UpgradeCode="{2d245bb4-19cf-4f90-ae19-3ff006ed0f48}">
+    <CompanyDetails Name="Blur Studio" Email="opensource@blur.com"/>
+    <Components Description="pre-start-up scripts parts">
+        <RuntimeRequirements OS="Win64" Platform="3ds Max" SeriesMin="2025" SeriesMax="2026" />
+        <ComponentEntry ModuleName="./preditor.ms" />
+    </Components>
+    <Components Description="macroscripts parts">
+        <RuntimeRequirements OS="Win64" Platform="3ds Max" SeriesMin="2025" SeriesMax="2026" />
+        <ComponentEntry ModuleName="./PrEditor-PrEditor_Show.mcr" />
+    </Components>
+    <Components Description="menu parts">
+        <RuntimeRequirements OS="Win64" Platform="3ds Max" SeriesMin="2025" SeriesMax="2026" />
+        <ComponentEntry ModuleName="./preditor_menu.mnx" />
+    </Components>
+    <Components Description="light icon paths parts">
+        <RuntimeRequirements OS="Win64" Platform="3ds Max" SeriesMin="2025" SeriesMax="2026" />
+        <ComponentEntry AppName="lighticons" Version="1.0.0" ModuleName="../../resource/img" />
+    </Components>
+    <Components Description="dark icon paths parts">
+        <RuntimeRequirements OS="Win64" Platform="3ds Max" SeriesMin="2025" SeriesMax="2026" />
+        <ComponentEntry AppName="darkicons" Version="1.0.0" ModuleName="../../resource/img" />
+    </Components>
+</ApplicationPackage>

preditor/dccs/studiomax/PrEditor-PrEditor_Show.mcr

@@ -0,0 +1,8 @@
+macroScript PrEditor_Show
+category:"PrEditor"
+tooltip:"PrEditor..."
+IconName:"preditor.ico"
+(
+    local preditor = python.import "preditor"
+    preditor.launch()
+)

preditor/dccs/studiomax/README.md

@@ -0,0 +1,17 @@
+# 3ds Max Integration
+
+This is an example of using an Autodesk Application Package to load PrEditor into
+3ds Max. This adds a PrEditor item to the Scripting menu in 3ds Max's menu bar
+to show PrEditor. It adds the excepthook so if a python exception is raised
+it will prompt the user to show PrEditor. PrEditor will show all python stdout/stderr
+output generated after the plugin is loaded.
+
+# Setup
+
+Make sure to follow these [setup instructions](/preditor/README.md#Setup) first to create the virtualenv.
+
+# Use
+
+The [preditor/dccs/studiomax](/preditor/dccs/studiomax) directory is setup as a 3ds Max Application Plugin.
+To load it in 3ds Max add the full path to that directory to the `ADSK_APPLICATION_PLUGINS` environment
+variable. You can use `;` on windows and `:` on linux to join multiple paths together.

preditor/dccs/studiomax/preditor.ms

@@ -0,0 +1,16 @@
+
+function configure_preditor = (
+    local pysite = python.import "site"
+    local WinEnv = dotNetClass "System.Environment"
+    -- If the env var PREDITOR_SITE is set, add its packages to python
+    local venv_path = WinEnv.GetEnvironmentVariable "PREDITOR_SITE"
+    if venv_path != undefined do (
+        print("Preditor is adding python site: " + venv_path)
+        pysite.addsitedir venv_path
+    )
+    -- Configure preditor, adding excepthook etc.
+    local preditor = python.import "preditor"
+    preditor.configure "studiomax"
+)
+
+configure_preditor()

preditor/dccs/studiomax/preditor_menu.mnx

@@ -0,0 +1,7 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<MaxMenuTransformations>
+    <CreateMenuSeparator MenuId="658724ec-de09-47dd-b723-918c59a28ad1" Id="9cdc28de-9e70-471c-ae5c-d86e3b7fefba" BeforeId="4e206a37-f502-4fa8-ba0e-70dd427d507f"/>
+    <MoveItem DestinationId="658724ec-de09-47dd-b723-918c59a28ad1" ItemId="4e206a37-f502-4fa8-ba0e-70dd427d507f"/>
+    <CreateMenuAction MenuId="658724ec-de09-47dd-b723-918c59a28ad1" Id="f243229b-f0f6-42b4-a94d-bebe9ef9777f" ActionId="647394-PrEditor_Show`PrEditor"/>
+    <MoveItem DestinationId="658724ec-de09-47dd-b723-918c59a28ad1" ItemId="9cdc28de-9e70-471c-ae5c-d86e3b7fefba" BeforeId="f243229b-f0f6-42b4-a94d-bebe9ef9777f"/>
+</MaxMenuTransformations>

preditor/debug.py

@@ -0,0 +1,149 @@
+from __future__ import absolute_import, print_function
+
+import datetime
+import inspect
+import logging
+import sys
+
+logger = logging.getLogger(__name__)
+
+
+class FileLogger:
+    def __init__(self, stdhandle, logfile, _print=True, clearLog=True):
+        self.old_stream = stdhandle
+        self._logfile = logfile
+        self._print = _print
+        if clearLog:
+            # clear the log file
+            self.clear()
+
+    def clear(self, stamp=False):
+        """Removes the contents of the log file."""
+        open(self._logfile, 'w', newline="\n", encoding="utf-8").close()
+        if stamp:
+            print(self.stamp())
+
+    def flush(self):
+        if self.old_stream:
+            self.old_stream.flush()
+
+    def stamp(self):
+        msg = '--------- Date: {today} Version: {version} ---------'
+        return msg.format(today=datetime.datetime.today(), version=sys.version)
+
+    def write(self, msg):
+        # Newline forces windows to write unix style newlines
+        with open(self._logfile, 'a', newline="\n", encoding="utf-8") as f:
+            f.write(msg)
+
+        if self._print:
+            self.old_stream.write(msg)
+
+
+def logToFile(path, stdout=True, stderr=True, useOldStd=True, clearLog=True):
+    """Redirect all stdout and/or stderr output to a log file.
+
+    Creates a FileLogger class for stdout and stderr and installs itself in python.
+    All output will be logged to the file path. Prints the current datetime and
+    sys.version info when stdout is True.
+
+    Args:
+        path (str): File path to log output to.
+
+        stdout (bool): If True(default) override sys.stdout.
+
+        stderr (bool): If True(default) override sys.stderr.
+
+        useOldStd (bool): If True, messages will be written to the FileLogger
+            and the previous sys.stdout/sys.stderr.
+
+        clearLog (bool): If True(default) clear the log file when this command is
+        called.
+    """
+    if stderr:
+        sys.stderr = FileLogger(sys.stderr, path, useOldStd, clearLog=clearLog)
+    if stdout:
+        sys.stdout = FileLogger(sys.stdout, path, useOldStd, clearLog=False)
+        if clearLog:
+            sys.stdout.clear(stamp=True)
+
+    from .streamhandler_helper import StreamHandlerHelper
+
+    # Update any StreamHandler's that were setup using the old stdout/err
+    if stdout:
+        StreamHandlerHelper.replace_stream(sys.stdout.old_stream, sys.stdout)
+    if stderr:
+        StreamHandlerHelper.replace_stream(sys.stderr.old_stream, sys.stderr)
+
+
+def printCallingFunction(compact=False):
+    """Prints and returns info about the calling function
+
+    Args:
+        compact (bool): If set to True, prints a more compact printout
+
+    Returns:
+        str: Info on the calling function.
+    """
+    import inspect
+
+    current = inspect.currentframe().f_back
+    try:
+        parent = current.f_back
+    except AttributeError:
+        print('No Calling function found')
+        return
+    currentInfo = inspect.getframeinfo(current)
+    parentInfo = inspect.getframeinfo(parent)
+    if parentInfo[3] is not None:
+        context = ', '.join(parentInfo[3]).strip('\t').rstrip()
+    else:
+        context = 'No context to return'
+    if compact:
+        output = '# %s Calling Function: %s Filename: %s Line: %i Context: %s' % (
+            currentInfo[2],
+            parentInfo[2],
+            parentInfo[0],
+            parentInfo[1],
+            context,
+        )
+    else:
+        output = ["Function: '%s' in file '%s'" % (currentInfo[2], currentInfo[0])]
+        output.append(
+            "    Calling Function: '%s' in file '%s'" % (parentInfo[2], parentInfo[0])
+        )
+        output.append("    Line: '%i'" % parentInfo[1])
+        output.append("    Context: '%s'" % context)
+        output = '\n'.join(output)
+    print(output)
+    return output
+
+
+def mroDump(obj, nice=True, joinString='\n'):
+    """Formats inspect.getmro into text.
+
+    For the given class object or instance of a class, use inspect to return the Method
+    Resolution Order.
+
+    Args: obj (object): The object to return the mro of. This can be a class object or
+        instance.1
+
+        nice (bool): Returns the same module names as help(object) if True, otherwise
+        repr(object).
+
+        joinString (str, optional): The repr of each class is joined by this string.
+
+    Returns:
+        str: A string showing the Method Resolution Order of the given object.
+    """
+    import pydoc
+
+    # getmro requires a class, turn instances into a class
+    if not inspect.isclass(obj):
+        obj = type(obj)
+    classes = inspect.getmro(obj)
+    if nice:
+        ret = [pydoc.classname(x, obj.__module__) for x in (classes)]
+    else:
+        ret = [repr(x) for x in (classes)]
+    return joinString.join(ret)

preditor/delayable_engine/__init__.py

@@ -0,0 +1,302 @@
+from __future__ import absolute_import, print_function
+
+import time
+import warnings
+import weakref
+from collections import OrderedDict
+from collections.abc import MutableSet
+
+from Qt import QtCompat
+from Qt.QtCore import QObject, QTimer, Signal
+
+from .delayables import Delayable
+
+
+# https://stackoverflow.com/a/7829569
+class OrderedSet(MutableSet):
+    def __init__(self, values=()):
+        self._od = OrderedDict().fromkeys(values)
+
+    def __len__(self):
+        return len(self._od)
+
+    def __iter__(self):
+        return iter(self._od)
+
+    def __contains__(self, value):
+        return value in self._od
+
+    def add(self, value):
+        self._od[value] = None
+
+    def discard(self, value):
+        self._od.pop(value, None)
+
+
+class OrderedWeakrefSet(weakref.WeakSet):
+    def __init__(self, values=()):
+        super(OrderedWeakrefSet, self).__init__()
+        self.data = OrderedSet()
+        for elem in values:
+            self.add(elem)
+
+
+class DelayableEngine(QObject):
+    """Provides a way for multiple DocumentEditors to run code over
+    multiple Qt event loops in chunks preventing locking up the ui.
+
+    Signals:
+        processing_finished (int, float): Emitted when the engine finishes
+            processing successfully.
+    """
+
+    _instance = {}
+    processing_finished = Signal()
+
+    def __init__(self, name, parent=None, interval=0):
+        super(DelayableEngine, self).__init__()
+        self.name = name
+        self.documents = OrderedWeakrefSet()
+        self.delayables = {}
+        self.maxLoopTime = 0.01
+        self.start_time = time.time()
+        # It's likely we wont' finish processing all documents and all delayables
+        # before we run out of time. These variables keep track of where we stopped.
+        self.document_index = 0
+        self.delayable_index = 0
+
+        self.timer = QTimer(self)
+        self.timer.setInterval(interval)
+        self.timer.timeout.connect(self.loop)
+
+        # These values are reset when enqueue needs to start self.timer
+        # Each of these lists have a item added when self.loop exits
+        # (this can be it finished or ran out of time)
+        # Number of documents that had a delayable.loop called on them this loop
+        self.processed = []
+        # Time spent processing delayables for this self.loop
+        self.processing_time = []
+        # Number of nonVisible items that were skipped for this self.loop
+        self.skipped = []
+
+    def __repr__(self):
+        return '{}.{}("{}")'.format(
+            self.__module__,
+            self.__class__.__name__,
+            self.name,
+        )
+
+    def __str__(self):
+        return '{}("{}")'.format(self.__class__.__name__, self.name)
+
+    def add_delayable(self, delayable):
+        """Add a Delayable subclass instance for processing in this engine.
+
+        Args:
+            delayable (Delayable or str): A Delayable instance or the key identifier.
+                If a Delayable instance is passed, it will replace any previous
+                instances. If a string is passed it will not replace previous instance.
+
+        Raises:
+            KeyError: A invalid key identifier string was passed.
+        """
+        if isinstance(delayable, str):
+            if delayable in self.delayables:
+                # Don't replace the instance if a string is passed
+                return
+            for cls in Delayable._all_subclasses():
+                if cls.key == delayable:
+                    delayable = cls(self)
+                    break
+            else:
+                raise KeyError('No Delayable found with key: "{}"'.format(delayable))
+        elif delayable.key in self.delayables:
+            # Remove the old delayable if it exists so we can replace it.
+            self.remove_delayable(self.delayables[delayable.key])
+
+        self.delayables[delayable.key] = delayable
+        for document in self.documents:
+            delayable.add_document(document)
+
+    def add_document(self, document):
+        self.documents.add(document)
+        document.delayable_engine = self
+        for delayable in self.delayables:
+            self.delayables[delayable].add_document(document)
+
+    def add_supported_delayables(self, name):
+        """Add all valid Delayable subclasses that have name in their supports."""
+        for delayable in Delayable._all_subclasses():
+            if delayable.key not in self.delayables:
+                if name in delayable.supports and delayable.key != 'invalid':
+                    self.add_delayable(delayable(self))
+
+    def delayable_enabled(self, delayable):
+        """Returns True if delayable is currently added.
+
+        Args:
+            delayable (Delayable or str): A Delayable instance or the key identifier.
+
+        Returns:
+            bool: Is the given delayable installed for this engine.
+        """
+        if isinstance(delayable, Delayable):
+            delayable = delayable.key
+        return delayable in self.delayables
+
+    def enqueue(self, document, key, *args):
+        # Only add a item to be processed if we have a delayable that can
+        # process the requested key.
+        if key in self.delayables:
+            # There is only ever one instance of a delayable class processed
+            # If we already have a class enqueued, merge the arguments so we
+            # don't end up loosing some processing.
+            if key in document.delayable_info:
+                args = self.delayables[key].merge_args(
+                    document.delayable_info[key], args
+                )
+            document.delayable_info[key] = args
+            if not self.timer.isActive():
+                self.timer.start()
+                self.processed = []
+                self.processing_time = []
+                self.skipped = []
+            return True
+        return False
+
+    def expired(self):
+        return time.time() - self.start_time > self.maxLoopTime
+
+    @classmethod
+    def instance(cls, name, parent=None, interval=0):
+        """Returns a shared instance of DelayableEngine, creating the instance
+        if needed.
+
+        Args:
+            name (str): The name of the delayable engine to get the instance of.
+            parent (QWidget, optional): If a new instance is created, use this
+                as its parent. Ignored otherwise.
+            interval (int, optional): If a new instance is created, use this as
+                its interval value. Defaults to zero.
+        """
+        if name not in cls._instance:
+            cls._instance[name] = cls(name, parent=parent, interval=interval)
+        return cls._instance[name]
+
+    def loop(self):  # noqa C901
+        self.start_time = time.time()
+        documents = list(self.documents)
+        # offset documents by the document_index so we can pickup where we left off
+        documents = documents[self.document_index :] + documents[: self.document_index]
+
+        count = 0
+        skipped = 0
+        finished = True
+        first_loop = True
+        while not self.expired():
+            for document in documents:
+                self.document_index += 1
+                if self.document_index >= len(documents):
+                    self.document_index = 0
+
+                if not QtCompat.isValid(document):
+                    if document in self.documents:
+                        self.documents.remove(document)
+                        print('Removing deleted document')
+                    continue
+
+                if not document.delayable_info:
+                    continue
+
+                if not document.isVisible() and first_loop:
+                    skipped += 1
+                    continue
+
+                keys = list(document.delayable_info.keys())
+                keys = keys[self.delayable_index :] + keys[: self.delayable_index]
+                for key in keys:
+                    self.delayable_index += 1
+                    if self.delayable_index > len(keys):
+                        self.delayable_index = 0
+
+                    # delayable_info should only have keys for delayables we can access.
+                    delayable = self.delayables[key]
+
+                    args = document.delayable_info[key]
+                    try:
+                        args = delayable.loop(document, *args)
+                    except Exception:
+                        warnings.warn('Error processing {}, canceling it'.format(key))
+                        del document.delayable_info[key]
+                        raise
+                    if args:
+                        document.delayable_info[key] = args
+                        # We need to process more items
+                        finished = False
+                    else:
+                        del document.delayable_info[key]
+                    count += 1
+                    if self.expired():
+                        self.processed.append(count)
+                        self.processing_time.append(time.time() - self.start_time)
+                        self.skipped.append(skipped)
+                        return
+
+            first_loop = False
+
+        self.processed.append(count)
+        self.processing_time.append(time.time() - self.start_time)
+        self.skipped.append(skipped)
+        if finished:
+            # Nothing else to do for now, just exit
+            self.timer.stop()
+            self.processing_finished.emit()
+
+    def remove_document(self, document):
+        """Removes a document from being processed"""
+        if document in self.documents:
+            for delayable in self.delayables:
+                self.delayables[delayable].remove_document(document)
+
+            self.documents.remove(document)
+            document.delayable_engine = type(self).instance('default')
+
+    def remove_delayable(self, delayable):
+        """Removes a Delayable subclass instance for processing in this engine.
+
+        Args:
+            delayable (Delayable or str): A Delayable instance or the key identifier.
+                Remove this delayable from the current documents if it was added.
+        """
+        if isinstance(delayable, str):
+            if delayable not in self.delayables:
+                return
+            delayable = self.delayables[delayable]
+        if delayable:
+            for document in self.documents:
+                delayable.remove_document(document)
+                # Stop processing this delayable if it's currently processing.
+                try:
+                    del document.delayable_info[delayable.key]
+                except KeyError:
+                    pass
+            self.delayables.pop(delayable.key)
+
+    def set_delayable_enabled(self, delayable, enabled):
+        """Add or remove the delayable provided.
+
+        Args:
+            delayable (Delayable or str): A Delayable instance or the key identifier.
+            enabled (bool): If True installs delayable, if False removes delayable.
+
+        See Also:
+            :py:meth:`DelayableEngine.add_delayable` and
+            :py:meth:`DelayableEngine.remove_delayable`
+
+        Raises:
+            KeyError: A invalid key identifier string was passed.
+        """
+        if enabled:
+            self.add_delayable(delayable)
+        else:
+            self.remove_delayable(delayable)