fix(nks): refactoring code to better shape

pype/plugins/nukestudio/publish/collect_effects.py

@@ -1,7 +1,7 @@
 import pyblish.api
-import hiero.core
 import re
 
+
 class CollectVideoTracksLuts(pyblish.api.InstancePlugin):
     """Collect video tracks effects into context."""
 
@@ -15,15 +15,57 @@ class CollectVideoTracksLuts(pyblish.api.InstancePlugin):
 
         # taking active sequence
         subset = instance.data["subset"]
-        sequence = instance.context.data['activeSequence']
+        track_effects = instance.context.data.get("trackEffects", {})
-        effects_on_tracks = instance.context.data.get("subTrackUsedTracks")
+        track_index = instance.data["trackIndex"]
-        sub_track_items = instance.context.data.get("subTrackItems")
+        effects = instance.data["effects"]
-        track = instance.data["track"]
 
+        # creating context attribute
+        self.effects = {"assignTo": subset, "effects": dict()}
+
+        for sitem in effects:
+            self.add_effect(instance, track_index, sitem)
+
+        for t_index, sitems in track_effects.items():
+            for sitem in sitems:
+                if not t_index > track_index:
+                    continue
+                self.log.debug(">> sitem: `{}`".format(sitem))
+                self.add_effect(instance, t_index, sitem)
+
+        instance.data["effectTrackItems"] = self.effects
+
+        if len(instance.data.get("effectTrackItems", {}).keys()) > 0:
+            instance.data["families"] += ["lut"]
+            self.log.debug("effects.keys: {}".format(instance.data.get("effectTrackItems", {}).keys()))
+            self.log.debug("effects: {}".format(instance.data.get("effectTrackItems", {})))
+
+    def add_effect(self, instance, track_index, item):
+        track = item.parentTrack().name()
+        # node serialization
+        node = item.node()
+        node_serialized = self.node_serialisation(instance, node)
+
+        # collect timelineIn/Out
+        effect_t_in = int(item.timelineIn())
+        effect_t_out = int(item.timelineOut())
+
+        node_name = item.name()
+        node_class = re.sub(r"\d+", "", node_name)
+
+        self.effects["effects"].update({node_name: {
+            "class": node_class,
+            "timelineIn": effect_t_in,
+            "timelineOut": effect_t_out,
+            "subTrackIndex": item.subTrackIndex(),
+            "trackIndex": track_index,
+            "track": track,
+            "node": node_serialized
+        }})
+
+    def node_serialisation(self, instance, node):
+        node_serialized = {}
         timeline_in_h = instance.data["clipInH"]
         timeline_out_h = instance.data["clipOutH"]
-        timeline_in = instance.data["clipIn"]
-        timeline_out = instance.data["clipOut"]
 
         # adding ignoring knob keys
         _ignoring_keys = ['invert_mask', 'help', 'mask',
@@ -33,81 +75,21 @@ class CollectVideoTracksLuts(pyblish.api.InstancePlugin):
                           'postage_stamp_frame', 'maskChannel', 'export_cc',
                           'select_cccid', 'mix', 'version']
 
-        # creating context attribute
+        # loop trough all knobs and collect not ignored
-        effects = {"assignTo": subset, "effects": dict()}
+        # and any with any value
-
+        for knob in node.knobs().keys():
-        for subtrack_item in sub_track_items:
+            # skip nodes in ignore keys
-            sub_track = subtrack_item.parentTrack().name()
+            if knob in _ignoring_keys:
-
-            # ignore anything not EffectTrackItem
-            if not isinstance(subtrack_item, hiero.core.EffectTrackItem):
-                continue
-            et_item = subtrack_item
-
-            # ignore item if not enabled
-            if not et_item.isEnabled():
                 continue
 
-            node = et_item.node()
+            # get animation if node is animated
-            node_serialized = {}
+            if node[knob].isAnimated():
-            # loop trough all knobs and collect not ignored
+                # grab animation including handles
-            # and any with any value
+                knob_anim = [node[knob].getValueAt(i)
-            for knob in node.knobs().keys():
+                             for i in range(timeline_in_h, timeline_out_h + 1)]
-                # skip nodes in ignore keys
-                if knob in _ignoring_keys:
-                    continue
 
-                # get animation if node is animated
+                node_serialized[knob] = knob_anim
-                if node[knob].isAnimated():
+            else:
-                    # grab animation including handles
+                node_serialized[knob] = node[knob].value()
-                    knob_anim = [node[knob].getValueAt(i)
-                                 for i in range(timeline_in_h, timeline_out_h + 1)]
 
-                    node_serialized[knob] = knob_anim
+        return node_serialized
-                else:
-                    node_serialized[knob] = node[knob].value()
-
-            # pick track index from subTrackItem
-            pick_sub_track = [indx for indx, vt
-                              in enumerate(sequence.videoTracks())
-                              if vt.name() in sub_track]
-            # pick track index from trackItem
-            pick_track = [indx for indx, vt in enumerate(sequence.videoTracks())
-                          if vt.name() in track]
-            # collect timelineIn/Out
-            effect_t_in = int(et_item.timelineIn())
-            effect_t_out = int(et_item.timelineOut())
-
-            # controle if parent track has video trackItems
-            items_check = et_item.parent().items()
-
-            node_name = et_item.name()
-            node_class = re.sub(r"\d+", "", node_name)
-            # filter out all track items under any track with effects
-            # also filter out track item bellow
-            if (pick_track[0] in effects_on_tracks) and (pick_sub_track[0] >= pick_track[0]):
-                if (effect_t_in == timeline_in) and (effect_t_out == timeline_out):
-                    effects["effects"].update({node_name: {
-                        "class": node_class,
-                        "timelineIn": effect_t_in,
-                        "timelineOut": effect_t_out,
-                        "subTrackIndex": et_item.subTrackIndex(),
-                        "trackIndex": pick_track[0],
-                        "node": node_serialized
-                    }})
-                # for subTrackItem on track without any trackItems
-                elif len(items_check) == 0:
-                    effects["effects"].update({node_name: {
-                        "class": node_class,
-                        "timelineIn": effect_t_in,
-                        "timelineOut": effect_t_out,
-                        "subTrackIndex": et_item.subTrackIndex(),
-                        "trackIndex": pick_track[0],
-                        "node": node_serialized
-                    }})
-
-        instance.data["effectTrackItems"] = effects
-        if len(instance.data.get("effectTrackItems", {}).keys()) > 0:
-            instance.data["families"] += ["lut"]
-            self.log.debug("effects.keys: {}".format(instance.data.get("effectTrackItems", {}).keys()))
-            self.log.debug("effects: {}".format(instance.data.get("effectTrackItems", {})))