Initial working version for palettes.

pype/hosts/harmony/__init__.py

@@ -121,7 +121,10 @@ def check_inventory():
     }
     func
     """
-    outdated_nodes = [x["node"] for x in outdated_containers]
+    outdated_nodes = []
+    for container in outdated_containers:
+        if container["loader"] == "ImageSequenceLoader":
+            outdated_nodes.append(container["name"])
     harmony.send({"function": func, "args": [outdated_nodes]})
 
     # Warn about outdated containers.

pype/plugins/global/publish/integrate_new.py

@@ -83,6 +83,7 @@ class IntegrateAssetNew(pyblish.api.InstancePlugin):
                 "textures",
                 "action",
                 "harmony.template",
+                "harmony.palette",
                 "editorial"
                 ]
     exclude_families = ["clip"]
@@ -605,7 +606,7 @@ class IntegrateAssetNew(pyblish.api.InstancePlugin):
                 "type": "subset",
                 "name": subset_name,
                 "data": {
-                    "families": instance.data.get('families')
+                    "families": instance.data.get("families", [])
                 },
                 "parent": asset["_id"]
             }).inserted_id

pype/plugins/harmony/load/load_imagesequence.py

@@ -3,6 +3,7 @@ import os
 import clique
 
 from avalon import api, harmony
+import pype.lib
 
 copy_files = """function copyFile(srcFilename, dstFilename)
 {
@@ -297,6 +298,27 @@ class ImageSequenceLoader(api.Loader):
             }
         )
 
+        # Colour node.
+        func = """function func(args){
+            for( var i =0; i <= args[0].length - 1; ++i)
+            {
+                var red_color = new ColorRGBA(255, 0, 0, 255);
+                var green_color = new ColorRGBA(0, 255, 0, 255);
+                if (args[1] == "red"){
+                    node.setColor(args[0], red_color);
+                }
+                if (args[1] == "green"){
+                    node.setColor(args[0], green_color);
+                }
+            }
+        }
+        func
+        """
+        if pype.lib.is_latest(representation):
+            harmony.send({"function": func, "args": [node, "green"]})
+        else:
+            harmony.send({"function": func, "args": [node, "red"]})
+
         harmony.imprint(
             node, {"representation": str(representation["_id"])}
         )

pype/plugins/harmony/load/load_palette.py

@@ -0,0 +1,93 @@
+import os
+import shutil
+import uuid
+
+from bson.objectid import ObjectId
+
+from avalon import api, harmony
+
+
+class ImportPaletteLoader(api.Loader):
+    """Import palettes."""
+
+    families = ["harmony.palette"]
+    representations = ["plt"]
+    label = "Import Palette"
+
+    def load(self, context, name=None, namespace=None, data=None):
+        name = self.load_palette(context["representation"])
+
+        return harmony.containerise(
+            name,
+            namespace,
+            name,
+            context,
+            self.__class__.__name__
+        )
+
+    def load_palette(self, representation):
+        subset_name = representation["context"]["subset"]
+        name = subset_name.replace("palette", "")
+        name += "_{}".format(uuid.uuid4())
+
+        # Import new palette.
+        scene_path = harmony.send(
+            {"function": "scene.currentProjectPath"}
+        )["result"]
+        src = api.get_representation_path(representation)
+        dst = os.path.join(
+            scene_path,
+            "palette-library",
+            "{}.plt".format(name)
+        )
+        shutil.copy(src, dst)
+
+        func = """function func(args)
+        {
+            var palette_list = PaletteObjectManager.getScenePaletteList();
+            var palette = palette_list.addPaletteAtLocation(
+                PaletteObjectManager.Constants.Location.SCENE, 0, args[0]
+            );
+            for(var i=0; i < palette_list.numPalettes; ++i)
+            {
+                palette_list.movePaletteUp(palette.id);
+            }
+            return palette.id;
+        }
+        func
+        """
+        harmony.send({"function": func, "args": [name]})
+
+        return name
+
+    def remove(self, container):
+        # Replace any palettes with same name.
+        func = """function func(args)
+        {
+            var pom = PaletteObjectManager;
+            var palette_list = pom.getScenePaletteList();
+            for(var i=0; i < palette_list.numPalettes; ++i)
+            {
+                var palette = palette_list.getPaletteByIndex(i);
+                if(palette.getName() == args[0])
+                    pom.removePaletteReferencesAndDeleteOnDisk(palette.id);
+            }
+        }
+        func
+        """
+        harmony.send({"function": func, "args": [container["name"]]})
+
+        harmony.remove(container["name"])
+
+        harmony.save_scene()
+
+    def switch(self, container, representation):
+        self.update(container, representation)
+
+    def update(self, container, representation):
+        self.remove(container)
+        name = self.load_palette(representation)
+
+        container["representation"] = str(representation["_id"])
+        container["name"] = name
+        harmony.imprint(name, container)

pype/plugins/harmony/publish/collect_palettes.py

@@ -0,0 +1,45 @@
+import os
+import json
+
+import pyblish.api
+from avalon import harmony
+
+
+class CollectPalettes(pyblish.api.ContextPlugin):
+    """Gather palettes from scene when publishing templates."""
+
+    label = "Palettes"
+    order = pyblish.api.CollectorOrder
+    hosts = ["harmony"]
+
+    def process(self, context):
+        func = """function func()
+        {
+            var palette_list = PaletteObjectManager.getScenePaletteList();
+
+            var palettes = {};
+            for(var i=0; i < palette_list.numPalettes; ++i)
+            {
+                var palette = palette_list.getPaletteByIndex(i);
+                palettes[palette.getName()] = palette.id;
+            }
+
+            return palettes;
+        }
+        func
+        """
+        palettes = harmony.send({"function": func})["result"]
+
+        for name, id in palettes.items():
+            instance = context.create_instance(name)
+            instance.data.update({
+                "id": id,
+                "family": "harmony.palette",
+                "asset": os.environ["AVALON_ASSET"],
+                "subset": "palette" + name
+            })
+            self.log.info(
+                "Created instance:\n" + json.dumps(
+                    instance.data, sort_keys=True, indent=4
+                )
+            )

pype/plugins/harmony/publish/extract_palette.py

@@ -0,0 +1,34 @@
+import os
+
+from avalon import harmony
+import pype.api
+import pype.hosts.harmony
+
+
+class ExtractPalette(pype.api.Extractor):
+    """Extract palette."""
+
+    label = "Extract Palette"
+    hosts = ["harmony"]
+    families = ["harmony.palette"]
+
+    def process(self, instance):
+        func = """function func(args)
+        {
+            var palette_list = PaletteObjectManager.getScenePaletteList();
+            var palette = palette_list.getPaletteById(args[0]);
+            return (palette.getPath() + "/" + palette.getName() + ".plt");
+        }
+        func
+        """
+        palette_file = harmony.send(
+            {"function": func, "args": [instance.data["id"]]}
+        )["result"]
+
+        representation = {
+            "name": "plt",
+            "ext": "plt",
+            "files": os.path.basename(palette_file),
+            "stagingDir": os.path.dirname(palette_file)
+        }
+        instance.data["representations"] = [representation]