workfile_template_builder

class BlenderPlaceholderPlugin(PlaceholderPlugin):
    """Base Placeholder Plugin for Blender with one unified cache.

    Creates a locator as placeholder node, which during populate provide
    all of its attributes defined on the locator's transform in
    `placeholder.data` and where `placeholder.scene_identifier` is the
    full path to the node.

    Inherited classes must still implement `populate_placeholder`

    """

    use_selection_as_parent = True
    item_class = PlaceholderItem

    def _create_placeholder_name(self, placeholder_data):
        return self.identifier.replace(".", "_")

    def _collect_scene_placeholders(self):
        nodes_by_identifier = self.builder.get_shared_populate_data(
            "placeholder_nodes"
        )
        if nodes_by_identifier is None:
            # Cache placeholder data to shared data
            nodes = [
                node for node in bpy.data.collections
                if get_ayon_property(node)
            ]

            nodes_by_identifier = {}
            for node in nodes:
                ayon_prop = get_ayon_property(node)
                identifier = ayon_prop.get("plugin_identifier")
                nodes_by_identifier.setdefault(identifier, []).append(node.name)

            # Set the cache
            self.builder.set_shared_populate_data(
                "placeholder_nodes", nodes_by_identifier
            )
        return nodes_by_identifier

    def create_placeholder(self, placeholder_data):

        parent_object = None
        if self.use_selection_as_parent:
            selection = get_selected_collections()
            if len(selection) > 1:
                raise ValueError(
                    "More than one collection is selected. "
                    "Please select only one to define the parent."
                )
            parent_object = selection[0] if selection else None

        placeholder_data["plugin_identifier"] = self.identifier
        placeholder_name = self._create_placeholder_name(placeholder_data)

        placeholder = bpy.data.collections.new(placeholder_name)
        if parent_object:
            parent_object.children.link(placeholder)
            imprinted_placeholder = parent_object
        else:
            bpy.context.scene.collection.children.link(placeholder)
            imprinted_placeholder = placeholder

        imprint(imprinted_placeholder, placeholder_data)

    def update_placeholder(self, placeholder_item, placeholder_data):
        node_name = placeholder_item.scene_identifier

        changed_values = {}
        for key, value in placeholder_data.items():
            if value != placeholder_item.data.get(key):
                changed_values[key] = value

        target_collection = bpy.data.collections.get(node_name)
        target_property = get_ayon_property(target_collection)
        # Delete attributes to ensure we imprint new data with correct type
        for key in changed_values.keys():
            if key in target_property:
                target_property.pop(key, None)

        imprint(target_collection, changed_values)

    def collect_placeholders(self):
        placeholders = []
        nodes_by_identifier = self._collect_scene_placeholders()
        for node_name in nodes_by_identifier.get(self.identifier, []):
            # TODO do data validations and maybe upgrades if they are invalid
            node = bpy.data.collections.get(node_name)
            placeholder_data = get_ayon_property(node)
            # Convert IDPropertyGroup to dict to avoid pickle errors
            if placeholder_data:
                placeholder_data = dict(placeholder_data)
            placeholders.append(
                self.item_class(scene_identifier=node_name,
                                data=placeholder_data,
                                plugin=self)
            )

        return placeholders

    def delete_placeholder(self, placeholder):
        """Remove placeholder if building was successful

        Used only by PlaceholderCreateMixin and PlaceholderLoadMixin.
        """
        node = placeholder.scene_identifier
        node_to_removed = bpy.data.collections.get(node)
        if node_to_removed:
            bpy.data.collections.remove(node_to_removed)

class BlenderTemplateBuilder(AbstractTemplateBuilder):
    """Concrete implementation of AbstractTemplateBuilder for Blender"""
    def import_template(self, path):
        """Import template into current scene.
        Block if a template is already loaded.

        Args:
            path (str): A path to current template (usually given by
            get_template_preset implementation)

        """
        bpy.ops.wm.read_homefile(filepath=path)
        update_content_on_context_change()