From 919f1cafecca658883b4eb6032c24f84c896e6c3 Mon Sep 17 00:00:00 2001
From: David Lai <davidlatwe@gmail.com>
Date: Fri, 27 Dec 2019 12:32:09 +0800
Subject: [PATCH 01/33] Fix TypeError: 'Node' object does not support item
 assignment

---
 avalon/nuke/lib.py | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/avalon/nuke/lib.py b/avalon/nuke/lib.py
index 2a8a5b170..1359161ba 100644
--- a/avalon/nuke/lib.py
+++ b/avalon/nuke/lib.py
@@ -36,7 +36,7 @@ def reset_selection():
     """Deselect all selected nodes
     """
     for node in nuke.selectedNodes():
-        node["selected"] = False
+        node["selected"].setValue(False)
 
 
 def select_nodes(nodes):

From 56f55fc1f296d07d05c97796967f597340983bb5 Mon Sep 17 00:00:00 2001
From: David Lai <davidlatwe@gmail.com>
Date: Fri, 27 Dec 2019 12:36:01 +0800
Subject: [PATCH 02/33] Push root logging message level to INFO level

---
 setup/nuke/nuke_path/menu.py | 3 +++
 1 file changed, 3 insertions(+)

diff --git a/setup/nuke/nuke_path/menu.py b/setup/nuke/nuke_path/menu.py
index 3ce80d64b..8e1d032ed 100644
--- a/setup/nuke/nuke_path/menu.py
+++ b/setup/nuke/nuke_path/menu.py
@@ -1,3 +1,6 @@
+import logging
 import avalon.api
 import avalon.nuke
+
+logging.getLogger("").setLevel(20)  # INFO level
 avalon.api.install(avalon.nuke)

From 1ff01fa9b4be22c3592561563bee5ade86aba350 Mon Sep 17 00:00:00 2001
From: David Lai <davidlatwe@gmail.com>
Date: Mon, 6 Jan 2020 16:38:54 +0800
Subject: [PATCH 03/33] Implement `lsattr`

---
 avalon/nuke/lib.py | 53 ++++++++++++++++++++++++++++++++++++++++++++++
 1 file changed, 53 insertions(+)

diff --git a/avalon/nuke/lib.py b/avalon/nuke/lib.py
index 1359161ba..a85024eda 100644
--- a/avalon/nuke/lib.py
+++ b/avalon/nuke/lib.py
@@ -286,6 +286,59 @@ def compat_prefixed(knob_name):
     return data
 
 
+def lsattr(attr, value=None, type=None, group=None, recursive=False):
+    """Return nodes matching `key` and `value`
+
+    Arguments:
+        attr (str): Name of Node knob
+        value (object, optional): Value of attribute. If none
+            is provided, return all nodes with this attribute.
+        type (str, optional): Node class name
+        group (nuke.Node, optional): Listing nodes from `group`, default `root`
+        recursive (bool, optional): Whether to look into child groups.
+
+    Return:
+         list: matching nodes.
+
+    """
+    group = group or nuke.toNode("root")
+
+    if value is None:
+        args = (type, ) if type else ()
+        nodes = nuke.allNodes(*args, group=group, recurseGroups=recursive)
+        return [n for n in nodes if n.knob(attr)]
+    return lsattrs({attr: value}, type=type, group=group, recursive=recursive)
+
+
+def lsattrs(attrs, type=None, group=None, recursive=False):
+    """Return nodes with the given attribute(s).
+
+    Arguments:
+        attrs (dict): Name and value pairs of expected matches
+        type (str, optional): Node class name
+        group (nuke.Node, optional): Listing nodes from `group`, default `root`
+        recursive (bool, optional): Whether to look into child groups.
+
+    Return:
+         list: matching nodes.
+
+    """
+    matches = set()
+    args = (type, ) if type else ()
+    group = group or nuke.toNode("root")
+    nodes = nuke.allNodes(*args, group=group, recurseGroups=recursive)
+    for node in nodes:
+        for attr in attrs:
+            knob = node.knob(attr)
+            if not knob:
+                continue
+            elif knob.getValue() != attrs[attr]:
+                continue
+            else:
+                matches.add(node)
+    return list(matches)
+
+
 def add_publish_knob(node):
     """Add Publish knob to node
 

From 9df1197a0b185b4821dccbb6e7e3d83ab80610c4 Mon Sep 17 00:00:00 2001
From: David Lai <davidlatwe@gmail.com>
Date: Mon, 6 Jan 2020 18:17:37 +0800
Subject: [PATCH 04/33] Implement node avalonId set/get and copies finder

This change is prerequisite for implementing node knob update/override system in Nuke.
---
 avalon/nuke/lib.py | 53 ++++++++++++++++++++++++++++++++++++++++++++++
 1 file changed, 53 insertions(+)

diff --git a/avalon/nuke/lib.py b/avalon/nuke/lib.py
index a85024eda..8f50c04d4 100644
--- a/avalon/nuke/lib.py
+++ b/avalon/nuke/lib.py
@@ -5,6 +5,7 @@
 import logging
 from collections import OrderedDict
 
+from .. import io
 from ..vendor import six, clique
 
 log = logging.getLogger(__name__)
@@ -339,6 +340,58 @@ def lsattrs(attrs, type=None, group=None, recursive=False):
     return list(matches)
 
 
+def set_id(node, container_id=None):
+    """Set 'avalonId' to `node`
+
+    Args:
+        node (nuke.Node): Node that id to apply to
+        container_id (str, optional): `node` container's id
+
+    """
+    data = OrderedDict()
+    data["avalonId"] = str(io.ObjectId())
+    if container_id:
+        data["containerId"] = container_id
+
+    set_avalon_knob_data(node, data)
+
+    return data["avalonId"]
+
+
+def get_id(node, container_id=False):
+    """Get 'avalonId' of `node`
+
+    Args:
+        node (nuke.Node): Node that id to apply to
+        container_id (bool, optional): Whether change to get `node`
+            container's id instead of `node` avalonId. Default False.
+
+    """
+    knob = "containerId" if container_id else "avalonId"
+    id_knob = node.knobs().get("avalon:" + knob)
+    return id_knob.value() if id_knob else None
+
+
+def find_copies(source, group=None, recursive=True):
+    """Return nodes that has same 'avalonId' as `source`
+
+    Args:
+        source (nuke.Node): The node to find copies from
+        group (nuke.Node, optional): Find copies from `group`, default `root`
+        recursive (bool, optional): Whether to look into child groups,
+            default True.
+
+    """
+    copies = list()
+    source_id = get_id(source)
+    if source_id:
+        copies = lsattr("avalon:avalonId",
+                        type=source.Class(),
+                        group=group,
+                        recursive=recursive)
+    return copies
+
+
 def add_publish_knob(node):
     """Add Publish knob to node
 

From 75e82c8938dfb0a30df464c02759a245789451c1 Mon Sep 17 00:00:00 2001
From: David Lai <davidlatwe@gmail.com>
Date: Mon, 6 Jan 2020 17:57:59 +0800
Subject: [PATCH 05/33] Refactored `containerise` and `ls`

---
 avalon/nuke/pipeline.py | 106 ++++++++++++++++++++++++++++++++++------
 1 file changed, 91 insertions(+), 15 deletions(-)

diff --git a/avalon/nuke/pipeline.py b/avalon/nuke/pipeline.py
index 31ac2295e..2db5f9633 100644
--- a/avalon/nuke/pipeline.py
+++ b/avalon/nuke/pipeline.py
@@ -18,6 +18,7 @@
 self = sys.modules[__name__]
 self._parent = None  # Main Window cache
 
+AVALON_CONTAINERS = "AVALON_CONTAINERS"
 AVALON_CONFIG = os.environ["AVALON_CONFIG"]
 
 
@@ -55,28 +56,41 @@ def reload_pipeline():
     _register_events()
 
 
-def containerise(node,
-                 name,
+def containerise(name,
                  namespace,
+                 nodes,
                  context,
                  loader=None,
-                 data=None):
+                 data=None,
+                 suffix="CON"):
     """Bundle `node` into an assembly and imprint it with metadata
 
     Containerisation enables a tracking of version, author and origin
     for loaded assets.
 
     Arguments:
-        node (nuke.Node): Nuke's node object to imprint as container
         name (str): Name of resulting assembly
         namespace (str): Namespace under which to host container
+        nodes (list): A list of `nuke.Node` object to containerise
         context (dict): Asset information
         loader (str, optional): Name of node used to produce this container.
+        data (dict, optional): Additional data to imprint.
+        suffix (str, optional): Suffix of container, defaults to `_CON`.
 
     Returns:
         node (nuke.Node): containerised nuke's node object
 
     """
+    from nukescripts import autoBackdrop
+
+    if isinstance(name, nuke.Node):
+        # For compatibling with old style args
+        #   containerise(node, name, namespace, context, ...)
+        _ = nodes
+        nodes = [name]
+        name = namespace
+        namespace = _
+
     data = OrderedDict(
         [
             ("schema", "avalon-core:container-2.0"),
@@ -84,15 +98,53 @@ def containerise(node,
             ("name", name),
             ("namespace", namespace),
             ("loader", str(loader)),
-            ("representation", context["representation"]["_id"]),
+            ("representation", str(context["representation"]["_id"])),
         ],
 
         **data or dict()
     )
+    container_color = data.pop("color", int("0x7A7A7AFF", 16))
+    container_name = "%s_%s_%s" % (namespace, name, suffix)
 
-    lib.set_avalon_knob_data(node, data)
+    lib.reset_selection()
+    lib.select_nodes(nodes)
 
-    return node
+    container = autoBackdrop()
+    container.setName(container_name)
+    container["label"].setValue(container_name)
+    container["tile_color"].setValue(container_color)
+    container["selected"].setValue(True)
+    # (NOTE) Backdrop may not fully cover if there's only one node, so we
+    #        expand backdrop a bit ot ensure that.
+    container["bdwidth"].setValue(container["bdwidth"].value() + 100)
+    container["bdheight"].setValue(container["bdheight"].value() + 100)
+    container["xpos"].setValue(container["xpos"].value() - 50)
+
+    lib.set_avalon_knob_data(container, data)
+
+    container_id = lib.set_id(container)
+    for node in nodes:
+        lib.set_id(node, container_id=container_id)
+
+    # Containerising
+
+    nuke.nodeCopy("_containerizing_")
+
+    main_container = nuke.toNode(AVALON_CONTAINERS)
+    if main_container is None:
+        main_container = nuke.createNode("Group")
+        main_container.setName(AVALON_CONTAINERS)
+        main_container["postage_stamp"].setValue(True)
+        main_container["note_font_size"].setValue(40)
+        main_container["tile_color"].setValue(int("0x283648FF", 16))
+        main_container["xpos"].setValue(-500)
+        main_container["ypos"].setValue(-500)
+
+    main_container.begin()
+    nuke.nodePaste("_containerizing_")
+    main_container.end()
+
+    return container
 
 
 def parse_container(node):
@@ -189,6 +241,24 @@ def process(self):
         return instance
 
 
+def _ls1():
+    """Yields all nodes for listing Avalon containers"""
+    for node in nuke.allNodes(recurseGroups=False):
+        yield node
+
+
+def _ls2():
+    """Yields nodes that has 'avalon:id' knob from AVALON_CONTAINERS"""
+    for node in nuke.allNodes("BackdropNode",
+                              group=nuke.toNode(AVALON_CONTAINERS)):
+        knob = node.fullName() + ".avalon:id"
+        if nuke.exists(knob) and nuke.knob(knob) == AVALON_CONTAINER_ID:
+            yield node
+
+
+_ls = _ls1 if os.getenv("AVALON_NUKE_CONTAINERS_AT_LARGE") else _ls2
+
+
 def ls():
     """List available containers.
 
@@ -199,16 +269,22 @@ def ls():
     See the `container.json` schema for details on how it should look,
     and the Maya equivalent, which is in `avalon.maya.pipeline`
     """
-    all_nodes = nuke.allNodes(recurseGroups=False)
+    config = find_host_config(api.registered_config())
+    has_metadata_collector = hasattr(config, "collect_container_metadata")
+
+    container_nodes = _ls()
+
+    for container in container_nodes:
+        data = parse_container(container)
+        if data is None:
+            continue
 
-    # TODO: add readgeo, readcamera, readimage
-    nodes = [n for n in all_nodes]
+        # Collect custom data if attribute is present
+        if has_metadata_collector:
+            metadata = config.collect_container_metadata(container)
+            data.update(metadata)
 
-    for n in nodes:
-        log.debug("name: `{}`".format(n.name()))
-        container = parse_container(n)
-        if container:
-            yield container
+        yield data
 
 
 def install(config):

From 3c685d019576b7a4165b3387bb607b95f1657557 Mon Sep 17 00:00:00 2001
From: David Lai <davidlatwe@gmail.com>
Date: Mon, 6 Jan 2020 17:58:30 +0800
Subject: [PATCH 06/33] Remove container data validation

---
 avalon/nuke/pipeline.py | 8 --------
 1 file changed, 8 deletions(-)

diff --git a/avalon/nuke/pipeline.py b/avalon/nuke/pipeline.py
index 2db5f9633..26d08ec24 100644
--- a/avalon/nuke/pipeline.py
+++ b/avalon/nuke/pipeline.py
@@ -161,14 +161,6 @@ def parse_container(node):
     """
     data = lib.read(node)
 
-    # (TODO) Remove key validation when `ls` has re-implemented.
-    #
-    # If not all required data return the empty container
-    required = ["schema", "id", "name",
-                "namespace", "loader", "representation"]
-    if not all(key in data for key in required):
-        return
-
     # Store the node's name
     data["objectName"] = node["name"].value()
     # Store reference to the node object

From c84473b81eed654d1b031fd6feab020ffb8061c7 Mon Sep 17 00:00:00 2001
From: David Lai <davidlatwe@gmail.com>
Date: Mon, 6 Jan 2020 20:15:23 +0800
Subject: [PATCH 07/33] Implement node sync

The key of node update/override system.
---
 avalon/nuke/lib.py | 77 ++++++++++++++++++++++++++++++++++++++++++++++
 1 file changed, 77 insertions(+)

diff --git a/avalon/nuke/lib.py b/avalon/nuke/lib.py
index 8f50c04d4..3b647a34b 100644
--- a/avalon/nuke/lib.py
+++ b/avalon/nuke/lib.py
@@ -392,6 +392,83 @@ def find_copies(source, group=None, recursive=True):
     return copies
 
 
+@contextlib.contextmanager
+def sync_copies(nodes, force=False):
+    """Context manager for Syncing nodes' knobs
+
+    When updating subset by `Loader.update`, use this context to auto sync all
+    copies of the subset.
+
+    By default, only knobs that haven't been modified, compares to the original
+    one inside the "AVALON_CONTAINERS". But if `force` set to True, all knobs
+    will be updated.
+
+    Example:
+        ```
+        class Loader(avalon.api.Loader):
+
+            def update(self, container, representation):
+
+                with lib.sync_copies(nodes):
+                    # Update subset
+                    ...
+                # All copies of `nodes` updated
+
+                with lib.sync_copies([container_node], force=True):
+                    # Update container data
+                    ...
+                # All copies of `container_node` updated
+
+        ```
+
+    Args:
+        nodes (list): Nodes to sync
+        force (bool, optional): Whether to force updating all knobs
+
+    """
+    def is_knob_eq(knob_a, knob_b):
+        return knob_a.toScript() == knob_b.toScript()
+
+    def sync_knob(knob_a, knob_b):
+        script = knob_a.toScript()
+        knob_b.fromScript(script)
+
+    staged = dict()
+    origin = dict()
+
+    # Collect knobs for updating
+    for node in nodes:
+        targets = list()
+
+        sources = node.knobs()
+        origin[node] = sources
+
+        for copy in find_copies(node):
+            for name, knob in copy.knobs().items():
+                if name not in sources:
+                    continue
+                # Only update knob that hasn't been modified
+                if force or is_knob_eq(sources[name], knob):
+                    targets.append(knob.fullyQualifiedName())
+
+        if targets:
+            staged[node] = targets
+
+    try:
+        yield  # Update `nodes`
+
+    finally:
+        # Sync update result to all copies
+        for node, targets in staged.items():
+            updates = origin[node]
+
+            for knob in targets:
+                copied, knob = knob.rsplit(".", 1)
+                copied = nuke.toNode(copied)
+
+                sync_knob(updates[knob], copied[knob])
+
+
 def add_publish_knob(node):
     """Add Publish knob to node
 

From 98d35620a28d5a5d8806a61cbc6487c273788c00 Mon Sep 17 00:00:00 2001
From: David Lai <davidlatwe@gmail.com>
Date: Mon, 6 Jan 2020 20:22:11 +0800
Subject: [PATCH 08/33] Fix Qt4 compat

---
 avalon/tools/models.py             |  5 +++--
 avalon/tools/sceneinventory/app.py | 12 ++++++------
 2 files changed, 9 insertions(+), 8 deletions(-)

diff --git a/avalon/tools/models.py b/avalon/tools/models.py
index 513b3ffc3..c73516150 100644
--- a/avalon/tools/models.py
+++ b/avalon/tools/models.py
@@ -2,7 +2,7 @@
 import logging
 import collections
 
-from ..vendor.Qt import QtCore, QtGui
+from ..vendor.Qt import Qt, QtCore, QtGui
 from ..vendor import qtawesome
 from .. import io
 from .. import style
@@ -62,7 +62,8 @@ def setData(self, index, value, role=QtCore.Qt.EditRole):
                 item[key] = value
 
                 # passing `list()` for PyQt5 (see PYSIDE-462)
-                self.dataChanged.emit(index, index, list())
+                args = () if Qt.IsPySide or Qt.IsPyQt4 else ([], )
+                self.dataChanged.emit(index, index, *args)
 
                 # must return true if successful
                 return True
diff --git a/avalon/tools/sceneinventory/app.py b/avalon/tools/sceneinventory/app.py
index 155868991..ad466dfa3 100644
--- a/avalon/tools/sceneinventory/app.py
+++ b/avalon/tools/sceneinventory/app.py
@@ -315,22 +315,22 @@ def get_children(i):
                 child = model.index(row, 0, parent=i)
                 yield child
 
-        subitems = set()
+        subitems = dict()
         for i in indices:
             valid_parent = i.parent().isValid()
-            if valid_parent and i not in subitems:
-                subitems.add(i)
+            if valid_parent and str(i) not in subitems:
+                subitems[str(i)] = i
 
                 if self._hierarchy_view:
                     # Assume this is a group node
                     for child in get_children(i):
-                        subitems.add(child)
+                        subitems[str(child)] = child
             else:
                 # is top level node
                 for child in get_children(i):
-                    subitems.add(child)
+                    subitems[str(child)] = child
 
-        return list(subitems)
+        return list(subitems.values())
 
     def show_version_dialog(self, items):
         """Create a dialog with the available versions for the selected file

From 134b4cd2398919d5cd6a32390c08b9aacc6235a1 Mon Sep 17 00:00:00 2001
From: David Lai <davidlatwe@gmail.com>
Date: Mon, 6 Jan 2020 20:53:36 +0800
Subject: [PATCH 09/33] Collect containerized nodes while parsing container

---
 avalon/nuke/pipeline.py | 9 +++++++++
 1 file changed, 9 insertions(+)

diff --git a/avalon/nuke/pipeline.py b/avalon/nuke/pipeline.py
index 26d08ec24..2889866df 100644
--- a/avalon/nuke/pipeline.py
+++ b/avalon/nuke/pipeline.py
@@ -165,6 +165,11 @@ def parse_container(node):
     data["objectName"] = node["name"].value()
     # Store reference to the node object
     data["_node"] = node
+    # Get containerized nodes
+    if node.fullName() == "%s.%s" % (AVALON_CONTAINERS, node.name()):
+        data["_members"] = lib.lsattr("avalon:containerId",
+                                      value=data["avalonId"],
+                                      group=nuke.toNode(AVALON_CONTAINERS))
 
     return data
 
@@ -189,6 +194,10 @@ def update_container(node, keys=None):
     if not container:
         raise TypeError("Not a valid container node.")
 
+    # Remove unprintable entries
+    container.pop("_node", None)
+    container.pop("_members", None)
+
     container.update(keys)
     node = lib.set_avalon_knob_data(node, container)
 

From bd88c1ad04b0d621d8bd6b41ccc5361292b33bf9 Mon Sep 17 00:00:00 2001
From: David Lai <davidlatwe@gmail.com>
Date: Mon, 6 Jan 2020 20:56:00 +0800
Subject: [PATCH 10/33] Provide a way to keep old style `containerise`

---
 avalon/nuke/pipeline.py | 12 +++++++++++-
 1 file changed, 11 insertions(+), 1 deletion(-)

diff --git a/avalon/nuke/pipeline.py b/avalon/nuke/pipeline.py
index 2889866df..1cb8e5445 100644
--- a/avalon/nuke/pipeline.py
+++ b/avalon/nuke/pipeline.py
@@ -21,6 +21,8 @@
 AVALON_CONTAINERS = "AVALON_CONTAINERS"
 AVALON_CONFIG = os.environ["AVALON_CONFIG"]
 
+USE_OLD_CONTAINER_STYLE = os.getenv("AVALON_NUKE_CONTAINERS_AT_LARGE")
+
 
 def reload_pipeline():
     """Attempt to reload pipeline at run-time.
@@ -103,6 +105,14 @@ def containerise(name,
 
         **data or dict()
     )
+
+    if USE_OLD_CONTAINER_STYLE:
+        node = nodes[0]
+        lib.set_avalon_knob_data(node, data)
+        return node
+
+    # New style
+
     container_color = data.pop("color", int("0x7A7A7AFF", 16))
     container_name = "%s_%s_%s" % (namespace, name, suffix)
 
@@ -257,7 +267,7 @@ def _ls2():
             yield node
 
 
-_ls = _ls1 if os.getenv("AVALON_NUKE_CONTAINERS_AT_LARGE") else _ls2
+_ls = _ls1 if USE_OLD_CONTAINER_STYLE else _ls2
 
 
 def ls():

From 05b5086341b5fce88f5668770ff1012aeeb789dd Mon Sep 17 00:00:00 2001
From: David Lai <davidlatwe@gmail.com>
Date: Mon, 6 Jan 2020 21:34:42 +0800
Subject: [PATCH 11/33] Vendorize `knobby`

---
 avalon/nuke/vendor/__init__.py        |   0
 avalon/nuke/vendor/knobby/__init__.py |  16 ++
 avalon/nuke/vendor/knobby/parser.py   | 143 ++++++++++++
 avalon/nuke/vendor/knobby/util.py     | 319 ++++++++++++++++++++++++++
 4 files changed, 478 insertions(+)
 create mode 100644 avalon/nuke/vendor/__init__.py
 create mode 100644 avalon/nuke/vendor/knobby/__init__.py
 create mode 100644 avalon/nuke/vendor/knobby/parser.py
 create mode 100644 avalon/nuke/vendor/knobby/util.py

diff --git a/avalon/nuke/vendor/__init__.py b/avalon/nuke/vendor/__init__.py
new file mode 100644
index 000000000..e69de29bb
diff --git a/avalon/nuke/vendor/knobby/__init__.py b/avalon/nuke/vendor/knobby/__init__.py
new file mode 100644
index 000000000..cad32a59c
--- /dev/null
+++ b/avalon/nuke/vendor/knobby/__init__.py
@@ -0,0 +1,16 @@
+
+__version__ = "0.1.1"
+
+from . import parser
+
+try:
+    from . import util
+except ImportError:
+    # No nuke module
+    util = None
+
+
+__all__ = [
+    "parser",
+    "util",
+]
diff --git a/avalon/nuke/vendor/knobby/parser.py b/avalon/nuke/vendor/knobby/parser.py
new file mode 100644
index 000000000..80fad194d
--- /dev/null
+++ b/avalon/nuke/vendor/knobby/parser.py
@@ -0,0 +1,143 @@
+
+import re
+from collections import deque
+
+
+def parse(script):
+    """Parse Nuke node's TCL script string into nested list structure
+
+    Args:
+        script (str): Node knobs TCL script string
+
+    Returns:
+        Tablet: A list containing knob scripts or tab knobs that has parsed
+            into list
+
+    """
+    queue = deque(script.split("\n"))
+    tab = Tablet()
+    tab.consume(queue)
+    return tab
+
+
+TYPE_NODE = 0
+TYPE_KNOBS = 1
+TYPE_GROUP = -2
+TYPE_KNOBS_CLOSE = -1
+TYPE_GROUP_CLOSE = -3
+
+TAB_PATTERN = re.compile(
+    "addUserKnob {20 "
+    "(?P<name>\\S+)"
+    "(| l (?P<label>\".*\"|\\S+))"
+    "(| n (?P<type>1|-[1-3]))"
+    "}"
+)
+
+
+class Tablet(list):
+    """
+    """
+
+    def __init__(self, name=None, label=None, type=None, parent=None):
+        self.name = name
+        self.label = label
+        self.type = type
+        self.parent = parent
+        self[:] = list()
+
+        self.tab_closed = False
+        self.not_in_group = type is not None and type != TYPE_GROUP
+
+    def __eq__(self, other):
+        return "@" + self.name == other
+
+    def find_tab(self, name):
+        """Return child tab if exists in list"""
+        return next((item for item in self if item == "@" + name), None)
+
+    def consume(self, queue):
+        """
+        """
+        def under_root():
+            return getattr(self.parent, "parent", None) is not None
+
+        def ignore_tab_value(name):
+            if queue and queue[0] == "%s 1" % name:
+                queue.popleft()
+
+        while queue:
+            line = queue.popleft()
+            if not line:
+                continue
+
+            matched = TAB_PATTERN.search(line)
+            if matched:
+                tab_profile = matched.groupdict()
+                name = tab_profile["name"]
+                label = tab_profile["label"]
+                type = int(tab_profile["type"] or 0)
+            else:
+                self.append(line)
+                continue
+
+            ignore_tab_value(name)
+
+            if type in (TYPE_KNOBS_CLOSE, TYPE_GROUP_CLOSE):
+                self.parent.tab_closed = True
+                return
+
+            elif type == TYPE_NODE:
+                if self.not_in_group:
+                    queue.appendleft(line)
+                    return
+
+            tab = Tablet(name, label, type=type, parent=self)
+            self.append(tab)
+
+            tab.consume(queue)
+
+            if self.tab_closed and under_root():
+                return
+
+    def merge(self, other):
+        """
+        """
+        for item in other:
+            if isinstance(item, Tablet):
+                tab = self.find_tab(item.name)
+                if tab is not None:
+                    tab.merge(item)
+                    continue
+
+            self.append(item)
+
+    def to_script(self, join=True):
+        """
+        """
+        script = list()
+        for item in self:
+            if isinstance(item, Tablet):
+                sub_script = item.to_script(join=False)
+
+                line = "addUserKnob {20 " + item.name
+                if item.label is not None:
+                    line += " l " + item.label
+
+                if item.type == TYPE_NODE:
+                    sub_script.insert(0, line + "}")
+
+                elif item.type == TYPE_KNOBS:
+                    sub_script.insert(0, line + " n 1}")
+                    sub_script.append(line + " n -1}")
+
+                elif item.type == TYPE_GROUP:
+                    sub_script.insert(0, line + " n -2}")
+                    sub_script.append(line + " n -3}")
+
+                script += sub_script
+                continue
+
+            script.append(item)
+
+        return "\n".join(script) if join else script
diff --git a/avalon/nuke/vendor/knobby/util.py b/avalon/nuke/vendor/knobby/util.py
new file mode 100644
index 000000000..aecc735c8
--- /dev/null
+++ b/avalon/nuke/vendor/knobby/util.py
@@ -0,0 +1,319 @@
+
+import sys
+import re
+import nuke
+
+from . import parser
+
+
+if sys.version_info[0] == 3:  # PY3
+    string_types = str,
+else:
+    string_types = basestring,
+
+
+def imprint(node, data, tab=None):
+    """Store attributes with value on node
+
+    Parse user data into Node knobs.
+    Use `collections.OrderedDict` to ensure knob order.
+
+    Args:
+        node(nuke.Node): node object from Nuke
+        data(dict): collection of attributes and their value
+        tab (str, optional): Tab name, default "User"
+
+    Returns:
+        None
+
+    """
+    tab = tab or "User"
+
+    existed_knobs = node.knobs()
+    tab_existed = tab in existed_knobs
+
+    def add_knobs(knobs, tab):
+        node.addKnob(nuke.Tab_Knob(tab))
+        for knob in knobs:
+            node.addKnob(knob)
+
+    if tab_existed:
+        TEMP = ":::temp_imprint_tab:::"
+        new_tab = TEMP + tab
+
+        new_knobs = list()
+        for knob in create_knobs(data, tab=new_tab):
+            name = knob.name()[len(TEMP):]
+            if name in existed_knobs and knob.Class() != "Tab_Knob":
+                existed_knobs[name].setValue(knob.value())
+            else:
+                new_knobs.append(knob)
+
+        old_tcl = node.writeKnobs(nuke.TO_SCRIPT | nuke.WRITE_USER_KNOB_DEFS)
+        old_tcl = old_tcl.strip()
+
+        add_knobs(new_knobs, new_tab)
+
+        new_tcl = node.writeKnobs(nuke.TO_SCRIPT | nuke.WRITE_USER_KNOB_DEFS)
+        new_tcl = new_tcl.strip()[len(old_tcl) + 1:].replace(TEMP, "")
+
+        first_user_knob = _parse_first_user_knob(node)
+        for knob in reversed(node.allKnobs()):
+            knob_name = knob.name()
+            node.removeKnob(knob)
+            if knob_name == first_user_knob:
+                break
+
+        tablet = parser.parse(old_tcl)
+        tablet.merge(parser.parse(new_tcl))
+        node.readKnobs(tablet.to_script())
+
+    else:
+        new_knobs = create_knobs(data, tab=tab)
+        add_knobs(new_knobs, tab)
+
+
+class Knobby(object):
+    """For creating knob which it's type isn't mapped in `create_knobs`
+
+    Args:
+        type (string): Nuke knob type name
+        value: Value to be set with `Knob.setValue`, put `None` if not required
+        flags (list, optional): Knob flags to be set with `Knob.setFlag`
+        *args: Args other than knob name for initializing knob class
+
+    """
+
+    def __init__(self, type, value, flags=None, *args):
+        self.type = type
+        self.value = value
+        self.flags = flags or []
+        self.args = args
+
+    def create(self, name, nice=None):
+        knob_cls = getattr(nuke, self.type)
+        knob = knob_cls(name, nice, *self.args)
+        if self.value is not None:
+            knob.setValue(self.value)
+        for flag in self.flags:
+            knob.setFlag(flag)
+        return knob
+
+
+def create_knobs(data, tab):
+    """Create knobs by data
+
+    Depending on the type of each dict value and creates the correct Knob.
+
+    Mapped types:
+        bool: nuke.Boolean_Knob
+        int: nuke.Int_Knob
+        float: nuke.Double_Knob
+        list: nuke.Enumeration_Knob
+        string_types: nuke.String_Knob
+
+        dict: If it's a nested dict (all values are dict), will turn into
+            A tabs group. Or just a knobs group.
+
+    Args:
+        data (dict): collection of attributes and their value
+        prefix (str): knob name prefix
+
+    Returns:
+        list: A list of `nuke.Knob` objects
+
+    """
+    def nice_naming(key):
+        """Convert camelCase name into UI Display Name"""
+        words = re.findall('[A-Z][^A-Z]*', key[0].upper() + key[1:])
+        return " ".join(words)
+
+    # Turn key-value pairs into knobs
+    knobs = list()
+    prefix = tab + ":"
+
+    for key, value in data.items():
+        # Knob name
+        if isinstance(key, tuple):
+            name, nice = key
+        else:
+            name, nice = key, nice_naming(key)
+
+        name = prefix + name
+
+        # Create knob by value type
+        if isinstance(value, Knobby):
+            knobby = value
+            knob = knobby.create(name, nice)
+
+        elif isinstance(value, float):
+            knob = nuke.Double_Knob(name, nice)
+            knob.setValue(value)
+
+        elif isinstance(value, bool):
+            knob = nuke.Boolean_Knob(name, nice)
+            knob.setValue(value)
+            knob.setFlag(nuke.STARTLINE)
+
+        elif isinstance(value, int):
+            knob = nuke.Int_Knob(name, nice)
+            knob.setValue(value)
+
+        elif isinstance(value, string_types):
+            knob = nuke.String_Knob(name, nice)
+            knob.setValue(value)
+
+        elif isinstance(value, list):
+            knob = nuke.Enumeration_Knob(name, nice, value)
+
+        elif isinstance(value, dict):
+            if all(isinstance(v, dict) for v in value.values()):
+                # Create a group of tabs
+                begin = nuke.BeginTabGroup_Knob(name)
+                end = nuke.EndTabGroup_Knob()
+                begin.setName(name)
+                begin.setLabel(nice)
+                end.setName(name)
+                knobs.append(begin)
+                for k, v in value.items():
+                    tab_name = "%s:%s" % (name, k)
+                    knobs.append(nuke.Tab_Knob(tab_name, k))
+                    knobs += create_knobs(v, tab=tab_name)
+                knobs.append(end)
+            else:
+                # Create a group of knobs
+                knobs.append(nuke.Tab_Knob(name, nice, nuke.TABBEGINGROUP))
+                knobs += create_knobs(value, tab=name)
+                knobs.append(nuke.Tab_Knob(name, nice, nuke.TABENDGROUP))
+            continue
+
+        else:
+            raise TypeError("Unsupported type: %r" % type(value))
+
+        knobs.append(knob)
+
+    return knobs
+
+
+EXCLUDED_KNOB_TYPE_ON_READ = (
+    20,  # Tab Knob
+    26,  # Text Knob (But for backward compatibility, still be read
+         #            if value is not an empty string.)
+)
+
+KNOB_PATTERN = re.compile(
+    "(?<=addUserKnob {)"
+    "([0-9]*) (\\S*)"  # Matching knob type and knob name
+    "(?=[ |}])"
+)
+
+
+def _parse_first_user_knob(node):
+    tcl = node.writeKnobs(nuke.WRITE_USER_KNOB_DEFS)
+    matched = KNOB_PATTERN.search(tcl)
+    if matched:
+        return matched.group(2)
+
+
+def read(node, filter=None):
+    """Return user-defined knobs from given `node`
+
+    Args:
+        node (nuke.Node): Nuke node object
+        filter (func, optional): Function for filtering knobs by
+            knob name prefix and remove prefix as data entry name.
+            If not provided, all user-defined knobs will be read.
+
+    Returns:
+        dict
+
+    """
+    data = dict()
+    filter = filter or (lambda name: name)
+
+    first_user_knob = _parse_first_user_knob(node)
+    if first_user_knob is not None:
+        # Collect user knobs from the end of the knob list
+        for knob in reversed(node.allKnobs()):
+            knob_name = knob.name()
+            if not knob_name:
+                # Ignore unnamed knob
+                continue
+
+            knob_type = nuke.knob(knob.fullyQualifiedName(), type=True)
+            value = knob.value()
+
+            if (
+                knob_type not in EXCLUDED_KNOB_TYPE_ON_READ or
+                # For compating read-only string data that imprinted
+                # by `nuke.Text_Knob`.
+                (knob_type == 26 and value)
+            ):
+                key = filter(knob_name)
+                if key:
+                    data[key] = value
+
+            if knob_name == first_user_knob:
+                break
+
+    return data
+
+
+def mold(node, tab=None, map_cls=None):
+    """Return user-defined knobs from given `node` with hierarchy
+
+    Args:
+        node (nuke.Node): Nuke node object
+        tab (str, optional): Target tab name. If given, only read
+            knobs of this tab.
+        map_cls (Mapping type class, optional): Default `dict`, use
+            `collections.OrderedDict` if orders need to be preserved.
+
+    Returns:
+        Instance of `map_cls`
+
+    """
+    knobs = node.knobs()
+    target = (tab or "") + ":"
+
+    map_cls = map_cls or dict
+
+    def _mold(tablet, prefix=None):
+        data = map_cls()
+        prefix = (prefix + ":") if prefix else ""
+
+        name = tablet.name or ""
+        abs_name = name + ":"
+        all_elem = abs_name.startswith(target) if tab and name else True
+
+        for item in tablet:
+            if isinstance(item, parser.Tablet):
+                name = item.name
+                abs_name = name + ":"
+
+                if tab and target.startswith(abs_name):
+
+                    data = _mold(item, prefix=name)
+
+                elif all_elem:
+
+                    key = name[len(prefix):] if prefix else name
+                    data[key] = _mold(item, prefix=name)
+
+            elif all_elem:
+
+                matched = KNOB_PATTERN.search(item)
+                if not matched:
+                    raise TypeError("Knob name can not be identified.")
+                else:
+                    name = matched.group(2)
+                    knob = knobs[name]
+                    key = name[len(prefix):] if prefix else name
+                    data[key] = knob.value()
+
+        return data
+
+    tcl = node.writeKnobs(nuke.WRITE_USER_KNOB_DEFS)
+    tablet = parser.parse(tcl)
+
+    return _mold(tablet)

From f217fa4658c96c1577de5c3ddfaba3a4b6d9c8e8 Mon Sep 17 00:00:00 2001
From: David Lai <davidlatwe@gmail.com>
Date: Mon, 6 Jan 2020 21:43:32 +0800
Subject: [PATCH 12/33] Replace with `vendor.knobby`

---
 avalon/nuke/lib.py | 242 ++-------------------------------------------
 1 file changed, 7 insertions(+), 235 deletions(-)

diff --git a/avalon/nuke/lib.py b/avalon/nuke/lib.py
index 2a8a5b170..bc6efbef9 100644
--- a/avalon/nuke/lib.py
+++ b/avalon/nuke/lib.py
@@ -6,10 +6,17 @@
 from collections import OrderedDict
 
 from ..vendor import six, clique
+from .vendor import knobby
 
 log = logging.getLogger(__name__)
 
 
+Knobby = knobby.util.Knobby
+imprint = knobby.util.imprint
+read = knobby.util.read
+mold = knobby.util.mold
+
+
 @contextlib.contextmanager
 def maintained_selection():
     """Maintain selection during context
@@ -51,241 +58,6 @@ def select_nodes(nodes):
         node["selected"].setValue(True)
 
 
-def imprint(node, data, tab=None):
-    """Store attributes with value on node
-
-    Parse user data into Node knobs.
-    Use `collections.OrderedDict` to ensure knob order.
-
-    Args:
-        node(nuke.Node): node object from Nuke
-        data(dict): collection of attributes and their value
-
-    Returns:
-        None
-
-    Examples:
-        ```
-        import nuke
-        from avalon.nuke import lib
-
-        node = nuke.createNode("NoOp")
-        data = {
-            # Regular type of attributes
-            "myList": ["x", "y", "z"],
-            "myBool": True,
-            "myFloat": 0.1,
-            "myInt": 5,
-
-            # Creating non-default imprint type of knob
-            "MyFilePath": lib.Knobby("File_Knob", "/file/path"),
-            "divider": lib.Knobby("Text_Knob", ""),
-
-            # Manual nice knob naming
-            ("my_knob", "Nice Knob Name"): "some text",
-
-            # dict type will be created as knob group
-            "KnobGroup": {
-                "knob1": 5,
-                "knob2": "hello",
-                "knob3": ["a", "b"],
-            },
-
-            # Nested dict will be created as tab group
-            "TabGroup": {
-                "tab1": {"count": 5},
-                "tab2": {"isGood": True},
-                "tab3": {"direction": ["Left", "Right"]},
-            },
-        }
-        lib.imprint(node, data, tab="Demo")
-
-        ```
-
-    """
-    for knob in create_knobs(data, tab):
-        node.addKnob(knob)
-
-
-class Knobby(object):
-    """For creating knob which it's type isn't mapped in `create_knobs`
-
-    Args:
-        type (string): Nuke knob type name
-        value: Value to be set with `Knob.setValue`, put `None` if not required
-        flags (list, optional): Knob flags to be set with `Knob.setFlag`
-        *args: Args other than knob name for initializing knob class
-
-    """
-
-    def __init__(self, type, value, flags=None, *args):
-        self.type = type
-        self.value = value
-        self.flags = flags or []
-        self.args = args
-
-    def create(self, name, nice=None):
-        knob_cls = getattr(nuke, self.type)
-        knob = knob_cls(name, nice, *self.args)
-        if self.value is not None:
-            knob.setValue(self.value)
-        for flag in self.flags:
-            knob.setFlag(flag)
-        return knob
-
-
-def create_knobs(data, tab=None):
-    """Create knobs by data
-
-    Depending on the type of each dict value and creates the correct Knob.
-
-    Mapped types:
-        bool: nuke.Boolean_Knob
-        int: nuke.Int_Knob
-        float: nuke.Double_Knob
-        list: nuke.Enumeration_Knob
-        six.string_types: nuke.String_Knob
-
-        dict: If it's a nested dict (all values are dict), will turn into
-            A tabs group. Or just a knobs group.
-
-    Args:
-        data (dict): collection of attributes and their value
-        tab (string, optional): Knobs' tab name
-
-    Returns:
-        list: A list of `nuke.Knob` objects
-
-    """
-    def nice_naming(key):
-        """Convert camelCase name into UI Display Name"""
-        words = re.findall('[A-Z][^A-Z]*', key[0].upper() + key[1:])
-        return " ".join(words)
-
-    # Turn key-value pairs into knobs
-    knobs = list()
-
-    if tab:
-        knobs.append(nuke.Tab_Knob(tab))
-
-    for key, value in data.items():
-        # Knob name
-        if isinstance(key, tuple):
-            name, nice = key
-        else:
-            name, nice = key, nice_naming(key)
-
-        # Create knob by value type
-        if isinstance(value, Knobby):
-            knobby = value
-            knob = knobby.create(name, nice)
-
-        elif isinstance(value, float):
-            knob = nuke.Double_Knob(name, nice)
-            knob.setValue(value)
-
-        elif isinstance(value, bool):
-            knob = nuke.Boolean_Knob(name, nice)
-            knob.setValue(value)
-            knob.setFlag(nuke.STARTLINE)
-
-        elif isinstance(value, int):
-            knob = nuke.Int_Knob(name, nice)
-            knob.setValue(value)
-
-        elif isinstance(value, six.string_types):
-            knob = nuke.String_Knob(name, nice)
-            knob.setValue(value)
-
-        elif isinstance(value, list):
-            knob = nuke.Enumeration_Knob(name, nice, value)
-
-        elif isinstance(value, dict):
-            if all(isinstance(v, dict) for v in value.values()):
-                # Create a group of tabs
-                begain = nuke.BeginTabGroup_Knob()
-                end = nuke.EndTabGroup_Knob()
-                begain.setName(name)
-                end.setName(name + "_End")
-                knobs.append(begain)
-                for k, v in value.items():
-                    knobs += create_knobs(v, tab=k)
-                knobs.append(end)
-            else:
-                # Create a group of knobs
-                knobs.append(nuke.Tab_Knob(name, nice, nuke.TABBEGINGROUP))
-                knobs += create_knobs(value)
-                knobs.append(nuke.Tab_Knob(name, nice, nuke.TABENDGROUP))
-            continue
-
-        else:
-            raise TypeError("Unsupported type: %r" % type(value))
-
-        knobs.append(knob)
-
-    return knobs
-
-
-EXCLUDED_KNOB_TYPE_ON_READ = (
-    20,  # Tab Knob
-    26,  # Text Knob (But for backward compatibility, still be read
-         #            if value is not an empty string.)
-)
-
-
-def read(node):
-    """Return user-defined knobs from given `node`
-
-    Args:
-        node (nuke.Node): Nuke node object
-
-    Returns:
-        list: A list of nuke.Knob object
-
-    """
-    def compat_prefixed(knob_name):
-        if knob_name.startswith("avalon:"):
-            return knob_name[len("avalon:"):]
-        elif knob_name.startswith("ak:"):
-            return knob_name[len("ak:"):]
-        else:
-            return knob_name
-
-    data = dict()
-
-    pattern = ("(?<=addUserKnob {)"
-               "([0-9]*) (\\S*)"  # Matching knob type and knob name
-               "(?=[ |}])")
-    tcl_script = node.writeKnobs(nuke.WRITE_USER_KNOB_DEFS)
-    result = re.search(pattern, tcl_script)
-
-    if result:
-        first_user_knob = result.group(2)
-        # Collect user knobs from the end of the knob list
-        for knob in reversed(node.allKnobs()):
-            knob_name = knob.name()
-            if not knob_name:
-                # Ignore unnamed knob
-                continue
-
-            knob_type = nuke.knob(knob.fullyQualifiedName(), type=True)
-            value = knob.value()
-
-            if (
-                knob_type not in EXCLUDED_KNOB_TYPE_ON_READ or
-                # For compating read-only string data that imprinted
-                # by `nuke.Text_Knob`.
-                (knob_type == 26 and value)
-            ):
-                key = compat_prefixed(knob_name)
-                data[key] = value
-
-            if knob_name == first_user_knob:
-                break
-
-    return data
-
-
 def add_publish_knob(node):
     """Add Publish knob to node
 

From 875f83f620658eb55dca2e6d2cd1c4128bb6f465 Mon Sep 17 00:00:00 2001
From: David Lai <davidlatwe@gmail.com>
Date: Mon, 6 Jan 2020 21:48:09 +0800
Subject: [PATCH 13/33] Adopt `knobby`

No need to check knob existence in `set_avalon_knob_data`, `knobby` will check it.

Knob name prefix compatibility now handled in `get_avalon_knob_data`.
---
 avalon/nuke/lib.py      | 74 ++++++++++++++++++-----------------------
 avalon/nuke/pipeline.py |  2 +-
 2 files changed, 34 insertions(+), 42 deletions(-)

diff --git a/avalon/nuke/lib.py b/avalon/nuke/lib.py
index bc6efbef9..11c7d04e4 100644
--- a/avalon/nuke/lib.py
+++ b/avalon/nuke/lib.py
@@ -16,6 +16,8 @@
 read = knobby.util.read
 mold = knobby.util.mold
 
+AVALON_TAB = "avalon"
+
 
 @contextlib.contextmanager
 def maintained_selection():
@@ -72,11 +74,11 @@ def add_publish_knob(node):
         body = OrderedDict()
         body[("divd", "")] = Knobby("Text_Knob", "")
         body["publish"] = True
-        imprint(node, body)
+        imprint(node, body, tab=AVALON_TAB)
     return node
 
 
-def set_avalon_knob_data(node, data=None, prefix="avalon:"):
+def set_avalon_knob_data(node, data=None):
     """ Sets data into nodes's avalon knob
 
     Arguments:
@@ -97,47 +99,32 @@ def set_avalon_knob_data(node, data=None, prefix="avalon:"):
     data = data or dict()
     create = OrderedDict()
 
-    tab_name = "AvalonTab"
     editable = ["asset", "subset", "name", "namespace"]
 
-    existed_knobs = node.knobs()
-
     for key, value in data.items():
-        knob_name = prefix + key
-        gui_name = key
-
-        if knob_name in existed_knobs:
-            # Set value
-            node[knob_name].setValue(value)
+        if key in editable:
+            create[key] = value
         else:
-            # New knob
-            name = (knob_name, gui_name)  # Hide prefix on GUI
-            if key in editable:
-                create[name] = value
-            else:
-                create[name] = Knobby("String_Knob",
-                                      str(value),
-                                      flags=[nuke.READ_ONLY])
-
-    if tab_name in existed_knobs:
-        tab_name = None
-    else:
-        tab = OrderedDict()
-        warn = Knobby("Text_Knob", "Warning! Do not change following data!")
-        divd = Knobby("Text_Knob", "")
-        head = [
-            (("warn", ""), warn),
-            (("divd", ""), divd),
-        ]
-        tab["avalonDataGroup"] = OrderedDict(head + create.items())
-        create = tab
-
-    imprint(node, create, tab=tab_name)
+            create[key] = Knobby("String_Knob",
+                                 str(value),
+                                 flags=[nuke.READ_ONLY])
+
+    tab = OrderedDict()
+    warn = Knobby("Text_Knob", "Warning! Do not change following data!")
+    divd = Knobby("Text_Knob", "")
+    head = [
+        (("warn", ""), warn),
+        (("divd", ""), divd),
+    ]
+    tab["avalonDataGroup"] = OrderedDict(head + create.items())
+    create = tab
+
+    imprint(node, create, tab=AVALON_TAB)
 
     return node
 
 
-def get_avalon_knob_data(node, prefix="avalon:"):
+def get_avalon_knob_data(node):
     """ Get data from nodes's avalon knob
 
     Arguments:
@@ -147,12 +134,17 @@ def get_avalon_knob_data(node, prefix="avalon:"):
     Returns:
         data (dict)
     """
-    data = {
-        knob[len(prefix):]: node[knob].value()
-        for knob in node.knobs().keys()
-        if knob.startswith(prefix)
-    }
-    return data
+    def compat_prefixed(knob_name):
+        if knob_name.startswith("avalon:avalonDataGroup:"):
+            return knob_name[len("avalon:avalonDataGroup:"):]
+        elif knob_name.startswith("avalon:"):
+            return knob_name[len("avalon:"):]
+        elif knob_name.startswith("ak:"):
+            return knob_name[len("ak:"):]
+        else:
+            return None
+
+    return read(node, filter=compat_prefixed)
 
 
 def fix_data_for_node_create(data):
diff --git a/avalon/nuke/pipeline.py b/avalon/nuke/pipeline.py
index 31ac2295e..092d7a574 100644
--- a/avalon/nuke/pipeline.py
+++ b/avalon/nuke/pipeline.py
@@ -107,7 +107,7 @@ def parse_container(node):
         dict: The container schema data for this container node.
 
     """
-    data = lib.read(node)
+    data = lib.get_avalon_knob_data(node)
 
     # (TODO) Remove key validation when `ls` has re-implemented.
     #

From f11e595bd873e9bce639ad28321b334d91f4e106 Mon Sep 17 00:00:00 2001
From: David Lai <davidlatwe@gmail.com>
Date: Mon, 6 Jan 2020 22:02:44 +0800
Subject: [PATCH 14/33] Drop 'avalonDataGroup' knob

---
 avalon/nuke/lib.py | 32 +++++++++++++-------------------
 1 file changed, 13 insertions(+), 19 deletions(-)

diff --git a/avalon/nuke/lib.py b/avalon/nuke/lib.py
index a826d08b1..b928ee5b8 100644
--- a/avalon/nuke/lib.py
+++ b/avalon/nuke/lib.py
@@ -280,29 +280,25 @@ def set_avalon_knob_data(node, data=None):
         }
     """
     data = data or dict()
-    create = OrderedDict()
+
+    warn = Knobby("Text_Knob", "Warning! Do not change following data!")
+    divd = Knobby("Text_Knob", "")
+    knobs = OrderedDict([
+        (("warn", ""), warn),
+        (("divd", ""), divd),
+    ])
 
     editable = ["asset", "subset", "name", "namespace"]
 
     for key, value in data.items():
         if key in editable:
-            create[key] = value
+            knobs[key] = value
         else:
-            create[key] = Knobby("String_Knob",
-                                 str(value),
-                                 flags=[nuke.READ_ONLY])
-
-    tab = OrderedDict()
-    warn = Knobby("Text_Knob", "Warning! Do not change following data!")
-    divd = Knobby("Text_Knob", "")
-    head = [
-        (("warn", ""), warn),
-        (("divd", ""), divd),
-    ]
-    tab["avalonDataGroup"] = OrderedDict(head + create.items())
-    create = tab
+            knobs[key] = Knobby("String_Knob",
+                                str(value),
+                                flags=[nuke.READ_ONLY])
 
-    imprint(node, create, tab=AVALON_TAB)
+    imprint(node, knobs, tab=AVALON_TAB)
 
     return node
 
@@ -318,9 +314,7 @@ def get_avalon_knob_data(node):
         data (dict)
     """
     def compat_prefixed(knob_name):
-        if knob_name.startswith("avalon:avalonDataGroup:"):
-            return knob_name[len("avalon:avalonDataGroup:"):]
-        elif knob_name.startswith("avalon:"):
+        if knob_name.startswith("avalon:"):
             return knob_name[len("avalon:"):]
         elif knob_name.startswith("ak:"):
             return knob_name[len("ak:"):]

From 78472b9cef7f678ada649fa1dc45a01d4424d4e6 Mon Sep 17 00:00:00 2001
From: David Lai <davidlatwe@gmail.com>
Date: Tue, 7 Jan 2020 23:06:16 +0800
Subject: [PATCH 15/33] Adopt #501

---
 avalon/nuke/pipeline.py | 7 ++++---
 1 file changed, 4 insertions(+), 3 deletions(-)

diff --git a/avalon/nuke/pipeline.py b/avalon/nuke/pipeline.py
index a810a594f..a61d7b32d 100644
--- a/avalon/nuke/pipeline.py
+++ b/avalon/nuke/pipeline.py
@@ -9,6 +9,7 @@
 from pyblish import api as pyblish
 
 from . import lib, command
+from ..lib import find_submodule
 from .. import api
 from ..vendor.Qt import QtWidgets
 from ..pipeline import AVALON_CONTAINER_ID
@@ -278,8 +279,8 @@ def ls():
     See the `container.json` schema for details on how it should look,
     and the Maya equivalent, which is in `avalon.maya.pipeline`
     """
-    config = find_host_config(api.registered_config())
-    has_metadata_collector = hasattr(config, "collect_container_metadata")
+    config_host = find_submodule(api.registered_config(), "nuke")
+    has_metadata_collector = hasattr(config_host, "collect_container_metadata")
 
     container_nodes = _ls()
 
@@ -290,7 +291,7 @@ def ls():
 
         # Collect custom data if attribute is present
         if has_metadata_collector:
-            metadata = config.collect_container_metadata(container)
+            metadata = config_host.collect_container_metadata(container)
             data.update(metadata)
 
         yield data

From 6a11ea74728d05c8c58f2244e169ff7546924e92 Mon Sep 17 00:00:00 2001
From: David Lai <davidlatwe@gmail.com>
Date: Tue, 7 Jan 2020 23:11:21 +0800
Subject: [PATCH 16/33] Able to opt-out container node in root

---
 avalon/nuke/pipeline.py | 5 +++++
 1 file changed, 5 insertions(+)

diff --git a/avalon/nuke/pipeline.py b/avalon/nuke/pipeline.py
index a61d7b32d..b27a4a921 100644
--- a/avalon/nuke/pipeline.py
+++ b/avalon/nuke/pipeline.py
@@ -63,6 +63,7 @@ def containerise(name,
                  context,
                  loader=None,
                  data=None,
+                 no_backdrop=True,
                  suffix="CON"):
     """Bundle `node` into an assembly and imprint it with metadata
 
@@ -76,6 +77,7 @@ def containerise(name,
         context (dict): Asset information
         loader (str, optional): Name of node used to produce this container.
         data (dict, optional): Additional data to imprint.
+        no_backdrop (bool, optional): No container(backdrop) node presented.
         suffix (str, optional): Suffix of container, defaults to `_CON`.
 
     Returns:
@@ -153,6 +155,9 @@ def containerise(name,
     nuke.nodePaste("_containerizing_")
     main_container.end()
 
+    if no_backdrop:
+        nuke.delete(container)
+
     return container
 
 

From e1a646844b966ae3fe4e01e868648c56c49072c4 Mon Sep 17 00:00:00 2001
From: David Lai <davidlatwe@gmail.com>
Date: Tue, 7 Jan 2020 23:45:00 +0800
Subject: [PATCH 17/33] Fix copies finder

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

diff --git a/avalon/nuke/lib.py b/avalon/nuke/lib.py
index b928ee5b8..b655cb6cc 100644
--- a/avalon/nuke/lib.py
+++ b/avalon/nuke/lib.py
@@ -159,10 +159,10 @@ def find_copies(source, group=None, recursive=True):
     copies = list()
     source_id = get_id(source)
     if source_id:
-        copies = lsattr("avalon:avalonId",
-                        type=source.Class(),
-                        group=group,
-                        recursive=recursive)
+        copies = lsattrs({"avalon:avalonId": source_id},
+                         type=source.Class(),
+                         group=group,
+                         recursive=recursive)
     return copies
 
 

From e56403499cf8bc6637425be9cb3c053ac5c83952 Mon Sep 17 00:00:00 2001
From: David Lai <davidlatwe@gmail.com>
Date: Wed, 8 Jan 2020 01:34:48 +0800
Subject: [PATCH 18/33] Cosmetic, by Black

---
 avalon/nuke/vendor/knobby/__init__.py | 1 -
 avalon/nuke/vendor/knobby/parser.py   | 1 -
 avalon/nuke/vendor/knobby/util.py     | 1 -
 avalon/tools/models.py                | 3 ++-
 4 files changed, 2 insertions(+), 4 deletions(-)

diff --git a/avalon/nuke/vendor/knobby/__init__.py b/avalon/nuke/vendor/knobby/__init__.py
index cad32a59c..e4ebaddfe 100644
--- a/avalon/nuke/vendor/knobby/__init__.py
+++ b/avalon/nuke/vendor/knobby/__init__.py
@@ -1,4 +1,3 @@
-
 __version__ = "0.1.1"
 
 from . import parser
diff --git a/avalon/nuke/vendor/knobby/parser.py b/avalon/nuke/vendor/knobby/parser.py
index 80fad194d..306387661 100644
--- a/avalon/nuke/vendor/knobby/parser.py
+++ b/avalon/nuke/vendor/knobby/parser.py
@@ -1,4 +1,3 @@
-
 import re
 from collections import deque
 
diff --git a/avalon/nuke/vendor/knobby/util.py b/avalon/nuke/vendor/knobby/util.py
index aecc735c8..1d63ae6cf 100644
--- a/avalon/nuke/vendor/knobby/util.py
+++ b/avalon/nuke/vendor/knobby/util.py
@@ -1,4 +1,3 @@
-
 import sys
 import re
 import nuke
diff --git a/avalon/tools/models.py b/avalon/tools/models.py
index c73516150..13aa2ca45 100644
--- a/avalon/tools/models.py
+++ b/avalon/tools/models.py
@@ -62,7 +62,7 @@ def setData(self, index, value, role=QtCore.Qt.EditRole):
                 item[key] = value
 
                 # passing `list()` for PyQt5 (see PYSIDE-462)
-                args = () if Qt.IsPySide or Qt.IsPyQt4 else ([], )
+                args = () if Qt.IsPySide or Qt.IsPyQt4 else ([],)
                 self.dataChanged.emit(index, index, *args)
 
                 # must return true if successful
@@ -444,6 +444,7 @@ def data(self, index, role):
 
 class RecursiveSortFilterProxyModel(QtCore.QSortFilterProxyModel):
     """Filters to the regex if any of the children matches allow parent"""
+
     def filterAcceptsRow(self, row, parent):
 
         regex = self.filterRegExp()

From 6125b2dea8fd59fc83c0c4647bcbff3093ea124b Mon Sep 17 00:00:00 2001
From: David Lai <davidlatwe@gmail.com>
Date: Wed, 8 Jan 2020 15:38:36 +0800
Subject: [PATCH 19/33] Update nuke.vendor.knobby

Update for Black
---
 avalon/nuke/vendor/knobby/__init__.py |  2 +-
 avalon/nuke/vendor/knobby/parser.py   | 10 +++++-----
 avalon/nuke/vendor/knobby/util.py     | 11 ++---------
 3 files changed, 8 insertions(+), 15 deletions(-)

diff --git a/avalon/nuke/vendor/knobby/__init__.py b/avalon/nuke/vendor/knobby/__init__.py
index e4ebaddfe..ab150eb8a 100644
--- a/avalon/nuke/vendor/knobby/__init__.py
+++ b/avalon/nuke/vendor/knobby/__init__.py
@@ -1,4 +1,4 @@
-__version__ = "0.1.1"
+__version__ = "0.1.2"
 
 from . import parser
 
diff --git a/avalon/nuke/vendor/knobby/parser.py b/avalon/nuke/vendor/knobby/parser.py
index 306387661..1ee581288 100644
--- a/avalon/nuke/vendor/knobby/parser.py
+++ b/avalon/nuke/vendor/knobby/parser.py
@@ -26,11 +26,11 @@ def parse(script):
 TYPE_GROUP_CLOSE = -3
 
 TAB_PATTERN = re.compile(
-    "addUserKnob {20 "
-    "(?P<name>\\S+)"
-    "(| l (?P<label>\".*\"|\\S+))"
-    "(| n (?P<type>1|-[1-3]))"
-    "}"
+    'addUserKnob {20 '
+    '(?P<name>\\S+)'
+    '(| l (?P<label>".*"|\\S+))'
+    '(| n (?P<type>1|-[1-3]))'
+    '}'
 )
 
 
diff --git a/avalon/nuke/vendor/knobby/util.py b/avalon/nuke/vendor/knobby/util.py
index 1d63ae6cf..5af5498ab 100644
--- a/avalon/nuke/vendor/knobby/util.py
+++ b/avalon/nuke/vendor/knobby/util.py
@@ -1,16 +1,9 @@
-import sys
 import re
 import nuke
 
 from . import parser
 
 
-if sys.version_info[0] == 3:  # PY3
-    string_types = str,
-else:
-    string_types = basestring,
-
-
 def imprint(node, data, tab=None):
     """Store attributes with value on node
 
@@ -109,7 +102,7 @@ def create_knobs(data, tab):
         int: nuke.Int_Knob
         float: nuke.Double_Knob
         list: nuke.Enumeration_Knob
-        string_types: nuke.String_Knob
+        str: nuke.String_Knob
 
         dict: If it's a nested dict (all values are dict), will turn into
             A tabs group. Or just a knobs group.
@@ -158,7 +151,7 @@ def nice_naming(key):
             knob = nuke.Int_Knob(name, nice)
             knob.setValue(value)
 
-        elif isinstance(value, string_types):
+        elif isinstance(value, str):
             knob = nuke.String_Knob(name, nice)
             knob.setValue(value)
 

From 0befc94b7babed4822461bcaa612bab9b79ff66a Mon Sep 17 00:00:00 2001
From: David Lai <davidlatwe@gmail.com>
Date: Thu, 9 Jan 2020 16:31:39 +0800
Subject: [PATCH 20/33] Update nuke.vendor.knobby

Revert back unicode string support
---
 avalon/nuke/vendor/knobby/__init__.py |  2 +-
 avalon/nuke/vendor/knobby/util.py     | 11 +++++++++--
 2 files changed, 10 insertions(+), 3 deletions(-)

diff --git a/avalon/nuke/vendor/knobby/__init__.py b/avalon/nuke/vendor/knobby/__init__.py
index ab150eb8a..e2d48a93a 100644
--- a/avalon/nuke/vendor/knobby/__init__.py
+++ b/avalon/nuke/vendor/knobby/__init__.py
@@ -1,4 +1,4 @@
-__version__ = "0.1.2"
+__version__ = "0.1.3"
 
 from . import parser
 
diff --git a/avalon/nuke/vendor/knobby/util.py b/avalon/nuke/vendor/knobby/util.py
index 5af5498ab..f4f2f57c6 100644
--- a/avalon/nuke/vendor/knobby/util.py
+++ b/avalon/nuke/vendor/knobby/util.py
@@ -1,9 +1,16 @@
+import sys
 import re
 import nuke
 
 from . import parser
 
 
+if sys.version_info[0] == 3:  # PY3
+    string_types = str,
+else:
+    string_types = __builtins__.basestring,
+
+
 def imprint(node, data, tab=None):
     """Store attributes with value on node
 
@@ -102,7 +109,7 @@ def create_knobs(data, tab):
         int: nuke.Int_Knob
         float: nuke.Double_Knob
         list: nuke.Enumeration_Knob
-        str: nuke.String_Knob
+        string_types: nuke.String_Knob
 
         dict: If it's a nested dict (all values are dict), will turn into
             A tabs group. Or just a knobs group.
@@ -151,7 +158,7 @@ def nice_naming(key):
             knob = nuke.Int_Knob(name, nice)
             knob.setValue(value)
 
-        elif isinstance(value, str):
+        elif isinstance(value, string_types):
             knob = nuke.String_Knob(name, nice)
             knob.setValue(value)
 

From 12a5722d6e9f9ec4159a2194c9130874cbcf4a49 Mon Sep 17 00:00:00 2001
From: David Lai <davidlatwe@gmail.com>
Date: Thu, 9 Jan 2020 16:46:29 +0800
Subject: [PATCH 21/33] Update nuke.vendor.knobby

Change to use __builtin__ module instead of it's alias
---
 avalon/nuke/vendor/knobby/__init__.py | 2 +-
 avalon/nuke/vendor/knobby/util.py     | 6 ++++--
 2 files changed, 5 insertions(+), 3 deletions(-)

diff --git a/avalon/nuke/vendor/knobby/__init__.py b/avalon/nuke/vendor/knobby/__init__.py
index e2d48a93a..e0db47d91 100644
--- a/avalon/nuke/vendor/knobby/__init__.py
+++ b/avalon/nuke/vendor/knobby/__init__.py
@@ -1,4 +1,4 @@
-__version__ = "0.1.3"
+__version__ = "0.1.4"
 
 from . import parser
 
diff --git a/avalon/nuke/vendor/knobby/util.py b/avalon/nuke/vendor/knobby/util.py
index f4f2f57c6..b72de6c13 100644
--- a/avalon/nuke/vendor/knobby/util.py
+++ b/avalon/nuke/vendor/knobby/util.py
@@ -6,9 +6,11 @@
 
 
 if sys.version_info[0] == 3:  # PY3
-    string_types = str,
+    string_types = str
 else:
-    string_types = __builtins__.basestring,
+    import __builtin__
+
+    string_types = __builtin__.basestring
 
 
 def imprint(node, data, tab=None):

From a19b066b929f8704738a2be53de9a75e2f6b0874 Mon Sep 17 00:00:00 2001
From: davidlatwe <davidlatwe@gmail.com>
Date: Tue, 14 Jan 2020 16:02:16 +0800
Subject: [PATCH 22/33] Change env var name to `AVALON_NUKE_OLD_CONTAINER`

---
 avalon/nuke/pipeline.py | 6 +++---
 1 file changed, 3 insertions(+), 3 deletions(-)

diff --git a/avalon/nuke/pipeline.py b/avalon/nuke/pipeline.py
index b27a4a921..59639ce3e 100644
--- a/avalon/nuke/pipeline.py
+++ b/avalon/nuke/pipeline.py
@@ -22,7 +22,7 @@
 AVALON_CONTAINERS = "AVALON_CONTAINERS"
 AVALON_CONFIG = os.environ["AVALON_CONFIG"]
 
-USE_OLD_CONTAINER_STYLE = os.getenv("AVALON_NUKE_CONTAINERS_AT_LARGE")
+USE_OLD_CONTAINER = os.getenv("AVALON_NUKE_OLD_CONTAINER")
 
 
 def reload_pipeline():
@@ -107,7 +107,7 @@ def containerise(name,
         **data or dict()
     )
 
-    if USE_OLD_CONTAINER_STYLE:
+    if USE_OLD_CONTAINER:
         node = nodes[0]
         lib.set_avalon_knob_data(node, data)
         return node
@@ -271,7 +271,7 @@ def _ls2():
             yield node
 
 
-_ls = _ls1 if USE_OLD_CONTAINER_STYLE else _ls2
+_ls = _ls1 if USE_OLD_CONTAINER else _ls2
 
 
 def ls():

From 0aa0d65d7414053b4ecaad54e7d9b80022461f22 Mon Sep 17 00:00:00 2001
From: davidlatwe <davidlatwe@gmail.com>
Date: Tue, 4 Feb 2020 18:53:20 +0800
Subject: [PATCH 23/33] Update nuke.vendor.knobby

---
 avalon/nuke/vendor/knobby/__init__.py |  2 +-
 avalon/nuke/vendor/knobby/util.py     | 14 ++++++++------
 2 files changed, 9 insertions(+), 7 deletions(-)

diff --git a/avalon/nuke/vendor/knobby/__init__.py b/avalon/nuke/vendor/knobby/__init__.py
index e0db47d91..dccad1f0e 100644
--- a/avalon/nuke/vendor/knobby/__init__.py
+++ b/avalon/nuke/vendor/knobby/__init__.py
@@ -1,4 +1,4 @@
-__version__ = "0.1.4"
+__version__ = "0.1.5"
 
 from . import parser
 
diff --git a/avalon/nuke/vendor/knobby/util.py b/avalon/nuke/vendor/knobby/util.py
index b72de6c13..5c19c33e1 100644
--- a/avalon/nuke/vendor/knobby/util.py
+++ b/avalon/nuke/vendor/knobby/util.py
@@ -13,6 +13,12 @@
     string_types = __builtin__.basestring
 
 
+def nice_naming(key):
+    """Convert camelCase name into UI Display Name"""
+    words = re.findall('[A-Z][^A-Z]*', key[0].upper() + key[1:])
+    return " ".join(words)
+
+
 def imprint(node, data, tab=None):
     """Store attributes with value on node
 
@@ -29,12 +35,13 @@ def imprint(node, data, tab=None):
 
     """
     tab = tab or "User"
+    nice = nice_naming(tab)
 
     existed_knobs = node.knobs()
     tab_existed = tab in existed_knobs
 
     def add_knobs(knobs, tab):
-        node.addKnob(nuke.Tab_Knob(tab))
+        node.addKnob(nuke.Tab_Knob(tab, nice))
         for knob in knobs:
             node.addKnob(knob)
 
@@ -124,11 +131,6 @@ def create_knobs(data, tab):
         list: A list of `nuke.Knob` objects
 
     """
-    def nice_naming(key):
-        """Convert camelCase name into UI Display Name"""
-        words = re.findall('[A-Z][^A-Z]*', key[0].upper() + key[1:])
-        return " ".join(words)
-
     # Turn key-value pairs into knobs
     knobs = list()
     prefix = tab + ":"

From b0c7f55fdbf89b315c846272ba13be67edb42fd7 Mon Sep 17 00:00:00 2001
From: davidlatwe <davidlatwe@gmail.com>
Date: Tue, 4 Feb 2020 18:57:01 +0800
Subject: [PATCH 24/33] Remove duplicated function call

`_register_events` already been called in above `api.install`, no need to call again.
---
 avalon/nuke/pipeline.py | 2 --
 1 file changed, 2 deletions(-)

diff --git a/avalon/nuke/pipeline.py b/avalon/nuke/pipeline.py
index 59639ce3e..36b8d44a6 100644
--- a/avalon/nuke/pipeline.py
+++ b/avalon/nuke/pipeline.py
@@ -54,8 +54,6 @@ def reload_pipeline():
     import avalon.nuke
     api.install(avalon.nuke)
 
-    _register_events()
-
 
 def containerise(name,
                  namespace,

From 97f77549afbbd15f057593dfe015084c428efb7a Mon Sep 17 00:00:00 2001
From: davidlatwe <davidlatwe@gmail.com>
Date: Tue, 4 Feb 2020 19:00:28 +0800
Subject: [PATCH 25/33] Re-implement task label update

Instead of re-build entire menu, just update the context manager menu item.
---
 avalon/nuke/pipeline.py | 35 ++++++++++++++++++++++++-----------
 1 file changed, 24 insertions(+), 11 deletions(-)

diff --git a/avalon/nuke/pipeline.py b/avalon/nuke/pipeline.py
index 36b8d44a6..029c9caa2 100644
--- a/avalon/nuke/pipeline.py
+++ b/avalon/nuke/pipeline.py
@@ -358,21 +358,14 @@ def _install_menu():
         workfiles,
         loader,
         sceneinventory,
-        contextmanager
     )
 
     # Create menu
     menubar = nuke.menu("Nuke")
     menu = menubar.addMenu(api.Session["AVALON_LABEL"])
 
-    label = "{0}, {1}".format(
-        api.Session["AVALON_ASSET"], api.Session["AVALON_TASK"]
-    )
-    context_menu = menu.addMenu(label)
-    context_menu.addCommand("Set Context",
-                            lambda: contextmanager.show(
-                                parent=get_main_window())
-                            )
+    _add_contextmanager_menu(menu)
+
     menu.addSeparator()
     menu.addCommand("Create...",
                     lambda: creator.show(parent=get_main_window()))
@@ -408,6 +401,27 @@ def _uninstall_menu():
     menubar.removeItem(api.Session["AVALON_LABEL"])
 
 
+def _add_contextmanager_menu(menu):
+    from ..tools import contextmanager
+
+    label = "{0}, {1}".format(
+        api.Session["AVALON_ASSET"], api.Session["AVALON_TASK"]
+    )
+    context_menu = menu.addMenu(label, index=0)
+    context_menu.addCommand("Set Context",
+                            lambda: contextmanager.show(
+                                parent=get_main_window())
+                            )
+
+
+def _update_menu_task_label():
+    menubar = nuke.menu("Nuke")
+    menu = menubar.findItem(api.Session["AVALON_LABEL"])
+
+    menu.removeItem(menu.items()[0].name())  # Assume it is the first item
+    _add_contextmanager_menu(menu)
+
+
 def publish():
     """Shorthand to publish from within host"""
     import pyblish.util
@@ -423,8 +437,7 @@ def _register_events():
 def _on_task_changed(*args):
 
     # Update menu
-    _uninstall_menu()
-    _install_menu()
+    _update_menu_task_label()
 
 
 # Backwards compatibility

From 7eb053638c7dc076715eae93d6432302002cf479 Mon Sep 17 00:00:00 2001
From: davidlatwe <davidlatwe@gmail.com>
Date: Wed, 22 Apr 2020 21:33:04 +0800
Subject: [PATCH 26/33] Fix finding copies in nested group

---
 avalon/nuke/lib.py | 9 ++++++---
 1 file changed, 6 insertions(+), 3 deletions(-)

diff --git a/avalon/nuke/lib.py b/avalon/nuke/lib.py
index b655cb6cc..e14ecc733 100644
--- a/avalon/nuke/lib.py
+++ b/avalon/nuke/lib.py
@@ -68,7 +68,7 @@ def lsattr(attr, value=None, type=None, group=None, recursive=False):
         attr (str): Name of Node knob
         value (object, optional): Value of attribute. If none
             is provided, return all nodes with this attribute.
-        type (str, optional): Node class name
+        type (str, optional): Node class name (Not work with `recursive`)
         group (nuke.Node, optional): Listing nodes from `group`, default `root`
         recursive (bool, optional): Whether to look into child groups.
 
@@ -90,7 +90,7 @@ def lsattrs(attrs, type=None, group=None, recursive=False):
 
     Arguments:
         attrs (dict): Name and value pairs of expected matches
-        type (str, optional): Node class name
+        type (str, optional): Node class name (Not work with `recursive`)
         group (nuke.Node, optional): Listing nodes from `group`, default `root`
         recursive (bool, optional): Whether to look into child groups.
 
@@ -160,7 +160,10 @@ def find_copies(source, group=None, recursive=True):
     source_id = get_id(source)
     if source_id:
         copies = lsattrs({"avalon:avalonId": source_id},
-                         type=source.Class(),
+                         # (NOTE) Cannot specify node `type` to `lsattrs()` if
+                         #        `recursive=True`. Because the arg `filter`
+                         #        in command `nuke.allNodes` doesn't work with
+                         #        `recurseGroups=True`.
                          group=group,
                          recursive=recursive)
     return copies

From b1fd0674222cc98ad3b85898eb15a7b3be01f684 Mon Sep 17 00:00:00 2001
From: davidlatwe <davidlatwe@gmail.com>
Date: Wed, 22 Apr 2020 21:34:12 +0800
Subject: [PATCH 27/33] Fix finding container members in nested group

---
 avalon/nuke/pipeline.py | 3 ++-
 1 file changed, 2 insertions(+), 1 deletion(-)

diff --git a/avalon/nuke/pipeline.py b/avalon/nuke/pipeline.py
index dd90676e6..46eb2e2e0 100644
--- a/avalon/nuke/pipeline.py
+++ b/avalon/nuke/pipeline.py
@@ -181,7 +181,8 @@ def parse_container(node):
     if node.fullName() == "%s.%s" % (AVALON_CONTAINERS, node.name()):
         data["_members"] = lib.lsattr("avalon:containerId",
                                       value=data["avalonId"],
-                                      group=nuke.toNode(AVALON_CONTAINERS))
+                                      group=nuke.toNode(AVALON_CONTAINERS),
+                                      recursive=True)
 
     return data
 

From 7819599bfeafb0e1852ff76c2488e1b6391d6729 Mon Sep 17 00:00:00 2001
From: davidlatwe <davidlatwe@gmail.com>
Date: Wed, 22 Apr 2020 21:41:31 +0800
Subject: [PATCH 28/33] Add `role` into dataChanged signal

---
 avalon/tools/models.py | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/avalon/tools/models.py b/avalon/tools/models.py
index 7bbc396de..b47f96fba 100644
--- a/avalon/tools/models.py
+++ b/avalon/tools/models.py
@@ -62,7 +62,7 @@ def setData(self, index, value, role=QtCore.Qt.EditRole):
                 item[key] = value
 
                 # passing `list()` for PyQt5 (see PYSIDE-462)
-                args = () if Qt.IsPySide or Qt.IsPyQt4 else ([],)
+                args = () if Qt.IsPySide or Qt.IsPyQt4 else ([role],)
                 self.dataChanged.emit(index, index, *args)
 
                 # must return true if successful

From be839a69af69ed1d20b7d113e980aa9d585288e8 Mon Sep 17 00:00:00 2001
From: Toke Jepsen <tokejepsen@gmail.com>
Date: Mon, 1 Jun 2020 12:13:40 +0100
Subject: [PATCH 29/33] Expose find_copies and sync_copies

- tidy `__all__`
---
 avalon/nuke/__init__.py | 49 +++++++++++++++++++++--------------------
 1 file changed, 25 insertions(+), 24 deletions(-)

diff --git a/avalon/nuke/__init__.py b/avalon/nuke/__init__.py
index 6c36d8568..dbda4d26e 100644
--- a/avalon/nuke/__init__.py
+++ b/avalon/nuke/__init__.py
@@ -5,12 +5,15 @@
 """
 
 from .lib import (
-    maintained_selection,
-    imprint,
-    read,
-
     add_publish_knob,
+    ls_img_sequence,
+    maintained_selection,
     get_node_path,
+    get_avalon_knob_data,
+    set_avalon_knob_data,
+    imprint,
+    find_copies,
+    sync_copies
 )
 
 from .workio import (
@@ -25,32 +28,30 @@
 from .pipeline import (
     install,
     uninstall,
-
     ls,
     publish,
-
     Creator,
-
     containerise,
     parse_container,
     update_container,
     get_handles,
-
-    # Experimental
     viewer_update_and_undo_stop,
     reload_pipeline,
 )
 
 __all__ = [
-    "reload_pipeline",
-    "install",
-    "uninstall",
-
-    "ls",
-    "publish",
-
-    "Creator",
+    # Lib API.
+    "add_publish_knob",
+    "ls_img_sequence",
+    "maintained_selection",
+    "get_node_path",
+    "get_avalon_knob_data",
+    "set_avalon_knob_data",
+    "imprint",
+    "find_copies",
+    "sync_copies",
 
+    # Workfiles API
     "file_extensions",
     "has_unsaved_changes",
     "save_file",
@@ -58,20 +59,20 @@
     "current_file",
     "work_root",
 
+    # Pipeline API.
+    "install",
+    "uninstall",
+    "ls",
+    "publish",
+    "Creator",
     "containerise",
     "parse_container",
     "update_container",
     "get_handles",
 
-    "imprint",
-    "read",
-
     # Experimental
     "viewer_update_and_undo_stop",
-
-    "add_publish_knob",
-    "maintained_selection",
-    "get_node_path",
+    "reload_pipeline"
 ]
 
 # Backwards API compatibility

From 64d563c26a6e757464c652739c1fe88a20a156e8 Mon Sep 17 00:00:00 2001
From: Toke Jepsen <tokejepsen@gmail.com>
Date: Mon, 1 Jun 2020 12:15:41 +0100
Subject: [PATCH 30/33] find_copies enhancements

- assert `source` argument.
- ensure "source" node is not returned.
---
 avalon/nuke/lib.py | 7 +++++++
 1 file changed, 7 insertions(+)

diff --git a/avalon/nuke/lib.py b/avalon/nuke/lib.py
index e14ecc733..8db868d7f 100644
--- a/avalon/nuke/lib.py
+++ b/avalon/nuke/lib.py
@@ -156,6 +156,8 @@ def find_copies(source, group=None, recursive=True):
             default True.
 
     """
+    assert isinstance(source, nuke.Node), "`Source` needs to be a nuke node."
+
     copies = list()
     source_id = get_id(source)
     if source_id:
@@ -166,6 +168,11 @@ def find_copies(source, group=None, recursive=True):
                          #        `recurseGroups=True`.
                          group=group,
                          recursive=recursive)
+
+    # Dont return the source.
+    if source in copies:
+        copies.remove(source)
+
     return copies
 
 

From 73747459fb5805e3a65cd14fe21b4a8cd0cc85f7 Mon Sep 17 00:00:00 2001
From: David Lai <davidlatwe@gmail.com>
Date: Wed, 22 Jul 2020 18:23:59 +0800
Subject: [PATCH 31/33] Fix knob KeyError when syncing in multi-view session

---
 avalon/nuke/lib.py | 10 +++++++++-
 1 file changed, 9 insertions(+), 1 deletion(-)

diff --git a/avalon/nuke/lib.py b/avalon/nuke/lib.py
index 8db868d7f..d8769425f 100644
--- a/avalon/nuke/lib.py
+++ b/avalon/nuke/lib.py
@@ -228,12 +228,20 @@ def sync_knob(knob_a, knob_b):
         origin[node] = sources
 
         for copy in find_copies(node):
+            copy_name = copy.fullName()
+
             for name, knob in copy.knobs().items():
                 if name not in sources:
                     continue
                 # Only update knob that hasn't been modified
                 if force or is_knob_eq(sources[name], knob):
-                    targets.append(knob.fullyQualifiedName())
+                    # (NOTE) If current Nuke session has multiple views, like
+                    #   working on stereo shot, `knob.fullyQualifiedName` will
+                    #   append current view at the end of the knob name, for
+                    #   example "renderlayer.Read1.first.left".
+                    #   Assemble from node's full name and knob name to avoid
+                    #   that.
+                    targets.append("%s.%s" % (copy_name, knob.name()))
 
         if targets:
             staged[node] = targets

From 3129b2490c7365361c012b11c2d5c55f75a23312 Mon Sep 17 00:00:00 2001
From: David Lai <davidlatwe@gmail.com>
Date: Wed, 22 Jul 2020 20:47:58 +0800
Subject: [PATCH 32/33] Avoid syncing node name when force enabled

---
 avalon/nuke/lib.py | 7 ++++++-
 1 file changed, 6 insertions(+), 1 deletion(-)

diff --git a/avalon/nuke/lib.py b/avalon/nuke/lib.py
index d8769425f..99c635b85 100644
--- a/avalon/nuke/lib.py
+++ b/avalon/nuke/lib.py
@@ -233,6 +233,11 @@ def sync_knob(knob_a, knob_b):
             for name, knob in copy.knobs().items():
                 if name not in sources:
                     continue
+
+                knob_name = knob.name()
+                if knob_name == "name":  # Node name should never be synced
+                    pass
+
                 # Only update knob that hasn't been modified
                 if force or is_knob_eq(sources[name], knob):
                     # (NOTE) If current Nuke session has multiple views, like
@@ -241,7 +246,7 @@ def sync_knob(knob_a, knob_b):
                     #   example "renderlayer.Read1.first.left".
                     #   Assemble from node's full name and knob name to avoid
                     #   that.
-                    targets.append("%s.%s" % (copy_name, knob.name()))
+                    targets.append("%s.%s" % (copy_name, knob_name))
 
         if targets:
             staged[node] = targets

From a6cd92bae5402abd57da1a79b9bcf3042f87df6b Mon Sep 17 00:00:00 2001
From: David Lai <davidlatwe@gmail.com>
Date: Wed, 22 Jul 2020 21:00:15 +0800
Subject: [PATCH 33/33] Fix for accidently committing test code..

---
 avalon/nuke/lib.py | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/avalon/nuke/lib.py b/avalon/nuke/lib.py
index 99c635b85..1cb16f778 100644
--- a/avalon/nuke/lib.py
+++ b/avalon/nuke/lib.py
@@ -236,7 +236,7 @@ def sync_knob(knob_a, knob_b):
 
                 knob_name = knob.name()
                 if knob_name == "name":  # Node name should never be synced
-                    pass
+                    continue
 
                 # Only update knob that hasn't been modified
                 if force or is_knob_eq(sources[name], knob):