extract_yeti_rig

class ExtractYetiRig(plugin.MayaExtractorPlugin):
    """Extract the Yeti rig to a Maya Scene and write the Yeti rig data."""

    label = "Extract Yeti Rig"
    families = ["yetiRig"]
    scene_type = "ma"

    def process(self, instance):
        """Plugin entry point."""
        maya_settings = instance.context.data["project_settings"]["maya"]
        ext_mapping = {
            item["name"]: item["value"]
            for item in maya_settings["ext_mapping"]
        }
        if ext_mapping:
            self.log.debug("Looking in settings for scene type ...")
            # use extension mapping for first family found
            for family in self.families:
                try:
                    self.scene_type = ext_mapping[family]
                    self.log.debug(
                        "Using {} as scene type".format(self.scene_type))
                    break
                except KeyError:
                    # no preset found
                    pass
        yeti_nodes = cmds.ls(instance, type="pgYetiMaya")
        if not yeti_nodes:
            raise RuntimeError("No pgYetiMaya nodes found in the instance")

        # Define extract output file path
        dirname = self.staging_dir(instance)
        settings_path = os.path.join(dirname, "yeti.rigsettings")

        # Yeti related staging dirs
        maya_path = os.path.join(dirname,
                                 "yeti_rig.{}".format(self.scene_type))

        self.log.debug("Writing metadata file: {}".format(settings_path))

        image_search_path = resources_dir = instance.data["resourcesDir"]

        settings = instance.data.get("rigsettings", None)
        assert settings, "Yeti rig settings were not collected."
        settings["imageSearchPath"] = image_search_path
        with open(settings_path, "w") as fp:
            json.dump(settings, fp, ensure_ascii=False)

        # add textures to transfers
        if 'transfers' not in instance.data:
            instance.data['transfers'] = []

        for resource in instance.data.get('resources', []):
            for file in resource['files']:
                src = file
                dst = os.path.join(image_search_path, os.path.basename(file))
                instance.data['transfers'].append([src, dst])

                self.log.debug("adding transfer {} -> {}". format(src, dst))

        # Ensure the imageSearchPath is being remapped to the publish folder
        attr_value = {"%s.imageSearchPath" % n: str(image_search_path) for
                      n in yeti_nodes}

        # Get input_SET members
        input_set = next(i for i in instance if i == "input_SET")

        # Get all items
        set_members = cmds.sets(input_set, query=True) or []
        set_members += cmds.listRelatives(set_members,
                                          allDescendents=True,
                                          fullPath=True) or []
        members = cmds.ls(set_members, long=True)

        nodes = instance.data["setMembers"]
        resources = instance.data.get("resources", {})
        with disconnect_plugs(settings, members):
            with yetigraph_attribute_values(resources_dir, resources):
                with lib.attribute_values(attr_value):
                    cmds.select(nodes, noExpand=True)
                    cmds.file(maya_path,
                              force=True,
                              exportSelected=True,
                              typ="mayaAscii" if self.scene_type == "ma" else "mayaBinary",  # noqa: E501
                              preserveReferences=False,
                              constructionHistory=True,
                              shader=False)

        # Ensure files can be stored
        # build representations
        if "representations" not in instance.data:
            instance.data["representations"] = []

        self.log.debug("rig file: {}".format(maya_path))
        instance.data["representations"].append(
            {
                'name': self.scene_type,
                'ext': self.scene_type,
                'files': os.path.basename(maya_path),
                'stagingDir': dirname
            }
        )
        self.log.debug("settings file: {}".format(settings_path))
        instance.data["representations"].append(
            {
                'name': 'rigsettings',
                'ext': 'rigsettings',
                'files': os.path.basename(settings_path),
                'stagingDir': dirname
            }
        )

        self.log.debug("Extracted {} to {}".format(instance, dirname))

        cmds.select(clear=True)