Initial Photoshop integration.

pype/hosts/photoshop/__init__.py

@@ -0,0 +1,24 @@
+import os
+
+from avalon import api
+import pyblish.api
+
+
+def install():
+    print("Installing Pype config...")
+
+    plugins_directory = os.path.join(
+        os.path.dirname(os.path.dirname(os.path.dirname(__file__))),
+        "plugins",
+        "photoshop"
+    )
+
+    pyblish.api.register_plugin_path(
+        os.path.join(plugins_directory, "publish")
+    )
+    api.register_plugin_path(
+        api.Loader, os.path.join(plugins_directory, "load")
+    )
+    api.register_plugin_path(
+        api.Creator, os.path.join(plugins_directory, "create")
+    )

pype/plugins/global/publish/integrate_new.py

@@ -77,7 +77,7 @@ class IntegrateAssetNew(pyblish.api.InstancePlugin):
                 "gizmo",
                 "source",
                 "matchmove",
-                "image"
+                "image",
                 "source",
                 "assembly",
                 "fbx",

pype/plugins/photoshop/create/create_image.py

@@ -0,0 +1,12 @@
+from avalon import photoshop
+
+
+class CreateImage(photoshop.Creator):
+    """Image folder for publish."""
+
+    name = "imageDefault"
+    label = "Image"
+    family = "image"
+
+    def __init__(self, *args, **kwargs):
+        super(CreateImage, self).__init__(*args, **kwargs)

pype/plugins/photoshop/load/load_image.py

@@ -0,0 +1,43 @@
+from avalon import api, photoshop
+
+
+class ImageLoader(api.Loader):
+    """Load images
+
+    Stores the imported asset in a container named after the asset.
+    """
+
+    families = ["image"]
+    representations = ["*"]
+
+    def load(self, context, name=None, namespace=None, data=None):
+        with photoshop.maintained_selection():
+            layer = photoshop.import_smart_object(self.fname)
+
+        self[:] = [layer]
+
+        return photoshop.containerise(
+            name,
+            namespace,
+            layer,
+            context,
+            self.__class__.__name__
+        )
+
+    def update(self, container, representation):
+        layer = container.pop("layer")
+
+        with photoshop.maintained_selection():
+            photoshop.replace_smart_object(
+                layer, api.get_representation_path(representation)
+            )
+
+        photoshop.imprint(
+            layer, {"representation": str(representation["_id"])}
+        )
+
+    def remove(self, container):
+        container["layer"].Delete()
+
+    def switch(self, container, representation):
+        self.update(container, representation)

pype/plugins/photoshop/publish/collect_current_file.py

@@ -0,0 +1,17 @@
+import os
+
+import pyblish.api
+from avalon import photoshop
+
+
+class CollectCurrentFile(pyblish.api.ContextPlugin):
+    """Inject the current working file into context"""
+
+    order = pyblish.api.CollectorOrder - 0.5
+    label = "Current File"
+    hosts = ["photoshop"]
+
+    def process(self, context):
+        context.data["currentFile"] = os.path.normpath(
+            photoshop.app().ActiveDocument.FullName
+        ).replace("\\", "/")

pype/plugins/photoshop/publish/collect_instances.py

@@ -0,0 +1,55 @@
+import pythoncom
+
+from avalon import photoshop
+
+import pyblish.api
+
+
+class CollectInstances(pyblish.api.ContextPlugin):
+    """Gather instances by LayerSet and file metadata
+
+    This collector takes into account assets that are associated with
+    an LayerSet and marked with a unique identifier;
+
+    Identifier:
+        id (str): "pyblish.avalon.instance"
+    """
+
+    label = "Instances"
+    order = pyblish.api.CollectorOrder
+    hosts = ["photoshop"]
+    families_mapping = {
+        "image": []
+    }
+
+    def process(self, context):
+        # Necessary call when running in a different thread which pyblish-qml
+        # can be.
+        pythoncom.CoInitialize()
+
+        for layer in photoshop.get_layers_in_document():
+            layer_data = photoshop.read(layer)
+
+            # Skip layers without metadata.
+            if layer_data is None:
+                continue
+
+            # Skip containers.
+            if "container" in layer_data["id"]:
+                continue
+
+            child_layers = [*layer.Layers]
+            if not child_layers:
+                self.log.info("%s skipped, it was empty." % layer.Name)
+                continue
+
+            instance = context.create_instance(layer.Name)
+            instance.append(layer)
+            instance.data.update(layer_data)
+            instance.data["families"] = self.families_mapping[
+                layer_data["family"]
+            ]
+
+            # Produce diagnostic message for any graphical
+            # user interface interested in visualising it.
+            self.log.info("Found: \"%s\" " % instance.data["name"])

pype/plugins/photoshop/publish/extract_image.py

@@ -0,0 +1,62 @@
+import os
+
+import pype.api
+from avalon import photoshop
+
+
+class ExtractImage(pype.api.Extractor):
+    """Produce a flattened image file from instance
+
+    This plug-in takes into account only the layers in the group.
+    """
+
+    label = "Extract Image"
+    hosts = ["photoshop"]
+    families = ["image"]
+
+    def process(self, instance):
+
+        staging_dir = self.staging_dir(instance)
+        self.log.info("Outputting image to {}".format(staging_dir))
+
+        # Perform extraction
+        files = {}
+        with photoshop.maintained_selection():
+            self.log.info("Extracting %s" % str(list(instance)))
+            with photoshop.maintained_visibility():
+                # Hide all other layers.
+                extract_ids = [
+                    x.id for x in photoshop.get_layers_in_layers([instance[0]])
+                ]
+                for layer in photoshop.get_layers_in_document():
+                    if layer.id not in extract_ids:
+                        layer.Visible = False
+
+                save_options = {
+                    "png": photoshop.com_objects.PNGSaveOptions(),
+                    "jpg": photoshop.com_objects.JPEGSaveOptions()
+                }
+
+                for extension, save_option in save_options.items():
+                    photoshop.app().ActiveDocument.SaveAs(
+                        staging_dir, save_option, True
+                    )
+                    files[extension] = "{} copy.{}".format(
+                        os.path.splitext(
+                            photoshop.app().ActiveDocument.Name
+                        )[0],
+                        extension
+                    )
+
+        representations = []
+        for extension, filename in files.items():
+            representations.append({
+                "name": extension,
+                "ext": extension,
+                "files": filename,
+                "stagingDir": staging_dir
+            })
+        instance.data["representations"] = representations
+        instance.data["stagingDir"] = staging_dir
+
+        self.log.info(f"Extracted {instance} to {staging_dir}")