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):

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/global/publish/integrate_new.py

@@ -301,6 +301,8 @@ def register(self, instance):
             sequence_repre = isinstance(files, list)
             repre_context = None
             if sequence_repre:
+                self.log.debug(
+                    "files: {}".format(files))
                 src_collections, remainder = clique.assemble(files)
                 self.log.debug(
                     "src_tail_collections: {}".format(str(src_collections)))
@@ -347,6 +349,7 @@ def register(self, instance):
                             anatomy.templates["render"].get("padding")
                         )
                     )
+
                     index_frame_start = int(repre.get("frameStart"))
 
                 # exception for slate workflow

pype/plugins/nukestudio/_unused/collect_timecodes.py

@@ -0,0 +1,90 @@
+import pyblish.api
+import opentimelineio.opentime as otio_ot
+
+
+class CollectClipTimecodes(pyblish.api.InstancePlugin):
+    """Collect time with OpenTimelineIO:
+        source_h(In,Out)[timecode, sec]
+        timeline(In,Out)[timecode, sec]
+    """
+
+    order = pyblish.api.CollectorOrder + 0.101
+    label = "Collect Timecodes"
+    hosts = ["nukestudio"]
+
+    def process(self, instance):
+
+        data = dict()
+        self.log.debug("__ instance.data: {}".format(instance.data))
+        # Timeline data.
+        handle_start = instance.data["handleStart"]
+        handle_end = instance.data["handleEnd"]
+
+        source_in_h = instance.data("sourceInH",
+                                    instance.data("sourceIn") - handle_start)
+        source_out_h = instance.data("sourceOutH",
+                                     instance.data("sourceOut") + handle_end)
+
+        timeline_in = instance.data["clipIn"]
+        timeline_out = instance.data["clipOut"]
+
+        # set frame start with tag or take it from timeline
+        frame_start = instance.data.get("startingFrame")
+
+        if not frame_start:
+            frame_start = timeline_in
+
+        source = instance.data.get("source")
+
+        otio_data = dict()
+        self.log.debug("__ source: `{}`".format(source))
+
+        rate_fps = instance.context.data["fps"]
+
+        otio_in_h_ratio = otio_ot.RationalTime(
+            value=(source.timecodeStart() + (
+                source_in_h + (source_out_h - source_in_h))),
+            rate=rate_fps)
+
+        otio_out_h_ratio = otio_ot.RationalTime(
+            value=(source.timecodeStart() + source_in_h),
+            rate=rate_fps)
+
+        otio_timeline_in_ratio = otio_ot.RationalTime(
+            value=int(
+                instance.data.get("timelineTimecodeStart", 0)) + timeline_in,
+            rate=rate_fps)
+
+        otio_timeline_out_ratio = otio_ot.RationalTime(
+            value=int(
+                instance.data.get("timelineTimecodeStart", 0)) + timeline_out,
+            rate=rate_fps)
+
+        otio_data.update({
+
+            "otioClipInHTimecode": otio_ot.to_timecode(otio_in_h_ratio),
+
+            "otioClipOutHTimecode": otio_ot.to_timecode(otio_out_h_ratio),
+
+            "otioClipInHSec": otio_ot.to_seconds(otio_in_h_ratio),
+
+            "otioClipOutHSec": otio_ot.to_seconds(otio_out_h_ratio),
+
+            "otioTimelineInTimecode": otio_ot.to_timecode(
+                otio_timeline_in_ratio),
+
+            "otioTimelineOutTimecode": otio_ot.to_timecode(
+                otio_timeline_out_ratio),
+
+            "otioTimelineInSec": otio_ot.to_seconds(otio_timeline_in_ratio),
+
+            "otioTimelineOutSec": otio_ot.to_seconds(otio_timeline_out_ratio)
+        })
+
+        data.update({
+            "otioData": otio_data,
+            "sourceTimecodeIn": otio_ot.to_timecode(otio_in_h_ratio),
+            "sourceTimecodeOut": otio_ot.to_timecode(otio_out_h_ratio)
+        })
+        instance.data.update(data)
+        self.log.debug("data: {}".format(instance.data))

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,42 @@ 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()
+                source_first_frame = int(file_info.startFrame())
                 is_sequence = False
 
+                self.log.debug(
+                    "__ assets_shared: {}".format(
+                        context.data["assetsShared"]))
+
+                # Check for clips with the same range
+                # this is for testing if any vertically neighbouring
+                # clips has been already processed
+                clip_matching_with_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)
+
+                # check if clip name is the same in matched
+                # vertically neighbouring clip
+                # if it is then it is correct and resent variable to False
+                # not to be rised wrong name exception
+                if asset in str(clip_matching_with_range):
+                    clip_matching_with_range = False
+
+                # rise wrong name exception if found one
+                assert (not clip_matching_with_range), (
+                    "matching clip: {asset}"
+                    " timeline range ({clip_in}:{clip_out})"
+                    " conflicting with {clip_matching_with_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 +120,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,15 @@ 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({
+            "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)