collect_shapes

class CollectShapes(pyblish.api.InstancePlugin):
    """Collect trackpoint data."""
    label = "Collect Shape Data"
    order = pyblish.api.CollectorOrder - 0.45
    hosts: ClassVar[list[str]] = ["mochapro"]
    families: ClassVar[list[str]] = ["matteshapes"]
    log: Logger

    @staticmethod
    def new_product_name(
        create_context: CreateContext,
        layer_name: str,
        product_type: str,
        product_base_type: str,
        variant: str) -> str:
        """Return the new product name."""
        sanitized_layer_name = layer_name.replace(" ", "_")
        variant = f"{sanitized_layer_name}{variant.capitalize()}"

        get_product_name_kwargs = {}

        if getattr(get_product_name, "use_entities", False):
            get_product_name_kwargs.update({
                "folder_entity": create_context.get_current_folder_entity(),
                "task_entity": create_context.get_current_task_entity(),
                "product_base_type": product_base_type,
            })
        else:
            get_product_name_kwargs.update({
                "task_name": create_context.get_current_task_name(),
                "task_type": create_context.get_current_task_type(),
            })

        return get_product_name(
            project_name=create_context.project_name,
            host_name=create_context.host_name,
            product_type=product_type,
            variant=variant,
            **get_product_name_kwargs
        )

    def process(self, instance: pyblish.api.Instance) -> None:
        """Process the instance.

        Raises:
            KnownPublishError: If layer mode is invalid.

        """
        # copy creator settings to the instance itself
        creator_attrs = instance.data["creator_attributes"]
        registered_exporters = get_shape_exporters()
        selected_exporters = [
            exporter
            for exporter in registered_exporters
            if exporter.id in creator_attrs["exporter"]
        ]

        instance.data["use_exporters"] = selected_exporters
        project: Project = instance.context.data["project"]
        layers: list[Layer] = []
        if creator_attrs["layer_mode"] == "selected":
            layers.extend(
                project.layers[selected_layer_idx]
                for selected_layer_idx in creator_attrs["layers"]
            )
        elif creator_attrs["layer_mode"] == "all":
            layers = project.layers
        else:
            msg = f"Invalid layer mode: {creator_attrs['layer_mode']}"
            raise KnownPublishError(msg)

        for layer in layers:
            new_instance = instance.context.create_instance(
                f"{instance.name} - {layer.name}"
            )
            for k, v in instance.data.items():
                # this is needed because the data is not always
                # "deepcopyable".
                try:
                    new_instance.data[k] = deepcopy(v)
                except TypeError:  # noqa: PERF203
                    new_instance.data[k] = v

            # new_instance.data = instance.data
            new_instance.data["label"] = f"{instance.name} ({layer.name})"
            new_instance.data["name"] = f"{instance.name}_{layer.name}"
            new_instance.data["productName"] = self.new_product_name(
                instance.context.data["create_context"],
                layer.name,
                product_type=instance.data["productType"],
                product_base_type=instance.data["productBaseType"],
                variant=instance.data["variant"],
            )
            self.set_layer_data_on_instance(new_instance, layer)
        if layers:
            instance.context.remove(instance)

    @staticmethod
    def set_layer_data_on_instance(
            instance: pyblish.api.Instance, layer: Layer) -> None:
        """Set data on instance."""
        instance.data["layer"] = layer
        instance.data["frameStart"] = layer.in_point()
        instance.data["frameEnd"] = layer.out_point()