connect_ornatrix_rig

class ConnectOrnatrixRig(InventoryAction):
    """Connect Ornatrix Rig with an animation or pointcache.

    Connect one animation or pointcache instance to one or multiple ornatrix
    rig instances.
    """

    label = "Connect Ornatrix Rig"
    icon = "link"
    color = "white"

    def process(self, containers):
        # Categorize containers by product type.
        containers_by_product_type = defaultdict(list)
        repre_ids = {
            container["representation"]
            for container in containers
        }
        repre_contexts_by_id = get_repres_contexts(repre_ids)
        for container in containers:
            repre_id = container["representation"]
            repre_context = repre_contexts_by_id[repre_id]

            product_type = repre_context["product"]["productType"]
            containers_by_product_type[product_type].append(container)

        # Validate to only 1 source container.
        source_containers = containers_by_product_type.get("animation", [])
        source_containers += containers_by_product_type.get("pointcache", [])
        source_container_namespaces = [
            x["namespace"] for x in source_containers
        ]
        message = (
            "{} animation containers selected:\n\n{}\n\nOnly select 1 of type "
            "\"animation\" or \"pointcache\".".format(
                len(source_containers), source_container_namespaces
            )
        )
        if len(source_containers) != 1:
            self.display_warning(message)
            return

        source_container = source_containers[0]
        source_repre_id = source_container["representation"]
        source_namespace = source_container["namespace"]

        # Validate source representation is an alembic.
        source_path = get_representation_path(
            repre_contexts_by_id[source_repre_id]["representation"]
        ).replace("\\", "/")
        message = "Animation container \"{}\" is not an alembic:\n{}".format(
            source_container["namespace"], source_path
        )
        if not source_path.endswith(".abc"):
            self.display_warning(message)
            return

        ox_rig_containers = containers_by_product_type.get("oxrig")
        if not ox_rig_containers:
            self.display_warning(
                "Select at least one oxrig container"
            )
            return

        # Define a mapping to quickly search among the members
        source_nodes = get_container_members(source_container)
        source_nodes_by_name = {
            get_node_name(node_path): node_path
            for node_path in source_nodes
        }

        project_name = get_current_project_name()
        for container in ox_rig_containers:
            # Get relevant ornatrix rig .rigsettings representation path
            repre_id = container["representation"]
            settings_repre = get_sibling_representation(
                project_name,
                repre_id,
                representation_name="rigsettings")
            if not settings_repre:
                continue
            settings_file = get_representation_path(settings_repre)
            if not os.path.exists(settings_file):
                continue

            with open(settings_file, "r") as fp:
                rig_source_nodes: List[Dict[str, Any]] = json.load(fp)
            if not rig_source_nodes:
                self.log.warning(
                    f"No source nodes in the .rigsettings file "
                    f"to process: {settings_file}")
                continue

            rig_nodes = get_container_members(container)

            # Find the node in the source
            for node in rig_source_nodes:
                node_name = get_node_name(node["node"])

                # Find the source node we want to connect to the target rig
                source_node = source_nodes_by_name.get(node_name)
                if not source_node:
                    self.log.warning(
                        "No source node found for '%s' searching in "
                        "namespace: %s", node_name, source_namespace)
                    self.display_warning(
                        "No source node found "
                        "in \"animation\" or \"pointcache\"."
                    )
                    return

                # Find matching target node
                for target_node in rig_nodes:
                    if get_node_name(target_node) != node_name:
                        continue

                    # Connect source mesh to target mesh
                    self.log.info("Connecting mesh %s -> %s",
                                  source_node, target_node)
                    connect_mesh(source_node, target_node)

    def display_warning(self, message, show_cancel=False):
        """Show feedback to user.

        Returns:
            bool
        """

        from qtpy import QtWidgets

        accept = QtWidgets.QMessageBox.Ok
        if show_cancel:
            buttons = accept | QtWidgets.QMessageBox.Cancel
        else:
            buttons = accept

        state = QtWidgets.QMessageBox.warning(
            None,
            "",
            message,
            buttons=buttons,
            defaultButton=accept
        )

        return state == accept