lib

def apply_attributes(attributes, nodes_by_id):
    """Alter the attributes to match the state when publishing

    Apply attribute settings from the publish to the node in the scene based
    on the UUID which is stored in the cbId attribute.

    Args:
        attributes (list): list of dictionaries
        nodes_by_id (dict): collection of nodes based on UUID
                           {uuid: [node, node]}

    """

    for attr_data in attributes:
        nodes = nodes_by_id[attr_data["uuid"]]
        attr_value = attr_data["attributes"]
        for node in nodes:
            for attr, value in attr_value.items():
                if value is None:
                    log.warning(
                        f"Skipping setting {node}.{attr} with value 'None'")
                    continue

                set_attribute(attr, value, node)

def apply_shaders(relationships, shadernodes, nodes):
    """Link shadingEngine to the right nodes based on relationship data

    Relationship data is constructed of a collection of `sets` and `attributes`
    `sets` corresponds with the shaderEngines found in the lookdev.
    Each set has the keys `name`, `members` and `uuid`, the `members`
    hold a collection of node information `name` and `uuid`.

    Args:
        relationships (dict): relationship data
        shadernodes (list): list of nodes of the shading objectSets (includes
        VRayObjectProperties and shadingEngines)
        nodes (list): list of nodes to apply shader to

    Returns:
        None
    """

    attributes = relationships.get("attributes", [])
    shader_data = relationships.get("relationships", {})

    shading_engines = cmds.ls(shadernodes, type="objectSet", long=True)
    assert shading_engines, "Error in retrieving objectSets from reference"

    # region compute lookup
    nodes_by_id = defaultdict(list)
    for node in nodes:
        nodes_by_id[get_id(node)].append(node)

    shading_engines_by_id = defaultdict(list)
    for shad in shading_engines:
        shading_engines_by_id[get_id(shad)].append(shad)
    # endregion

    # region assign shading engines and other sets
    for data in shader_data.values():
        # collect all unique IDs of the set members
        shader_uuid = data["uuid"]
        member_uuids = [member["uuid"] for member in data["members"]]

        filtered_nodes = list()
        for m_uuid in member_uuids:
            filtered_nodes.extend(nodes_by_id[m_uuid])

        id_shading_engines = shading_engines_by_id[shader_uuid]
        if not id_shading_engines:
            log.error("No shader found with cbId "
                      "'{}'".format(shader_uuid))
            continue
        elif len(id_shading_engines) > 1:
            log.error("Skipping shader assignment. "
                      "More than one shader found with cbId "
                      "'{}'. (found: {})".format(shader_uuid,
                                                 id_shading_engines))
            continue

        if not filtered_nodes:
            log.warning("No nodes found for shading engine "
                        "'{0}'".format(id_shading_engines[0]))
            continue
        try:
            cmds.sets(filtered_nodes, forceElement=id_shading_engines[0])
        except RuntimeError as rte:
            log.error("Error during shader assignment: {}".format(rte))

    # endregion

    apply_attributes(attributes, nodes_by_id)

def assign_look(nodes, product_name="lookMain"):
    """Assigns a look to a node.

    Optimizes the nodes by grouping by folder id and finding
    related product by name.

    Args:
        nodes (list): all nodes to assign the look to
        product_name (str): name of the product to find
    """

    # Group all nodes per folder id
    grouped = defaultdict(list)
    for node in nodes:
        hash_id = get_id(node)
        if not hash_id:
            continue

        parts = hash_id.split(":", 1)
        grouped[parts[0]].append(node)

    project_name = get_current_project_name()
    product_entities = ayon_api.get_products(
        project_name, product_names=[product_name], folder_ids=grouped.keys()
    )
    product_entities_by_folder_id = {
        product_entity["folderId"]: product_entity
        for product_entity in product_entities
    }
    product_ids = {
        product_entity["id"]
        for product_entity in product_entities_by_folder_id.values()
    }
    last_version_entities_by_product_id = ayon_api.get_last_versions(
        project_name,
        product_ids
    )

    for folder_id, asset_nodes in grouped.items():
        product_entity = product_entities_by_folder_id.get(folder_id)
        if not product_entity:
            log.warning((
                "No product '{}' found for {}"
            ).format(product_name, folder_id))
            continue

        product_id = product_entity["id"]
        last_version = last_version_entities_by_product_id.get(product_id)
        if not last_version:
            log.warning((
                "Not found last version for product '{}' on folder with id {}"
            ).format(product_name, folder_id))
            continue

        families = last_version.get("attrib", {}).get("families") or []
        if "look" not in families:
            log.warning((
                "Last version for product '{}' on folder with id {}"
                " does not have look product type"
            ).format(product_name, folder_id))
            continue

        log.debug("Assigning look '{}' <v{:03d}>".format(
            product_name, last_version["version"]))

        assign_look_by_version(asset_nodes, last_version["id"])

def assign_look_by_version(nodes, version_id):
    """Assign nodes a specific published look version by id.

    This assumes the nodes correspond with the asset.

    Args:
        nodes(list): nodes to assign look to
        version_id (bson.ObjectId): database id of the version

    Returns:
        None
    """

    project_name = get_current_project_name()

    # Get representations of shader file and relationships
    representations = list(ayon_api.get_representations(
        project_name=project_name,
        representation_names={"ma", "json"},
        version_ids=[version_id]
    ))
    look_representation = next(
        repre for repre in representations if repre["name"] == "ma")
    json_representation = next(
        repre for repre in representations if repre["name"] == "json")

    # See if representation is already loaded, if so reuse it.
    host = registered_host()
    representation_id = look_representation["id"]
    for container in host.ls():
        if (container['loader'] == "LookLoader" and
                container['representation'] == representation_id):
            log.info("Reusing loaded look ..")
            container_node = container['objectName']
            break
    else:
        log.info("Using look for the first time ..")

        # Load file
        _loaders = discover_loader_plugins()
        loaders = loaders_from_representation(_loaders, representation_id)
        Loader = next((i for i in loaders if i.__name__ == "LookLoader"), None)
        if Loader is None:
            raise RuntimeError("Could not find LookLoader, this is a bug")

        # Reference the look file
        with maintained_selection():
            container_node = load_container(Loader, look_representation)

    # Get container members
    shader_nodes = get_container_members(container_node)

    # Load relationships
    shader_relation = get_representation_path(json_representation)
    with open(shader_relation, "r") as f:
        relationships = json.load(f)

    # Assign relationships
    apply_shaders(relationships, shader_nodes, nodes)

@contextlib.contextmanager
def attribute_values(attr_values):
    """Remaps node attributes to values during context.

    Arguments:
        attr_values (dict): Dictionary with (attr, value)

    """

    original = [(attr, cmds.getAttr(attr)) for attr in attr_values]
    try:
        for attr, value in attr_values.items():
            if isinstance(value, str):
                cmds.setAttr(attr, value, type="string")
            else:
                cmds.setAttr(attr, value)
        yield
    finally:
        for attr, value in original:
            if isinstance(value, str):
                cmds.setAttr(attr, value, type="string")
            elif value is None and cmds.getAttr(attr, type=True) == "string":
                # In some cases the maya.cmds.getAttr command returns None
                # for string attributes but this value cannot assigned.
                # Note: After setting it once to "" it will then return ""
                #       instead of None. So this would only happen once.
                cmds.setAttr(attr, "", type="string")
            else:
                cmds.setAttr(attr, value)

def bake(nodes,
         frame_range=None,
         step=1.0,
         simulation=True,
         preserve_outside_keys=False,
         disable_implicit_control=True,
         shape=True):
    """Bake the given nodes over the time range.

    This will bake all attributes of the node, including custom attributes.

    Args:
        nodes (list): Names of transform nodes, eg. camera, light.
        frame_range (list): frame range with start and end frame.
            or if None then takes timeSliderRange
        simulation (bool): Whether to perform a full simulation of the
            attributes over time.
        preserve_outside_keys (bool): Keep keys that are outside of the baked
            range.
        disable_implicit_control (bool): When True will disable any
            constraints to the object.
        shape (bool): When True also bake attributes on the children shapes.
        step (float): The step size to sample by.

    Returns:
        None

    """

    # Parse inputs
    if not nodes:
        return

    assert isinstance(nodes, (list, tuple)), "Nodes must be a list or tuple"

    # If frame range is None fall back to time slider playback time range
    if frame_range is None:
        frame_range = [cmds.playbackOptions(query=True, minTime=True),
                       cmds.playbackOptions(query=True, maxTime=True)]

    # If frame range is single frame bake one frame more,
    # otherwise maya.cmds.bakeResults gets confused
    if frame_range[1] == frame_range[0]:
        frame_range[1] += 1

    # Bake it
    with keytangent_default(in_tangent_type='auto',
                            out_tangent_type='auto'):
        cmds.bakeResults(nodes,
                         simulation=simulation,
                         preserveOutsideKeys=preserve_outside_keys,
                         disableImplicitControl=disable_implicit_control,
                         shape=shape,
                         sampleBy=step,
                         time=(frame_range[0], frame_range[1]))

def bake_to_world_space(nodes,
                        frame_range=None,
                        simulation=True,
                        preserve_outside_keys=False,
                        disable_implicit_control=True,
                        shape=True,
                        step=1.0):
    """Bake the nodes to world space transformation (incl. other attributes)

    Bakes the transforms to world space (while maintaining all its animated
    attributes and settings) by duplicating the node. Then parents it to world
    and constrains to the original.

    Other attributes are also baked by connecting all attributes directly.
    Baking is then done using Maya's bakeResults command.

    See `bake` for the argument documentation.

    Returns:
         list: The newly created and baked node names.

    """
    @contextlib.contextmanager
    def _unlock_attr(attr):
        """Unlock attribute during context if it is locked"""
        if not cmds.getAttr(attr, lock=True):
            # If not locked, do nothing
            yield
            return
        try:
            cmds.setAttr(attr, lock=False)
            yield
        finally:
            cmds.setAttr(attr, lock=True)

    def _get_attrs(node):
        """Workaround for buggy shape attribute listing with listAttr

        This will only return keyable settable attributes that have an
        incoming connections (those that have a reason to be baked).

        Technically this *may* fail to return attributes driven by complex
        expressions for which maya makes no connections, e.g. doing actual
        `setAttr` calls in expressions.

        Arguments:
            node (str): The node to list attributes for.

        Returns:
            list: Keyable attributes with incoming connections.
                The attribute may be locked.

        """
        attrs = cmds.listAttr(node,
                              write=True,
                              scalar=True,
                              settable=True,
                              connectable=True,
                              keyable=True,
                              shortNames=True) or []
        valid_attrs = []
        for attr in attrs:
            node_attr = '{0}.{1}'.format(node, attr)

            # Sometimes Maya returns 'non-existent' attributes for shapes
            # so we filter those out
            if not cmds.attributeQuery(attr, node=node, exists=True):
                continue

            # We only need those that have a connection, just to be safe
            # that it's actually keyable/connectable anyway.
            if cmds.connectionInfo(node_attr,
                                   isDestination=True):
                valid_attrs.append(attr)

        return valid_attrs

    transform_attrs = {"t", "r", "s",
                       "tx", "ty", "tz",
                       "rx", "ry", "rz",
                       "sx", "sy", "sz"}

    world_space_nodes = []
    with contextlib.ExitStack() as stack:
        delete_bin = stack.enter_context(delete_after())
        # Create the duplicate nodes that are in world-space connected to
        # the originals
        for node in nodes:

            # Duplicate the node
            short_name = node.rsplit("|", 1)[-1]
            new_name = "{0}_baked".format(short_name)
            new_node = cmds.duplicate(node,
                                      name=new_name,
                                      renameChildren=True)[0]  # noqa

            # Parent new node to world
            if cmds.listRelatives(new_node, parent=True):
                new_node = cmds.parent(new_node, world=True)[0]

            # Temporarily unlock and passthrough connect all attributes
            # so we can bake them over time
            # Skip transform attributes because we will constrain them later
            attrs = set(_get_attrs(node)) - transform_attrs
            for attr in attrs:
                orig_node_attr = "{}.{}".format(node, attr)
                new_node_attr = "{}.{}".format(new_node, attr)

                # unlock during context to avoid connection errors
                stack.enter_context(_unlock_attr(new_node_attr))
                cmds.connectAttr(orig_node_attr,
                                 new_node_attr,
                                 force=True)

            # If shapes are also baked then also temporarily unlock and
            # passthrough connect all shape attributes for baking
            if shape:
                children_shapes = cmds.listRelatives(new_node,
                                                     children=True,
                                                     fullPath=True,
                                                     shapes=True)
                if children_shapes:
                    orig_children_shapes = cmds.listRelatives(node,
                                                              children=True,
                                                              fullPath=True,
                                                              shapes=True)
                    for orig_shape, new_shape in zip(orig_children_shapes,
                                                     children_shapes):
                        attrs = _get_attrs(orig_shape)
                        for attr in attrs:
                            orig_node_attr = "{}.{}".format(orig_shape, attr)
                            new_node_attr = "{}.{}".format(new_shape, attr)

                            # unlock during context to avoid connection errors
                            stack.enter_context(_unlock_attr(new_node_attr))
                            cmds.connectAttr(orig_node_attr,
                                             new_node_attr,
                                             force=True)

            # Constraint transforms
            for attr in transform_attrs:
                transform_attr = "{}.{}".format(new_node, attr)
                stack.enter_context(_unlock_attr(transform_attr))
            delete_bin.extend(cmds.parentConstraint(node, new_node, mo=False))
            delete_bin.extend(cmds.scaleConstraint(node, new_node, mo=False))

            world_space_nodes.append(new_node)

        bake(world_space_nodes,
             frame_range=frame_range,
             step=step,
             simulation=simulation,
             preserve_outside_keys=preserve_outside_keys,
             disable_implicit_control=disable_implicit_control,
             shape=shape)

    return world_space_nodes

def collect_animation_defs(fps=False, create_context=None):
    """Get the basic animation attribute definitions for the publisher.

    Arguments:
        fps (bool): Whether to include `fps` attribute definition.
        create_context (CreateContext | None): When provided the context of
            publisher will be used to define the defaults for the attributes.
            Depending on project settings this may then use the entity's frame
            range and FPS instead of the current scene values.

    Returns:
        List[NumberDef]: List of number attribute definitions.

    """

    use_entity_frame_range = False
    if create_context is not None:
        project_settings = create_context.get_current_project_settings()
        use_entity_frame_range: bool = project_settings["maya"]["create"].get(
            "use_entity_attributes_as_defaults", False)

    if create_context is not None and use_entity_frame_range:
        task_entity = create_context.get_current_task_entity()
        frame_start = task_entity["attrib"]["frameStart"]
        frame_end = task_entity["attrib"]["frameEnd"]
        handle_start = task_entity["attrib"]["handleStart"]
        handle_end = task_entity["attrib"]["handleEnd"]
        default_fps = task_entity["attrib"]["fps"]
    else:
        # get scene values as defaults
        frame_start = cmds.playbackOptions(query=True, minTime=True)
        frame_end = cmds.playbackOptions(query=True, maxTime=True)
        frame_start_handle = cmds.playbackOptions(
            query=True, animationStartTime=True)
        frame_end_handle = cmds.playbackOptions(
            query=True, animationEndTime=True)

        handle_start = frame_start - frame_start_handle
        handle_end = frame_end_handle - frame_end
        default_fps = mel.eval('currentTimeUnitToFPS()')

    # build attributes
    defs = [
        NumberDef("frameStart",
                  label="Frame Start",
                  default=frame_start,
                  decimals=0),
        NumberDef("frameEnd",
                  label="Frame End",
                  default=frame_end,
                  decimals=0),
        NumberDef("handleStart",
                  label="Handle Start",
                  default=handle_start,
                  decimals=0),
        NumberDef("handleEnd",
                  label="Handle End",
                  default=handle_end,
                  decimals=0),
        NumberDef("step",
                  label="Step size",
                  tooltip="A smaller step size means more samples and larger "
                          "output files.\n"
                          "A 1.0 step size is a single sample every frame.\n"
                          "A 0.5 step size is two samples per frame.\n"
                          "A 0.2 step size is five samples per frame.",
                  default=1.0,
                  decimals=3),
    ]

    if fps:
        fps_def = NumberDef(
            "fps", label="FPS", default=default_fps, decimals=5
        )
        defs.append(fps_def)

    return defs

def convert_to_maya_fps(fps):
    """Convert any fps to supported Maya framerates."""
    float_framerates = [
        23.976023976023978,
        # WTF is 29.97 df vs fps?
        29.97002997002997,
        47.952047952047955,
        59.94005994005994
    ]
    # 44100 fps evaluates as 41000.0. Why? Omitting for now.
    int_framerates = [
        2,
        3,
        4,
        5,
        6,
        8,
        10,
        12,
        15,
        16,
        20,
        24,
        25,
        30,
        40,
        48,
        50,
        60,
        75,
        80,
        90,
        100,
        120,
        125,
        150,
        200,
        240,
        250,
        300,
        375,
        400,
        500,
        600,
        750,
        1200,
        1500,
        2000,
        3000,
        6000,
        48000
    ]

    # If input fps is a whole number we'll return.
    if float(fps).is_integer():
        # Validate fps is part of Maya's fps selection.
        if int(fps) not in int_framerates:
            raise ValueError(
                "Framerate \"{}\" is not supported in Maya".format(fps)
            )
        return int(fps)
    else:
        # Differences to supported float frame rates.
        differences = []
        for i in float_framerates:
            differences.append(abs(i - fps))

        # Validate difference does not stray too far from supported framerates.
        min_difference = min(differences)
        min_index = differences.index(min_difference)
        supported_framerate = float_framerates[min_index]
        if min_difference > 0.1:
            raise ValueError(
                "Framerate \"{}\" strays too far from any supported framerate"
                " in Maya. Closest supported framerate is \"{}\"".format(
                    fps, supported_framerate
                )
            )

        return supported_framerate

def create_rig_animation_instance(
    nodes, context, namespace, options=None, log=None
):
    """Create an animation publish instance for loaded rigs.

    See the RecreateRigAnimationInstance inventory action on how to use this
    for loaded rig containers.

    Arguments:
        nodes (list): Member nodes of the rig instance.
        context (dict): Representation context of the rig container
        namespace (str): Namespace of the rig container
        options (dict, optional): Additional loader data
        log (logging.Logger, optional): Logger to log to if provided

    Returns:
        None

    """
    if options is None:
        options = {}
    name = context["representation"]["name"]
    output = next((node for node in nodes if
                   node.endswith("out_SET")), None)
    controls = next((node for node in nodes if
                     node.endswith("controls_SET")), None)
    if name != "fbx":
        if not output:
            raise RigSetsNotExistError(
                "No out_SET in rig. The loaded rig publish is lacking the "
                "out_SET required for animation instances.")
        if not controls:
            raise RigSetsNotExistError(
                "No controls_SET in rig. The loaded rig publish is lacking "
                "the controls_SET required for animation instances.")

    anim_skeleton = next((node for node in nodes if
                          node.endswith("skeletonAnim_SET")), None)
    skeleton_mesh = next((node for node in nodes if
                          node.endswith("skeletonMesh_SET")), None)

    # Find the roots amongst the loaded nodes
    roots = (
        cmds.ls(nodes, assemblies=True, long=True) or
        get_highest_in_hierarchy(nodes)
    )
    assert roots, "No root nodes in rig, this is a bug."

    folder_entity = context["folder"]
    product_entity = context["product"]
    product_type = product_entity["productType"]
    product_name = product_entity["name"]

    custom_product_name = options.get("animationProductName")
    if custom_product_name:
        formatting_data = {
            "folder": {
                "name": folder_entity["name"]
            },
            "product": {
                "type": product_type,
                "name": product_name,
            },
            "asset": folder_entity["name"],
            "subset": product_name,
            "family": product_type
        }
        namespace = get_custom_namespace(
            custom_product_name.format(**formatting_data)
        )

    if log:
        log.info("Creating product: {}".format(namespace))

    # Fill creator identifier
    creator_identifier = "io.openpype.creators.maya.animation"

    host = registered_host()
    create_context = CreateContext(host)
    # Create the animation instance
    rig_sets = [output, controls, anim_skeleton, skeleton_mesh]
    # Remove sets that this particular rig does not have
    rig_sets = [s for s in rig_sets if s is not None]
    with maintained_selection():
        cmds.select(rig_sets + roots, noExpand=True)
        create_context.create(
            creator_identifier=creator_identifier,
            variant=namespace,
            pre_create_data={"use_selection": True}
        )

@contextlib.contextmanager
def displaySmoothness(nodes,
                      divisionsU=0,
                      divisionsV=0,
                      pointsWire=4,
                      pointsShaded=1,
                      polygonObject=1):
    """Set the displaySmoothness during the context"""

    # Ensure only non-intermediate shapes
    nodes = cmds.ls(nodes,
                    dag=1,
                    shapes=1,
                    long=1,
                    noIntermediate=True)

    def parse(node):
        """Parse the current state of a node"""
        state = {}
        for key in ["divisionsU",
                    "divisionsV",
                    "pointsWire",
                    "pointsShaded",
                    "polygonObject"]:
            value = cmds.displaySmoothness(node, query=1, **{key: True})
            if value is not None:
                state[key] = value[0]
        return state

    originals = dict((node, parse(node)) for node in nodes)

    try:
        # Apply current state
        cmds.displaySmoothness(nodes,
                               divisionsU=divisionsU,
                               divisionsV=divisionsV,
                               pointsWire=pointsWire,
                               pointsShaded=pointsShaded,
                               polygonObject=polygonObject)
        yield
    finally:
        # Revert state
        _iteritems = getattr(originals, "iteritems", originals.items)
        for node, state in _iteritems():
            if state:
                cmds.displaySmoothness(node, **state)

@contextlib.contextmanager
def empty_sets(sets, force=False):
    """Remove all members of the sets during the context"""

    assert isinstance(sets, (list, tuple))

    original = dict()
    original_connections = []

    # Store original state
    for obj_set in sets:
        members = cmds.sets(obj_set, query=True)
        original[obj_set] = members

    try:
        for obj_set in sets:
            cmds.sets(clear=obj_set)
            if force:
                # Break all connections if force is enabled, this way we
                # prevent Maya from exporting any reference nodes which are
                # connected with placeHolder[x] attributes
                plug = "%s.dagSetMembers" % obj_set
                connections = cmds.listConnections(plug,
                                                   source=True,
                                                   destination=False,
                                                   plugs=True,
                                                   connections=True) or []
                original_connections.extend(connections)
                for dest, src in pairwise(connections):
                    cmds.disconnectAttr(src, dest)
        yield
    finally:

        for dest, src in pairwise(original_connections):
            cmds.connectAttr(src, dest)

        # Restore original members
        _iteritems = getattr(original, "iteritems", original.items)
        for origin_set, members in _iteritems():
            cmds.sets(members, forceElement=origin_set)

@contextlib.contextmanager
def evaluation(mode="off"):
    """Set the evaluation manager during context.

    Arguments:
        mode (str): The mode to apply during context.
            "off": The standard DG evaluation (stable)
            "serial": A serial DG evaluation
            "parallel": The Maya 2016+ parallel evaluation

    """

    original = cmds.evaluationManager(query=True, mode=1)[0]
    try:
        cmds.evaluationManager(mode=mode)
        yield
    finally:
        cmds.evaluationManager(mode=original)

def fix_incompatible_containers():
    """Backwards compatibility: old containers to use new ReferenceLoader"""
    old_loaders = {
        "MayaAsciiLoader",
        "AbcLoader",
        "ModelLoader",
        "CameraLoader",
        "RigLoader",
        "FBXLoader"
    }
    host = registered_host()
    for container in host.ls():
        loader = container['loader']
        if loader in old_loaders:
            log.info(
                "Converting legacy container loader {} to "
                "ReferenceLoader: {}".format(loader, container["objectName"])
            )
            cmds.setAttr(container["objectName"] + ".loader",
                         "ReferenceLoader", type="string")

@contextlib.contextmanager
def force_shader_assignments_to_faces(shapes):
    """Replaces any non-face shader assignments with shader assignments
    to the faces during the context.

    Args:
        shapes (List[str]): The shapes to add into face sets for any component
            assignments of shading engine
    """
    shapes = cmds.ls(shapes, shapes=True, type="mesh", long=True)
    if not shapes:
        # Do nothing
        yield
        return

    all_render_sets = set()
    for shape in shapes:
        render_sets = cmds.listSets(object=shape, t=1, extendToShape=False)
        if render_sets:
            all_render_sets.update(render_sets)

    shapes_lookup = set(shapes)

    # Maya has the tendency to return component assignment using the transform
    # name instead of the shape name, like `pCube1.f[1]` instead of
    # `pCube1Shape.f[1]` so we need to take those into consideration as members
    def get_parent(_shape: str) -> str:
        return _shape.rsplit("|", 1)[0]

    components_lookup = {f"{shape}." for shape in shapes}
    components_lookup.update(f"{get_parent(shape)}." for shape in shapes)
    components_lookup = tuple(components_lookup)  # support str.startswith

    original_assignments = {}
    override_assignments = defaultdict(list)
    for shading_engine in cmds.ls(list(all_render_sets), type="shadingEngine"):
        members = cmds.sets(shading_engine, query=True)
        if not members:
            continue

        members = cmds.ls(members, long=True)

        # Include ALL originals, even those not among our shapes
        original_assignments[shading_engine] = members

        has_conversions = False
        for member in members:
            # Only consider shapes from our inputs
            if (
                    member not in shapes_lookup
                    and not member.startswith(components_lookup)
            ):
                continue

            if "." not in member:
                # Convert to face assignments
                member = f"{member}.f[*]"
                if not cmds.objExists(member):
                    # It is possible for a mesh to have no faces at all
                    # for which we cannot convert to face assignments anyway.
                    # It is a `mesh` node type - it just would error on
                    # 'No object matches name' when trying to assign to the
                    # faces. So we skip the conversion
                    log.debug(
                        "Skipping face assignment conversion because "
                        f"no mesh faces were found: {member}")
                    continue

                has_conversions = True
            override_assignments[shading_engine].append(member)

        if not has_conversions:
            # We can skip this shading engine completely because
            # we have nothing to override
            original_assignments.pop(shading_engine, None)
            override_assignments.pop(shading_engine, None)

    try:
        # Apply overrides
        for shading_engine, override_members in override_assignments.items():
            # We force remove the members because this allows maya to take
            # out the mesh (also without the components)
            cmds.sets(clear=shading_engine)
            cmds.sets(override_members, forceElement=shading_engine)

        yield

    finally:
        # Revert to original assignments
        for shading_engine, original_members in original_assignments.items():
            cmds.sets(clear=shading_engine)
            cmds.sets(original_members, forceElement=shading_engine)

def generate_capture_preset(instance, camera, path,
                            start=None, end=None, capture_preset=None):
    """Function for getting all the data of preset options for
    playblast capturing

    Args:
        instance (pyblish.api.Instance): instance
        camera (str): review camera
        path (str): filepath
        start (int): frameStart
        end (int): frameEnd
        capture_preset (dict): capture preset

    Returns:
        dict: Resulting preset
    """
    preset = load_capture_preset(data=capture_preset)

    preset["camera"] = camera
    preset["start_frame"] = start
    preset["end_frame"] = end
    preset["filename"] = path
    preset["overwrite"] = True
    preset["panel"] = instance.data["panel"]

    # Disable viewer since we use the rendering logic for publishing
    # We don't want to open the generated playblast in a viewer directly.
    preset["viewer"] = False

    # "isolate_view" will already have been applied at creation, so we'll
    # ignore it here.
    preset.pop("isolate_view")

    # Set resolution variables from capture presets
    width_preset = capture_preset["Resolution"]["width"]
    height_preset = capture_preset["Resolution"]["height"]

    # Set resolution variables from folder values
    folder_attributes = instance.data["folderEntity"]["attrib"]
    folder_width = folder_attributes.get("resolutionWidth")
    folder_height = folder_attributes.get("resolutionHeight")
    review_instance_width = instance.data.get("review_width")
    review_instance_height = instance.data.get("review_height")

    # Use resolution from instance if review width/height is set
    # Otherwise use the resolution from preset if it has non-zero values
    # Otherwise fall back to folder width x height
    # Else define no width, then `capture.capture` will use render resolution
    if review_instance_width and review_instance_height:
        preset["width"] = review_instance_width
        preset["height"] = review_instance_height
    elif width_preset and height_preset:
        preset["width"] = width_preset
        preset["height"] = height_preset
    elif folder_width and folder_height:
        preset["width"] = folder_width
        preset["height"] = folder_height

    # Isolate view is requested by having objects in the set besides a
    # camera. If there is only 1 member it'll be the camera because we
    # validate to have 1 camera only.
    if instance.data["isolate"] and len(instance.data["setMembers"]) > 1:
        preset["isolate"] = instance.data["setMembers"]

    # Override camera options
    # Enforce persisting camera depth of field
    camera_options = preset.setdefault("camera_options", {})
    camera_options["depthOfField"] = cmds.getAttr(
        "{0}.depthOfField".format(camera)
    )

    # Use Pan/Zoom from instance data instead of from preset
    preset.pop("pan_zoom", None)
    camera_options["panZoomEnabled"] = instance.data["panZoom"]

    # Override viewport options by instance data
    viewport_options = preset.setdefault("viewport_options", {})
    viewport_options["imagePlane"] = instance.data.get("imagePlane", True)

    # When using 'project settings' we preserve the capture preset that
    # was picked, then we do not override it with the instance data
    if instance.data["displayLights"] != "project_settings":
        viewport_options["displayLights"] = instance.data["displayLights"]

    # Override transparency if requested.
    transparency = instance.data.get("transparency", 0)
    if transparency != 0:
        preset["viewport2_options"]["transparencyAlgorithm"] = transparency

    # Update preset with current panel setting
    # if override_viewport_options is turned off
    if not capture_preset["ViewportOptions"]["override_viewport_options"]:
        panel_preset = capture.parse_view(preset["panel"])
        panel_preset.pop("camera")
        preset.update(panel_preset)

    return preset

def generate_ids(nodes, folder_id=None):
    """Returns new unique ids for the given nodes.

    Note: This does not assign the new ids, it only generates the values.

    To assign new ids using this method:
    >>> nodes = ["a", "b", "c"]
    >>> for node, id in generate_ids(nodes):
    >>>     set_id(node, id)

    To also override any existing values (and assign regenerated ids):
    >>> nodes = ["a", "b", "c"]
    >>> for node, id in generate_ids(nodes):
    >>>     set_id(node, id, overwrite=True)

    Args:
        nodes (list): List of nodes.
        folder_id (Optional[str]): Folder id to generate id for. When None
            provided current folder is used.

    Returns:
        list: A list of (node, id) tuples.

    """

    if folder_id is None:
        # Get the folder id based on current context folder
        project_name = get_current_project_name()
        folder_path = get_current_folder_path()
        if not folder_path:
            raise ValueError("Current folder path is not set")
        folder_entity = ayon_api.get_folder_by_path(
            project_name, folder_path, fields=["id"]
        )
        if not folder_entity:
            raise ValueError((
                "Current folder '{}' was not found on the server"
            ).format(folder_path))
        folder_id = folder_entity["id"]

    node_ids = []
    for node in nodes:
        _, uid = str(uuid.uuid4()).rsplit("-", 1)
        unique_id = "{}:{}".format(folder_id, uid)
        node_ids.append((node, unique_id))

    return node_ids

def get_all_children(nodes, ignore_intermediate_objects=False):
    """Return all children of `nodes` including each instanced child.
    Using maya.cmds.listRelatives(allDescendents=True) includes only the first
    instance. As such, this function acts as an optimal replacement with a
    focus on a fast query.

    Args:
        nodes (iterable): List of nodes to get children for.
        ignore_intermediate_objects (bool): Ignore any children that
            are intermediate objects.

    Returns:
        set: Children of input nodes.

    """

    sel = OpenMaya.MSelectionList()
    traversed = set()
    iterator = OpenMaya.MItDag(OpenMaya.MItDag.kDepthFirst)
    fn_dag = OpenMaya.MFnDagNode()
    for node in nodes:

        if node in traversed:
            # Ignore if already processed as a child
            # before
            continue

        sel.clear()
        sel.add(node)
        dag = sel.getDagPath(0)

        iterator.reset(dag)
        # ignore self
        iterator.next()  # noqa: B305
        while not iterator.isDone():

            if ignore_intermediate_objects:
                fn_dag.setObject(iterator.currentItem())
                if fn_dag.isIntermediateObject:
                    iterator.prune()
                    iterator.next()  # noqa: B305
                    continue

            path = iterator.fullPathName()

            if path in traversed:
                iterator.prune()
                iterator.next()  # noqa: B305
                continue

            traversed.add(path)
            iterator.next()  # noqa: B305

    return traversed

def get_attr_in_layer(attr, layer, as_string=True):
    """Return attribute value in specified renderlayer.

    Same as cmds.getAttr but this gets the attribute's value in a
    given render layer without having to switch to it.

    Warning for parent attribute overrides:
        Attributes that have render layer overrides to their parent attribute
        are not captured correctly since they do not have a direct connection.
        For example, an override to sphere.rotate when querying sphere.rotateX
        will not return correctly!

    Note: This is much faster for Maya's renderLayer system, yet the code
        does no optimized query for render setup.

    Args:
        attr (str): attribute name, ex. "node.attribute"
        layer (str): layer name
        as_string (bool): whether attribute should convert to a string value

    Returns:
        The return value from `maya.cmds.getAttr`

    """

    try:
        if cmds.mayaHasRenderSetup():
            from . import lib_rendersetup
            return lib_rendersetup.get_attr_in_layer(
                attr, layer, as_string=as_string)
    except AttributeError:
        pass

    # Ignore complex query if we're in the layer anyway
    current_layer = cmds.editRenderLayerGlobals(query=True,
                                                currentRenderLayer=True)
    if layer == current_layer:
        return cmds.getAttr(attr, asString=as_string)

    connections = cmds.listConnections(attr,
                                       plugs=True,
                                       source=False,
                                       destination=True,
                                       type="renderLayer") or []
    connections = filter(lambda x: x.endswith(".plug"), connections)
    if not connections:
        return cmds.getAttr(attr)

    # Some value types perform a conversion when assigning
    # TODO: See if there's a maya method to allow this conversion
    # instead of computing it ourselves.
    attr_type = cmds.getAttr(attr, type=True)
    conversion = None
    if attr_type == "time":
        conversion = mel.eval('currentTimeUnitToFPS()')  # returns float
    elif attr_type == "doubleAngle":
        # Radians to Degrees: 180 / pi
        # TODO: This will likely only be correct when Maya units are set
        #       to degrees
        conversion = 57.2957795131
    elif attr_type == "doubleLinear":
        raise NotImplementedError("doubleLinear conversion not implemented.")

    for connection in connections:
        if connection.startswith(layer + "."):
            attr_split = connection.split(".")
            if attr_split[0] == layer:
                attr = ".".join(attr_split[0:-1])
                value = cmds.getAttr("%s.value" % attr)
                if conversion:
                    value *= conversion
                return value

    else:
        # When connections are present, but none
        # to the specific renderlayer than the layer
        # should have the "defaultRenderLayer"'s value
        layer = "defaultRenderLayer"
        for connection in connections:
            if connection.startswith(layer):
                attr_split = connection.split(".")
                if attr_split[0] == "defaultRenderLayer":
                    attr = ".".join(attr_split[0:-1])
                    value = cmds.getAttr("%s.value" % attr)
                    if conversion:
                        value *= conversion
                    return value

    return cmds.getAttr(attr, asString=as_string)

def get_attribute(plug,
                  asString=False,
                  expandEnvironmentVariables=False,
                  **kwargs):
    """Maya getAttr with some fixes based on `pymel.core.general.getAttr()`.

    Like Pymel getAttr this applies some changes to `maya.cmds.getAttr`
      - maya pointlessly returned vector results as a tuple wrapped in a list
        (ex.  '[(1,2,3)]'). This command unpacks the vector for you.
      - when getting a multi-attr, maya would raise an error, but this will
        return a list of values for the multi-attr
      - added support for getting message attributes by returning the
        connections instead

    Note that the asString + expandEnvironmentVariables argument naming
    convention matches the `maya.cmds.getAttr` arguments so that it can
    act as a direct replacement for it.

    Args:
        plug (str): Node's attribute plug as `node.attribute`
        asString (bool): Return string value for enum attributes instead
            of the index. Note that the return value can be dependent on the
            UI language Maya is running in.
        expandEnvironmentVariables (bool): Expand any environment variable and
            (tilde characters on UNIX) found in string attributes which are
            returned.

    Kwargs:
        Supports the keyword arguments of `maya.cmds.getAttr`

    Returns:
        object: The value of the maya attribute.

    """
    attr_type = cmds.getAttr(plug, type=True)
    if asString:
        kwargs["asString"] = True
    if expandEnvironmentVariables:
        kwargs["expandEnvironmentVariables"] = True
    try:
        res = cmds.getAttr(plug, **kwargs)
    except RuntimeError:
        if attr_type == "message":
            return cmds.listConnections(plug)

        node, attr = plug.split(".", 1)
        children = cmds.attributeQuery(attr, node=node, listChildren=True)
        if children:
            return [
                get_attribute("{}.{}".format(node, child))
                for child in children
            ]

        raise

    # Convert vector result wrapped in tuple
    if isinstance(res, list) and len(res):
        if isinstance(res[0], tuple) and len(res):
            if attr_type in {'pointArray', 'vectorArray'}:
                return res
            return res[0]

    return res

def get_capture_preset(
    task_name, task_type, product_name, project_settings, log
):
    """Get capture preset for playblasting.

    Logic for transitioning from old style capture preset to new capture preset
    profiles.

    Args:
        task_name (str): Task name.
        task_type (str): Task type.
        product_name (str): Product name.
        project_settings (dict): Project settings.
        log (logging.Logger): Logging object.
    """
    capture_preset = None
    filtering_criteria = {
        "task_names": task_name,
        "task_types": task_type,
        "product_names": product_name
    }

    plugin_settings = project_settings["maya"]["publish"]["ExtractPlayblast"]
    if plugin_settings["profiles"]:
        profile = filter_profiles(
            plugin_settings["profiles"],
            filtering_criteria,
            logger=log
        ) or {}
        capture_preset = profile.get("capture_preset")
    else:
        log.warning("No profiles present for Extract Playblast")

    # Backward compatibility for deprecated Extract Playblast settings
    # without profiles.
    if capture_preset is None:
        log.debug(
            "Falling back to deprecated Extract Playblast capture preset "
            "because no new style playblast profiles are defined or no "
            "profile matches for your current context."
        )
        capture_preset = plugin_settings.get("capture_preset")

    if capture_preset:
        # Create deepcopy of preset as we'll change the values
        capture_preset = copy.deepcopy(capture_preset)

        viewport_options = capture_preset["ViewportOptions"]
        # Change 'list' to 'dict' for 'capture.py'
        viewport_options["pluginObjects"] = {
            item["name"]: item["value"]
            for item in viewport_options["pluginObjects"]
        }
    return capture_preset or {}