PrEditor 1.0.0__py3-none-any.whl

preditor/osystem.py

@@ -0,0 +1,401 @@
+"""
+This module provides additional methods that aren't easily found in existing
+python or Qt modules for cross-platform usage.
+
+The osystem module provides a number of functions to make dealing with
+paths and other platform-specific things in a more abstract platform-agnostic
+way.
+"""
+from __future__ import absolute_import, print_function
+
+import os
+import subprocess
+import sys
+from builtins import str as text
+
+import preditor
+
+from . import settings
+
+
+def getPointerSize():
+    import struct
+
+    try:
+        size = struct.calcsize('P')
+    except struct.error:
+        # Older installations can only query longs
+        size = struct.calcsize('l')
+    size *= 8
+    global getPointerSize
+
+    def getPointerSize():
+        return size
+
+    return size
+
+
+# Get the active version of python, not a hard coded value.
+def pythonPath(pyw=False, architecture=None):
+    if settings.OS_TYPE != 'Windows':
+        return 'python'
+    from distutils.sysconfig import get_python_inc
+
+    # Unable to pull the path from the registry just use the current python path
+    basepath = os.path.split(get_python_inc())[0]
+    # build the path to the python executable. If requested use pythonw instead of
+    # python
+    return os.path.join(basepath, 'python{w}.exe'.format(w=pyw and 'w' or ''))
+
+
+def defaultLogFile(filename='preditorProtocol.log'):
+    """Returns a default log file path often used for redirecting stdout/err to.
+    Uses the `BDEV_PATH_BLUR` environment variable as the basepath.
+
+    Args:
+        filename (str, optional): filename to log to.
+    """
+    basepath = expandvars(os.environ['BDEV_PATH_BLUR'])
+    return os.path.join(basepath, filename)
+
+
+def expandvars(text, cache=None):
+    """
+    Recursively expands the text variables, vs. the os.path.expandvars
+    method which only works at one level.
+
+    :param text: text string to expand
+    :type text: str
+    :param cache: used internally during recursion to prevent infinite loop
+    :type cache: dict
+    :rtype: str
+
+    """
+    # make sure we have data
+    if not text:
+        return ''
+
+    import re
+
+    # check for circular dependencies
+    if cache is None:
+        cache = {}
+
+    # return the cleaned variable
+    output = str(text)
+    keys = re.findall(r'\$(\w+)|\${(\w+)\}|\%(\w+)\%', text)
+
+    for first, second, third in keys:
+        repl = ''
+        key = ''
+        if first:
+            repl = '$%s' % first
+            key = first
+        elif second:
+            repl = '${%s}' % second
+            key = second
+        elif third:
+            repl = '%%%s%%' % third
+            key = third
+        else:
+            continue
+
+        value = os.environ.get(key)
+        if value:
+            if key not in cache:
+                cache[key] = value
+                value = expandvars(value, cache)
+            else:
+                print(
+                    'WARNING! %s environ variable contains a circular dependency' % key
+                )
+                value = cache[key]
+        else:
+            value = repl
+
+        output = output.replace(repl, value)
+
+    return output
+
+
+def explore(filename, dirFallback=False):
+    """Launches the provided filename in the prefered editor for the specific platform.
+
+    Args:
+        filename (str): The file path to explore to.
+        dirFallback (bool): If True, and the file path does not exist, explore to
+            the deepest folder that does exist.
+
+    Returns:
+        bool: If it was able to explore the filename.
+    """
+    # pull the file path from the inputed filename
+    fpath = os.path.normpath(filename)
+
+    if dirFallback:
+        # If the provided filename does not exist, recursively check each parent folder
+        # for existence.
+        while not os.path.exists(fpath) and not os.path.ismount(fpath):
+            fpath = os.path.split(fpath)[0]
+
+    # run the file in windows
+    if settings.OS_TYPE == 'Windows':
+        env = subprocessEnvironment()
+        if os.path.isfile(fpath):
+            subprocess.Popen(r'explorer.exe /select, "{}"'.format(fpath), env=env)
+            return True
+        subprocess.Popen(r'explorer.exe "{}"'.format(fpath), env=env)
+        return True
+
+    # run the file in linux
+    elif settings.OS_TYPE == 'Linux':
+        cmd = expandvars(os.environ.get('BDEV_CMD_BROWSE', ''))
+        if not cmd:
+            return False
+        subprocess.Popen(cmd % {'filepath': fpath}, shell=True)
+        return True
+    return False
+
+
+def subprocessEnvironment(env=None):
+    """Returns a copy of the environment that will restore a new python instance to
+    current state.
+
+    Provides a environment dict that can be passed to subprocess.Popen that will restore
+    the current treegrunt environment settings, and blurdev stylesheet. It also resets
+    any environment variables set by a dcc that may cause problems when running a
+    subprocess.
+
+    Args:
+
+        env (dict, Optional): The base dictionary that is modified with blurdev
+            variables. if None(default) it will be populated with a copy of os.environ.
+
+    Returns:
+        dict: A list of environment variables to be passed to subprocess's env argument.
+    """
+    if env is None:
+        env = os.environ.copy()
+
+    # By default libstone adds "C:\Windows\System32\blur64" or "C:\blur\common" to
+    # QApplication.libraryPaths(), setting this env var to a invalid path disables that.
+    # Leaving this set likely will cause the subprocess to not be configured correctly.
+    # The subprocess should be responsible for setting this variable
+    if 'LIBSTONE_QT_LIBRARY_PATH' in env:
+        del env['LIBSTONE_QT_LIBRARY_PATH']
+
+    # If PYTHONPATH is being used, attempt to reset it to the system value.
+    # Applications like maya add PYTHONPATH, and this breaks subprocesses.
+    if env.get('PYTHONPATH'):
+        if settings.OS_TYPE == 'Windows':
+            try:
+                # Store the 'PYTHONPATH' from the system registry if set
+                env['PYTHONPATH'] = getEnvironmentVariable('PYTHONPATH')
+            except WindowsError:
+                # If the registry is not set, then remove the variable
+                del env['PYTHONPATH']
+
+    # If PYTHONHOME is used, just remove it. This variable is supposed to point
+    # to a folder relative to the python stdlib
+    # Applications like Houdini add PYTHONHOME, and it breaks the subprocesses
+    if env.get('PYTHONHOME'):
+        if settings.OS_TYPE == 'Windows':
+            try:
+                # Store the 'PYTHONHOME' from the system registry if set
+                env['PYTHONHOME'] = getEnvironmentVariable('PYTHONHOME')
+            except WindowsError:
+                # If the registry is not set, then remove the variable
+                del env['PYTHONHOME']
+
+    # Some DCC's require inserting or appending path variables. When using subprocess
+    # these path variables may cause problems with the target application. This allows
+    # removing those path variables from the environment being passed to subprocess.
+    def normalize(i):
+        return os.path.normpath(os.path.normcase(i))
+
+    removePaths = set([normalize(x) for x in preditor.core._removeFromPATHEnv])
+
+    # blurpath records any paths it adds to the PATH variable and other env variable
+    # modifications it makes, revert these changes.
+    try:
+        import blurpath
+
+        # Restore the original environment variables stored by blurpath.
+        blurpath.resetEnvVars(env)  # blurpath v0.0.16 or newer
+    except ImportError:
+        pass
+    except AttributeError:
+        # TODO: Once blurpath v0.0.16 or newer is passed out, remove the
+        # outter AttributeError except block. Its just for backwards compatibility.
+        try:
+            removePaths.update([normalize(x) for x in blurpath.addedToPathEnv])
+        except AttributeError:
+            pass
+
+    path = env.get('PATH')
+    if path:
+        paths = [
+            x for x in path.split(os.path.pathsep) if normalize(x) not in removePaths
+        ]
+        path = os.path.pathsep.join(paths)
+        # subprocess does not accept unicode in python 2
+        if sys.version_info[0] == 2 and isinstance(path, text):
+            path = path.encode('utf8')
+        env['PATH'] = path
+
+    # settings.environStr does nothing in python3, so this code only needs
+    # to run in python2
+    if sys.version_info[0] < 3:
+        # subprocess explodes if it receives unicode in Python2 and in Python3,
+        # it explodes if it *doesn't* receive unicode.
+        temp = {}
+        for k, v in env.items():
+            # Attempt to remove any unicode objects. Ignore any conversion failures
+            try:
+                k = settings.environStr(k)
+            except Exception:
+                pass
+            try:
+                v = settings.environStr(v)
+            except AttributeError:
+                pass
+            temp[k] = v
+        env = temp
+
+    return env
+
+
+# --------------------------------------------------------------------------------
+#                               Read registy values
+# --------------------------------------------------------------------------------
+def getRegKey(registry, key, architecture=None, write=False):
+    """Returns a winreg hkey or none.
+
+    Args: registry (str): The registry to look in. 'HKEY_LOCAL_MACHINE' for example
+
+        key (str): The key to open. r'Software\\Autodesk\\Softimage\\InstallPaths' for
+            example
+
+        architecture (int | None): 32 or 64 bit. If None use system default.
+            Defaults to None
+
+    Returns:
+        A winreg handle object
+    """
+    # Do not want to import winreg unless it is neccissary
+    regKey = None
+    import winreg
+
+    aReg = winreg.ConnectRegistry(None, getattr(winreg, registry))
+    if architecture == 32:
+        sam = winreg.KEY_WOW64_32KEY
+    elif architecture == 64:
+        sam = winreg.KEY_WOW64_64KEY
+    else:
+        sam = 0
+    access = winreg.KEY_READ
+    if write:
+        access = winreg.KEY_WRITE
+    try:
+        regKey = winreg.OpenKey(aReg, key, 0, access | sam)
+    except WindowsError:
+        pass
+    return regKey
+
+
+def registryValue(registry, key, value_name, architecture=None):
+    """Returns the value and type of the provided registry key's value name.
+
+    Args:
+
+        registry (str): The registry to look in. 'HKEY_LOCAL_MACHINE' for example
+
+        key (str): The key to open. r'Software\\Autodesk\\Softimage\\InstallPaths' for
+            example
+
+        value_name (str): The name of the value to read. To read the '(Default)' key
+            pass a empty string.
+
+        architecture (int | None): 32 or 64 bit. If None use system default.
+            Defaults to None.
+
+    Returns:
+        object: Value stored in key
+        int: registry type for value. See winreg's Value Types
+    """
+    # Do not want to import winreg unless it is neccissary
+    regKey = getRegKey(registry, key, architecture=architecture)
+    if regKey:
+        import winreg
+
+        return winreg.QueryValueEx(regKey, value_name)
+    return '', 0
+
+
+def getEnvironmentRegKey(machine=False):
+    """Get the Registry Path and Key for the environment, either of the current
+    user or the system.
+
+    Args:
+        machine (bool, optional): If True, the system Environment location will
+            be returned.  Otherwise, the Environment location for the current
+            user will be returned.  Defaults to False.
+
+    Returns:
+        tuple: Returns a tuple of two strings (registry path, key).
+    """
+    registry = 'HKEY_CURRENT_USER'
+    key = r'Environment'
+    # Replace {PATH} with the existing path variable.
+    if machine:
+        registry = 'HKEY_LOCAL_MACHINE'
+        key = r'SYSTEM\CurrentControlSet\Control\Session Manager\Environment'
+    return registry, key
+
+
+def getEnvironmentVariable(value_name, system=None, default=None, architecture=None):
+    """Returns the environment variable stored in the windows registry.
+
+    Args:
+        value_name (str): The name of the environment variable to get the value of.
+        system (bool or None, optional): If True, then only look in the system
+            environment variables. If False, then only look at the user
+            environment variables. If None(default), then return the user value
+            if set, otherwise return the system value.
+        default: If the variable is not set, return this value.
+            If None(default) then a WindowsError is raised.
+        architecture (int or None): 32 or 64 bit. If None use system default.
+            Defaults to None.
+
+    Raises:
+        WindowsError: [Error 2] is returned if the environment variable is not
+            stored in the requested registry. If you pass a default value other
+            than None this will not be raised.
+    """
+    if system is None and value_name.lower() == 'path':
+        msg = "PATH is a special environment variable, set system to True or False."
+        raise ValueError(msg)
+
+    if not system:
+        # system is None or False, so check user variables.
+        registry, key = getEnvironmentRegKey(False)
+        try:
+            return registryValue(registry, key, value_name, architecture=architecture)[
+                0
+            ]
+        except WindowsError:
+            pass
+        if system is False:
+            # If system is False, then return the default.
+            # If None, then check the system.
+            if default is None:
+                raise
+            return default
+
+    registry, key = getEnvironmentRegKey(True)
+    try:
+        return registryValue(registry, key, value_name, architecture=architecture)[0]
+    except WindowsError:
+        if default is None:
+            raise
+        return default

preditor/plugins.py

@@ -0,0 +1,118 @@
+from __future__ import absolute_import
+
+import logging
+
+from importlib_metadata import EntryPoint, entry_points
+
+_logger = logging.getLogger(__name__)
+
+
+class Plugins(object):
+    def about_module(self):
+        plugs = {}
+        for ep in self.iterator("preditor.plug.about_module"):
+            name = ep.name
+            if name in plugs:
+                _logger.warning(
+                    'Duplicate "preditor.plug.about_module" plugin found with '
+                    'name "{}"'.format(name)
+                )
+            else:
+                plugs[name] = ep
+
+        # Sort the plugins alphabetically
+        for name in sorted(plugs.keys(), key=lambda i: i.lower()):
+            ep = plugs[name]
+            try:
+                result = ep.load()
+            except Exception as error:
+                result = "Error processing: {}".format(error)
+
+            yield name, result
+
+    def add_logging_handler(self, logger, handler_cls, *args, **kwargs):
+        """Add a logging handler to a logger if not already installed.
+
+        Checks for an existing handler on logger for the specific class(does not
+        use isinstance). If not then it will create an instance of the handler
+        and add it to the logger.
+
+        Args:
+            logger (logging.RootLogger): The logger instance to add the handler.
+            handler_cls (logging.Handler or str): If a string is passed it will
+                use `self.logging_handlers` to get the class. If not found then
+                exits with success marked as False. Other values are treated as
+                the handler class to add to the logger.
+            *args: Passed to the handler_cls if a new instance is created.
+            **kargs: Passed to the handler_cls if a new instance is created.
+
+        Returns:
+            logging.Handler or None: The handler instance that was added, already
+                has been added, or None if the handler name isn't a valid plugin.
+            bool: True only if the handler_cls was not already added to this logger.
+        """
+        if isinstance(handler_cls, str):
+            handlers = dict(self.logging_handlers(handler_cls))
+            if not handlers:
+                # No handler to add for this name
+                return None, False
+            handler_cls = handlers[handler_cls]
+
+        # Attempt to find an existing handler instance and return it
+        for h in logger.handlers:
+            if type(h) is handler_cls:
+                return h, False
+
+        # No handler installed create and install it
+        handler = handler_cls(*args, **kwargs)
+        logger.addHandler(handler)
+        return handler, True
+
+    def editor(self, name):
+        for plug_name, ep in self.editors(name):
+            return plug_name, ep.load()
+        return None, None
+
+    def editors(self, name=None):
+        for ep in self.iterator(group="preditor.plug.editors"):
+            if name and ep.name != name:
+                continue
+            yield ep.name, ep
+
+    def initialize(self, name=None):
+        for ep in self.iterator(group="preditor.plug.initialize"):
+            yield ep.load()
+
+    def loggerwindow(self, name=None):
+        """Returns instances of "preditor.plug.loggerwindow" plugins.
+
+        These plugins are used by the LoggerWindow to extend its interface. For
+        example it can be used to add a toolbar or update the menus.
+
+        When using this plugin, make sure the returned class is a subclass of
+        `preditor.gui.logger_window_plugin.LoggerWindowPlugin`.
+        """
+        for ep in self.iterator(group="preditor.plug.loggerwindow"):
+            if name and ep.name != name:
+                continue
+            yield ep.name, ep.load()
+
+    def logging_handlers(self, name=None):
+        for ep in self.iterator(group="preditor.plug.logging_handlers"):
+            yield ep.name, ep.load()
+
+    @classmethod
+    def iterator(cls, group=None, name=None):
+        """Iterates over the requested entry point yielding results."""
+        for ep in entry_points().select(group=group):
+            yield ep
+
+    @classmethod
+    def from_string(cls, value, name="", group=""):
+        """Resolve an EntryPoint string into its object.
+
+        Example:
+            cls = from_string("preditor.gui.errordialog:ErrorDialog")
+        """
+        ep = EntryPoint(name=name, value=value, group=group)
+        return ep.load()

preditor/prefs.py

@@ -0,0 +1,74 @@
+"""
+Module for handling user interface preferences
+
+"""
+from __future__ import absolute_import
+
+import os
+import sys
+
+# cache of all the preferences
+_cache = {}
+
+
+def backup():
+    """Saves a copy of the current preferences to a zip archive."""
+    import glob
+    import shutil
+
+    archive_base = "preditor_backup_"
+    # Save all prefs not just the current core_name.
+    prefs = prefs_path()
+    # Note: Using parent dir of prefs so we can use shutil.make_archive without
+    # backing up the previous backups.
+    parent_dir = os.path.join(os.path.dirname(prefs), "_backups")
+
+    # Get the next backup version number to use.
+    filenames = glob.glob(os.path.join(parent_dir, "{}*.zip".format(archive_base)))
+    version = 1
+    if filenames:
+        # Add one to the largest version that exists on disk.
+        version = int(os.path.splitext(max(filenames))[0].split(archive_base)[-1])
+        version += 1
+
+    # Build the file path to save the archive to.
+    archive_base = os.path.join(parent_dir, archive_base + "{:04}".format(version))
+
+    # Save the preferences to the given archive name.
+    zip_path = shutil.make_archive(archive_base, "zip", prefs)
+
+    return zip_path
+
+
+def browse(core_name):
+    from . import osystem
+
+    path = prefs_path(core_name)
+    osystem.explore(path)
+
+
+def existing():
+    """Returns a list of PrEditor preference path names that exist on disk."""
+    root = prefs_path()
+    return sorted(next(os.walk(root))[1], key=lambda i: i.lower())
+
+
+def prefs_path(filename=None, core_name=None):
+    """The path PrEditor's preferences are saved as a json file.
+
+    The enviroment variable `PREDITOR_PREF_PATH` is used if set, otherwise
+    it is saved in one of the user folders.
+    """
+    if "PREDITOR_PREF_PATH" in os.environ:
+        ret = os.environ["PREDITOR_PREF_PATH"]
+    else:
+        if sys.platform == "win32":
+            ret = "%appdata%/blur/preditor"
+        else:
+            ret = "$HOME/.blur/preditor"
+    ret = os.path.normpath(os.path.expandvars(os.path.expanduser(ret)))
+    if core_name:
+        ret = os.path.join(ret, core_name)
+    if filename:
+        ret = os.path.join(ret, filename)
+    return ret

preditor/resource/environment_variables.html

@@ -0,0 +1,26 @@
+<html>
+<head/>
+<body>
+	<h1>blurdev</h1>
+	<hr>
+	<h2>blurdev Site variables:</h2>
+	<p><span style=" font-style:italic;">These variables should be defined at a user or system level to configure blurdev.</span></p>
+	<p><span style=" font-weight:bold;">BDEV_DESIGNERPLUG_*:</span> Used to add a collection of designer plugins to QDesigner. Should be set to "XMLPATH,MODULE_DIR". XMLPATH is the full path to a xml file listing plugins to load. MODULE_DIR is a path that needs added to sys.path so the modules in XMLPATH are importable. You can use environment variables in these strings, they will be expanded. This is used by QDesigner, nothing else.</p>
+	<p><span style=" font-weight:bold;">BDEV_OFFLINE:</span> If set to 1, this indicates that blurdev is not running on the "Blur" network. This causes the [* Offline] section of blurdev/resource/settings.ini to override the [Default] and [*] sections. When blurdev is imported it adds all env vars defined in settings.ini for the current operating system  and Default if they are not already defined in os.environ.</p>
+	<p><span style=" font-weight:bold;">BDEV_PATH_PREFS:</span> This environment variable points to where per-computer user prefs are stored.</p>
+	<p><span style=" font-weight:bold;">BDEV_PATH_PREFS_SHARED:</span> This environment variable points to where shared user prefs are stored. This is often on the network and includes the os's logged in username in the path. If BDEV_OFFLINE is set to 1 this may point to the BDEV_PATH_PREFS location.</p>
+	<p></p>
+	<h2>blurdev Temp variables:</h2>
+	<p><span style=" font-style:italic;">These variables should not be defined all the time.</span></p>
+	<p><span style=" font-weight:bold;">BDEV_DISABLE_AUTORUN:</span> Set to "true" to disable the autorun.bat script used at blur. If this is not set when Maya shuts down, maya takes minutes to close. Maya uses several subprocess calls when closing and for some reason the doskey calls in the script take much longer than normal.</p>
+	<p><span style=" font-weight:bold;">BDEV_STYLESHEET:</span> Used to override the stylesheet when initalizing blurdev.</p>
+	<p><span style=" font-weight:bold;">BDEV_TOOL_ENVIRONMENT:</span> Forces blurdev to initialize with this treegrunt environment name. When saving prefs, this environment name change will not be saved. This is mostly used to ensure that launching a subprocess or farm job happens on the same treegrunt environment.</p>
+	<p></p>
+	<h1>trax</h1>
+	<hr>
+	<p><span style=" font-weight:bold;">TRAX_SPOOL_DIRECTORY_OVERRIDE:</span> If defined, all messages will be stored the directory of this variable. Each message filename will have a "[mapping.mount()]_" prefix added giving you a hint to which server it would have ended up on. Defining this variable effectively disables all spool messages, and gives you a way to see what each spool message would look like. If your code depends on trax.api.spool.waitForCompletion, it will never complete.</p>
+	<h1>Notes</h1>
+	<hr>
+	<p>Any variable names containing a * are wildcards. This allows you to add as many instances of that environment variable type as needed.</p>
+</body>
+</html>