From 444071e2d05f36dcc467cc76b7cad4172017e3a4 Mon Sep 17 00:00:00 2001
From: Jakub Jezek <jakub@pype.club>
Date: Thu, 21 Nov 2019 10:22:54 +0100
Subject: [PATCH 01/14] fix(nuke): not necessary to do it on all write nodes

---
 pype/nuke/lib.py | 4 ++++
 1 file changed, 4 insertions(+)

diff --git a/pype/nuke/lib.py b/pype/nuke/lib.py
index 157af9019d..0079a23266 100644
--- a/pype/nuke/lib.py
+++ b/pype/nuke/lib.py
@@ -105,6 +105,10 @@ def writes_version_sync():
 
     for each in nuke.allNodes():
         if each.Class() == 'Write':
+            # check if the node is avalon tracked
+            if "AvalonTab" not in each.knobs():
+                continue
+                
             avalon_knob_data = avalon.nuke.get_avalon_knob_data(
                 each, ['avalon:', 'ak:'])
 

From 74b1be0da35fc160094eda38600ca9e5f1ae6b50 Mon Sep 17 00:00:00 2001
From: Jakub Jezek <jakub@pype.club>
Date: Thu, 21 Nov 2019 13:17:48 +0100
Subject: [PATCH 02/14] fix(nuke): code is redundant

---
 pype/plugins/nuke/create/create_write.py | 2 --
 1 file changed, 2 deletions(-)

diff --git a/pype/plugins/nuke/create/create_write.py b/pype/plugins/nuke/create/create_write.py
index a8c9c932da..c885631794 100644
--- a/pype/plugins/nuke/create/create_write.py
+++ b/pype/plugins/nuke/create/create_write.py
@@ -24,8 +24,6 @@ class CreateWriteRender(plugin.PypeCreator):
     def __init__(self, *args, **kwargs):
         super(CreateWriteRender, self).__init__(*args, **kwargs)
 
-        self.name = self.data["subset"]
-
         data = OrderedDict()
 
         data["family"] = self.family

From 3fbe8b6f455009177dc38d141fa11240e1708a16 Mon Sep 17 00:00:00 2001
From: Jakub Jezek <jakub@pype.club>
Date: Thu, 21 Nov 2019 18:09:22 +0100
Subject: [PATCH 03/14] feat(nuke):  update head info in create backdrop

---
 pype/plugins/nuke/create/create_backdrop.py | 9 ++++-----
 1 file changed, 4 insertions(+), 5 deletions(-)

diff --git a/pype/plugins/nuke/create/create_backdrop.py b/pype/plugins/nuke/create/create_backdrop.py
index b5600e8b37..237f9ac8f0 100644
--- a/pype/plugins/nuke/create/create_backdrop.py
+++ b/pype/plugins/nuke/create/create_backdrop.py
@@ -4,13 +4,12 @@ from avalon.nuke.pipeline import Creator
 class CreateBackdrop(Creator):
     """Add Publishable Backdrop"""
 
-    name = "backdrop"
-    label = "Backdrop"
-    family = "group"
-    icon = "cube"
+    name = "nukenodes"
+    label = "Create Backdrop"
+    family = "nukenodes"
+    icon = "file-archive-o"
     defaults = ["Main"]
 
     def __init__(self, *args, **kwargs):
         super(CreateBackdrop, self).__init__(*args, **kwargs)
-
         return

From df41c92f44cf6b5f434c9d8fb7c0378f4b43d4ae Mon Sep 17 00:00:00 2001
From: Jakub Jezek <jakub@pype.club>
Date: Thu, 21 Nov 2019 19:06:00 +0100
Subject: [PATCH 04/14] feat(nuke): include only nodes with subset knob

---
 pype/plugins/nuke/publish/collect_instances.py | 14 ++++++--------
 1 file changed, 6 insertions(+), 8 deletions(-)

diff --git a/pype/plugins/nuke/publish/collect_instances.py b/pype/plugins/nuke/publish/collect_instances.py
index 2500f3fca5..f83f4f5e9a 100644
--- a/pype/plugins/nuke/publish/collect_instances.py
+++ b/pype/plugins/nuke/publish/collect_instances.py
@@ -23,15 +23,13 @@ class CollectNukeInstances(pyblish.api.ContextPlugin):
         instances = []
         # creating instances per write node
 
-        self.log.debug("nuke.allNodes(): {}".format(nuke.allNodes()))
-        for node in nuke.allNodes():
-            try:
-                if node["disable"].value():
-                    continue
-            except Exception as E:
-                self.log.warning(E)
-                continue
+        # gets only nodes with subset knob
+        nodes = [n for n in nuke.allNodes()
+                 if get_avalon_knob_data(n,
+                 ["avalon:", "ak:"]).get("subset")]
 
+        # creating instances per write node
+        for node in nodes:
             # get data from avalon knob
             self.log.debug("node[name]: {}".format(node['name'].value()))
             avalon_knob_data = get_avalon_knob_data(node)

From 2bf235ece19f98bcbe8b932946cc6ea58f91214b Mon Sep 17 00:00:00 2001
From: Jakub Jezek <jakub@pype.club>
Date: Thu, 21 Nov 2019 19:07:04 +0100
Subject: [PATCH 05/14] clean(nuke): remove unused lines

---
 pype/plugins/nuke/publish/collect_instances.py | 2 --
 1 file changed, 2 deletions(-)

diff --git a/pype/plugins/nuke/publish/collect_instances.py b/pype/plugins/nuke/publish/collect_instances.py
index f83f4f5e9a..c901d2c161 100644
--- a/pype/plugins/nuke/publish/collect_instances.py
+++ b/pype/plugins/nuke/publish/collect_instances.py
@@ -18,10 +18,8 @@ class CollectNukeInstances(pyblish.api.ContextPlugin):
         asset_data = io.find_one({"type": "asset",
                                   "name": api.Session["AVALON_ASSET"]})
 
-
         self.log.debug("asset_data: {}".format(asset_data["data"]))
         instances = []
-        # creating instances per write node
 
         # gets only nodes with subset knob
         nodes = [n for n in nuke.allNodes()

From a87d7cf054a088df41d907e5ce8462802d3a0b74 Mon Sep 17 00:00:00 2001
From: Jakub Jezek <jakub@pype.club>
Date: Thu, 21 Nov 2019 19:08:34 +0100
Subject: [PATCH 06/14] feat(nuke): fixing family/class detection

- render families only for render group node
- any group will be accepted too
- disable nodes are not included
---
 .../plugins/nuke/publish/collect_instances.py | 40 ++++++++++++-------
 1 file changed, 25 insertions(+), 15 deletions(-)

diff --git a/pype/plugins/nuke/publish/collect_instances.py b/pype/plugins/nuke/publish/collect_instances.py
index c901d2c161..ea8c885d9a 100644
--- a/pype/plugins/nuke/publish/collect_instances.py
+++ b/pype/plugins/nuke/publish/collect_instances.py
@@ -40,6 +40,14 @@ class CollectNukeInstances(pyblish.api.ContextPlugin):
             if avalon_knob_data["id"] != "pyblish.avalon.instance":
                 continue
 
+            # establish families
+            family = avalon_knob_data["family"]
+            families = list()
+
+            # except disabled nodes but exclude backdrops in test
+            if ("nukenodes" not in family) and (node["disable"].value()):
+                continue
+
             subset = avalon_knob_data.get(
                 "subset", None) or node["name"].value()
 
@@ -49,26 +57,28 @@ class CollectNukeInstances(pyblish.api.ContextPlugin):
 
             # Add all nodes in group instances.
             if node.Class() == "Group":
+                # only alter families for render family
+                if ("render" in family):
+                    # check if node is not disabled
+                    families.append(avalon_knob_data["families"])
+                    if node["render"].value():
+                        self.log.info("flagged for render")
+                        add_family = "render.local"
+                        # dealing with local/farm rendering
+                        if node["render_farm"].value():
+                            self.log.info("adding render farm family")
+                            add_family = "render.farm"
+                            instance.data["transfer"] = False
+                        families.append(add_family)
+                    else:
+                        # add family into families
+                        families.insert(0, family)
+
                 node.begin()
                 for i in nuke.allNodes():
                     instance.append(i)
                 node.end()
 
-            family = avalon_knob_data["family"]
-            families = [avalon_knob_data["families"]]
-            if node["render"].value():
-                self.log.info("flagged for render")
-                add_family = "render.local"
-                # dealing with local/farm rendering
-                if node["render_farm"].value():
-                    self.log.info("adding render farm family")
-                    add_family = "render.farm"
-                    instance.data["transfer"] = False
-                families.append(add_family)
-            else:
-                # add family into families
-                families.insert(0, family)
-
             instance.data.update({
                 "subset": subset,
                 "asset": os.environ["AVALON_ASSET"],

From c4292d3add70c3ea1353a78afea4ca82b6e4e925 Mon Sep 17 00:00:00 2001
From: Jakub Jezek <jakub@pype.club>
Date: Thu, 21 Nov 2019 19:56:12 +0100
Subject: [PATCH 07/14] feat(nuke):  adding collect backdrop plugin

---
 .../plugins/nuke/publish/collect_nukenodes.py | 34 +++++++++++++++++++
 1 file changed, 34 insertions(+)
 create mode 100644 pype/plugins/nuke/publish/collect_nukenodes.py

diff --git a/pype/plugins/nuke/publish/collect_nukenodes.py b/pype/plugins/nuke/publish/collect_nukenodes.py
new file mode 100644
index 0000000000..ba5a28c44a
--- /dev/null
+++ b/pype/plugins/nuke/publish/collect_nukenodes.py
@@ -0,0 +1,34 @@
+import pyblish.api
+import nuke
+
+class CollectBackdrops(pyblish.api.InstancePlugin):
+    """Collect Backdrop instance from rendered frames
+    """
+
+    order = pyblish.api.CollectorOrder + 0.3
+    label = "Collect Backdrop"
+    hosts = ["nuke"]
+    families = ["nukenodes"]
+
+    def process(self, instance):
+
+        bckn = instance[0]
+
+        left = bckn.xpos()
+        top = bckn.ypos()
+        right = left + bckn['bdwidth'].value()
+        bottom = top + bckn['bdheight'].value()
+
+        inNodes = []
+        for node in nuke.allNodes():
+            if node.Class() == "Viewer":
+                continue
+
+            if (node.xpos() > left) \
+                and (node.xpos() + node.screenWidth() < right) \
+                    and (node.ypos() > top) \
+                    and (node.ypos() + node.screenHeight() < bottom):
+                inNodes.append(node)
+
+        self.log.info("Backdrop content collected: `{}`".format(inNodes))
+        self.log.info("Backdrop instance collected: `{}`".format(instance))

From a2f81fbdb02593bd216c05e531952a5c3238e6a2 Mon Sep 17 00:00:00 2001
From: Jakub Jezek <jakub@pype.club>
Date: Fri, 22 Nov 2019 11:50:31 +0100
Subject: [PATCH 08/14] feat(nuke): adding label to collect backdrop

---
 ...llect_nukenodes.py => collect_backdrop.py} | 21 ++++++++++++++-----
 1 file changed, 16 insertions(+), 5 deletions(-)
 rename pype/plugins/nuke/publish/{collect_nukenodes.py => collect_backdrop.py} (64%)

diff --git a/pype/plugins/nuke/publish/collect_nukenodes.py b/pype/plugins/nuke/publish/collect_backdrop.py
similarity index 64%
rename from pype/plugins/nuke/publish/collect_nukenodes.py
rename to pype/plugins/nuke/publish/collect_backdrop.py
index ba5a28c44a..d88a702a84 100644
--- a/pype/plugins/nuke/publish/collect_nukenodes.py
+++ b/pype/plugins/nuke/publish/collect_backdrop.py
@@ -1,11 +1,13 @@
 import pyblish.api
 import nuke
 
+
+@pyblish.api.log
 class CollectBackdrops(pyblish.api.InstancePlugin):
-    """Collect Backdrop instance from rendered frames
+    """Collect Backdrop node instance and its content
     """
 
-    order = pyblish.api.CollectorOrder + 0.3
+    order = pyblish.api.CollectorOrder + 0.22
     label = "Collect Backdrop"
     hosts = ["nuke"]
     families = ["nukenodes"]
@@ -14,21 +16,30 @@ class CollectBackdrops(pyblish.api.InstancePlugin):
 
         bckn = instance[0]
 
+        # define size of the backdrop
         left = bckn.xpos()
         top = bckn.ypos()
         right = left + bckn['bdwidth'].value()
         bottom = top + bckn['bdheight'].value()
 
-        inNodes = []
+        # iterate all nodes
         for node in nuke.allNodes():
+
+            # exclude viewer
             if node.Class() == "Viewer":
                 continue
 
+            # find all related nodes
             if (node.xpos() > left) \
                 and (node.xpos() + node.screenWidth() < right) \
                     and (node.ypos() > top) \
                     and (node.ypos() + node.screenHeight() < bottom):
-                inNodes.append(node)
 
-        self.log.info("Backdrop content collected: `{}`".format(inNodes))
+                # add contained nodes to instance's node list
+                instance.append(node)
+
+        instance.data["label"] = "{0} ({1} nodes)".format(
+            bckn.name(), len(instance)-1)
+
+        self.log.info("Backdrop content collected: `{}`".format(instance[:]))
         self.log.info("Backdrop instance collected: `{}`".format(instance))

From 351c7ed95f4ef71d1d434df04126baab26c2411f Mon Sep 17 00:00:00 2001
From: Jakub Jezek <jakub@pype.club>
Date: Fri, 22 Nov 2019 11:51:12 +0100
Subject: [PATCH 09/14] feat(nuke): adding validate backdrop

checking if there are nodes above backdrop
---
 .../plugins/nuke/publish/validate_backdrop.py | 64 +++++++++++++++++++
 1 file changed, 64 insertions(+)
 create mode 100644 pype/plugins/nuke/publish/validate_backdrop.py

diff --git a/pype/plugins/nuke/publish/validate_backdrop.py b/pype/plugins/nuke/publish/validate_backdrop.py
new file mode 100644
index 0000000000..59c4e96b37
--- /dev/null
+++ b/pype/plugins/nuke/publish/validate_backdrop.py
@@ -0,0 +1,64 @@
+import pyblish
+from avalon.nuke import lib as anlib
+import nuke
+
+
+class SelectCenterInNodeGraph(pyblish.api.Action):
+    """
+    Centering failed instance node in node grap
+    """
+
+    label = "Center node in node graph"
+    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)
+
+        all_xC = list()
+        all_yC = list()
+
+        # maintain selection
+        with anlib.maintained_selection():
+            # collect all failed nodes xpos and ypos
+            for instance in instances:
+                bdn = instance[0]
+                xC = bdn.xpos() + bdn.screenWidth()/2
+                yC = bdn.ypos() + bdn.screenHeight()/2
+
+                all_xC.append(xC)
+                all_yC.append(yC)
+
+        self.log.info("all_xC: `{}`".format(all_xC))
+        self.log.info("all_yC: `{}`".format(all_yC))
+
+        # zoom to nodes in node graph
+        nuke.zoom(2, [min(all_xC), min(all_yC)])
+
+
+@pyblish.api.log
+class ValidateBackdrop(pyblish.api.InstancePlugin):
+    """Validate amount of nodes on backdrop node in case user
+    forgoten to add nodes above the publishing backdrop node"""
+
+    order = pyblish.api.ValidatorOrder
+    optional = True
+    families = ["nukenodes"]
+    label = "Validate Backdrop"
+    hosts = ["nuke"]
+    actions = [SelectCenterInNodeGraph]
+
+    def process(self, instance):
+
+        msg = "No content on backdrop node: \"{}\"".format(
+            instance.data["name"])
+        assert len(instance) > 1, msg

From 443f47d240637322a9ea80c8077c78ffce9af2a6 Mon Sep 17 00:00:00 2001
From: Jakub Jezek <jakub@pype.club>
Date: Sat, 23 Nov 2019 23:43:48 +0100
Subject: [PATCH 10/14] feat(nuke): adding `nukenodes` family

---
 pype/nuke/__init__.py                        | 3 ++-
 pype/plugins/global/publish/integrate_new.py | 3 ++-
 2 files changed, 4 insertions(+), 2 deletions(-)

diff --git a/pype/nuke/__init__.py b/pype/nuke/__init__.py
index b7dbf69510..a7e63bf06d 100644
--- a/pype/nuke/__init__.py
+++ b/pype/nuke/__init__.py
@@ -112,7 +112,8 @@ def install():
     # Disable all families except for the ones we explicitly want to see
     family_states = [
         "write",
-        "review"
+        "review",
+        "nukenodes" 
     ]
 
     avalon.data["familiesStateDefault"] = False
diff --git a/pype/plugins/global/publish/integrate_new.py b/pype/plugins/global/publish/integrate_new.py
index 64f6dd5015..10df19b953 100644
--- a/pype/plugins/global/publish/integrate_new.py
+++ b/pype/plugins/global/publish/integrate_new.py
@@ -70,7 +70,8 @@ class IntegrateAssetNew(pyblish.api.InstancePlugin):
                 "lut",
                 "audio",
                 "yetiRig",
-                "yeticache"
+                "yeticache",
+                "nukenodes"
                 ]
     exclude_families = ["clip"]
 

From d21e98aea977303b25342105b45476003a936647 Mon Sep 17 00:00:00 2001
From: Jakub Jezek <jakub@pype.club>
Date: Sat, 23 Nov 2019 23:44:43 +0100
Subject: [PATCH 11/14] feat(nuke): adding method for getting dependency for
 list of nodes

---
 pype/nuke/lib.py | 38 +++++++++++++++++++++++++++++++++++++-
 1 file changed, 37 insertions(+), 1 deletion(-)

diff --git a/pype/nuke/lib.py b/pype/nuke/lib.py
index 0079a23266..816a7d5116 100644
--- a/pype/nuke/lib.py
+++ b/pype/nuke/lib.py
@@ -108,7 +108,7 @@ def writes_version_sync():
             # check if the node is avalon tracked
             if "AvalonTab" not in each.knobs():
                 continue
-                
+
             avalon_knob_data = avalon.nuke.get_avalon_knob_data(
                 each, ['avalon:', 'ak:'])
 
@@ -1194,3 +1194,39 @@ class BuildWorkfile(WorkfileSettings):
 
     def position_up(self, multiply=1):
         self.ypos -= (self.ypos_size * multiply) + self.ypos_gap
+
+def get_dependent_nodes(nodes):
+    """Get all dependent nodes connected to the list of nodes.
+
+    Looking for connections outside of the nodes in incoming argument.
+
+    Arguments:
+        nodes (list): list of nuke.Node objects
+
+    Returns:
+        connections_in: dictionary of nodes and its dependencies
+        connections_out: dictionary of nodes and its dependency
+    """
+
+    connections_in = dict()
+    connections_out = dict()
+    node_names = [n.name() for n in nodes]
+    for node in nodes:
+        inputs = node.dependencies()
+        outputs = node.dependent()
+        # collect all inputs outside
+        test_in = [(i, n) for i, n in enumerate(inputs)
+                   if n.name() not in node_names]
+        if test_in:
+            connections_in.update({
+                node: test_in
+                })
+        # collect all outputs outside
+        test_out = [i for i in outputs if i.name() not in node_names]
+        if test_out:
+            # only one dependent node is allowed
+            connections_out.update({
+                node: test_out[-1]
+                })
+
+    return connections_in, connections_out

From 641406c08846603cc829fa0669c00f35f8a79b81 Mon Sep 17 00:00:00 2001
From: Jakub Jezek <jakub@pype.club>
Date: Sat, 23 Nov 2019 23:45:37 +0100
Subject: [PATCH 12/14] feat(nuke): adding `nukenodes` family for loading
 precoms

---
 pype/plugins/nuke/load/load_script_precomp.py | 21 +++++++++----------
 1 file changed, 10 insertions(+), 11 deletions(-)

diff --git a/pype/plugins/nuke/load/load_script_precomp.py b/pype/plugins/nuke/load/load_script_precomp.py
index e84e23a890..310157f099 100644
--- a/pype/plugins/nuke/load/load_script_precomp.py
+++ b/pype/plugins/nuke/load/load_script_precomp.py
@@ -7,7 +7,7 @@ class LinkAsGroup(api.Loader):
     """Copy the published file to be pasted at the desired location"""
 
     representations = ["nk"]
-    families = ["workfile"]
+    families = ["workfile", "nukenodes"]
 
     label = "Load Precomp"
     order = 0
@@ -63,8 +63,6 @@ class LinkAsGroup(api.Loader):
         colorspace = context["version"]["data"].get("colorspace", None)
         self.log.info("colorspace: {}\n".format(colorspace))
 
-        # ['version', 'file', 'reading', 'output', 'useOutput']
-
         P["name"].setValue("{}_{}".format(name, namespace))
         P["useOutput"].setValue(True)
 
@@ -74,14 +72,15 @@ class LinkAsGroup(api.Loader):
                       if n.Class() == "Group"
                       if get_avalon_knob_data(n)]
 
-            # create panel for selecting output
-            panel_choices = " ".join(writes)
-            panel_label = "Select write node for output"
-            p = nuke.Panel("Select Write Node")
-            p.addEnumerationPulldown(
-                panel_label, panel_choices)
-            p.show()
-            P["output"].setValue(p.value(panel_label))
+            if writes:
+                # create panel for selecting output
+                panel_choices = " ".join(writes)
+                panel_label = "Select write node for output"
+                p = nuke.Panel("Select Write Node")
+                p.addEnumerationPulldown(
+                    panel_label, panel_choices)
+                p.show()
+                P["output"].setValue(p.value(panel_label))
 
         P["tile_color"].setValue(0xff0ff0ff)
 

From c8a1bd151f9d23c3a432d86dd58b54db97af0f77 Mon Sep 17 00:00:00 2001
From: Jakub Jezek <jakub@pype.club>
Date: Sat, 23 Nov 2019 23:46:29 +0100
Subject: [PATCH 13/14] feat(nuke): collecting | validating | extracting
 backdrop

---
 pype/plugins/nuke/publish/collect_backdrop.py |  41 ++++++-
 pype/plugins/nuke/publish/extract_backdrop.py | 103 ++++++++++++++++++
 .../plugins/nuke/publish/validate_backdrop.py |   9 +-
 3 files changed, 150 insertions(+), 3 deletions(-)
 create mode 100644 pype/plugins/nuke/publish/extract_backdrop.py

diff --git a/pype/plugins/nuke/publish/collect_backdrop.py b/pype/plugins/nuke/publish/collect_backdrop.py
index d88a702a84..39402f5352 100644
--- a/pype/plugins/nuke/publish/collect_backdrop.py
+++ b/pype/plugins/nuke/publish/collect_backdrop.py
@@ -1,7 +1,8 @@
 import pyblish.api
+import pype.api as pype
+from pype.nuke import lib as pnlib
 import nuke
 
-
 @pyblish.api.log
 class CollectBackdrops(pyblish.api.InstancePlugin):
     """Collect Backdrop node instance and its content
@@ -38,8 +39,46 @@ class CollectBackdrops(pyblish.api.InstancePlugin):
                 # add contained nodes to instance's node list
                 instance.append(node)
 
+        # get all connections from outside of backdrop
+        nodes = instance[1:]
+        connections_in, connections_out = pnlib.get_dependent_nodes(nodes)
+        instance.data["connections_in"] = connections_in
+        instance.data["connections_out"] = connections_out
+
+        # make label nicer
         instance.data["label"] = "{0} ({1} nodes)".format(
             bckn.name(), len(instance)-1)
 
+        instance.data["families"].append(instance.data["family"])
+
+        # Get frame range
+        handle_start = instance.context.data["handleStart"]
+        handle_end = instance.context.data["handleEnd"]
+        first_frame = int(nuke.root()["first_frame"].getValue())
+        last_frame = int(nuke.root()["last_frame"].getValue())
+
+        # get version
+        version = pype.get_version_from_path(nuke.root().name())
+        instance.data['version'] = version
+
+        # Add version data to instance
+        version_data = {
+            "handles": handle_start,
+            "handleStart": handle_start,
+            "handleEnd": handle_end,
+            "frameStart": first_frame + handle_start,
+            "frameEnd": last_frame - handle_end,
+            "version": int(version),
+            "families": [instance.data["family"]] + instance.data["families"],
+            "subset": instance.data["subset"],
+            "fps": instance.context.data["fps"]
+        }
+
+        instance.data.update({
+            "versionData": version_data,
+            "frameStart": first_frame,
+            "frameEnd": last_frame,
+            "subsetGroup": "backdrops"
+        })
         self.log.info("Backdrop content collected: `{}`".format(instance[:]))
         self.log.info("Backdrop instance collected: `{}`".format(instance))
diff --git a/pype/plugins/nuke/publish/extract_backdrop.py b/pype/plugins/nuke/publish/extract_backdrop.py
new file mode 100644
index 0000000000..7b01b5deac
--- /dev/null
+++ b/pype/plugins/nuke/publish/extract_backdrop.py
@@ -0,0 +1,103 @@
+import pyblish.api
+from avalon.nuke import lib as anlib
+from pype.nuke import lib as pnlib
+import nuke
+import os
+import pype
+reload(pnlib)
+
+class ExtractBackdropNode(pype.api.Extractor):
+    """Extracting content of backdrop nodes
+
+    Will create nuke script only with containing nodes.
+    Also it will solve Input and Output nodes.
+
+    """
+
+    order = pyblish.api.ExtractorOrder
+    label = "Extract Backdrop"
+    hosts = ["nuke"]
+    families = ["nukenodes"]
+
+    def process(self, instance):
+        tmp_nodes = list()
+        nodes = instance[1:]
+        # Define extract output file path
+        stagingdir = self.staging_dir(instance)
+        filename = "{0}.nk".format(instance.name)
+        path = os.path.join(stagingdir, filename)
+
+        # maintain selection
+        with anlib.maintained_selection():
+            # all connections outside of backdrop
+            connections_in = instance.data["connections_in"]
+            connections_out = instance.data["connections_out"]
+            self.log.debug("_ connections_in: `{}`".format(connections_in))
+            self.log.debug("_ connections_out: `{}`".format(connections_out))
+
+            # create input nodes and name them as passing node (*_INP)
+            for n, inputs in connections_in.items():
+                for i, input in inputs:
+                    inpn = nuke.createNode("Input")
+                    inpn["name"].setValue("{}_{}_INP".format(n.name(), i))
+                    n.setInput(i, inpn)
+                    inpn.setXYpos(input.xpos(), input.ypos())
+                    nodes.append(inpn)
+                    tmp_nodes.append(inpn)
+
+            anlib.reset_selection()
+
+            # connect output node
+            for n, output in connections_out.items():
+                opn = nuke.createNode("Output")
+                self.log.info(n.name())
+                self.log.info(output.name())
+                output.setInput(
+                    next((i for i, d in enumerate(output.dependencies())
+                          if d.name() in n.name()), 0), opn)
+                opn.setInput(0, n)
+                opn.autoplace()
+                nodes.append(opn)
+                tmp_nodes.append(opn)
+                anlib.reset_selection()
+
+            # select nodes to copy
+            anlib.reset_selection()
+            anlib.select_nodes(nodes)
+            # create tmp nk file
+            # save file to the path
+            nuke.nodeCopy(path)
+
+            # Clean up
+            for tn in tmp_nodes:
+                nuke.delete(tn)
+
+            # restore original connections
+            # reconnect input node
+            for n, inputs in connections_in.items():
+                for i, input in inputs:
+                    n.setInput(i, input)
+
+            # reconnect output node
+            for n, output in connections_out.items():
+                output.setInput(
+                    next((i for i, d in enumerate(output.dependencies())
+                          if d.name() in n.name()), 0), n)
+
+        if "representations" not in instance.data:
+            instance.data["representations"] = []
+
+        # create representation
+        representation = {
+            'name': 'nk',
+            'ext': 'nk',
+            'files': filename,
+            "stagingDir": stagingdir
+        }
+        instance.data["representations"].append(representation)
+
+        self.log.info("Extracted instance '{}' to: {}".format(
+            instance.name, path))
+
+        self.log.info("Data {}".format(
+            instance.data))
diff --git a/pype/plugins/nuke/publish/validate_backdrop.py b/pype/plugins/nuke/publish/validate_backdrop.py
index 59c4e96b37..cf2d56087d 100644
--- a/pype/plugins/nuke/publish/validate_backdrop.py
+++ b/pype/plugins/nuke/publish/validate_backdrop.py
@@ -58,7 +58,12 @@ class ValidateBackdrop(pyblish.api.InstancePlugin):
     actions = [SelectCenterInNodeGraph]
 
     def process(self, instance):
+        connections_out = instance.data["connections_out"]
 
-        msg = "No content on backdrop node: \"{}\"".format(
+        msg_multiple_outputs = "Only one outcoming connection from \"{}\" is allowed".format(
             instance.data["name"])
-        assert len(instance) > 1, msg
+        assert len(connections_out.keys()) <= 1, msg_multiple_outputs
+
+        msg_no_content = "No content on backdrop node: \"{}\"".format(
+            instance.data["name"])
+        assert len(instance) > 1, msg_no_content

From 1077a02e9296635646dd3e3890561a156b8e4cab Mon Sep 17 00:00:00 2001
From: Jakub Jezek <jakub@pype.club>
Date: Mon, 25 Nov 2019 15:09:52 +0100
Subject: [PATCH 14/14] feat(nuke): adding process() to create backdrop

---
 pype/plugins/nuke/create/create_backdrop.py | 37 ++++++++++++++++++++-
 1 file changed, 36 insertions(+), 1 deletion(-)

diff --git a/pype/plugins/nuke/create/create_backdrop.py b/pype/plugins/nuke/create/create_backdrop.py
index 237f9ac8f0..767e92b592 100644
--- a/pype/plugins/nuke/create/create_backdrop.py
+++ b/pype/plugins/nuke/create/create_backdrop.py
@@ -1,5 +1,6 @@
 from avalon.nuke.pipeline import Creator
-
+from avalon.nuke import lib as anlib
+import nuke
 
 class CreateBackdrop(Creator):
     """Add Publishable Backdrop"""
@@ -12,4 +13,38 @@ class CreateBackdrop(Creator):
 
     def __init__(self, *args, **kwargs):
         super(CreateBackdrop, self).__init__(*args, **kwargs)
+        self.nodes = nuke.selectedNodes()
+        self.node_color = "0xdfea5dff"
         return
+
+    def process(self):
+        from nukescripts import autoBackdrop
+        nodes = list()
+        if (self.options or {}).get("useSelection"):
+            nodes = self.nodes
+
+            if len(nodes) >= 1:
+                anlib.select_nodes(nodes)
+                bckd_node = autoBackdrop()
+                bckd_node["name"].setValue("{}_BDN".format(self.name))
+                bckd_node["tile_color"].setValue(int(self.node_color, 16))
+                bckd_node["note_font_size"].setValue(24)
+                bckd_node["label"].setValue("[{}]".format(self.name))
+                # add avalon knobs
+                instance = anlib.imprint(bckd_node, self.data)
+
+                return instance
+            else:
+                nuke.message("Please select nodes you "
+                             "wish to add to a container")
+                return
+        else:
+            bckd_node = autoBackdrop()
+            bckd_node["name"].setValue("{}_BDN".format(self.name))
+            bckd_node["tile_color"].setValue(int(self.node_color, 16))
+            bckd_node["note_font_size"].setValue(24)
+            bckd_node["label"].setValue("[{}]".format(self.name))
+            # add avalon knobs
+            instance = anlib.imprint(bckd_node, self.data)
+
+            return instance