hiero: loading sequence wip

pype/hosts/resolve/__init__.py

@@ -20,6 +20,7 @@ from .lib import (
     get_current_sequence,
     get_video_track_names,
     get_current_track_items,
+    get_track_item_by_name,
     get_track_item_pype_tag,
     set_track_item_pype_tag,
     imprint,
@@ -37,6 +38,7 @@ from .lib import (
 from .menu import launch_pype_menu
 
 from .plugin import (
+    SequenceLoader,
     Creator,
     PublishClip
 )
@@ -75,6 +77,7 @@ __all__ = [
     "get_current_sequence",
     "get_video_track_names",
     "get_current_track_items",
+    "get_track_item_by_name",
     "get_track_item_pype_tag",
     "set_track_item_pype_tag",
     "imprint",
@@ -92,6 +95,7 @@ __all__ = [
     "launch_pype_menu",
 
     # plugin
+    "SequenceLoader",
     "Creator",
     "PublishClip",
 

pype/hosts/resolve/lib.py

@@ -115,6 +115,18 @@ def get_current_track_items(
     return selected_clips
 
 
+def get_track_item_by_name(name: str) -> object:
+    track_itmes = get_current_track_items()
+    for _ti in track_itmes:
+        tag_data = get_track_item_pype_tag(_ti["clip"]["item"])
+        tag_name = tag_data.get("name")
+        if not tag_name:
+            continue
+        if tag_data.get("name") in name:
+            return _ti
+    return None
+
+
 def get_track_item_pype_tag(track_item):
     """
     Get pype track item tag created by creator or loader plugin.

pype/plugins/resolve/load/load_sequence.py

@@ -0,0 +1,153 @@
+from avalon import io, api
+from pype.hosts import resolve
+
+
+class LoadClip(resolve.SequenceLoader):
+    """Load a subset to timeline as clip
+
+    Place clip to timeline on its asset origin timings collected
+    during conforming to project
+    """
+
+    families = ["render2d", "source", "plate", "render", "review"]
+    representations = ["exr", "dpx", "jpg", "jpeg", "png", "h264"]
+
+    label = "Load as clip"
+    order = -10
+    icon = "code-fork"
+    color = "orange"
+
+    # for loader multiselection
+    sequence = None
+    track = None
+
+    # presets
+    clip_color_last = "green"
+    clip_color = "red"
+
+    def load(self, context, name, namespace, options):
+
+        # in case loader uses multiselection
+        if self.track and self.sequence:
+            options.update({
+                "sequence": self.sequence,
+                "track": self.track
+            })
+
+        # load clip to timeline and get main variables
+        track_item = phiero.ClipLoader(self, context, **options).load()
+        namespace = namespace or track_item.name()
+        version = context['version']
+        version_data = version.get("data", {})
+        version_name = version.get("name", None)
+        colorspace = version_data.get("colorspace", None)
+        object_name = "{}_{}".format(name, namespace)
+
+        # add additional metadata from the version to imprint Avalon knob
+        add_keys = [
+            "frameStart", "frameEnd", "source", "author",
+            "fps", "handleStart", "handleEnd"
+        ]
+
+        # move all version data keys to tag data
+        data_imprint = {}
+        for key in add_keys:
+            data_imprint.update({
+                key: version_data.get(key, str(None))
+            })
+
+        # add variables related to version context
+        data_imprint.update({
+            "version": version_name,
+            "colorspace": colorspace,
+            "objectName": object_name
+        })
+
+        # update color of clip regarding the version order
+        self.set_item_color(track_item, version)
+
+        # deal with multiselection
+        self.multiselection(track_item)
+
+        self.log.info("Loader done: `{}`".format(name))
+
+        return resolve.containerise(
+            track_item,
+            name, namespace, context,
+            self.__class__.__name__,
+            data_imprint)
+
+    def switch(self, container, representation):
+        self.update(container, representation)
+
+    def update(self, container, representation):
+        """ Updating previously loaded clips
+        """
+
+        # load clip to timeline and get main variables
+        name = container['name']
+        namespace = container['namespace']
+        track_item = resolve.get_track_item_by_name(namespace)
+        version = io.find_one({
+            "type": "version",
+            "_id": representation["parent"]
+        })
+        version_data = version.get("data", {})
+        version_name = version.get("name", None)
+        colorspace = version_data.get("colorspace", None)
+        object_name = "{}_{}".format(name, namespace)
+        file = api.get_representation_path(representation).replace("\\", "/")
+
+        # reconnect media to new path
+        track_item.source().reconnectMedia(file)
+
+        # add additional metadata from the version to imprint Avalon knob
+        add_keys = [
+            "frameStart", "frameEnd", "source", "author",
+            "fps", "handleStart", "handleEnd"
+        ]
+
+        # move all version data keys to tag data
+        data_imprint = {}
+        for key in add_keys:
+            data_imprint.update({
+                key: version_data.get(key, str(None))
+            })
+
+        # add variables related to version context
+        data_imprint.update({
+            "representation": str(representation["_id"]),
+            "version": version_name,
+            "colorspace": colorspace,
+            "objectName": object_name
+        })
+
+        # update color of clip regarding the version order
+        self.set_item_color(track_item, version)
+
+        return resolve.update_container(track_item, data_imprint)
+
+    @classmethod
+    def multiselection(cls, track_item):
+        if not cls.track:
+            cls.track = track_item.parent()
+            cls.sequence = cls.track.parent()
+
+    @classmethod
+    def set_item_color(cls, track_item, version):
+
+        # define version name
+        version_name = version.get("name", None)
+        # get all versions in list
+        versions = io.find({
+            "type": "version",
+            "parent": version["parent"]
+        }).distinct('name')
+
+        max_version = max(versions)
+
+        # set clip colour
+        if version_name == max_version:
+            track_item.source().binItem().setColor(cls.clip_color_last)
+        else:
+            track_item.source().binItem().setColor(cls.clip_color)