Merge branch 'develop' into enhancement/OP-6021_Nuke-custom-write-nodes-scripts

openpype/hosts/houdini/api/colorspace.py

@@ -0,0 +1,56 @@
+import attr
+import hou
+from openpype.hosts.houdini.api.lib import get_color_management_preferences
+
+
+@attr.s
+class LayerMetadata(object):
+    """Data class for Render Layer metadata."""
+    frameStart = attr.ib()
+    frameEnd = attr.ib()
+
+
+@attr.s
+class RenderProduct(object):
+    """Getting Colorspace as
+    Specific Render Product Parameter for submitting
+    publish job.
+
+    """
+    colorspace = attr.ib()                      # colorspace
+    view = attr.ib()
+    productName = attr.ib(default=None)
+
+
+class ARenderProduct(object):
+
+    def __init__(self):
+        """Constructor."""
+        # Initialize
+        self.layer_data = self._get_layer_data()
+        self.layer_data.products = self.get_colorspace_data()
+
+    def _get_layer_data(self):
+        return LayerMetadata(
+            frameStart=int(hou.playbar.frameRange()[0]),
+            frameEnd=int(hou.playbar.frameRange()[1]),
+        )
+
+    def get_colorspace_data(self):
+        """To be implemented by renderer class.
+
+        This should return a list of RenderProducts.
+
+        Returns:
+            list: List of RenderProduct
+
+        """
+        data = get_color_management_preferences()
+        colorspace_data = [
+            RenderProduct(
+                colorspace=data["display"],
+                view=data["view"],
+                productName=""
+            )
+        ]
+        return colorspace_data

openpype/hosts/houdini/api/lib.py

@@ -1,6 +1,7 @@
 # -*- coding: utf-8 -*-
 import sys
 import os
+import re
 import uuid
 import logging
 from contextlib import contextmanager
@@ -581,3 +582,74 @@ def splitext(name, allowed_multidot_extensions):
             return name[:-len(ext)], ext
 
     return os.path.splitext(name)
+
+
+def get_top_referenced_parm(parm):
+
+    processed = set()  # disallow infinite loop
+    while True:
+        if parm.path() in processed:
+            raise RuntimeError("Parameter references result in cycle.")
+
+        processed.add(parm.path())
+
+        ref = parm.getReferencedParm()
+        if ref.path() == parm.path():
+            # It returns itself when it doesn't reference
+            # another parameter
+            return ref
+        else:
+            parm = ref
+
+
+def evalParmNoFrame(node, parm, pad_character="#"):
+
+    parameter = node.parm(parm)
+    assert parameter, "Parameter does not exist: %s.%s" % (node, parm)
+
+    # If the parameter has a parameter reference, then get that
+    # parameter instead as otherwise `unexpandedString()` fails.
+    parameter = get_top_referenced_parm(parameter)
+
+    # Substitute out the frame numbering with padded characters
+    try:
+        raw = parameter.unexpandedString()
+    except hou.Error as exc:
+        print("Failed: %s" % parameter)
+        raise RuntimeError(exc)
+
+    def replace(match):
+        padding = 1
+        n = match.group(2)
+        if n and int(n):
+            padding = int(n)
+        return pad_character * padding
+
+    expression = re.sub(r"(\$F([0-9]*))", replace, raw)
+
+    with hou.ScriptEvalContext(parameter):
+        return hou.expandStringAtFrame(expression, 0)
+
+
+def get_color_management_preferences():
+    """Get default OCIO preferences"""
+    data = {
+        "config": hou.Color.ocio_configPath()
+
+    }
+
+    # Get default display and view from OCIO
+    display = hou.Color.ocio_defaultDisplay()
+    disp_regex = re.compile(r"^(?P<name>.+-)(?P<display>.+)$")
+    disp_match = disp_regex.match(display)
+
+    view = hou.Color.ocio_defaultView()
+    view_regex = re.compile(r"^(?P<name>.+- )(?P<view>.+)$")
+    view_match = view_regex.match(view)
+    data.update({
+        "display": disp_match.group("display"),
+        "view": view_match.group("view")
+
+    })
+
+    return data

openpype/hosts/houdini/plugins/create/create_arnold_rop.py

@@ -0,0 +1,71 @@
+from openpype.hosts.houdini.api import plugin
+from openpype.lib import EnumDef
+
+
+class CreateArnoldRop(plugin.HoudiniCreator):
+    """Arnold ROP"""
+
+    identifier = "io.openpype.creators.houdini.arnold_rop"
+    label = "Arnold ROP"
+    family = "arnold_rop"
+    icon = "magic"
+    defaults = ["master"]
+
+    # Default extension
+    ext = "exr"
+
+    def create(self, subset_name, instance_data, pre_create_data):
+        import hou
+
+        # Remove the active, we are checking the bypass flag of the nodes
+        instance_data.pop("active", None)
+        instance_data.update({"node_type": "arnold"})
+
+        # Add chunk size attribute
+        instance_data["chunkSize"] = 1
+        # Submit for job publishing
+        instance_data["farm"] = True
+
+        instance = super(CreateArnoldRop, self).create(
+            subset_name,
+            instance_data,
+            pre_create_data)  # type: plugin.CreatedInstance
+
+        instance_node = hou.node(instance.get("instance_node"))
+
+        ext = pre_create_data.get("image_format")
+
+        filepath = "{renders_dir}{subset_name}/{subset_name}.$F4.{ext}".format(
+            renders_dir=hou.text.expandString("$HIP/pyblish/renders/"),
+            subset_name=subset_name,
+            ext=ext,
+        )
+        parms = {
+            # Render frame range
+            "trange": 1,
+
+            # Arnold ROP settings
+            "ar_picture": filepath,
+            "ar_exr_half_precision": 1           # half precision
+        }
+
+        instance_node.setParms(parms)
+
+        # Lock any parameters in this list
+        to_lock = ["family", "id"]
+        self.lock_parameters(instance_node, to_lock)
+
+    def get_pre_create_attr_defs(self):
+        attrs = super(CreateArnoldRop, self).get_pre_create_attr_defs()
+
+        image_format_enum = [
+            "bmp", "cin", "exr", "jpg", "pic", "pic.gz", "png",
+            "rad", "rat", "rta", "sgi", "tga", "tif",
+        ]
+
+        return attrs + [
+            EnumDef("image_format",
+                    image_format_enum,
+                    default=self.ext,
+                    label="Image Format Options")
+        ]

openpype/hosts/houdini/plugins/create/create_karma_rop.py

@@ -0,0 +1,114 @@
+# -*- coding: utf-8 -*-
+"""Creator plugin to create Karma ROP."""
+from openpype.hosts.houdini.api import plugin
+from openpype.pipeline import CreatedInstance
+from openpype.lib import BoolDef, EnumDef, NumberDef
+
+
+class CreateKarmaROP(plugin.HoudiniCreator):
+    """Karma ROP"""
+    identifier = "io.openpype.creators.houdini.karma_rop"
+    label = "Karma ROP"
+    family = "karma_rop"
+    icon = "magic"
+    defaults = ["master"]
+
+    def create(self, subset_name, instance_data, pre_create_data):
+        import hou  # noqa
+
+        instance_data.pop("active", None)
+        instance_data.update({"node_type": "karma"})
+        # Add chunk size attribute
+        instance_data["chunkSize"] = 10
+        # Submit for job publishing
+        instance_data["farm"] = True
+
+        instance = super(CreateKarmaROP, self).create(
+            subset_name,
+            instance_data,
+            pre_create_data)  # type: CreatedInstance
+
+        instance_node = hou.node(instance.get("instance_node"))
+
+        ext = pre_create_data.get("image_format")
+
+        filepath = "{renders_dir}{subset_name}/{subset_name}.$F4.{ext}".format(
+            renders_dir=hou.text.expandString("$HIP/pyblish/renders/"),
+            subset_name=subset_name,
+            ext=ext,
+        )
+        checkpoint = "{cp_dir}{subset_name}.$F4.checkpoint".format(
+            cp_dir=hou.text.expandString("$HIP/pyblish/"),
+            subset_name=subset_name
+        )
+
+        usd_directory = "{usd_dir}{subset_name}_$RENDERID".format(
+            usd_dir=hou.text.expandString("$HIP/pyblish/renders/usd_renders/"),     # noqa
+            subset_name=subset_name
+        )
+
+        parms = {
+            # Render Frame Range
+            "trange": 1,
+            # Karma ROP Setting
+            "picture": filepath,
+            # Karma Checkpoint Setting
+            "productName": checkpoint,
+            # USD Output Directory
+            "savetodirectory": usd_directory,
+        }
+
+        res_x = pre_create_data.get("res_x")
+        res_y = pre_create_data.get("res_y")
+
+        if self.selected_nodes:
+            # If camera found in selection
+            # we will use as render camera
+            camera = None
+            for node in self.selected_nodes:
+                if node.type().name() == "cam":
+                    has_camera = pre_create_data.get("cam_res")
+                    if has_camera:
+                        res_x = node.evalParm("resx")
+                        res_y = node.evalParm("resy")
+
+            if not camera:
+                self.log.warning("No render camera found in selection")
+
+            parms.update({
+                "camera": camera or "",
+                "resolutionx": res_x,
+                "resolutiony": res_y,
+            })
+
+        instance_node.setParms(parms)
+
+        # Lock some Avalon attributes
+        to_lock = ["family", "id"]
+        self.lock_parameters(instance_node, to_lock)
+
+    def get_pre_create_attr_defs(self):
+        attrs = super(CreateKarmaROP, self).get_pre_create_attr_defs()
+
+        image_format_enum = [
+            "bmp", "cin", "exr", "jpg", "pic", "pic.gz", "png",
+            "rad", "rat", "rta", "sgi", "tga", "tif",
+        ]
+
+        return attrs + [
+            EnumDef("image_format",
+                    image_format_enum,
+                    default="exr",
+                    label="Image Format Options"),
+            NumberDef("res_x",
+                      label="width",
+                      default=1920,
+                      decimals=0),
+            NumberDef("res_y",
+                      label="height",
+                      default=720,
+                      decimals=0),
+            BoolDef("cam_res",
+                    label="Camera Resolution",
+                    default=False)
+        ]

openpype/hosts/houdini/plugins/create/create_mantra_rop.py

@@ -0,0 +1,88 @@
+# -*- coding: utf-8 -*-
+"""Creator plugin to create Mantra ROP."""
+from openpype.hosts.houdini.api import plugin
+from openpype.pipeline import CreatedInstance
+from openpype.lib import EnumDef, BoolDef
+
+
+class CreateMantraROP(plugin.HoudiniCreator):
+    """Mantra ROP"""
+    identifier = "io.openpype.creators.houdini.mantra_rop"
+    label = "Mantra ROP"
+    family = "mantra_rop"
+    icon = "magic"
+    defaults = ["master"]
+
+    def create(self, subset_name, instance_data, pre_create_data):
+        import hou  # noqa
+
+        instance_data.pop("active", None)
+        instance_data.update({"node_type": "ifd"})
+        # Add chunk size attribute
+        instance_data["chunkSize"] = 10
+        # Submit for job publishing
+        instance_data["farm"] = True
+
+        instance = super(CreateMantraROP, self).create(
+            subset_name,
+            instance_data,
+            pre_create_data)  # type: CreatedInstance
+
+        instance_node = hou.node(instance.get("instance_node"))
+
+        ext = pre_create_data.get("image_format")
+
+        filepath = "{renders_dir}{subset_name}/{subset_name}.$F4.{ext}".format(
+            renders_dir=hou.text.expandString("$HIP/pyblish/renders/"),
+            subset_name=subset_name,
+            ext=ext,
+        )
+
+        parms = {
+            # Render Frame Range
+            "trange": 1,
+            # Mantra ROP Setting
+            "vm_picture": filepath,
+        }
+
+        if self.selected_nodes:
+            # If camera found in selection
+            # we will use as render camera
+            camera = None
+            for node in self.selected_nodes:
+                if node.type().name() == "cam":
+                    camera = node.path()
+
+            if not camera:
+                self.log.warning("No render camera found in selection")
+
+            parms.update({"camera": camera or ""})
+
+        custom_res = pre_create_data.get("override_resolution")
+        if custom_res:
+            parms.update({"override_camerares": 1})
+        instance_node.setParms(parms)
+
+        # Lock some Avalon attributes
+        to_lock = ["family", "id"]
+        self.lock_parameters(instance_node, to_lock)
+
+    def get_pre_create_attr_defs(self):
+        attrs = super(CreateMantraROP, self).get_pre_create_attr_defs()
+
+        image_format_enum = [
+            "bmp", "cin", "exr", "jpg", "pic", "pic.gz", "png",
+            "rad", "rat", "rta", "sgi", "tga", "tif",
+        ]
+
+        return attrs + [
+            EnumDef("image_format",
+                    image_format_enum,
+                    default="exr",
+                    label="Image Format Options"),
+            BoolDef("override_resolution",
+                    label="Override Camera Resolution",
+                    tooltip="Override the current camera "
+                            "resolution, recommended for IPR.",
+                    default=False)
+        ]

openpype/hosts/houdini/plugins/create/create_redshift_rop.py

@@ -1,7 +1,10 @@
 # -*- coding: utf-8 -*-
 """Creator plugin to create Redshift ROP."""
+import hou  # noqa
+
 from openpype.hosts.houdini.api import plugin
 from openpype.pipeline import CreatedInstance
+from openpype.lib import EnumDef
 
 
 class CreateRedshiftROP(plugin.HoudiniCreator):
@@ -11,20 +14,16 @@ class CreateRedshiftROP(plugin.HoudiniCreator):
     family = "redshift_rop"
     icon = "magic"
     defaults = ["master"]
+    ext = "exr"
 
     def create(self, subset_name, instance_data, pre_create_data):
-        import hou  # noqa
 
         instance_data.pop("active", None)
         instance_data.update({"node_type": "Redshift_ROP"})
         # Add chunk size attribute
         instance_data["chunkSize"] = 10
-
-        # Clear the family prefix from the subset
-        subset = subset_name
-        subset_no_prefix = subset[len(self.family):]
-        subset_no_prefix = subset_no_prefix[0].lower() + subset_no_prefix[1:]
-        subset_name = subset_no_prefix
+        # Submit for job publishing
+        instance_data["farm"] = True
 
         instance = super(CreateRedshiftROP, self).create(
             subset_name,
@@ -34,11 +33,10 @@ class CreateRedshiftROP(plugin.HoudiniCreator):
         instance_node = hou.node(instance.get("instance_node"))
 
         basename = instance_node.name()
-        instance_node.setName(basename + "_ROP", unique_name=True)
 
         # Also create the linked Redshift IPR Rop
         try:
-            ipr_rop = self.parent.createNode(
+            ipr_rop = instance_node.parent().createNode(
                 "Redshift_IPR", node_name=basename + "_IPR"
             )
         except hou.OperationFailed:
@@ -50,19 +48,58 @@ class CreateRedshiftROP(plugin.HoudiniCreator):
         ipr_rop.setPosition(instance_node.position() + hou.Vector2(0, -1))
 
         # Set the linked rop to the Redshift ROP
-        ipr_rop.parm("linked_rop").set(ipr_rop.relativePathTo(instance))
+        ipr_rop.parm("linked_rop").set(instance_node.path())
+
+        ext = pre_create_data.get("image_format")
+        filepath = "{renders_dir}{subset_name}/{subset_name}.{fmt}".format(
+            renders_dir=hou.text.expandString("$HIP/pyblish/renders/"),
+            subset_name=subset_name,
+            fmt="${aov}.$F4.{ext}".format(aov="AOV", ext=ext)
+        )
 
-        prefix = '${HIP}/render/${HIPNAME}/`chs("subset")`.${AOV}.$F4.exr'
         parms = {
             # Render frame range
             "trange": 1,
             # Redshift ROP settings
-            "RS_outputFileNamePrefix": prefix,
-            "RS_outputMultilayerMode": 0,  # no multi-layered exr
+            "RS_outputFileNamePrefix": filepath,
+            "RS_outputMultilayerMode": "1",  # no multi-layered exr
             "RS_outputBeautyAOVSuffix": "beauty",
         }
+
+        if self.selected_nodes:
+            # set up the render camera from the selected node
+            camera = None
+            for node in self.selected_nodes:
+                if node.type().name() == "cam":
+                    camera = node.path()
+            parms.update({
+                "RS_renderCamera": camera or ""})
         instance_node.setParms(parms)
 
         # Lock some Avalon attributes
         to_lock = ["family", "id"]
         self.lock_parameters(instance_node, to_lock)
+
+    def remove_instances(self, instances):
+        for instance in instances:
+            node = instance.data.get("instance_node")
+
+            ipr_node = hou.node(f"{node}_IPR")
+            if ipr_node:
+                ipr_node.destroy()
+
+        return super(CreateRedshiftROP, self).remove_instances(instances)
+
+    def get_pre_create_attr_defs(self):
+        attrs = super(CreateRedshiftROP, self).get_pre_create_attr_defs()
+        image_format_enum = [
+            "bmp", "cin", "exr", "jpg", "pic", "pic.gz", "png",
+            "rad", "rat", "rta", "sgi", "tga", "tif",
+        ]
+
+        return attrs + [
+            EnumDef("image_format",
+                    image_format_enum,
+                    default=self.ext,
+                    label="Image Format Options")
+        ]

openpype/hosts/houdini/plugins/create/create_vray_rop.py

@@ -0,0 +1,156 @@
+# -*- coding: utf-8 -*-
+"""Creator plugin to create VRay ROP."""
+import hou
+
+from openpype.hosts.houdini.api import plugin
+from openpype.pipeline import CreatedInstance
+from openpype.lib import EnumDef, BoolDef
+
+
+class CreateVrayROP(plugin.HoudiniCreator):
+    """VRay ROP"""
+
+    identifier = "io.openpype.creators.houdini.vray_rop"
+    label = "VRay ROP"
+    family = "vray_rop"
+    icon = "magic"
+    defaults = ["master"]
+
+    ext = "exr"
+
+    def create(self, subset_name, instance_data, pre_create_data):
+
+        instance_data.pop("active", None)
+        instance_data.update({"node_type": "vray_renderer"})
+        # Add chunk size attribute
+        instance_data["chunkSize"] = 10
+        # Submit for job publishing
+        instance_data["farm"] = True
+
+        instance = super(CreateVrayROP, self).create(
+            subset_name,
+            instance_data,
+            pre_create_data)  # type: CreatedInstance
+
+        instance_node = hou.node(instance.get("instance_node"))
+
+        # Add IPR for Vray
+        basename = instance_node.name()
+        try:
+            ipr_rop = instance_node.parent().createNode(
+                "vray", node_name=basename + "_IPR"
+            )
+        except hou.OperationFailed:
+            raise plugin.OpenPypeCreatorError(
+                "Cannot create Vray render node. "
+                "Make sure Vray installed and enabled!"
+            )
+
+        ipr_rop.setPosition(instance_node.position() + hou.Vector2(0, -1))
+        ipr_rop.parm("rop").set(instance_node.path())
+
+        parms = {
+            "trange": 1,
+            "SettingsEXR_bits_per_channel": "16"   # half precision
+        }
+
+        if self.selected_nodes:
+            # set up the render camera from the selected node
+            camera = None
+            for node in self.selected_nodes:
+                if node.type().name() == "cam":
+                    camera = node.path()
+            parms.update({
+                "render_camera": camera or ""
+            })
+
+        # Enable render element
+        ext = pre_create_data.get("image_format")
+        instance_data["RenderElement"] = pre_create_data.get("render_element_enabled")         # noqa
+        if pre_create_data.get("render_element_enabled", True):
+            # Vray has its own tag for AOV file output
+            filepath = "{renders_dir}{subset_name}/{subset_name}.{fmt}".format(
+                renders_dir=hou.text.expandString("$HIP/pyblish/renders/"),
+                subset_name=subset_name,
+                fmt="${aov}.$F4.{ext}".format(aov="AOV",
+                                              ext=ext)
+            )
+            filepath = "{}{}".format(
+                hou.text.expandString("$HIP/pyblish/renders/"),
+                "{}/{}.${}.$F4.{}".format(subset_name,
+                                          subset_name,
+                                          "AOV",
+                                          ext)
+            )
+            re_rop = instance_node.parent().createNode(
+                "vray_render_channels",
+                node_name=basename + "_render_element"
+            )
+            # move the render element node next to the vray renderer node
+            re_rop.setPosition(instance_node.position() + hou.Vector2(0, 1))
+            re_path = re_rop.path()
+            parms.update({
+                "use_render_channels": 1,
+                "SettingsOutput_img_file_path": filepath,
+                "render_network_render_channels": re_path
+            })
+
+        else:
+            filepath = "{renders_dir}{subset_name}/{subset_name}.{fmt}".format(
+                renders_dir=hou.text.expandString("$HIP/pyblish/renders/"),
+                subset_name=subset_name,
+                fmt="$F4.{ext}".format(ext=ext)
+            )
+            parms.update({
+                "use_render_channels": 0,
+                "SettingsOutput_img_file_path": filepath
+            })
+
+        custom_res = pre_create_data.get("override_resolution")
+        if custom_res:
+            parms.update({"override_camerares": 1})
+
+        instance_node.setParms(parms)
+
+        # lock parameters from AVALON
+        to_lock = ["family", "id"]
+        self.lock_parameters(instance_node, to_lock)
+
+    def remove_instances(self, instances):
+        for instance in instances:
+            node = instance.data.get("instance_node")
+            # for the extra render node from the plugins
+            # such as vray and redshift
+            ipr_node = hou.node("{}{}".format(node, "_IPR"))
+            if ipr_node:
+                ipr_node.destroy()
+            re_node = hou.node("{}{}".format(node,
+                                             "_render_element"))
+            if re_node:
+                re_node.destroy()
+
+        return super(CreateVrayROP, self).remove_instances(instances)
+
+    def get_pre_create_attr_defs(self):
+        attrs = super(CreateVrayROP, self).get_pre_create_attr_defs()
+        image_format_enum = [
+            "bmp", "cin", "exr", "jpg", "pic", "pic.gz", "png",
+            "rad", "rat", "rta", "sgi", "tga", "tif",
+        ]
+
+        return attrs + [
+            EnumDef("image_format",
+                    image_format_enum,
+                    default=self.ext,
+                    label="Image Format Options"),
+            BoolDef("override_resolution",
+                    label="Override Camera Resolution",
+                    tooltip="Override the current camera "
+                            "resolution, recommended for IPR.",
+                    default=False),
+            BoolDef("render_element_enabled",
+                    label="Render Element",
+                    tooltip="Create Render Element Node "
+                            "if enabled",
+                    default=False)
+        ]

openpype/hosts/houdini/plugins/publish/collect_arnold_rop.py

@@ -0,0 +1,135 @@
+import os
+import re
+
+import hou
+import pyblish.api
+
+from openpype.hosts.houdini.api import colorspace
+from openpype.hosts.houdini.api.lib import (
+    evalParmNoFrame, get_color_management_preferences)
+
+
+class CollectArnoldROPRenderProducts(pyblish.api.InstancePlugin):
+    """Collect Arnold ROP Render Products
+
+    Collects the instance.data["files"] for the render products.
+
+    Provides:
+        instance    -> files
+
+    """
+
+    label = "Arnold ROP Render Products"
+    order = pyblish.api.CollectorOrder + 0.4
+    hosts = ["houdini"]
+    families = ["arnold_rop"]
+
+    def process(self, instance):
+
+        rop = hou.node(instance.data.get("instance_node"))
+
+        # Collect chunkSize
+        chunk_size_parm = rop.parm("chunkSize")
+        if chunk_size_parm:
+            chunk_size = int(chunk_size_parm.eval())
+            instance.data["chunkSize"] = chunk_size
+            self.log.debug("Chunk Size: %s" % chunk_size)
+
+        default_prefix = evalParmNoFrame(rop, "ar_picture")
+        render_products = []
+
+        # Default beauty AOV
+        beauty_product = self.get_render_product_name(prefix=default_prefix,
+                                                      suffix=None)
+        render_products.append(beauty_product)
+
+        files_by_aov = {
+            "": self.generate_expected_files(instance, beauty_product)
+        }
+
+        num_aovs = rop.evalParm("ar_aovs")
+        for index in range(1, num_aovs + 1):
+            # Skip disabled AOVs
+            if not rop.evalParm("ar_enable_aovP{}".format(index)):
+                continue
+
+            if rop.evalParm("ar_aov_exr_enable_layer_name{}".format(index)):
+                label = rop.evalParm("ar_aov_exr_layer_name{}".format(index))
+            else:
+                label = evalParmNoFrame(rop, "ar_aov_label{}".format(index))
+
+            aov_product = self.get_render_product_name(default_prefix,
+                                                       suffix=label)
+            render_products.append(aov_product)
+            files_by_aov[label] = self.generate_expected_files(instance,
+                                                               aov_product)
+
+        for product in render_products:
+            self.log.debug("Found render product: {}".format(product))
+
+        instance.data["files"] = list(render_products)
+        instance.data["renderProducts"] = colorspace.ARenderProduct()
+
+        # For now by default do NOT try to publish the rendered output
+        instance.data["publishJobState"] = "Suspended"
+        instance.data["attachTo"] = []      # stub required data
+
+        if "expectedFiles" not in instance.data:
+            instance.data["expectedFiles"] = list()
+        instance.data["expectedFiles"].append(files_by_aov)
+
+        # update the colorspace data
+        colorspace_data = get_color_management_preferences()
+        instance.data["colorspaceConfig"] = colorspace_data["config"]
+        instance.data["colorspaceDisplay"] = colorspace_data["display"]
+        instance.data["colorspaceView"] = colorspace_data["view"]
+
+    def get_render_product_name(self, prefix, suffix):
+        """Return the output filename using the AOV prefix and suffix"""
+
+        # When AOV is explicitly defined in prefix we just swap it out
+        # directly with the AOV suffix to embed it.
+        # Note: ${AOV} seems to be evaluated in the parameter as %AOV%
+        if "%AOV%" in prefix:
+            # It seems that when some special separator characters are present
+            # before the %AOV% token that Redshift will secretly remove it if
+            # there is no suffix for the current product, for example:
+            # foo_%AOV% -> foo.exr
+            pattern = "%AOV%" if suffix else "[._-]?%AOV%"
+            product_name = re.sub(pattern,
+                                  suffix,
+                                  prefix,
+                                  flags=re.IGNORECASE)
+        else:
+            if suffix:
+                # Add ".{suffix}" before the extension
+                prefix_base, ext = os.path.splitext(prefix)
+                product_name = prefix_base + "." + suffix + ext
+            else:
+                product_name = prefix
+
+        return product_name
+
+    def generate_expected_files(self, instance, path):
+        """Create expected files in instance data"""
+
+        dir = os.path.dirname(path)
+        file = os.path.basename(path)
+
+        if "#" in file:
+            def replace(match):
+                return "%0{}d".format(len(match.group()))
+
+            file = re.sub("#+", replace, file)
+
+        if "%" not in file:
+            return path
+
+        expected_files = []
+        start = instance.data["frameStart"]
+        end = instance.data["frameEnd"]
+        for i in range(int(start), (int(end) + 1)):
+            expected_files.append(
+                os.path.join(dir, (file % i)).replace("\\", "/"))
+
+        return expected_files

openpype/hosts/houdini/plugins/publish/collect_frames.py

@@ -11,15 +11,13 @@ from openpype.hosts.houdini.api import lib
 class CollectFrames(pyblish.api.InstancePlugin):
     """Collect all frames which would be saved from the ROP nodes"""
 
-    order = pyblish.api.CollectorOrder
+    order = pyblish.api.CollectorOrder + 0.01
     label = "Collect Frames"
     families = ["vdbcache", "imagesequence", "ass", "redshiftproxy", "review"]
 
     def process(self, instance):
 
         ropnode = hou.node(instance.data["instance_node"])
-        frame_data = lib.get_frame_data(ropnode)
-        instance.data.update(frame_data)
 
         start_frame = instance.data.get("frameStart", None)
         end_frame = instance.data.get("frameEnd", None)

openpype/hosts/houdini/plugins/publish/collect_instance_frame_data.py

@@ -0,0 +1,56 @@
+import hou
+
+import pyblish.api
+
+
+class CollectInstanceNodeFrameRange(pyblish.api.InstancePlugin):
+    """Collect time range frame data for the instance node."""
+
+    order = pyblish.api.CollectorOrder + 0.001
+    label = "Instance Node Frame Range"
+    hosts = ["houdini"]
+
+    def process(self, instance):
+
+        node_path = instance.data.get("instance_node")
+        node = hou.node(node_path) if node_path else None
+        if not node_path or not node:
+            self.log.debug("No instance node found for instance: "
+                           "{}".format(instance))
+            return
+
+        frame_data = self.get_frame_data(node)
+        if not frame_data:
+            return
+
+        self.log.info("Collected time data: {}".format(frame_data))
+        instance.data.update(frame_data)
+
+    def get_frame_data(self, node):
+        """Get the frame data: start frame, end frame and steps
+        Args:
+            node(hou.Node)
+
+        Returns:
+            dict
+
+        """
+
+        data = {}
+
+        if node.parm("trange") is None:
+            self.log.debug("Node has no 'trange' parameter: "
+                           "{}".format(node.path()))
+            return data
+
+        if node.evalParm("trange") == 0:
+            # Ignore 'render current frame'
+            self.log.debug("Node '{}' has 'Render current frame' set. "
+                           "Time range data ignored.".format(node.path()))
+            return data
+
+        data["frameStart"] = node.evalParm("f1")
+        data["frameEnd"] = node.evalParm("f2")
+        data["byFrameStep"] = node.evalParm("f3")
+
+        return data

openpype/hosts/houdini/plugins/publish/collect_instances.py

@@ -70,16 +70,10 @@ class CollectInstances(pyblish.api.ContextPlugin):
             if "active" in data:
                 data["publish"] = data["active"]
 
-            data.update(self.get_frame_data(node))
-
             # Create nice name if the instance has a frame range.
             label = data.get("name", node.name())
             label += " (%s)" % data["asset"]  # include asset in name
 
-            if "frameStart" in data and "frameEnd" in data:
-                frames = "[{frameStart} - {frameEnd}]".format(**data)
-                label = "{} {}".format(label, frames)
-
             instance = context.create_instance(label)
 
             # Include `families` using `family` data
@@ -118,6 +112,6 @@ class CollectInstances(pyblish.api.ContextPlugin):
 
         data["frameStart"] = node.evalParm("f1")
         data["frameEnd"] = node.evalParm("f2")
-        data["steps"] = node.evalParm("f3")
+        data["byFrameStep"] = node.evalParm("f3")
 
         return data

openpype/hosts/houdini/plugins/publish/collect_karma_rop.py

@@ -0,0 +1,104 @@
+import re
+import os
+
+import hou
+import pyblish.api
+
+from openpype.hosts.houdini.api.lib import (
+    evalParmNoFrame,
+    get_color_management_preferences
+)
+from openpype.hosts.houdini.api import (
+    colorspace
+)
+
+
+class CollectKarmaROPRenderProducts(pyblish.api.InstancePlugin):
+    """Collect Karma Render Products
+
+    Collects the instance.data["files"] for the multipart render product.
+
+    Provides:
+        instance    -> files
+
+    """
+
+    label = "Karma ROP Render Products"
+    order = pyblish.api.CollectorOrder + 0.4
+    hosts = ["houdini"]
+    families = ["karma_rop"]
+
+    def process(self, instance):
+
+        rop = hou.node(instance.data.get("instance_node"))
+
+        # Collect chunkSize
+        chunk_size_parm = rop.parm("chunkSize")
+        if chunk_size_parm:
+            chunk_size = int(chunk_size_parm.eval())
+            instance.data["chunkSize"] = chunk_size
+            self.log.debug("Chunk Size: %s" % chunk_size)
+
+            default_prefix = evalParmNoFrame(rop, "picture")
+            render_products = []
+
+            # Default beauty AOV
+            beauty_product = self.get_render_product_name(
+                prefix=default_prefix, suffix=None
+            )
+            render_products.append(beauty_product)
+
+            files_by_aov = {
+                "beauty": self.generate_expected_files(instance,
+                                                       beauty_product)
+            }
+
+            filenames = list(render_products)
+            instance.data["files"] = filenames
+            instance.data["renderProducts"] = colorspace.ARenderProduct()
+
+        for product in render_products:
+            self.log.debug("Found render product: %s" % product)
+
+        if "expectedFiles" not in instance.data:
+            instance.data["expectedFiles"] = list()
+        instance.data["expectedFiles"].append(files_by_aov)
+
+        # update the colorspace data
+        colorspace_data = get_color_management_preferences()
+        instance.data["colorspaceConfig"] = colorspace_data["config"]
+        instance.data["colorspaceDisplay"] = colorspace_data["display"]
+        instance.data["colorspaceView"] = colorspace_data["view"]
+
+    def get_render_product_name(self, prefix, suffix):
+        product_name = prefix
+        if suffix:
+            # Add ".{suffix}" before the extension
+            prefix_base, ext = os.path.splitext(prefix)
+            product_name = "{}.{}{}".format(prefix_base, suffix, ext)
+
+        return product_name
+
+    def generate_expected_files(self, instance, path):
+        """Create expected files in instance data"""
+
+        dir = os.path.dirname(path)
+        file = os.path.basename(path)
+
+        if "#" in file:
+            def replace(match):
+                return "%0{}d".format(len(match.group()))
+
+            file = re.sub("#+", replace, file)
+
+        if "%" not in file:
+            return path
+
+        expected_files = []
+        start = instance.data["frameStart"]
+        end = instance.data["frameEnd"]
+        for i in range(int(start), (int(end) + 1)):
+            expected_files.append(
+                os.path.join(dir, (file % i)).replace("\\", "/"))
+
+        return expected_files

openpype/hosts/houdini/plugins/publish/collect_mantra_rop.py

@@ -0,0 +1,127 @@
+import re
+import os
+
+import hou
+import pyblish.api
+
+from openpype.hosts.houdini.api.lib import (
+    evalParmNoFrame,
+    get_color_management_preferences
+)
+from openpype.hosts.houdini.api import (
+    colorspace
+)
+
+
+class CollectMantraROPRenderProducts(pyblish.api.InstancePlugin):
+    """Collect Mantra Render Products
+
+    Collects the instance.data["files"] for the render products.
+
+    Provides:
+        instance    -> files
+
+    """
+
+    label = "Mantra ROP Render Products"
+    order = pyblish.api.CollectorOrder + 0.4
+    hosts = ["houdini"]
+    families = ["mantra_rop"]
+
+    def process(self, instance):
+
+        rop = hou.node(instance.data.get("instance_node"))
+
+        # Collect chunkSize
+        chunk_size_parm = rop.parm("chunkSize")
+        if chunk_size_parm:
+            chunk_size = int(chunk_size_parm.eval())
+            instance.data["chunkSize"] = chunk_size
+            self.log.debug("Chunk Size: %s" % chunk_size)
+
+            default_prefix = evalParmNoFrame(rop, "vm_picture")
+            render_products = []
+
+            # Default beauty AOV
+            beauty_product = self.get_render_product_name(
+                prefix=default_prefix, suffix=None
+            )
+            render_products.append(beauty_product)
+
+            files_by_aov = {
+                "beauty": self.generate_expected_files(instance,
+                                                       beauty_product)
+            }
+
+            aov_numbers = rop.evalParm("vm_numaux")
+            if aov_numbers > 0:
+                # get the filenames of the AOVs
+                for i in range(1, aov_numbers + 1):
+                    var = rop.evalParm("vm_variable_plane%d" % i)
+                    if var:
+                        aov_name = "vm_filename_plane%d" % i
+                        aov_boolean = "vm_usefile_plane%d" % i
+                        aov_enabled = rop.evalParm(aov_boolean)
+                        has_aov_path = rop.evalParm(aov_name)
+                        if has_aov_path and aov_enabled == 1:
+                            aov_prefix = evalParmNoFrame(rop, aov_name)
+                            aov_product = self.get_render_product_name(
+                                prefix=aov_prefix, suffix=None
+                            )
+                            render_products.append(aov_product)
+
+                            files_by_aov[var] = self.generate_expected_files(instance, aov_product)     # noqa
+
+        for product in render_products:
+            self.log.debug("Found render product: %s" % product)
+
+        filenames = list(render_products)
+        instance.data["files"] = filenames
+        instance.data["renderProducts"] = colorspace.ARenderProduct()
+
+        # For now by default do NOT try to publish the rendered output
+        instance.data["publishJobState"] = "Suspended"
+        instance.data["attachTo"] = []      # stub required data
+
+        if "expectedFiles" not in instance.data:
+            instance.data["expectedFiles"] = list()
+        instance.data["expectedFiles"].append(files_by_aov)
+
+        # update the colorspace data
+        colorspace_data = get_color_management_preferences()
+        instance.data["colorspaceConfig"] = colorspace_data["config"]
+        instance.data["colorspaceDisplay"] = colorspace_data["display"]
+        instance.data["colorspaceView"] = colorspace_data["view"]
+
+    def get_render_product_name(self, prefix, suffix):
+        product_name = prefix
+        if suffix:
+            # Add ".{suffix}" before the extension
+            prefix_base, ext = os.path.splitext(prefix)
+            product_name = prefix_base + "." + suffix + ext
+
+        return product_name
+
+    def generate_expected_files(self, instance, path):
+        """Create expected files in instance data"""
+
+        dir = os.path.dirname(path)
+        file = os.path.basename(path)
+
+        if "#" in file:
+            def replace(match):
+                return "%0{}d".format(len(match.group()))
+
+            file = re.sub("#+", replace, file)
+
+        if "%" not in file:
+            return path
+
+        expected_files = []
+        start = instance.data["frameStart"]
+        end = instance.data["frameEnd"]
+        for i in range(int(start), (int(end) + 1)):
+            expected_files.append(
+                os.path.join(dir, (file % i)).replace("\\", "/"))
+
+        return expected_files

openpype/hosts/houdini/plugins/publish/collect_redshift_rop.py

@@ -4,52 +4,13 @@ import os
 import hou
 import pyblish.api
 
-
-def get_top_referenced_parm(parm):
-
-    processed = set()  # disallow infinite loop
-    while True:
-        if parm.path() in processed:
-            raise RuntimeError("Parameter references result in cycle.")
-
-        processed.add(parm.path())
-
-        ref = parm.getReferencedParm()
-        if ref.path() == parm.path():
-            # It returns itself when it doesn't reference
-            # another parameter
-            return ref
-        else:
-            parm = ref
-
-
-def evalParmNoFrame(node, parm, pad_character="#"):
-
-    parameter = node.parm(parm)
-    assert parameter, "Parameter does not exist: %s.%s" % (node, parm)
-
-    # If the parameter has a parameter reference, then get that
-    # parameter instead as otherwise `unexpandedString()` fails.
-    parameter = get_top_referenced_parm(parameter)
-
-    # Substitute out the frame numbering with padded characters
-    try:
-        raw = parameter.unexpandedString()
-    except hou.Error as exc:
-        print("Failed: %s" % parameter)
-        raise RuntimeError(exc)
-
-    def replace(match):
-        padding = 1
-        n = match.group(2)
-        if n and int(n):
-            padding = int(n)
-        return pad_character * padding
-
-    expression = re.sub(r"(\$F([0-9]*))", replace, raw)
-
-    with hou.ScriptEvalContext(parameter):
-        return hou.expandStringAtFrame(expression, 0)
+from openpype.hosts.houdini.api.lib import (
+    evalParmNoFrame,
+    get_color_management_preferences
+)
+from openpype.hosts.houdini.api import (
+    colorspace
+)
 
 
 class CollectRedshiftROPRenderProducts(pyblish.api.InstancePlugin):
@@ -87,6 +48,9 @@ class CollectRedshiftROPRenderProducts(pyblish.api.InstancePlugin):
             prefix=default_prefix, suffix=beauty_suffix
         )
         render_products.append(beauty_product)
+        files_by_aov = {
+            "_": self.generate_expected_files(instance,
+                                              beauty_product)}
 
         num_aovs = rop.evalParm("RS_aov")
         for index in range(num_aovs):
@@ -104,11 +68,29 @@ class CollectRedshiftROPRenderProducts(pyblish.api.InstancePlugin):
             aov_product = self.get_render_product_name(aov_prefix, aov_suffix)
             render_products.append(aov_product)
 
+            files_by_aov[aov_suffix] = self.generate_expected_files(instance,
+                                                                    aov_product)    # noqa
+
         for product in render_products:
             self.log.debug("Found render product: %s" % product)
 
         filenames = list(render_products)
         instance.data["files"] = filenames
+        instance.data["renderProducts"] = colorspace.ARenderProduct()
+
+        # For now by default do NOT try to publish the rendered output
+        instance.data["publishJobState"] = "Suspended"
+        instance.data["attachTo"] = []      # stub required data
+
+        if "expectedFiles" not in instance.data:
+            instance.data["expectedFiles"] = list()
+        instance.data["expectedFiles"].append(files_by_aov)
+
+        # update the colorspace data
+        colorspace_data = get_color_management_preferences()
+        instance.data["colorspaceConfig"] = colorspace_data["config"]
+        instance.data["colorspaceDisplay"] = colorspace_data["display"]
+        instance.data["colorspaceView"] = colorspace_data["view"]
 
     def get_render_product_name(self, prefix, suffix):
         """Return the output filename using the AOV prefix and suffix"""
@@ -133,3 +115,27 @@ class CollectRedshiftROPRenderProducts(pyblish.api.InstancePlugin):
                 product_name = prefix
 
         return product_name
+
+    def generate_expected_files(self, instance, path):
+        """Create expected files in instance data"""
+
+        dir = os.path.dirname(path)
+        file = os.path.basename(path)
+
+        if "#" in file:
+            def replace(match):
+                return "%0{}d".format(len(match.group()))
+
+            file = re.sub("#+", replace, file)
+
+        if "%" not in file:
+            return path
+
+        expected_files = []
+        start = instance.data["frameStart"]
+        end = instance.data["frameEnd"]
+        for i in range(int(start), (int(end) + 1)):
+            expected_files.append(
+                os.path.join(dir, (file % i)).replace("\\", "/"))
+
+        return expected_files

openpype/hosts/houdini/plugins/publish/collect_rop_frame_range.py

@@ -0,0 +1,41 @@
+# -*- coding: utf-8 -*-
+"""Collector plugin for frames data on ROP instances."""
+import hou  # noqa
+import pyblish.api
+from openpype.hosts.houdini.api import lib
+
+
+class CollectRopFrameRange(pyblish.api.InstancePlugin):
+    """Collect all frames which would be saved from the ROP nodes"""
+
+    order = pyblish.api.CollectorOrder
+    label = "Collect RopNode Frame Range"
+
+    def process(self, instance):
+
+        node_path = instance.data.get("instance_node")
+        if node_path is None:
+            # Instance without instance node like a workfile instance
+            return
+
+        ropnode = hou.node(node_path)
+        frame_data = lib.get_frame_data(ropnode)
+
+        if "frameStart" in frame_data and "frameEnd" in frame_data:
+
+            # Log artist friendly message about the collected frame range
+            message = (
+                "Frame range {0[frameStart]} - {0[frameEnd]}"
+            ).format(frame_data)
+            if frame_data.get("step", 1.0) != 1.0:
+                message += " with step {0[step]}".format(frame_data)
+            self.log.info(message)
+
+            instance.data.update(frame_data)
+
+            # Add frame range to label if the instance has a frame range.
+            label = instance.data.get("label", instance.data["name"])
+            instance.data["label"] = (
+                "{0} [{1[frameStart]} - {1[frameEnd]}]".format(label,
+                                                               frame_data)
+            )

openpype/hosts/houdini/plugins/publish/collect_vray_rop.py

@@ -0,0 +1,129 @@
+import re
+import os
+
+import hou
+import pyblish.api
+
+from openpype.hosts.houdini.api.lib import (
+    evalParmNoFrame,
+    get_color_management_preferences
+)
+from openpype.hosts.houdini.api import (
+    colorspace
+)
+
+
+class CollectVrayROPRenderProducts(pyblish.api.InstancePlugin):
+    """Collect Vray Render Products
+
+    Collects the instance.data["files"] for the render products.
+
+    Provides:
+        instance    -> files
+
+    """
+
+    label = "VRay ROP Render Products"
+    order = pyblish.api.CollectorOrder + 0.4
+    hosts = ["houdini"]
+    families = ["vray_rop"]
+
+    def process(self, instance):
+
+        rop = hou.node(instance.data.get("instance_node"))
+
+        # Collect chunkSize
+        chunk_size_parm = rop.parm("chunkSize")
+        if chunk_size_parm:
+            chunk_size = int(chunk_size_parm.eval())
+            instance.data["chunkSize"] = chunk_size
+            self.log.debug("Chunk Size: %s" % chunk_size)
+
+        default_prefix = evalParmNoFrame(rop, "SettingsOutput_img_file_path")
+        render_products = []
+        # TODO: add render elements if render element
+
+        beauty_product = self.get_beauty_render_product(default_prefix)
+        render_products.append(beauty_product)
+        files_by_aov = {
+            "RGB Color": self.generate_expected_files(instance,
+                                                      beauty_product)}
+
+        if instance.data.get("RenderElement", True):
+            render_element = self.get_render_element_name(rop, default_prefix)
+            if render_element:
+                for aov, renderpass in render_element.items():
+                    render_products.append(renderpass)
+                    files_by_aov[aov] = self.generate_expected_files(instance, renderpass)          # noqa
+
+        for product in render_products:
+            self.log.debug("Found render product: %s" % product)
+        filenames = list(render_products)
+        instance.data["files"] = filenames
+        instance.data["renderProducts"] = colorspace.ARenderProduct()
+
+        # For now by default do NOT try to publish the rendered output
+        instance.data["publishJobState"] = "Suspended"
+        instance.data["attachTo"] = []      # stub required data
+
+        if "expectedFiles" not in instance.data:
+            instance.data["expectedFiles"] = list()
+        instance.data["expectedFiles"].append(files_by_aov)
+        self.log.debug("expectedFiles:{}".format(files_by_aov))
+
+        # update the colorspace data
+        colorspace_data = get_color_management_preferences()
+        instance.data["colorspaceConfig"] = colorspace_data["config"]
+        instance.data["colorspaceDisplay"] = colorspace_data["display"]
+        instance.data["colorspaceView"] = colorspace_data["view"]
+
+    def get_beauty_render_product(self, prefix, suffix="<reName>"):
+        """Return the beauty output filename if render element enabled
+        """
+        aov_parm = ".{}".format(suffix)
+        beauty_product = None
+        if aov_parm in prefix:
+            beauty_product = prefix.replace(aov_parm, "")
+        else:
+            beauty_product = prefix
+
+        return beauty_product
+
+    def get_render_element_name(self, node, prefix, suffix="<reName>"):
+        """Return the output filename using the AOV prefix and suffix
+        """
+        render_element_dict = {}
+        # need a rewrite
+        re_path = node.evalParm("render_network_render_channels")
+        if re_path:
+            node_children = hou.node(re_path).children()
+            for element in node_children:
+                if element.shaderName() != "vray:SettingsRenderChannels":
+                    aov = str(element)
+                    render_product = prefix.replace(suffix, aov)
+                    render_element_dict[aov] = render_product
+        return render_element_dict
+
+    def generate_expected_files(self, instance, path):
+        """Create expected files in instance data"""
+
+        dir = os.path.dirname(path)
+        file = os.path.basename(path)
+
+        if "#" in file:
+            def replace(match):
+                return "%0{}d".format(len(match.group()))
+
+            file = re.sub("#+", replace, file)
+
+        if "%" not in file:
+            return path
+
+        expected_files = []
+        start = instance.data["frameStart"]
+        end = instance.data["frameEnd"]
+        for i in range(int(start), (int(end) + 1)):
+            expected_files.append(
+                os.path.join(dir, (file % i)).replace("\\", "/"))
+
+        return expected_files

openpype/hosts/houdini/plugins/publish/increment_current_file.py

@@ -2,7 +2,10 @@ import pyblish.api
 
 from openpype.lib import version_up
 from openpype.pipeline import registered_host
+from openpype.action import get_errored_plugins_from_data
 from openpype.hosts.houdini.api import HoudiniHost
+from openpype.pipeline.publish import KnownPublishError
+
 
 class IncrementCurrentFile(pyblish.api.ContextPlugin):
     """Increment the current file.
@@ -14,17 +17,32 @@ class IncrementCurrentFile(pyblish.api.ContextPlugin):
     label = "Increment current file"
     order = pyblish.api.IntegratorOrder + 9.0
     hosts = ["houdini"]
-    families = ["workfile"]
+    families = ["workfile",
+                "redshift_rop",
+                "arnold_rop",
+                "mantra_rop",
+                "karma_rop",
+                "usdrender"]
     optional = True
 
     def process(self, context):
 
+        errored_plugins = get_errored_plugins_from_data(context)
+        if any(
+            plugin.__name__ == "HoudiniSubmitPublishDeadline"
+            for plugin in errored_plugins
+        ):
+            raise KnownPublishError(
+                "Skipping incrementing current file because "
+                "submission to deadline failed."
+            )
+
         # Filename must not have changed since collecting
         host = registered_host()  # type: HoudiniHost
         current_file = host.current_file()
         assert (
             context.data["currentFile"] == current_file
-        ), "Collected filename from current scene name."
+        ), "Collected filename mismatches from current scene name."
 
         new_filepath = version_up(current_file)
         host.save_workfile(new_filepath)

openpype/hosts/maya/plugins/publish/collect_arnold_scene_source.py

@@ -35,13 +35,16 @@ class CollectArnoldSceneSource(pyblish.api.InstancePlugin):
         # camera.
         cameras = cmds.ls(type="camera", long=True)
         renderable = [c for c in cameras if cmds.getAttr("%s.renderable" % c)]
-        camera = renderable[0]
-        for node in instance.data["contentMembers"]:
-            camera_shapes = cmds.listRelatives(
-                node, shapes=True, type="camera"
-            )
-            if camera_shapes:
-                camera = node
-        instance.data["camera"] = camera
+        if renderable:
+            camera = renderable[0]
+            for node in instance.data["contentMembers"]:
+                camera_shapes = cmds.listRelatives(
+                    node, shapes=True, type="camera"
+                )
+                if camera_shapes:
+                    camera = node
+            instance.data["camera"] = camera
+        else:
+            self.log.debug("No renderable cameras found.")
 
         self.log.debug("data: {}".format(instance.data))

openpype/hosts/maya/plugins/publish/validate_arnold_scene_source_cbid.py

@@ -70,5 +70,5 @@ class ValidateArnoldSceneSourceCbid(pyblish.api.InstancePlugin):
 
     @classmethod
     def repair(cls, instance):
-        for content_node, proxy_node in cls.get_invalid_couples(cls, instance):
-            lib.set_id(proxy_node, lib.get_id(content_node), overwrite=False)
+        for content_node, proxy_node in cls.get_invalid_couples(instance):
+            lib.set_id(proxy_node, lib.get_id(content_node), overwrite=True)