collect_inputs

class CollectUpstreamInputs(plugin.MayaInstancePlugin):
    """Collect input source inputs for this publish.

    This will include `inputs` data of which loaded publishes were used in the
    generation of this publish. This leaves an upstream trace to what was used
    as input.

    """

    label = "Collect Inputs"
    order = pyblish.api.CollectorOrder + 0.34

    def process(self, instance):

        # For large scenes the querying of "host.ls()" can be relatively slow
        # e.g. up to a second. Many instances calling it easily slows this
        # down. As such, we cache it so we trigger it only once.
        # todo: Instead of hidden cache make "CollectContainers" plug-in
        cache_key = "__cache_containers"
        scene_containers = instance.context.data.get(cache_key, None)
        if scene_containers is None:
            # Query the scenes' containers if there's no cache yet
            host = registered_host()
            scene_containers = list(host.ls())
            for container in scene_containers:
                # Embed the members into the container dictionary
                container_members = set(get_container_members(container))
                container["_members"] = container_members
            instance.context.data["__cache_containers"] = scene_containers

        # Collect the relevant input containers for this instance
        if "renderlayer" in set(instance.data.get("families", [])):
            # Special behavior for renderlayers
            self.log.debug("Collecting renderlayer inputs....")
            containers = self._collect_renderlayer_inputs(scene_containers,
                                                          instance)

        else:
            # Basic behavior
            nodes = instance[:]

            # Include any input connections of history with long names
            # For optimization purposes only trace upstream from shape nodes
            # looking for used dag nodes. This way having just a constraint
            # on a transform is also ignored which tended to give irrelevant
            # inputs for the majority of our use cases. We tend to care more
            # about geometry inputs.
            shapes = cmds.ls(nodes,
                             type=("mesh", "nurbsSurface", "nurbsCurve"),
                             noIntermediate=True)
            if shapes:
                history = list(iter_history(shapes, filter=om.MFn.kShape))
                history = cmds.ls(history, long=True)

                # Include the transforms in the collected history as shapes
                # are excluded from containers
                transforms = cmds.listRelatives(cmds.ls(history, shapes=True),
                                                parent=True,
                                                fullPath=True,
                                                type="transform")
                if transforms:
                    history.extend(transforms)

                if history:
                    nodes = list(set(nodes + history))

            # Collect containers for the given set of nodes
            containers = collect_input_containers(scene_containers,
                                                  nodes)

        inputs = [c["representation"] for c in containers]
        instance.data["inputRepresentations"] = inputs
        self.log.debug("Collected inputs: %s" % inputs)

    def _collect_renderlayer_inputs(self, scene_containers, instance):
        """Collects inputs from nodes in renderlayer, incl. shaders + camera"""

        # Get the renderlayer
        renderlayer = instance.data.get("setMembers")

        if renderlayer == "defaultRenderLayer":
            # Assume all loaded containers in the scene are inputs
            # for the masterlayer
            return copy.deepcopy(scene_containers)
        else:
            # Get the members of the layer
            members = cmds.editRenderLayerMembers(renderlayer,
                                                  query=True,
                                                  fullNames=True) or []

            # In some cases invalid objects are returned from
            # `editRenderLayerMembers` so we filter them out
            members = cmds.ls(members, long=True)

            # Include all children
            children = cmds.listRelatives(members,
                                          allDescendents=True,
                                          fullPath=True) or []
            members.extend(children)

            # Include assigned shaders in renderlayer
            shapes = cmds.ls(members, shapes=True, long=True)
            shaders = set()
            for shape in shapes:
                shape_shaders = get_shader_in_layer(shape, layer=renderlayer)
                if not shape_shaders:
                    continue
                shaders.update(shape_shaders)
            members.extend(shaders)

            # Explicitly include the camera being rendered in renderlayer
            cameras = instance.data.get("cameras")
            members.extend(cameras)

            containers = collect_input_containers(scene_containers, members)

        return containers