feat(nuke): validate legacy writes

pype/plugins/nuke/publish/collect_legacy_write.py

@@ -1,31 +0,0 @@
-import pyblish.api
-
-
-class CollectWriteLegacy(pyblish.api.InstancePlugin):
-    """Collect legacy write nodes."""
-
-    order = pyblish.api.CollectorOrder + 0.0101
-    label = "Collect Write node Legacy"
-    hosts = ["nuke", "nukeassist"]
-
-    def process(self, instance):
-        self.log.info(instance[:])
-        node = instance[0]
-
-        if node.Class() not in ["Group", "Write"]:
-            return
-
-        family_knobs = ["ak:family", "avalon:family"]
-        test = [k for k in node.knobs().keys() if k in family_knobs]
-        self.log.info(test)
-
-        if len(test) == 1:
-            if "render" in node[test[0]].value():
-                self.log.info("render")
-                return
-
-        if "render" in node.knobs():
-            instance.data.update(
-                {"family": "write.legacy",
-                 "families": []}
-            )

pype/plugins/nuke/publish/validate_write_legacy.py

@@ -6,81 +6,103 @@ import nuke
 from avalon import api
 import re
 import pyblish.api
+import pype.api
 from avalon.nuke import get_avalon_knob_data
 
-class RepairWriteLegacyAction(pyblish.api.Action):
-
-    label = "Repair"
-    icon = "wrench"
-    on = "failed"
-
-    def process(self, context, plugin):
-
-        # Get the errored instances
-        failed = []
-        for result in context.data["results"]:
-            if (result["error"] is not None and result["instance"] is not None
-               and result["instance"] not in failed):
-                failed.append(result["instance"])
-
-        # Apply pyblish.logic to get the instances for the plug-in
-        instances = pyblish.api.instances_by_plugin(failed, plugin)
-
-        for instance in instances:
-            if "Write" in instance[0].Class():
-                data = toml.loads(instance[0]["avalon"].value())
-            else:
-                data = get_avalon_knob_data(instance[0])
-
-            self.log.info(data)
-
-            data["xpos"] = instance[0].xpos()
-            data["ypos"] = instance[0].ypos()
-            data["input"] = instance[0].input(0)
-            data["publish"] = instance[0]["publish"].value()
-            data["render"] = instance[0]["render"].value()
-            data["render_farm"] = instance[0]["render_farm"].value()
-            data["review"] = instance[0]["review"].value()
-
-            # nuke.delete(instance[0])
-
-            task = os.environ["AVALON_TASK"]
-            sanitized_task = re.sub('[^0-9a-zA-Z]+', '', task)
-            subset_name = "render{}Main".format(
-                sanitized_task.capitalize())
-
-            Create_name = "CreateWriteRender"
-
-            creator_plugin = None
-            for Creator in api.discover(api.Creator):
-                if Creator.__name__ != Create_name:
-                    continue
-
-                creator_plugin = Creator
-
-            # return api.create()
-            creator_plugin(data["subset"], data["asset"]).process()
-
-            node = nuke.toNode(data["subset"])
-            node.setXYpos(data["xpos"], data["ypos"])
-            node.setInput(0, data["input"])
-            node["publish"].setValue(data["publish"])
-            node["render"].setValue(data["render"])
-            node["render_farm"].setValue(data["render_farm"])
-            node["review"].setValue(data["review"])
-
 
 class ValidateWriteLegacy(pyblish.api.InstancePlugin):
     """Validate legacy write nodes."""
 
     order = pyblish.api.ValidatorOrder
     optional = True
-    families = ["write.legacy"]
-    label = "Write Legacy"
+    families = ["write"]
+    label = "Validate Write Legacy"
     hosts = ["nuke"]
-    actions = [RepairWriteLegacyAction]
+    actions = [pype.api.RepairAction]
 
     def process(self, instance):
-
+        node = instance[0]
         msg = "Clean up legacy write node \"{}\"".format(instance)
-        assert False, msg
+
+        if node.Class() not in ["Group", "Write"]:
+            return
+
+        # test avalon knobs
+        family_knobs = ["ak:family", "avalon:family"]
+        family_test = [k for k in node.knobs().keys() if k in family_knobs]
+        self.log.debug("_ family_test: {}".format(family_test))
+
+        # test if render in family test knob
+        # and only one item should be available
+        if len(family_test) == 1:
+            assert "render" in node[family_test[0]].value(), msg
+        else:
+            assert False, msg
+
+        # test if `file` knob in node, this way old
+        # non-group-node write could be detected
+        if "file" in node.knobs():
+            assert False, msg
+
+        # check if write node is having old render targeting
+        if "render_farm" in node.knobs():
+            assert False, msg
+
+    @classmethod
+    def repair(cls, instance):
+        node = instance[0]
+
+        if "Write" in node.Class():
+            data = toml.loads(node["avalon"].value())
+        else:
+            data = get_avalon_knob_data(node)
+
+        # collect reusable data
+        data["XYpos"] = (node.xpos(), node.ypos())
+        data["input"] = node.input(0)
+        data["publish"] = node["publish"].value()
+        data["render"] = node["render"].value()
+        data["render_farm"] = node["render_farm"].value()
+        data["review"] = node["review"].value()
+        data["use_limit"] = node["use_limit"].value()
+        data["first"] = node["first"].value()
+        data["last"] = node["last"].value()
+
+        family = data["family"]
+        cls.log.debug("_ orig node family: {}".format(family))
+
+        # define what family of write node should be recreated
+        if family == "render":
+            Create_name = "CreateWriteRender"
+        elif family == "prerender":
+            Create_name = "CreateWritePrerender"
+
+        # get appropriate plugin class
+        creator_plugin = None
+        for Creator in api.discover(api.Creator):
+            if Creator.__name__ != Create_name:
+                continue
+
+            creator_plugin = Creator
+
+        # delete the legaci write node
+        # nuke.delete(node)
+
+        # create write node with creator
+        new_node_name = data["subset"] + "_1"
+        creator_plugin(new_node_name, data["asset"]).process()
+
+        node = nuke.toNode(new_node_name)
+        node.setXYpos(*data["XYpos"])
+        node.setInput(0, data["input"])
+        node["publish"].setValue(data["publish"])
+        node["review"].setValue(data["review"])
+        node["use_limit"].setValue(data["use_limit"])
+        node["first"].setValue(data["first"])
+        node["last"].setValue(data["last"])
+
+        # recreate render targets
+        if data["render"]:
+            node["render"].setValue("Local")
+            if data["render_farm"]:
+                node["render"].setValue("On farm")