Merge pull request #232 from tokejepsen/2.x/feature/photoshop

Initial Photoshop integration.

pype/hosts/photoshop/__init__.py

@@ -0,0 +1,33 @@
+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")
+ )
+
+ pyblish.api.register_callback(
+ "instanceToggled", on_pyblish_instance_toggled
+ )
+
+
+def on_pyblish_instance_toggled(instance, old_value, new_value):
+ """Toggle layer visibility on instance toggles."""
+ instance[0].Visible = new_value

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,56 @@
+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"]
+ ]
+ instance.data["publish"] = layer.Visible
+
+ # Produce diagnostic message for any graphical
+ # user interface interested in visualising it.
+ self.log.info("Found: \"%s\" " % instance.data["name"])

pype/plugins/photoshop/publish/collect_workfile.py

@@ -0,0 +1,39 @@
+import pyblish.api
+import os
+
+
+class CollectWorkfile(pyblish.api.ContextPlugin):
+ """Collect current script for publish."""
+
+ order = pyblish.api.CollectorOrder + 0.1
+ label = "Collect Workfile"
+ hosts = ["photoshop"]
+
+ def process(self, context):
+ family = "workfile"
+ task = os.getenv("AVALON_TASK", None)
+ subset = family + task.capitalize()
+
+ file_path = context.data["currentFile"]
+ staging_dir = os.path.dirname(file_path)
+ base_name = os.path.basename(file_path)
+
+ # Create instance
+ instance = context.create_instance(subset)
+ instance.data.update({
+ "subset": subset,
+ "label": base_name,
+ "name": base_name,
+ "family": family,
+ "families": [],
+ "representations": [],
+ "asset": os.environ["AVALON_ASSET"]
+ })
+
+ # creating representation
+ instance.data["representations"].append({
+ "name": "psd",
+ "ext": "psd",
+ "files": base_name,
+ "stagingDir": staging_dir,
+ })

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}")

pype/plugins/photoshop/publish/extract_save_scene.py

@@ -0,0 +1,14 @@
+import pype.api
+from avalon import photoshop
+
+
+class ExtractSaveScene(pype.api.Extractor):
+ """Save scene before extraction."""
+
+ order = pype.api.Extractor.order - 0.49
+ label = "Extract Save Scene"
+ hosts = ["photoshop"]
+ families = ["workfile"]
+
+ def process(self, instance):
+ photoshop.app().ActiveDocument.Save()

pype/plugins/photoshop/publish/validate_instance_asset.py

@@ -0,0 +1,48 @@
+import os
+
+import pyblish.api
+import pype.api
+from avalon import photoshop
+
+
+class ValidateInstanceAssetRepair(pyblish.api.Action):
+ """Repair the instance asset."""
+
+ label = "Repair"
+ icon = "wrench"
+ on = "failed"
+
+ def process(self, context, plugin):
+
+ # Get the errored instances
+ failed = []
+ for result in context.data["results"]:
+ if (result["error"] is not None and result["instance"] is not None
+ and result["instance"] not in failed):
+ failed.append(result["instance"])
+
+ # Apply pyblish.logic to get the instances for the plug-in
+ instances = pyblish.api.instances_by_plugin(failed, plugin)
+
+ for instance in instances:
+ data = photoshop.read(instance[0])
+ data["asset"] = os.environ["AVALON_ASSET"]
+ photoshop.imprint(instance[0], data)
+
+
+class ValidateInstanceAsset(pyblish.api.InstancePlugin):
+ """Validate the instance asset is the current asset."""
+
+ label = "Validate Instance Asset"
+ hosts = ["photoshop"]
+ actions = [ValidateInstanceAssetRepair]
+ order = pype.api.ValidateContentsOrder
+
+ def process(self, instance):
+ instance_asset = instance.data["asset"]
+ current_asset = os.environ["AVALON_ASSET"]
+ msg = (
+ "Instance asset is not the same as current asset:"
+ f"\nInstance: {instance_asset}\nCurrent: {current_asset}"
+ )
+ assert instance_asset == current_asset, msg