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

{blurdev → preditor}/contexts.py

@@ -1,119 +1,119 @@
-from __future__ import print_function
-from __future__ import absolute_import
-import logging
-
-_LOGGER = logging.getLogger(__name__)
-
-
-class ErrorReport(object):
-    """Allows you to provide additional debug info if a error happens in this context.
-
-    The blurdev Python Logger can send a error email when any python error is raised.
-    Sometimes just a traceback does not provide enough information to debug the
-    traceback. This class allows you to provide additional information to the error
-    report only if it is generated. For example if your treegrunt environment does not
-    have a email setup, or the current debug level is not set to Disabled.
-
-    ErrorReport can be used as a with context, or as a function decorator.
-
-    Examples:
-        This example shows a class using both the with context and a decorated method.
-
-        from blurdev.contexts import ErrorReport
-        class Test(object):
-            def __init__(self):
-                self.value = None
-            def errorInfo(self):
-                # The text returned by this function will be included in the error email
-                return 'Info about the Test class: {}'.format(self.value)
-            def doStuff(self):
-                with ErrorReport(self.errorInfo, 'Test.doStuff'):
-                    self.value = 'doStuff'
-                    raise RuntimeError("BILL")
-            @ErrorReport(errorInfo, 'Test.doMoreStuff')
-            def doMoreStuff(self):
-                self.value = 'doMoreStuff'
-                raise RuntimeError("BOB")
-
-    Using this class does not initialize the Python Logger, so you don't need to worry
-    if your class is running headless and not use this class. However unless you set up
-    your own error reporting system the callbacks will not be called and nothing will be
-    reported.
-
-    If you want to set up your own error reporting system you need to set
-    `ErrorReport.enabled = True`. Then you will need to call ErrorReport.clearReports()
-    any time excepthook is called. This prevents a buildup of all error reports any time
-    a exception occurs. It should always be in place when you set enabled == True to
-    prevent wasting memory. Calling ErrorReport.generateReport() will return the info
-    you should include in your report. Calling generateReport is optional, but must be
-    called before calling clearReports.
-
-    Args:
-        callback (function): If a exception happens this function is called and its
-            returned value is added to the error email if sent. No arguments are passed
-            to this function and it is expected to only return a string.
-        title (str, optional): This short string is added to the title of the
-            ErrorReport.
-    Attributes:
-        enabled (bool): If False(the default), then all callbacks are cleared even if
-            there is a exception. This is used to prevent these functions from leaking
-            memory if there isn't a excepthook calling clearReports.
-    """
-
-    __reports__ = []
-    enabled = False
-
-    def __init__(self, callback, title=''):
-        self._callback = callback
-        self._title = title
-
-    def __call__(self, funct):
-        def wrapper(wrappedSelf, *args, **kwargs):
-            unbound = self._callback
-            self._callback = self._callback.__get__(wrappedSelf)
-            try:
-                with self:
-                    return funct(wrappedSelf, *args, **kwargs)
-            finally:
-                self._callback = unbound
-
-        return wrapper
-
-    def __enter__(self):
-        type(self).__reports__.append((self._title, self._callback))
-
-    def __exit__(self, exc_type, exc_val, exc_tb):
-        # If exc_type is None, then no exception was raised, so we should remove the
-        # callback. If cls.enabled is False, then nothing has set itself up to call
-        # clearReports. We need to remove the callback so it doesn't stay in memory.
-        if exc_type is None or not type(self).enabled:
-            type(self).__reports__.remove((self._title, self._callback))
-
-    @classmethod
-    def clearReports(cls):
-        """Removes all of the currently stored callbacks.
-
-        This should be called after all error reporting is finished, or if a error
-        happened and there is nothing to report it. If you set cls.enabled to True,
-        something in excepthook should call this to prevent keeping refrences to
-        functions from staying in memory.
-        """
-        cls.__reports__ = []
-
-    @classmethod
-    def generateReport(cls, fmt='{result}'):
-        """Executes and returns all of the currently stored callbacks.
-        Args:
-
-            ftm (str, Optional): The results of the callbacks will be inserted into this
-                string using str.format into {results}.
-        Returns:
-            list: A list of tuples for all active ErrorReport classes. The tuples
-                contain two strings; the title string, and result of the passed in
-                callback function.
-        """
-        ret = []
-        for title, callback in cls.__reports__:
-            result = callback()
-            ret.append((title, fmt.format(result=result)))
-        return ret
+from __future__ import absolute_import, print_function
+
+import logging
+
+_LOGGER = logging.getLogger(__name__)
+
+
+class ErrorReport(object):
+    """Allows you to provide additional debug info if a error happens in this context.
+
+    PrEditor can send a error email when any python error is raised.
+    Sometimes just a traceback does not provide enough information to debug the
+    traceback. This class allows you to provide additional information to the error
+    report only if it is generated. For example if your treegrunt environment does not
+    have a email setup, or the current debug level is not set to Disabled.
+
+    ErrorReport can be used as a with context, or as a function decorator.
+
+    Examples:
+        This example shows a class using both the with context and a decorated method.
+
+        from preditor.contexts import ErrorReport
+        class Test(object):
+            def __init__(self):
+                self.value = None
+            def errorInfo(self):
+                # The text returned by this function will be included in the error email
+                return 'Info about the Test class: {}'.format(self.value)
+            def doStuff(self):
+                with ErrorReport(self.errorInfo, 'Test.doStuff'):
+                    self.value = 'doStuff'
+                    raise RuntimeError("BILL")
+            @ErrorReport(errorInfo, 'Test.doMoreStuff')
+            def doMoreStuff(self):
+                self.value = 'doMoreStuff'
+                raise RuntimeError("BOB")
+
+    Using this class does not initialize the Python Logger, so you don't need to worry
+    if your class is running headless and not use this class. However unless you set up
+    your own error reporting system the callbacks will not be called and nothing will be
+    reported.
+
+    If you want to set up your own error reporting system you need to set
+    `ErrorReport.enabled = True`. Then you will need to call ErrorReport.clearReports()
+    any time excepthook is called. This prevents a buildup of all error reports any time
+    a exception occurs. It should always be in place when you set enabled == True to
+    prevent wasting memory. Calling ErrorReport.generateReport() will return the info
+    you should include in your report. Calling generateReport is optional, but must be
+    called before calling clearReports.
+
+    Args:
+        callback (function): If a exception happens this function is called and its
+            returned value is added to the error email if sent. No arguments are passed
+            to this function and it is expected to only return a string.
+        title (str, optional): This short string is added to the title of the
+            ErrorReport.
+    Attributes:
+        enabled (bool): If False(the default), then all callbacks are cleared even if
+            there is a exception. This is used to prevent these functions from leaking
+            memory if there isn't a excepthook calling clearReports.
+    """
+
+    __reports__ = []
+    enabled = False
+
+    def __init__(self, callback, title=''):
+        self._callback = callback
+        self._title = title
+
+    def __call__(self, funct):
+        def wrapper(wrappedSelf, *args, **kwargs):
+            unbound = self._callback
+            self._callback = self._callback.__get__(wrappedSelf)
+            try:
+                with self:
+                    return funct(wrappedSelf, *args, **kwargs)
+            finally:
+                self._callback = unbound
+
+        return wrapper
+
+    def __enter__(self):
+        type(self).__reports__.append((self._title, self._callback))
+
+    def __exit__(self, exc_type, exc_val, exc_tb):
+        # If exc_type is None, then no exception was raised, so we should remove the
+        # callback. If cls.enabled is False, then nothing has set itself up to call
+        # clearReports. We need to remove the callback so it doesn't stay in memory.
+        if exc_type is None or not type(self).enabled:
+            type(self).__reports__.remove((self._title, self._callback))
+
+    @classmethod
+    def clearReports(cls):
+        """Removes all of the currently stored callbacks.
+
+        This should be called after all error reporting is finished, or if a error
+        happened and there is nothing to report it. If you set cls.enabled to True,
+        something in excepthook should call this to prevent keeping refrences to
+        functions from staying in memory.
+        """
+        cls.__reports__ = []
+
+    @classmethod
+    def generateReport(cls, fmt='{result}'):
+        """Executes and returns all of the currently stored callbacks.
+        Args:
+
+            ftm (str, Optional): The results of the callbacks will be inserted into this
+                string using str.format into {results}.
+        Returns:
+            list: A list of tuples for all active ErrorReport classes. The tuples
+                contain two strings; the title string, and result of the passed in
+                callback function.
+        """
+        ret = []
+        for title, callback in cls.__reports__:
+            result = callback()
+            ret.append((title, fmt.format(result=result)))
+        return ret

preditor/cores/core.py

@@ -0,0 +1,65 @@
+from __future__ import absolute_import, print_function
+
+from Qt.QtCore import QObject, Signal
+
+
+class Core(QObject):
+    """
+    The Core class provides all the main shared functionality and signals that need to
+    be distributed between different pacakges.
+    """
+
+    # ----------------------------------------------------------------
+    # blurdev signals
+    aboutToClearPaths = Signal()  # Emitted before environment is changed or reloaded
+
+    # ----------------------------------------------------------------
+
+    def __init__(self, objectName=None):
+        QObject.__init__(self)
+        if objectName is None:
+            objectName = 'blurdev'
+        QObject.setObjectName(self, objectName)
+
+        # create custom properties
+        self._headless = False
+
+        # Paths in this variable will be removed in
+        # preditor.osystem.subprocessEnvironment
+        self._removeFromPATHEnv = set()
+
+    def shouldReportException(self, exc_type, exc_value, exc_traceback, actions=None):
+        """
+        Allow core to control how exceptions are handled. Currently being used
+        by `BlurExcepthook`, informing which excepthooks should or should not
+        be executed.
+
+        Args:
+            exc_type (type): exception type class object
+            exc_value (Exception): class instance of exception parameter
+            exc_traceback (traceback): encapsulation of call stack for exception
+            actions (dict, optional): default values for the returned dict. A copy
+                of this dict is returned with standard defaults applied.
+
+        Returns:
+            dict: Boolean values representing whether to perform excepthook
+                action, keyed to the name of the excepthook
+        """
+        if actions is None:
+            actions = {}
+        # Create a shallow copy so we don't modify the passed in dict and don't
+        # need to use a default value of None
+        actions = actions.copy()
+
+        # provide the expected default values
+        actions.setdefault('email', True)
+        # If blurdev is running headless, there is no way to show a gui prompt
+        actions.setdefault('prompt', not self.headless)
+        return actions
+
+    @property
+    def headless(self):
+        """If true, no Qt gui elements should be used because python is running a
+        QCoreApplication.
+        """
+        return self._headless

preditor/dccs/maya/PrEditor_maya.mod

@@ -0,0 +1,2 @@
++ PrEditor DEVELOPMENT .
+PYTHONPATH +:= ../..

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

@@ -0,0 +1,108 @@
+from __future__ import absolute_import
+
+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 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():
+        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,
+        )
+
+        # 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="Show",
+            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()