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

preditor/__init__.py

@@ -0,0 +1,301 @@
+from __future__ import absolute_import, print_function
+
+import logging  # noqa: E402
+import os  # noqa: E402
+import sys  # noqa: E402
+
+from Qt.QtCore import Qt  # noqa: E402
+
+from . import osystem  # noqa: E402
+from .plugins import Plugins  # noqa: E402
+from .version import version as __version__  # noqa: E402,F401
+
+DEFAULT_CORE_NAME = "PrEditor"
+"""The default name to use for the core name."""
+
+_global_config = {}
+
+core = None  # create a managed Core instance
+"""
+The blurdev managed :class:`Core` object from the :mod:`blurdev.cores` module.
+"""
+
+# Create the root blurdev module logging object.
+_logger = logging.getLogger(__name__)
+
+# Add a NullHandler to suppress the "No handlers could be found for _logger"
+# warnings from being printed to stderr. Studiomax and possibly other DCC's
+# tend to treat any text written to stderr as a error when running headless.
+# We also don't want this warning showing up in production anyway.
+_logger.addHandler(logging.NullHandler())
+
+plugins = Plugins()
+
+
+def about_preditor(instance=None):
+    """Useful info about installed packages generated by plugins.
+
+    Args:
+        instance (LoggerWindow, optional): Used by the AboutModule plugins
+            to access the current instance of a Preditor GUI.
+    """
+    from .about_module import AboutModule
+
+    return AboutModule.generate(instance=instance)
+
+
+def init():
+    os.environ['BDEV_EMAILINFO_PREDITOR_VERSION'] = __version__
+    pythonw_print_bugfix()
+    global core
+    # create the core
+    if not core:
+        from .cores.core import Core
+
+        objectName = None
+        _exe = os.path.basename(sys.executable).lower()
+        # Treat designer as a seperate core so it gets its own prefrences.
+        if 'designer' in _exe:
+            objectName = 'designer'
+        elif 'assfreezer' in _exe:
+            objectName = 'assfreezer'
+        core = Core(objectName=objectName)
+
+    for plugin in plugins.initialize():
+        plugin()
+
+
+def configure(name, parent_callback=None, excepthook=True, logging=True, streams=True):
+    """Global configuration of PrEditor. Nothing is done if called more than once.
+
+    Args:
+        name (str): The core_name to use for the global instance of PrEditor.
+            Once this has been set, you can call `launch` without passing name
+            to access the main instance.
+        parent_callback (callable, optional): Callback that returns a QWidget
+            to use as the parent of the LoggerWindow when its first created.
+            This can be used by DCC's to set the parent to their main window.
+        excepthook (bool, optional): Replaces `sys.excepthook` with a interactive
+            exception handler that prompts the user to show PrEditor when an
+            python exception is raised.
+        logging (bool, optional): Restore the python logging configuration that
+            was recorded the last time PrEditor prefs were saved.
+        streams (bool, optional): Install the stream manager to capture any
+            stdout/stderr text written. Later when calling launch, the
+            LoggerWindow will show all of the captured text. This lets you only
+            create the LoggerWindow IF you need to, but when you do it will have
+            all of the std stream text written after this call.
+    """
+    # Once this has been set, configure should not do anything
+    if 'core_name' in _global_config:
+        return
+
+    # Store the core_name,.
+    _global_config['core_name'] = name
+    if parent_callback:
+        _global_config['parent_callback'] = parent_callback
+
+    if streams:
+        # Install the stream manager to capture output
+        from preditor.stream import install_to_std
+
+        install_to_std()
+
+    if logging:
+        from .logging_config import LoggingConfig
+
+        cfg = LoggingConfig(core_name=name)
+        cfg.load()
+
+    if excepthook:
+        import preditor.debug
+
+        preditor.debug.BlurExcepthook.install()
+
+
+def launch(run_workbox=False, app_id=None, name=None, standalone=False):
+    """Launches the preditor gui creating the QApplication instance if not
+    already created.
+
+    Args:
+        modal (bool, optional): If True, preditor's gui will be created as a
+            modal window (ie. blocks current code execution while its shown).
+        run_workbox (bool, optional): After preditor's gui is shown, run its
+            current workbox text.
+        app_id (str, optional): Set the QApplication's applicationName to this
+            value. This is normally only used when launching a standalone
+            instance of the PrEditor gui.
+        standalone (bool, optional): Launch PrEditor in standalone mode. This
+            enables extra options that only make sense when it is running as
+            its own app, not inside of another app.
+
+    Returns:
+        preditor.gui.loggerwindow.LoggerWindow: The instance of the PrEditor
+            gui that was created.
+    """
+    if name is None:
+        # If the name wasn't passed we will get it from the name stored when
+        # configure was called.
+        if 'core_name' not in _global_config:
+            raise RuntimeError(
+                "You call configure before calling launch if not passing name"
+            )
+        name = _global_config['core_name']
+    else:
+        # A name was provided, call configure to ensure it has been called
+        configure(name=name)
+
+    from .gui.app import App
+    from .gui.loggerwindow import LoggerWindow
+
+    # Check if we can actually run the PrEditor gui and setup Qt if required
+    app = App(name=app_id)
+    widget = LoggerWindow.instance(
+        run_workbox=run_workbox, name=name, standalone=standalone
+    )
+
+    # Show the PrEditor instance and make sure it regains focus and visibility
+    widget.show()
+    # If the instance was already shown, raise it to the top and make
+    # it regain focus.
+    widget.activateWindow()
+    widget.raise_()
+    widget.setWindowState(widget.windowState() & ~Qt.WindowMinimized | Qt.WindowActive)
+    widget.console().setFocus()
+    app.start()
+
+    return widget
+
+
+def prefPath(relpath, coreName=''):
+    # use the core
+    if not coreName and core:
+        coreName = core.objectName()
+    basepath = os.path.join(
+        osystem.expandvars(os.environ['BDEV_PATH_PREFS']), 'app_%s/' % coreName
+    )
+    return os.path.normpath(os.path.join(basepath, relpath))
+
+
+def pythonw_print_bugfix():
+    """
+    When running pythonw print statements and file handles tend to have problems
+    so, if its pythonw and stderr and stdout haven't been redirected, redirect them
+    to os.devnull.
+    """
+    if os.path.basename(sys.executable) == 'pythonw.exe':
+        if sys.stdout == sys.__stdout__:
+            sys.stdout = open(os.devnull, 'w')
+        if sys.stderr == sys.__stderr__:
+            sys.stderr = open(os.devnull, 'w')
+
+
+def relativePath(path, additional=''):
+    """
+    Replaces the last element in the path with the passed in additional path.
+    :param path: Source path. Generally a file name.
+    :param additional: Additional folder/file path appended to the path.
+    :return str: The modified path
+    """
+    return os.path.join(os.path.dirname(path), additional)
+
+
+def resourcePath(relpath=''):
+    """Returns the full path to the file inside the preditor/resource folder
+
+    Args:
+        relpath (str, optional): The additional path added to the
+            preditor/resource folder path.
+
+    Returns:
+        str: The modified path
+    """
+    return os.path.join(relativePath(__file__), 'resource', relpath)
+
+
+def root_window():
+    # If a parent widget callback was configured, use it
+    if 'parent_callback' in _global_config:
+        return _global_config['parent_callback']()
+
+    # Otherwise, attempt to find the top level widget from Qt
+    from .gui.app import App
+
+    return App.root_window()
+
+
+def connect_preditor(
+    parent, sequence='F2', text='Show PrEditor', obj_name='uiShowPreditorACT', name=None
+):
+    """Creates a QAction that shows the PrEditor gui with a keyboard shortcut.
+    This will automatically call `preditor.configure` if name is provided,
+    capturing any `sys.stdout` and `sys.stderr` writes after this call. This does
+    not initialize the PrEditor gui instance until the action is actually called.
+
+    Args:
+        parent: The parent widget, normally a window
+        sequence (str, optional): A string representing the keyboard shortcut
+            associated with the QAction.
+        text (str, optional): The display text for the QAction.
+        obj_name (str, optional): Set the QAction's objectName to this value.
+
+    Returns:
+        QAction: The created QAction
+    """
+    from Qt.QtGui import QKeySequence
+    from Qt.QtWidgets import QAction
+
+    if name:
+        # Set the core_name if provided
+        configure(name)
+
+    # Create shortcut for launching the PrEditor gui.
+    action = QAction(text, parent)
+    action.setObjectName(obj_name)
+    action.triggered.connect(launch)
+    action.setShortcut(QKeySequence(sequence))
+    parent.addAction(action)
+    return action
+
+
+def instance(parent=None, run_workbox=False, create=True):
+    """Returns the existing instance of the PrEditor gui creating it on first call.
+
+    Args:
+        parent (QWidget, optional): If the instance hasn't been created yet, create
+            it and parent it to this object.
+        run_workbox (bool, optional): If the instance hasn't been created yet, this
+            will execute the active workbox's code once fully initialized.
+        create (bool, optional): Returns None if the instance has not been created.
+
+    Returns:
+        Returns a fully initialized instance of the PrEditor gui. If called more
+        than once, the same instance will be returned. If create is False, it may
+        return None.
+    """
+    from .gui.loggerwindow import LoggerWindow
+
+    return LoggerWindow.instance(parent=parent, run_workbox=run_workbox, create=create)
+
+
+def shutdown():
+    """Fully close and cleanup the PrEditor gui if it was created.
+
+    Call this when shutting down your application to ensure any unsaved changes
+    to the PrEditor gui are saved and the instance is actually closed instead
+    of just hidden.
+
+    If the PrEditor gui was never created, this does nothing so its safe to call
+    even if the user never showed the gui. It also won't add extra time creating
+    the gui just so it can "save any changes".
+
+    Returns:
+        bool: If a shutdown was required
+    """
+    from .gui.loggerwindow import LoggerWindow
+
+    return LoggerWindow.instance_shutdown()
+
+
+# initialize the core
+init()

{blurdev → preditor}/__main__.py

@@ -1,13 +1,13 @@
-""" Enables support for calling the blurdev cli using `python -m blurdev`
-"""
-
-from __future__ import absolute_import
-
-import sys
-import blurdev.cli
-
-if __name__ == '__main__':
-    # prog_name prevents __main__.py from being shown as the command name in the help
-    # text. We don't know the exact command the user passed so we provide a generic
-    # `python -m blurdev` command.
-    sys.exit(blurdev.cli.main(prog_name="python -m blurdev"))
+""" Enables support for calling the preditor cli using `python -m preditor`
+"""
+from __future__ import absolute_import
+
+import sys
+
+import preditor.cli
+
+if __name__ == '__main__':
+    # prog_name prevents __main__.py from being shown as the command name in the help
+    # text. We don't know the exact command the user passed so we provide a generic
+    # `python -m preditor` command.
+    sys.exit(preditor.cli.cli(prog_name="python -m preditor"))

preditor/about_module.py

@@ -0,0 +1,166 @@
+from __future__ import absolute_import
+
+import abc
+import os
+import sys
+import textwrap
+
+import six
+from future.utils import with_metaclass
+
+import preditor
+
+
+class AboutModule(with_metaclass(abc.ABCMeta, object)):
+    """Base class for the `preditor.plug.about_module` entry point. Create a
+    subclass of this method and expose the class object to the entry point.
+
+    Properties:
+        instance: If provided, the instance of PrEditor to generate text for.
+    """
+
+    indent = "  "
+    """Use this to indent new lines for text"""
+
+    def __init__(self, instance=None):
+        self.instance = instance
+
+    @classmethod
+    def generate(cls, instance=None):
+        """Generates the output text for all plugins.
+
+        Outputs this for each plugin:
+
+            {name}: {version}
+            {indent}{text line 1}
+            {indent}{text line ...}
+
+        Name is the name of each entry point. If duplicates are found, a logging
+        warning is generated. Each line of `self.text()` is indented
+        """
+        ret = []
+        for name, plugin in preditor.plugins.about_module():
+            version = "Unknown"
+            if isinstance(plugin, str):
+                text = plugin
+            else:
+                try:
+                    plug = plugin(instance=instance)
+                    if not plug.enabled():
+                        continue
+                    version = plug.version()
+                    text = plug.text()
+                except Exception as error:
+                    text = "Error processing: {}".format(error)
+            if six.PY3:
+                text = textwrap.indent(text, cls.indent)
+            else:
+                text = ['{}{}'.format(cls.indent, line) for line in text.split('\n')]
+                text = "\n".join(text)
+
+            # Build the output string including the version information if provided.
+            if version is not None:
+                ret.append("{}: {}\n{}".format(name, version, text))
+            else:
+                ret.append("{}:\n{}".format(name, text))
+
+        return '\n'.join(ret)
+
+    def enabled(self):
+        """The plugin can use this to disable reporting by generate."""
+        return True
+
+    @abc.abstractmethod
+    def text(self):
+        """Returns info about this plugin. This can have multiple lines, and
+        each line will be indented to provide visual distinction between plugins.
+        """
+
+    @abc.abstractmethod
+    def version(self):
+        """Returns The version as a string to show next to name."""
+
+
+class AboutPreditor(AboutModule):
+    """About module used to show info about PrEditor."""
+
+    def text(self):
+        """Return the path PrEditor was loaded from for quick debugging."""
+        ret = []
+        # Include the core_name of the current PrEditor gui instance if possible
+        if self.instance:
+            ret.append("Core Name: {}".format(self.instance.name))
+        # THe path to the PrEditor package
+        ret.append("Path: {}".format(os.path.dirname(preditor.__file__)))
+        return "\n".join(ret)
+
+    def version(self):
+        return preditor.__version__
+
+
+class AboutQt(AboutModule):
+    """Info about Qt modules being used."""
+
+    def text(self):
+        """Return the path PrEditor was loaded from for quick debugging."""
+        from Qt import QtCore, __binding__, __version__
+
+        ret = ['Qt.py: {}, binding: {}'.format(__version__, __binding__)]
+
+        # Attempt to get a version for QtSiteConfig if defined
+        try:
+            import QtSiteConfig
+
+            ret.append('QtSiteConfig: {}'.format(QtSiteConfig.__version__))
+        except (ImportError, AttributeError):
+            pass
+
+        # Add info for all Qt5 bindings that have been imported
+        if 'PyQt5.QtCore' in sys.modules:
+            ret.append('PyQt5: {}'.format(sys.modules['PyQt5.QtCore'].PYQT_VERSION_STR))
+        if 'PySide2.QtCore' in sys.modules:
+            ret.append('PySide2: {}'.format(sys.modules['PySide2.QtCore'].qVersion()))
+
+        # Add qt library paths for plugin debugging
+        for i, path in enumerate(QtCore.QCoreApplication.libraryPaths()):
+            if i == 0:
+                ret.append('Library Paths: {}'.format(path))
+            else:
+                ret.append('               {}'.format(path))
+
+        return "\n".join(ret)
+
+    def version(self):
+        from Qt import __qt_version__
+
+        return __qt_version__
+
+
+class AboutPython(AboutModule):
+    """Info about the current instance of python."""
+
+    def text(self):
+        """Return the path PrEditor was loaded from for quick debugging."""
+        ret = sys.version
+        # Windows doesn't add a newline before the compiler info, and it can end
+        # up being a little long for QMessageBox's with short file paths. Add
+        # the newline like is present on linux
+        ret = ret.replace(") [", ")\n[")
+        return ret
+
+    def version(self):
+        return '{}.{}.{}'.format(*sys.version_info[:3])
+
+
+class AboutExe(AboutModule):
+    """The value of sys.executable, disabled if not set."""
+
+    def enabled(self):
+        return bool(sys.executable)
+
+    def text(self):
+        return sys.executable
+
+    def version(self):
+        """No version is returned for this class."""
+        return None

preditor/cli.py

@@ -0,0 +1,192 @@
+from __future__ import absolute_import
+
+import logging
+import sys
+from distutils.spawn import find_executable
+
+import click
+from click.core import ParameterSource
+from click_default_group import DefaultGroup
+
+import preditor
+import preditor.prefs
+from preditor.settings import OS_TYPE
+
+# No one wants to actually type `--help`
+CONTEXT_SETTINGS = dict(help_option_names=["-h", "--help"])
+
+logger = logging.getLogger(__name__)
+
+
+def get_app_id(name, is_default):
+    """Returns the name to use for the app_id of windows shortcuts.
+    This allows for taskbar/start menu pinning.
+    """
+    if is_default:
+        # If not using a custom name, just use it for the app_id
+        return name
+    # Otherwise use a prefix of the name provided by the user
+    return "PrEditor - {}".format(name)
+
+
+@click.group(
+    cls=DefaultGroup,
+    default='launch',
+    default_if_no_args=True,
+    context_settings=CONTEXT_SETTINGS,
+)
+def cli():
+    """PrEditor is a Qt based python console and code editor. It runs in many
+    DCC's like Maya, Houdini, Nuke, and 3ds Max.
+
+    To see help for launching the PrEditor gui, use `preditor launch -h`.
+    """
+    pass
+
+
+# launch
+@cli.command()
+@click.option(
+    "-n",
+    "--name",
+    default=preditor.DEFAULT_CORE_NAME,
+    envvar="PREDITOR_NAME",
+    help="Name to save preferences with. This allows you to open multiple "
+    "instances with their own code and settings.",
+)
+@click.option(
+    '-r',
+    '--run-workbox',
+    is_flag=True,
+    help='After the logger is shown, run the current workbox text.',
+)
+def launch(name, run_workbox):
+    """Run the PrEditor console's gui."""
+    # Check if the user passed the name or it was the default
+    parameter_source = click.get_current_context().get_parameter_source('name')
+    app_id = get_app_id(name, parameter_source == ParameterSource.DEFAULT)
+
+    preditor.launch(run_workbox=run_workbox, app_id=app_id, name=name, standalone=True)
+
+
+# shortcut
+@cli.command()
+@click.argument("path")
+@click.option(
+    "-p",
+    "--public",
+    is_flag=True,
+    help='If using "start-menu" or "desktop" for path, create the shortcut '
+    'in the public location not the user location. This may require '
+    'administrative privileges.',
+)
+@click.option(
+    "-n",
+    "--name",
+    default=preditor.DEFAULT_CORE_NAME,
+    envvar="PREDITOR_NAME",
+    help="Name to save preferences with. This allows you to open multiple "
+    "instances with their own code and settings.",
+)
+@click.option(
+    "--target",
+    default="preditorw",
+    help='The command the shortcut will run. "preditor" or "preditorw" are '
+    'converted to the full path to the exe.',
+)
+@click.option(
+    '--args',
+    default="",
+    help="The command the shortcut will run.",
+)
+@click.option(
+    '--description',
+    default='Opens PrEditor',
+    help="The description to give the shortcut.",
+)
+def shortcut(path, public, name, target, args, description):
+    """Create a shortcut to launch PrEditor.
+
+    Path is a the full path of the shortcut to create. On windows you can
+    pass "start-menu" to create the shortcut in the start menu.
+    """
+
+    if OS_TYPE != "Windows":
+        click.echo("Creating a shortcut is currently only supported on Windows.")
+        sys.exit(1)
+
+    try:
+        from casement.shortcut import Shortcut
+    except ImportError:
+        click.echo(
+            "Unable to import casement use `pip install casement` to enable "
+            "creating shortcuts on windows."
+        )
+        sys.exit(1)
+
+    if path in ("desktop", "start-menu"):
+        path = [path]
+
+    # Resolve the full path to the preditor exe.
+    if target in ("preditor", "preditorw"):
+        target = find_executable(target)
+
+    parameter_source = click.get_current_context().get_parameter_source('name')
+    if parameter_source == ParameterSource.DEFAULT:
+        app_id = name
+    else:
+        # Strip off the leading "launch " command argument if it was passed
+        if args.startswith('launch '):
+            args = args[7:]
+        # Pass the name to the launched PrEditor instance
+        args = 'launch --name "{}" {}'.format(name, args)
+        app_id = name = get_app_id(name, parameter_source == ParameterSource.DEFAULT)
+
+    Shortcut.create(
+        name,
+        args,
+        target=target,
+        # icon=None,
+        icon_source=preditor.resourcePath('img/preditor.ico'),
+        icon_filename="preditor",
+        path=path,
+        description=description,
+        common=int(public),
+        app_id=app_id,
+    )
+
+
+# prefs
+@cli.group()
+def prefs():
+    """PrEditor preference management."""
+    pass
+
+
+@prefs.command()
+def backup():
+    """Backup all of preferences inside a zip file."""
+    zip_path = preditor.prefs.backup()
+    click.echo('PrEditor Preferences backed up to "{}"'.format(zip_path))
+
+
+@prefs.command()
+@click.argument("name", default="", required=False)
+def browse(name):
+    """Open a file explorer to the preference directory. Optionally pass the
+    name of a specific preference.
+    """
+    preditor.prefs.browse(name)
+
+
+@prefs.command()
+def list():
+    """List the core_names for existing preferences."""
+    click.echo("Existing pref names:")
+    click.echo("--------------------")
+    for pref in preditor.prefs.existing():
+        click.echo(pref)
+
+
+if __name__ == '__main__':
+    cli()