OpenRV integration

openpype/hosts/openrv/__init__.py

@@ -0,0 +1,10 @@
+from .addon import (
+    OpenRVAddon,
+    OPENRV_ROOT_DIR
+)
+
+
+__all__ = (
+    "OpenRVAddon",
+    "OPENRV_ROOT_DIR"
+)

openpype/hosts/openrv/addon.py

@@ -0,0 +1,39 @@
+import os
+import sys
+from openpype.modules import OpenPypeModule
+from openpype.modules.interfaces import IHostAddon
+
+OPENRV_ROOT_DIR = os.path.dirname(os.path.abspath(__file__))
+
+
+class OpenRVAddon(OpenPypeModule, IHostAddon):
+    name = "openrv"
+    host_name = "openrv"
+
+    def initialize(self, module_settings):
+        self.enabled = True
+
+    def add_implementation_envs(self, env, app):
+        """Modify environments to contain all required for implementation."""
+        vendor_python = os.path.join(os.getenv("OPENPYPE_ROOT"),
+                                     "vendor",
+                                     "python")
+        sys.path.insert(0, vendor_python)
+
+        # Set default environments if are not set via settings
+        defaults = {
+            "OPENPYPE_LOG_NO_COLORS": "True"
+        }
+        for key, value in defaults.items():
+            if not env.get(key):
+                env[key] = value
+
+    def get_launch_hook_paths(self, app):
+        if app.host_name != self.host_name:
+            return []
+        return [
+            os.path.join(OPENRV_ROOT_DIR, "hooks")
+        ]
+
+    def get_workfile_extensions(self):
+        return [".rv"]

openpype/hosts/openrv/api/__init__.py

@@ -0,0 +1,10 @@
+# -*- coding: utf-8 -*-
+"""OpenRV OpenPype host API."""
+
+from .pipeline import (
+    OpenRVHost
+)
+
+__all__ = [
+    "OpenRVHost"
+]

openpype/hosts/openrv/api/commands.py

@@ -0,0 +1,41 @@
+import logging
+
+import rv
+from openpype.pipeline.context_tools import get_current_project_asset
+
+log = logging.getLogger(__name__)
+
+
+def reset_frame_range():
+    """ Set timeline frame range.
+    """
+    asset_doc = get_current_project_asset()
+    asset_data = asset_doc["data"]
+
+    frame_start = int(asset_data.get(
+        "frameStart",
+        asset_data.get("edit_in")))
+
+    frame_end = int(asset_data.get(
+        "frameEnd",
+        asset_data.get("edit_out")))
+
+    rv.commands.setFrameStart(frame_start)
+    rv.commands.setFrameEnd(frame_end)
+    rv.commands.setFrame(frame_start)
+
+    log.info("Project frame range set")
+
+
+def set_session_fps():
+    """ Set session fps.
+    """
+    asset_doc = get_current_project_asset()
+    asset_data = asset_doc["data"]
+    fps = float(asset_data.get("fps", 25))
+    rv.commands.setFPS(fps)
+
+
+def create_support_ticket():
+    import webbrowser
+    webbrowser.open("http://localhost:5400/tickets/create_tickets")

openpype/hosts/openrv/api/lib.py

@@ -0,0 +1,23 @@
+import contextlib
+
+
+@contextlib.contextmanager
+def maintained_selection():
+    return
+
+
+@contextlib.contextmanager
+def command_batch(name):
+    return
+
+
+def group_member_of_type(group_node, member_type):
+    """
+    usage layout_stack = group_member_of_type(sequence_layout, "RVStack")
+    :param group_node:
+    :param member_type:
+    :return:
+    """
+    for node in rv.commands.nodesInGroup(group_node):
+        if rv.commands.nodeType(node) == member_type:
+            return node

openpype/hosts/openrv/api/pipeline.py

@@ -0,0 +1,182 @@
+# -*- coding: utf-8 -*-
+import contextlib
+import os
+from collections import OrderedDict
+
+import pyblish
+import rv
+
+from openpype.host import HostBase, ILoadHost, IWorkfileHost
+from openpype.hosts.openrv import OPENRV_ROOT_DIR
+from openpype.pipeline import (
+    register_loader_plugin_path,
+    register_inventory_action_path,
+    register_creator_plugin_path,
+    AVALON_CONTAINER_ID,
+)
+from . import lib
+
+PLUGINS_DIR = os.path.join(OPENRV_ROOT_DIR, "plugins")
+PUBLISH_PATH = os.path.join(PLUGINS_DIR, "publish")
+LOAD_PATH = os.path.join(PLUGINS_DIR, "load")
+CREATE_PATH = os.path.join(PLUGINS_DIR, "create")
+INVENTORY_PATH = os.path.join(PLUGINS_DIR, "inventory")
+
+OPENPYPE_ATTR_PREFIX = "openpype"
+
+
+class OpenRVHost(HostBase, IWorkfileHost, ILoadHost):
+    name = "openrv"
+
+    def __init__(self):
+        super(OpenRVHost, self).__init__()
+        self._op_events = {}
+
+    def install(self):
+        pyblish.api.register_plugin_path(PUBLISH_PATH)
+        pyblish.api.register_host("openrv")
+
+        register_loader_plugin_path(LOAD_PATH)
+        register_creator_plugin_path(CREATE_PATH)
+        register_inventory_action_path(INVENTORY_PATH)
+
+    def open_workfile(self, filepath):
+        return rv.commands.addSources([filepath])
+
+    def save_workfile(self, filepath=None):
+        return rv.commands.saveSession(filepath)
+
+    def work_root(self, session):
+        work_dir = session.get("AVALON_WORKDIR")
+        scene_dir = session.get("AVALON_SCENEDIR")
+        if scene_dir:
+            return os.path.join(work_dir, scene_dir)
+        else:
+            return work_dir
+
+    def get_current_workfile(self):
+        return rv.commands.sessionFileName()
+
+    def workfile_has_unsaved_changes(self):
+        # dont ask to save if we are on the startup scene without a name
+        # set to untitled project and return False
+        print("filename", rv.commands.sessionFileName())
+        return False
+
+    def get_workfile_extensions(self):
+        return [".rv"]
+
+    def get_containers(self):
+        """Get containers.
+        """
+        all_items = gather_containers()
+        for rvnode in all_items:
+            parsed = parse_container(rvnode)
+            yield parsed
+
+    @contextlib.contextmanager
+    def maintained_selection(self):
+        with lib.maintained_selection():
+            yield
+
+
+def imprint(node, data):
+    """Store string attributes with value on a node
+
+    Args:
+        node (object): The node to imprint data on.
+        data (dict): Key value pairs of attributes to create.
+        group (str): The Group to add the attributes to.
+
+    Returns:
+        None
+
+    """
+    for attr, value in data.items():
+        # Create and set the attribute
+        prop = "{}.{}.{}".format(node, OPENPYPE_ATTR_PREFIX, attr)
+        if not rv.commands.propertyExists(prop):
+            rv.commands.newProperty(prop, rv.commands.StringType, 1)
+        rv.commands.setStringProperty(prop, [str(value)], True)
+
+    return
+
+
+def imprint_container(node, name, namespace, context, loader):
+    """Imprint `node` with container metadata.
+
+    Arguments:
+        node (object): The node to containerise.
+        name (str): Name of resulting assembly
+        namespace (str): Namespace under which to host container
+        context (dict): Asset information
+        loader (str): Name of loader used to produce this container.
+
+    Returns:
+        None
+
+    """
+
+    data = [
+        ("schema", "openpype:container-2.0"),
+        ("id", AVALON_CONTAINER_ID),
+        ("name", name),
+        ("namespace", namespace),
+        ("loader", loader),
+        ("representation", context["representation"]["_id"])
+    ]
+
+    # We use an OrderedDict to make sure the attributes
+    # are always created in the same order. This is solely
+    # to make debugging easier when reading the values in
+    # the attribute editor.
+    imprint(node, OrderedDict(data))
+
+
+def parse_container(node):
+    """Returns imprinted container data of a tool
+
+    This reads the imprinted data from `imprint_container`.
+
+    """
+    # If not all required data return None
+    required = ['id', 'schema', 'name',
+                'namespace', 'loader', 'representation']
+
+    data = {}
+    for key in required:
+        attr = node + "." + OPENPYPE_ATTR_PREFIX + "." + key
+        if not rv.commands.propertyExists(attr):
+            return
+
+        value = rv.commands.getStringProperty(attr)[0]
+        data[key] = value
+
+    # Store the node's name
+    data["objectName"] = str(node)
+
+    # Store reference to the node object
+    data["node"] = node
+
+    return data
+
+
+def gather_containers():
+    """gathers all rv nodes list
+    """
+    all_files = []
+    all_nodes = rv.commands.nodes()
+    for node in all_nodes:
+        prop = node + "." + OPENPYPE_ATTR_PREFIX + ".schema"
+        if rv.commands.propertyExists(prop):
+            all_files.append(node)
+    return set(all_files)
+
+
+def get_containers():
+    """Get containers.
+    """
+    all_items = gather_containers()
+    for rvnode in all_items:
+        parsed = parse_container(rvnode)
+        yield parsed

openpype/hosts/openrv/api/review.py

@@ -0,0 +1,47 @@
+"""review code"""
+import os
+
+import rv
+
+
+def get_path_annotated_frame(frame=None, asset=None, asset_folder=None):
+    """Get path for annotations
+    """
+    # TODO: This should be less hardcoded
+    filename = os.path.normpath(
+        "{}/pyblish/exports/annotated_frames/annotate_{}_{}.jpg".format(
+            str(asset_folder),
+            str(asset),
+            str(frame)
+        )
+    )
+    return filename
+
+
+def extract_annotated_frame(filepath=None):
+    """Export frame to file
+    """
+    if filepath:
+        return rv.commands.exportCurrentFrame(filepath)
+
+
+def review_attributes(node=None):
+    prop_status = node + ".openpype" + ".review_status"
+    prop_comment = node + ".openpype" + ".review_comment"
+
+
+def get_review_attribute(node=None, attribute=None):
+    attr = node + ".openpype" + "." + attribute
+    return rv.commands.getStringProperty(attr)[0]
+
+
+def write_review_attribute(node=None, attribute=None, att_value=None):
+    att_prop = node + ".openpype" + ".{}".format(attribute)
+    if not rv.commands.propertyExists(att_prop):
+        rv.commands.newProperty(att_prop, rv.commands.StringType, 1)
+    rv.commands.setStringProperty(att_prop, [str(att_value)], True)
+
+
+def export_current_view_frame(frame=None, export_path=None):
+    rv.commands.setFrame(int(frame))
+    rv.commands.exportCurrentFrame(export_path)