Merge branch '2.x/develop' into 2.x/feature/photoshop_flag_outdated_containers

pype/hosts/harmony/__init__.py

@@ -1,8 +1,9 @@
 import os
 import sys
 
-from avalon import api, harmony
+from avalon import api, io, harmony
 from avalon.vendor import Qt
+import avalon.tools.sceneinventory
 import pyblish.api
 from pype import lib
 
@@ -92,6 +93,56 @@ def ensure_scene_settings():
     set_scene_settings(valid_settings)
 
 
+def check_inventory():
+    if not lib.any_outdated():
+        return
+
+    host = avalon.api.registered_host()
+    outdated_containers = []
+    for container in host.ls():
+        representation = container['representation']
+        representation_doc = io.find_one(
+            {
+                "_id": io.ObjectId(representation),
+                "type": "representation"
+            },
+            projection={"parent": True}
+        )
+        if representation_doc and not lib.is_latest(representation_doc):
+            outdated_containers.append(container)
+
+    # Colour nodes.
+    func = """function func(args){
+        for( var i =0; i <= args[0].length - 1; ++i)
+        {
+            var red_color = new ColorRGBA(255, 0, 0, 255);
+            node.setColor(args[0][i], red_color);
+        }
+    }
+    func
+    """
+    outdated_nodes = [x["node"] for x in outdated_containers]
+    harmony.send({"function": func, "args": [outdated_nodes]})
+
+    # Warn about outdated containers.
+    print("Starting new QApplication..")
+    app = Qt.QtWidgets.QApplication(sys.argv)
+
+    message_box = Qt.QtWidgets.QMessageBox()
+    message_box.setIcon(Qt.QtWidgets.QMessageBox.Warning)
+    msg = "There are outdated containers in the scene."
+    message_box.setText(msg)
+    message_box.exec_()
+
+    # Garbage collect QApplication.
+    del app
+
+
+def application_launch():
+    ensure_scene_settings()
+    check_inventory()
+
+
 def export_template(backdrops, nodes, filepath):
     func = """function func(args)
     {
@@ -161,7 +212,7 @@ def install():
         "instanceToggled", on_pyblish_instance_toggled
     )
 
-    api.on("application.launched", ensure_scene_settings)
+    api.on("application.launched", application_launch)
 
 
 def on_pyblish_instance_toggled(instance, old_value, new_value):

pype/modules/ftrack/ftrack_server/lib.py

@@ -51,9 +51,10 @@ def get_ftrack_event_mongo_info():
 
     if not _used_ftrack_url or components["database"] is None:
         components["database"] = database_name
-    components["collection"] = collection_name
 
-    uri = compose_url(components)
+    components.pop("collection", None)
+
+    uri = compose_url(**components)
 
     return uri, components["port"], database_name, collection_name
 

pype/plugins/blender/create/create_camera.py

@@ -0,0 +1,32 @@
+"""Create a camera asset."""
+
+import bpy
+
+from avalon import api
+from avalon.blender import Creator, lib
+import pype.hosts.blender.plugin
+
+
+class CreateCamera(Creator):
+    """Polygonal static geometry"""
+
+    name = "cameraMain"
+    label = "Camera"
+    family = "camera"
+    icon = "video-camera"
+
+    def process(self):
+
+        asset = self.data["asset"]
+        subset = self.data["subset"]
+        name = pype.hosts.blender.plugin.asset_name(asset, subset)
+        collection = bpy.data.collections.new(name=name)
+        bpy.context.scene.collection.children.link(collection)
+        self.data['task'] = api.Session.get('AVALON_TASK')
+        lib.imprint(collection, self.data)
+
+        if (self.options or {}).get("useSelection"):
+            for obj in lib.get_selection():
+                collection.objects.link(obj)
+
+        return collection

pype/plugins/blender/load/load_camera.py

@@ -0,0 +1,239 @@
+"""Load a camera asset in Blender."""
+
+import logging
+from pathlib import Path
+from pprint import pformat
+from typing import Dict, List, Optional
+
+from avalon import api, blender
+import bpy
+import pype.hosts.blender.plugin
+
+logger = logging.getLogger("pype").getChild("blender").getChild("load_camera")
+
+
+class BlendCameraLoader(pype.hosts.blender.plugin.AssetLoader):
+    """Load a camera from a .blend file.
+
+    Warning:
+        Loading the same asset more then once is not properly supported at the
+        moment.
+    """
+
+    families = ["camera"]
+    representations = ["blend"]
+
+    label = "Link Camera"
+    icon = "code-fork"
+    color = "orange"
+
+    def _remove(self, objects, lib_container):
+
+        for obj in objects:
+            bpy.data.cameras.remove(obj.data)
+
+        bpy.data.collections.remove(bpy.data.collections[lib_container])
+
+    def _process(self, libpath, lib_container, container_name, actions):
+
+        relative = bpy.context.preferences.filepaths.use_relative_paths
+        with bpy.data.libraries.load(
+            libpath, link=True, relative=relative
+        ) as (_, data_to):
+            data_to.collections = [lib_container]
+
+        scene = bpy.context.scene
+
+        scene.collection.children.link(bpy.data.collections[lib_container])
+
+        camera_container = scene.collection.children[lib_container].make_local()
+
+        objects_list = []
+
+        for obj in camera_container.objects:
+            obj = obj.make_local()
+            obj.data.make_local()
+
+            if not obj.get(blender.pipeline.AVALON_PROPERTY):
+                obj[blender.pipeline.AVALON_PROPERTY] = dict()
+
+            avalon_info = obj[blender.pipeline.AVALON_PROPERTY]
+            avalon_info.update({"container_name": container_name})
+
+            if actions[0] is not None:
+                if obj.animation_data is None:
+                    obj.animation_data_create()
+                obj.animation_data.action = actions[0]
+
+            if actions[1] is not None:
+                if obj.data.animation_data is None:
+                    obj.data.animation_data_create()
+                obj.data.animation_data.action = actions[1]
+
+            objects_list.append(obj)
+
+        camera_container.pop(blender.pipeline.AVALON_PROPERTY)
+
+        bpy.ops.object.select_all(action='DESELECT')
+
+        return objects_list
+
+    def process_asset(
+        self, context: dict, name: str, namespace: Optional[str] = None,
+        options: Optional[Dict] = None
+    ) -> Optional[List]:
+        """
+        Arguments:
+            name: Use pre-defined name
+            namespace: Use pre-defined namespace
+            context: Full parenthood of representation to load
+            options: Additional settings dictionary
+        """
+
+        libpath = self.fname
+        asset = context["asset"]["name"]
+        subset = context["subset"]["name"]
+        lib_container = pype.hosts.blender.plugin.asset_name(asset, subset)
+        container_name = pype.hosts.blender.plugin.asset_name(
+            asset, subset, namespace
+        )
+
+        container = bpy.data.collections.new(lib_container)
+        container.name = container_name
+        blender.pipeline.containerise_existing(
+            container,
+            name,
+            namespace,
+            context,
+            self.__class__.__name__,
+        )
+
+        container_metadata = container.get(
+            blender.pipeline.AVALON_PROPERTY)
+
+        container_metadata["libpath"] = libpath
+        container_metadata["lib_container"] = lib_container
+
+        objects_list = self._process(
+            libpath, lib_container, container_name, (None, None))
+
+        # Save the list of objects in the metadata container
+        container_metadata["objects"] = objects_list
+
+        nodes = list(container.objects)
+        nodes.append(container)
+        self[:] = nodes
+        return nodes
+
+    def update(self, container: Dict, representation: Dict):
+        """Update the loaded asset.
+
+        This will remove all objects of the current collection, load the new
+        ones and add them to the collection.
+        If the objects of the collection are used in another collection they
+        will not be removed, only unlinked. Normally this should not be the
+        case though.
+
+        Warning:
+            No nested collections are supported at the moment!
+        """
+
+        collection = bpy.data.collections.get(
+            container["objectName"]
+        )
+
+        libpath = Path(api.get_representation_path(representation))
+        extension = libpath.suffix.lower()
+
+        logger.info(
+            "Container: %s\nRepresentation: %s",
+            pformat(container, indent=2),
+            pformat(representation, indent=2),
+        )
+
+        assert collection, (
+            f"The asset is not loaded: {container['objectName']}"
+        )
+        assert not (collection.children), (
+            "Nested collections are not supported."
+        )
+        assert libpath, (
+            "No existing library file found for {container['objectName']}"
+        )
+        assert libpath.is_file(), (
+            f"The file doesn't exist: {libpath}"
+        )
+        assert extension in pype.hosts.blender.plugin.VALID_EXTENSIONS, (
+            f"Unsupported file: {libpath}"
+        )
+
+        collection_metadata = collection.get(
+            blender.pipeline.AVALON_PROPERTY)
+        collection_libpath = collection_metadata["libpath"]
+        objects = collection_metadata["objects"]
+        lib_container = collection_metadata["lib_container"]
+
+        normalized_collection_libpath = (
+            str(Path(bpy.path.abspath(collection_libpath)).resolve())
+        )
+        normalized_libpath = (
+            str(Path(bpy.path.abspath(str(libpath))).resolve())
+        )
+        logger.debug(
+            "normalized_collection_libpath:\n  %s\nnormalized_libpath:\n  %s",
+            normalized_collection_libpath,
+            normalized_libpath,
+        )
+        if normalized_collection_libpath == normalized_libpath:
+            logger.info("Library already loaded, not updating...")
+            return
+
+        camera = objects[0]
+
+        actions = (camera.animation_data.action, camera.data.animation_data.action)
+
+        self._remove(objects, lib_container)
+
+        objects_list = self._process(
+            str(libpath), lib_container, collection.name, actions)
+
+        # Save the list of objects in the metadata container
+        collection_metadata["objects"] = objects_list
+        collection_metadata["libpath"] = str(libpath)
+        collection_metadata["representation"] = str(representation["_id"])
+
+        bpy.ops.object.select_all(action='DESELECT')
+
+    def remove(self, container: Dict) -> bool:
+        """Remove an existing container from a Blender scene.
+
+        Arguments:
+            container (avalon-core:container-1.0): Container to remove,
+                from `host.ls()`.
+
+        Returns:
+            bool: Whether the container was deleted.
+
+        Warning:
+            No nested collections are supported at the moment!
+        """
+
+        collection = bpy.data.collections.get(
+            container["objectName"]
+        )
+        if not collection:
+            return False
+        assert not (collection.children), (
+            "Nested collections are not supported."
+        )
+
+        collection_metadata = collection.get(
+            blender.pipeline.AVALON_PROPERTY)
+        objects = collection_metadata["objects"]
+        lib_container = collection_metadata["lib_container"]
+
+        self._remove(objects, lib_container)
+
+        bpy.data.collections.remove(collection)
+
+        return True

pype/plugins/blender/publish/extract_blend.py

@@ -9,7 +9,7 @@ class ExtractBlend(pype.api.Extractor):
 
     label = "Extract Blend"
     hosts = ["blender"]
-    families = ["animation", "model", "rig", "action", "layout"]
+    families = ["model", "camera", "rig", "action", "layout", "animation"]
     optional = True
 
     def process(self, instance):

pype/plugins/global/publish/validate_containers.py

@@ -19,7 +19,7 @@ class ValidateContainers(pyblish.api.ContextPlugin):
 
     label = "Validate Containers"
     order = pyblish.api.ValidatorOrder
-    hosts = ["maya", "houdini", "nuke", "photoshop"]
+    hosts = ["maya", "houdini", "nuke", "harmony", "photoshop"]
     optional = True
     actions = [ShowInventory]
 

pype/plugins/harmony/load/load_imagesequence.py

@@ -98,33 +98,63 @@ function import_files(args)
         transparencyModeAttr.setValue(SGITransparencyMode);
     if (extension == "psd")
         transparencyModeAttr.setValue(FlatPSDTransparencyMode);
+    if (extension == "jpg")
+        transparencyModeAttr.setValue(LayeredPSDTransparencyMode);
 
     node.linkAttr(read, "DRAWING.ELEMENT", uniqueColumnName);
 
-    // Create a drawing for each file.
-    for( var i =0; i <= files.length - 1; ++i)
+    if (files.length == 1)
     {
-        timing = start_frame + i
         // Create a drawing drawing, 'true' indicate that the file exists.
-        Drawing.create(elemId, timing, true);
+        Drawing.create(elemId, 1, true);
         // Get the actual path, in tmp folder.
-        var drawingFilePath = Drawing.filename(elemId, timing.toString());
-        copyFile( files[i], drawingFilePath );
+        var drawingFilePath = Drawing.filename(elemId, "1");
+        copyFile(files[0], drawingFilePath);
+        // Expose the image for the entire frame range.
+        for( var i =0; i <= frame.numberOf() - 1; ++i)
+        {
+            timing = start_frame + i
+            column.setEntry(uniqueColumnName, 1, timing, "1");
+        }
+    } else {
+        // Create a drawing for each file.
+        for( var i =0; i <= files.length - 1; ++i)
+        {
+            timing = start_frame + i
+            // Create a drawing drawing, 'true' indicate that the file exists.
+            Drawing.create(elemId, timing, true);
+            // Get the actual path, in tmp folder.
+            var drawingFilePath = Drawing.filename(elemId, timing.toString());
+            copyFile( files[i], drawingFilePath );
 
-        column.setEntry(uniqueColumnName, 1, timing, timing.toString());
+            column.setEntry(uniqueColumnName, 1, timing, timing.toString());
+        }
     }
+
+    var green_color = new ColorRGBA(0, 255, 0, 255);
+    node.setColor(read, green_color);
+
     return read;
 }
 import_files
 """
 
-replace_files = """function replace_files(args)
+replace_files = """var PNGTransparencyMode = 0; //Premultiplied wih Black
+var TGATransparencyMode = 0; //Premultiplied wih Black
+var SGITransparencyMode = 0; //Premultiplied wih Black
+var LayeredPSDTransparencyMode = 1; //Straight
+var FlatPSDTransparencyMode = 2; //Premultiplied wih White
+
+function replace_files(args)
 {
     var files = args[0];
+    MessageLog.trace(files);
+    MessageLog.trace(files.length);
     var _node = args[1];
     var start_frame = args[2];
 
     var _column = node.linkedColumn(_node, "DRAWING.ELEMENT");
+    var elemId = column.getElementIdOfDrawing(_column);
 
     // Delete existing drawings.
     var timings = column.getDrawingTimings(_column);
@@ -133,20 +163,62 @@ replace_files = """function replace_files(args)
         column.deleteDrawingAt(_column, parseInt(timings[i]));
     }
 
-    // Create new drawings.
-    for( var i =0; i <= files.length - 1; ++i)
-    {
-        timing = start_frame + i
-        // Create a drawing drawing, 'true' indicate that the file exists.
-        Drawing.create(node.getElementId(_node), timing, true);
-        // Get the actual path, in tmp folder.
-        var drawingFilePath = Drawing.filename(
-            node.getElementId(_node), timing.toString()
-        );
-        copyFile( files[i], drawingFilePath );
 
-        column.setEntry(_column, 1, timing, timing.toString());
+    var filename = files[0];
+    var pos = filename.lastIndexOf(".");
+    if( pos < 0 )
+        return null;
+    var extension = filename.substr(pos+1).toLowerCase();
+
+    if(extension == "jpeg")
+        extension = "jpg";
+
+    var transparencyModeAttr = node.getAttr(
+        _node, frame.current(), "applyMatteToColor"
+    );
+    if (extension == "png")
+        transparencyModeAttr.setValue(PNGTransparencyMode);
+    if (extension == "tga")
+        transparencyModeAttr.setValue(TGATransparencyMode);
+    if (extension == "sgi")
+        transparencyModeAttr.setValue(SGITransparencyMode);
+    if (extension == "psd")
+        transparencyModeAttr.setValue(FlatPSDTransparencyMode);
+    if (extension == "jpg")
+        transparencyModeAttr.setValue(LayeredPSDTransparencyMode);
+
+    if (files.length == 1)
+    {
+        // Create a drawing drawing, 'true' indicate that the file exists.
+        Drawing.create(elemId, 1, true);
+        // Get the actual path, in tmp folder.
+        var drawingFilePath = Drawing.filename(elemId, "1");
+        copyFile(files[0], drawingFilePath);
+        MessageLog.trace(files[0]);
+        MessageLog.trace(drawingFilePath);
+        // Expose the image for the entire frame range.
+        for( var i =0; i <= frame.numberOf() - 1; ++i)
+        {
+            timing = start_frame + i
+            column.setEntry(_column, 1, timing, "1");
+        }
+    } else {
+        // Create a drawing for each file.
+        for( var i =0; i <= files.length - 1; ++i)
+        {
+            timing = start_frame + i
+            // Create a drawing drawing, 'true' indicate that the file exists.
+            Drawing.create(elemId, timing, true);
+            // Get the actual path, in tmp folder.
+            var drawingFilePath = Drawing.filename(elemId, timing.toString());
+            copyFile( files[i], drawingFilePath );
+
+            column.setEntry(_column, 1, timing, timing.toString());
+        }
     }
+
+    var green_color = new ColorRGBA(0, 255, 0, 255);
+    node.setColor(_node, green_color);
 }
 replace_files
 """
@@ -156,8 +228,8 @@ class ImageSequenceLoader(api.Loader):
     """Load images
     Stores the imported asset in a container named after the asset.
     """
-    families = ["shot", "render"]
-    representations = ["jpeg", "png"]
+    families = ["shot", "render", "image"]
+    representations = ["jpeg", "png", "jpg"]
 
     def load(self, context, name=None, namespace=None, data=None):
 
@@ -165,9 +237,18 @@ class ImageSequenceLoader(api.Loader):
             os.listdir(os.path.dirname(self.fname))
         )
         files = []
-        for f in list(collections[0]):
+        if collections:
+            for f in list(collections[0]):
+                files.append(
+                    os.path.join(
+                        os.path.dirname(self.fname), f
+                    ).replace("\\", "/")
+                )
+        else:
             files.append(
-                os.path.join(os.path.dirname(self.fname), f).replace("\\", "/")
+                os.path.join(
+                    os.path.dirname(self.fname), remainder[0]
+                ).replace("\\", "/")
             )
 
         read_node = harmony.send(
@@ -190,15 +271,23 @@ class ImageSequenceLoader(api.Loader):
     def update(self, container, representation):
         node = container.pop("node")
 
+        path = api.get_representation_path(representation)
         collections, remainder = clique.assemble(
-            os.listdir(
-                os.path.dirname(api.get_representation_path(representation))
-            )
+            os.listdir(os.path.dirname(path))
         )
         files = []
-        for f in list(collections[0]):
+        if collections:
+            for f in list(collections[0]):
+                files.append(
+                    os.path.join(
+                        os.path.dirname(path), f
+                    ).replace("\\", "/")
+                )
+        else:
             files.append(
-                os.path.join(os.path.dirname(self.fname), f).replace("\\", "/")
+                os.path.join(
+                    os.path.dirname(path), remainder[0]
+                ).replace("\\", "/")
             )
 
         harmony.send(

pype/plugins/photoshop/create/create_image.py

@@ -74,4 +74,5 @@ class CreateImage(api.Creator):
             groups.append(group)
 
         for group in groups:
+            self.data.update({"subset": "image" + group.Name})
             photoshop.imprint(group, self.data)

pype/plugins/photoshop/publish/collect_review.py

@@ -0,0 +1,36 @@
+import os
+
+import pythoncom
+
+import pyblish.api
+
+
+class CollectReview(pyblish.api.ContextPlugin):
+    """Gather the active document as review instance."""
+
+    label = "Review"
+    order = pyblish.api.CollectorOrder
+    hosts = ["photoshop"]
+
+    def process(self, context):
+        # Necessary call when running in a different thread which pyblish-qml
+        # can be.
+        pythoncom.CoInitialize()
+
+        family = "review"
+        task = os.getenv("AVALON_TASK", None)
+        subset = family + task.capitalize()
+
+        file_path = context.data["currentFile"]
+        base_name = os.path.basename(file_path)
+
+        instance = context.create_instance(subset)
+        instance.data.update({
+            "subset": subset,
+            "label": base_name,
+            "name": base_name,
+            "family": family,
+            "families": ["ftrack"],
+            "representations": [],
+            "asset": os.environ["AVALON_ASSET"]
+        })

pype/plugins/photoshop/publish/extract_review.py

@@ -0,0 +1,103 @@
+import os
+
+import pype.api
+import pype.lib
+from avalon import photoshop
+
+
+class ExtractReview(pype.api.Extractor):
+    """Produce a flattened image file from all instances."""
+
+    label = "Extract Review"
+    hosts = ["photoshop"]
+    families = ["review"]
+
+    def process(self, instance):
+
+        staging_dir = self.staging_dir(instance)
+        self.log.info("Outputting image to {}".format(staging_dir))
+
+        layers = []
+        for image_instance in instance.context:
+            if image_instance.data["family"] != "image":
+                continue
+            layers.append(image_instance[0])
+
+        # Perform extraction
+        output_image = "{} copy.jpg".format(
+            os.path.splitext(photoshop.app().ActiveDocument.Name)[0]
+        )
+        with photoshop.maintained_visibility():
+            # Hide all other layers.
+            extract_ids = [
+                x.id for x in photoshop.get_layers_in_layers(layers)
+            ]
+            for layer in photoshop.get_layers_in_document():
+                if layer.id in extract_ids:
+                    layer.Visible = True
+                else:
+                    layer.Visible = False
+
+            photoshop.app().ActiveDocument.SaveAs(
+                staging_dir, photoshop.com_objects.JPEGSaveOptions(), True
+            )
+
+        instance.data["representations"].append({
+            "name": "jpg",
+            "ext": "jpg",
+            "files": output_image,
+            "stagingDir": staging_dir
+        })
+        instance.data["stagingDir"] = staging_dir
+
+        # Generate thumbnail.
+        thumbnail_path = os.path.join(staging_dir, "thumbnail.jpg")
+        args = [
+            "ffmpeg", "-y",
+            "-i", os.path.join(staging_dir, output_image),
+            "-vf", "scale=300:-1",
+            "-vframes", "1",
+            thumbnail_path
+        ]
+        output = pype.lib._subprocess(args, cwd=os.environ["FFMPEG_PATH"])
+
+        self.log.debug(output)
+
+        instance.data["representations"].append({
+            "name": "thumbnail",
+            "ext": "jpg",
+            "files": os.path.basename(thumbnail_path),
+            "stagingDir": staging_dir,
+            "tags": ["thumbnail"]
+        })
+
+        # Generate mov.
+        mov_path = os.path.join(staging_dir, "review.mov")
+        args = [
+            "ffmpeg", "-y",
+            "-i", os.path.join(staging_dir, output_image),
+            "-vframes", "1",
+            mov_path
+        ]
+        output = pype.lib._subprocess(args, cwd=os.environ["FFMPEG_PATH"])
+
+        self.log.debug(output)
+
+        instance.data["representations"].append({
+            "name": "mov",
+            "ext": "mov",
+            "files": os.path.basename(mov_path),
+            "stagingDir": staging_dir,
+            "frameStart": 1,
+            "frameEnd": 1,
+            "fps": 25,
+            "preview": True,
+            "tags": ["review", "ftrackreview"]
+        })
+
+        # Required for extract_review plugin (L222 onwards).
+        instance.data["frameStart"] = 1
+        instance.data["frameEnd"] = 1
+        instance.data["fps"] = 25
+
+        self.log.info(f"Extracted {instance} to {staging_dir}")

pype/plugins/photoshop/publish/validate_naming.py

@@ -1,5 +1,6 @@
 import pyblish.api
 import pype.api
+from avalon import photoshop
 
 
 class ValidateNamingRepair(pyblish.api.Action):
@@ -22,7 +23,11 @@ class ValidateNamingRepair(pyblish.api.Action):
         instances = pyblish.api.instances_by_plugin(failed, plugin)
 
         for instance in instances:
-            instance[0].Name = instance.data["name"].replace(" ", "_")
+            name = instance.data["name"].replace(" ", "_")
+            instance[0].Name = name
+            data = photoshop.read(instance[0])
+            data["subset"] = "image" + name
+            photoshop.imprint(instance[0], data)
 
         return True
 
@@ -42,3 +47,6 @@ class ValidateNaming(pyblish.api.InstancePlugin):
     def process(self, instance):
         msg = "Name \"{}\" is not allowed.".format(instance.data["name"])
         assert " " not in instance.data["name"], msg
+
+        msg = "Subset \"{}\" is not allowed.".format(instance.data["subset"])
+        assert " " not in instance.data["subset"], msg