nks cut reference videos

pype/plugins/global/publish/extract_burnin.py

@@ -18,7 +18,7 @@ class ExtractBurnin(pype.api.Extractor):
     label = "Extract burnins"
     order = pyblish.api.ExtractorOrder + 0.03
     families = ["review", "burnin"]
-    hosts = ["nuke", "maya", "shell", "premiere"]
+    hosts = ["nuke", "maya", "shell", "nukestudio", "premiere"]
     optional = True
 
     def process(self, instance):
@@ -193,7 +193,7 @@ def process(self, instance):
             self.log.debug("Output: {}".format(output))
 
             repre_update = {
-                "anatomy_template": "render",
+                "anatomy_template": repre.get("anatomy_template", "render"),
                 "files": movieFileBurnin,
                 "name": repre["name"],
                 "tags": [x for x in repre["tags"] if x != "delete"]

pype/plugins/global/publish/extract_review.py

@@ -20,15 +20,15 @@ class ExtractReview(pyblish.api.InstancePlugin):
     label = "Extract Review"
     order = pyblish.api.ExtractorOrder + 0.02
     families = ["review"]
-    hosts = ["nuke", "maya", "shell", "premiere"]
+    hosts = ["nuke", "maya", "shell", "nukestudio", "premiere"]
 
     outputs = {}
     ext_filter = []
     to_width = 1920
     to_height = 1080
 
-    def process(self, instance):
 
+    def process(self, instance):
         output_profiles = self.outputs or {}
 
         inst_data = instance.data
@@ -82,6 +82,12 @@ def process(self, instance):
                 repre_new = repre.copy()
                 ext = profile.get("ext", None)
                 p_tags = profile.get('tags', [])
+
+                # append repre tags into profile tags
+                for t in tags:
+                    if t not in p_tags:
+                        p_tags.append(t)
+
                 self.log.info("p_tags: `{}`".format(p_tags))
 
                 # adding control for presets to be sequence
@@ -175,7 +181,8 @@ def process(self, instance):
                 frame_start_handle = frame_start - handle_start
                 frame_end_handle = frame_end + handle_end
                 if isinstance(repre["files"], list):
-                    if frame_start_handle != repre.get("detectedStart", frame_start_handle):
+                    if frame_start_handle != repre.get(
+                            "detectedStart", frame_start_handle):
                         frame_start_handle = repre.get("detectedStart")
 
                     # exclude handle if no handles defined

pype/plugins/nukestudio/publish/collect_clip_resolution.py

@@ -0,0 +1,21 @@
+import pyblish.api
+
+
+class CollectClipResolution(pyblish.api.InstancePlugin):
+    """Collect clip geometry resolution"""
+
+    order = pyblish.api.CollectorOrder + 0.101
+    label = "Collect Clip Resoluton"
+    hosts = ["nukestudio"]
+
+    def process(self, instance):
+        sequence = instance.context.data['activeSequence']
+        resolution_width = int(sequence.format().width())
+        resolution_height = int(sequence.format().height())
+        pixel_aspect = sequence.format().pixelAspect()
+
+        instance.data.update({
+            "resolutionWidth": resolution_width,
+            "resolutionHeight": resolution_height,
+            "pixelAspect": pixel_aspect
+        })

pype/plugins/nukestudio/publish/collect_clips.py

@@ -47,11 +47,32 @@ def process(self, context):
                 track = item.parent()
                 source = item.source().mediaSource()
                 source_path = source.firstpath()
+                clip_in = int(item.timelineIn())
+                clip_out = int(item.timelineOut())
                 file_head = source.filenameHead()
                 file_info = next((f for f in source.fileinfos()), None)
                 source_first_frame = file_info.startFrame()
                 is_sequence = False
 
+                self.log.debug(
+                    "__ assets_shared: {}".format(context.data["assetsShared"]))
+                match_range = next(
+                    (k for k, v in context.data["assetsShared"].items()
+                     if (v.get("_clipIn", 0) == clip_in)
+                     and (v.get("_clipOut", 0) == clip_out)
+                     ), False)
+
+                if asset in str(match_range):
+                    match_range = False
+
+                assert (not match_range), (
+                    "matching clip: {asset}"
+                    " timeline range ({clip_in}:{clip_out})"
+                    " conflicting with {match_range}"
+                    " >> rename any of clips to be the same as the other <<"
+                ).format(
+                    **locals())
+
                 if not source.singleFile():
                     self.log.info("Single file")
                     is_sequence = True
@@ -89,40 +110,42 @@ def process(self, context):
                     )
 
                 data.update({
-                        "name": "{0}_{1}".format(track.name(), item.name()),
-                        "item": item,
-                        "source": source,
-                        "timecodeStart": str(source.timecodeStart()),
-                        "timelineTimecodeStart": str(sequence.timecodeStart()),
-                        "sourcePath": source_path,
-                        "sourceFileHead": file_head,
-                        "isSequence": is_sequence,
-                        "track": track.name(),
-                        "trackIndex": track_index,
-                        "sourceFirst": source_first_frame,
-                        "effects": effects,
-                        "sourceIn": int(item.sourceIn()),
-                        "sourceOut": int(item.sourceOut()),
-                        "mediaDuration": (int(item.sourceOut()) -
-                            int(item.sourceIn())) + 1,
-                        "clipIn": int(item.timelineIn()),
-                        "clipOut": int(item.timelineOut()),
-                        "clipDuration": (
-                            int(item.timelineOut()) - int(
-                                item.timelineIn())) + 1,
-                        "asset": asset,
-                        "family": "clip",
-                        "families": [],
-                        "handleStart": projectdata.get("handleStart", 0),
-                        "handleEnd": projectdata.get("handleEnd", 0)})
+                    "name": "{0}_{1}".format(track.name(), item.name()),
+                    "item": item,
+                    "source": source,
+                    "timecodeStart": str(source.timecodeStart()),
+                    "timelineTimecodeStart": str(sequence.timecodeStart()),
+                    "sourcePath": source_path,
+                    "sourceFileHead": file_head,
+                    "isSequence": is_sequence,
+                    "track": track.name(),
+                    "trackIndex": track_index,
+                    "sourceFirst": source_first_frame,
+                    "effects": effects,
+                    "sourceIn": int(item.sourceIn()),
+                    "sourceOut": int(item.sourceOut()),
+                    "mediaDuration": int(source.duration()),
+                    "clipIn": clip_in,
+                    "clipOut": clip_out,
+                    "clipDuration": (
+                        int(item.timelineOut()) - int(
+                            item.timelineIn())) + 1,
+                    "asset": asset,
+                    "family": "clip",
+                    "families": [],
+                    "handleStart": projectdata.get("handleStart", 0),
+                    "handleEnd": projectdata.get("handleEnd", 0)})
 
                 instance = context.create_instance(**data)
 
                 self.log.info("Created instance: {}".format(instance))
                 self.log.info("Created instance.data: {}".format(instance.data))
                 self.log.debug(">> effects: {}".format(instance.data["effects"]))
 
-                context.data["assetsShared"][asset] = dict()
+                context.data["assetsShared"][asset] = {
+                    "_clipIn": clip_in,
+                    "_clipOut": clip_out
+                }
 
             # from now we are collecting only subtrackitems on
             # track with no video items

pype/plugins/nukestudio/publish/collect_frame_ranges.py

@@ -35,14 +35,16 @@ def process(self, instance):
 
         frame_end = frame_start + (timeline_out - timeline_in)
 
-        data.update(
-            {
-                "sourceInH": source_in_h,
-                "sourceOutH": source_out_h,
-                "frameStart": frame_start,
-                "frameEnd": frame_end,
-                "clipInH": timeline_in_h,
-                "clipOutH": timeline_out_h
+        data.update({
+            "sourceFirst": source_in_h,
+            "sourceInH": source_in_h,
+            "sourceOutH": source_out_h,
+            "frameStart": frame_start,
+            "frameEnd": frame_end,
+            "clipInH": timeline_in_h,
+            "clipOutH": timeline_out_h,
+            "clipDurationH": instance.data.get(
+                "clipDuration") + handle_start + handle_end
             }
         )
         self.log.debug("__ data: {}".format(data))

pype/plugins/nukestudio/publish/collect_framerate.py

@@ -1,5 +1,6 @@
 from pyblish import api
 
+
 class CollectFramerate(api.ContextPlugin):
     """Collect framerate from selected sequence."""
 
@@ -9,4 +10,13 @@ class CollectFramerate(api.ContextPlugin):
 
     def process(self, context):
         sequence = context.data["activeSequence"]
-        context.data["fps"] = sequence.framerate().toFloat()
+        context.data["fps"] = self.get_rate(sequence)
+
+    def get_rate(self, sequence):
+        num, den = sequence.framerate().toRational()
+        rate = float(num) / float(den)
+
+        if rate.is_integer():
+            return rate
+
+        return round(rate, 3)

pype/plugins/nukestudio/publish/collect_hierarchy_context.py

@@ -37,11 +37,13 @@ def process(self, context):
             assets_shared = context.data.get("assetsShared")
             tags = instance.data.get("tags", None)
             clip = instance.data["item"]
-            asset = instance.data.get("asset")
+            asset = instance.data["asset"]
             sequence = context.data['activeSequence']
-            width = int(sequence.format().width())
-            height = int(sequence.format().height())
-            pixel_aspect = sequence.format().pixelAspect()
+            resolution_width = instance.data["resolutionWidth"]
+            resolution_height = instance.data["resolutionHeight"]
+            pixel_aspect = instance.data["pixelAspect"]
+            clip_in = instance.data["clipIn"]
+            clip_out = instance.data["clipOut"]
             fps = context.data["fps"]
 
             # build data for inner nukestudio project property
@@ -72,6 +74,24 @@ def process(self, context):
 
                 # and finding only hierarchical tag
                 if "hierarchy" in t_type.lower():
+                    match = next(
+                        (k for k, v in assets_shared.items()
+                         if (v["_clipIn"] == clip_in)
+                         and (v["_clipOut"] == clip_out)
+                         ), False)
+                    self.log.warning("Clip matching name: {}".format(match))
+                    self.log.debug(
+                        "__ assets_shared[match]: {}".format(
+                            assets_shared[match]))
+                    # check if hierarchy key is in match
+                    if not assets_shared[match].get("hierarchy"):
+                        match = False
+                    assert not match, (
+                        "Two clips above each other with"
+                        " hierarchy tag are not allowed"
+                        " >> keep hierarchy tag only in one of them <<"
+                    )
+
                     d_metadata = dict()
                     parents = list()
 
@@ -82,7 +102,8 @@ def process(self, context):
                     if "shot" in template.lower():
                         instance.data["asset"] = [
                             t for t in template.split('/')][-1]
-                        template = "/".join([t for t in template.split('/')][0:-1])
+                        template = "/".join(
+                            [t for t in template.split('/')][0:-1])
 
                     # take template from Tag.note and break it into parts
                     template_split = template.split("/")
@@ -149,8 +170,12 @@ def process(self, context):
                     instance.data["hierarchy"] = hierarchy
                     instance.data["parents"] = parents
 
+                    self.log.info(
+                        "clip: {asset}[{clip_in}:{clip_out}]".format(
+                            **locals()))
                     # adding to asset shared dict
-                    self.log.debug("__ assets_shared: {}".format(assets_shared))
+                    self.log.debug(
+                        "__ assets_shared: {}".format(assets_shared))
                     if assets_shared.get(asset):
                         self.log.debug("Adding to shared assets: `{}`".format(
                             asset))
@@ -162,11 +187,11 @@ def process(self, context):
                         "asset": asset,
                         "hierarchy": hierarchy,
                         "parents": parents,
-                        "resolutionWidth": width,
-                        "resolutionHeight": height,
+                        "resolutionWidth": resolution_width,
+                        "resolutionHeight": resolution_height,
                         "pixelAspect": pixel_aspect,
                         "fps": fps,
-                        "tasks":  instance.data["tasks"]
+                        "tasks": instance.data["tasks"]
                     })
 
                     # adding frame start if any on instance
@@ -175,8 +200,8 @@ def process(self, context):
                         asset_shared.update({
                             "startingFrame": start_frame
                         })
-
-
+                    self.log.debug(
+                        "assets_shared: {assets_shared}".format(**locals()))
 
 class CollectHierarchyContext(pyblish.api.ContextPlugin):
     '''Collecting Hierarchy from instaces and building

pype/plugins/nukestudio/publish/collect_plates.py

@@ -64,15 +64,15 @@ def process(self, instance):
         # adding SourceResolution if Tag was present
         if instance.data.get("sourceResolution") and instance.data.get("main"):
             item = instance.data["item"]
-            width = int(item.source().mediaSource().width())
-            height = int(item.source().mediaSource().height())
+            resolution_width = int(item.source().mediaSource().width())
+            resolution_height = int(item.source().mediaSource().height())
             pixel_aspect = int(item.source().mediaSource().pixelAspect())
 
             self.log.info("Source Width and Height are: `{0} x {1} : {2}`".format(
-                width, height, pixel_aspect))
+                resolution_width, resolution_height, pixel_aspect))
             data.update({
-                "width": width,
-                "height": height,
+                "resolutionWidth": resolution_width,
+                "resolutionHeight": resolution_height,
                 "pixelAspect": pixel_aspect
             })
 
@@ -185,8 +185,7 @@ def process(self, instance):
                 "frameEnd": instance.data["sourceOut"] - instance.data["sourceIn"] + 1,
                 'step': 1,
                 'fps': instance.context.data["fps"],
-                'preview': True,
-                'thumbnail': False,
+                'tags': ["preview"],
                 'name': "preview",
                 'ext': "mov",
             }