workfile_template_builder

class SilhouettePlaceholderPlugin(PlaceholderPlugin):
    data_key = "ayon.placeholder"
    item_class = PlaceholderItem

    def _create_placeholder_node(
            self, placeholder_data, session, node_type="NullNode"):
        # Create node
        placeholder_node = fx.Node(node_type)
        placeholder_node.label = "PLACEHOLDER"
        session.addNode(placeholder_node)
        lib.set_new_node_position(placeholder_node)
        return placeholder_node

    @lib.undo_chunk("Create placeholder")
    def create_placeholder(self, placeholder_data) -> PlaceholderItem:
        session = fx.activeSession()
        if not session:
            raise RuntimeError("Must have active session.")

        placeholder_data["plugin_identifier"] = self.identifier

        placeholder_node = self._create_placeholder_node(
            placeholder_data, session)

        fx.activate(placeholder_node)

        imprint(placeholder_node, placeholder_data, key=self.data_key)

        item = self.item_class(
            scene_identifier=placeholder_node.id,
            data=placeholder_data,
            plugin=self
        )
        # Add transient data for easier access
        item.transient_data = {
            "node": placeholder_node
        }

        return item

    @lib.undo_chunk("Update placeholder")
    def update_placeholder(self,
                           placeholder_item: PlaceholderItem,
                           placeholder_data: dict):
        node = placeholder_item.transient_data["node"]  # noqa
        placeholder_data["plugin_identifier"] = self.identifier
        imprint(node, placeholder_data, key=self.data_key)

    def _collect_placeholder_nodes(self) -> Dict[str, List[fx.Node]]:
        nodes = self.builder.get_shared_populate_data("placeholder_nodes")
        if nodes is None:
            # Populate cache
            session = fx.activeSession()
            project = fx.activeProject()
            nodes_by_plugin_identifier = {}
            for node in itertools.chain(session.nodes, project.sources):
                node_data = read(node, key=self.data_key)
                if not node_data:
                    continue

                plugin_identifier = node_data.get("plugin_identifier")
                if not plugin_identifier:
                    continue

                nodes_by_plugin_identifier.setdefault(
                    plugin_identifier, []).append(node)

            nodes = nodes_by_plugin_identifier
            self.builder.set_shared_populate_data("placeholder_nodes",
                                                  nodes_by_plugin_identifier)

        return nodes

    def collect_placeholders(self) -> List[PlaceholderItem]:
        nodes_by_identifier = self._collect_placeholder_nodes()

        placeholder_items = []
        for node in nodes_by_identifier.get(self.identifier, []):
            data = self._parse_placeholder_node_data(node)
            placeholder_item = self.item_class(
                scene_identifier=node.id,
                data=data,
                plugin=self)

            # Add transient data for easier access
            placeholder_item.transient_data = {
                "node": node
            }
            placeholder_items.append(placeholder_item)

        return placeholder_items

    def _parse_placeholder_node_data(self, node) -> dict:
        return read(node, key=self.data_key)

    @lib.undo_chunk("Delete placeholder")
    def delete_placeholder(self, placeholder: PlaceholderItem):
        """Remove placeholder if building was successful"""
        node = placeholder.transient_data["node"]  # noqa
        if isinstance(node, fx.Node):
            session = node.session
            session.removeNode(node)
        elif isinstance(node, fx.Source):
            project = node.parent.parent  # Source -> SourceItem -> Project
            project.removeItem(node)
        else:
            raise TypeError(f"Unsupported placeholder node: {node}")

class SilhouetteTemplateBuilder(AbstractTemplateBuilder):
    """Concrete implementation of AbstractTemplateBuilder for Silhouette"""

    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)

        Returns:
            bool: Whether the template was successfully imported or not
        """
        # TODO check if the template is already imported
        lib.import_project(path)

        # Clear any selection if it occurred on load or import
        fx.select([])

        return True