workfile_template_builder

class NukePlaceholderPlugin(PlaceholderPlugin):
    node_color = 4278190335

    item_class = PlaceholderItem

    def _collect_scene_placeholders(self):
        # Cache placeholder data to shared data
        placeholder_nodes = self.builder.get_shared_populate_data(
            "placeholder_nodes"
        )
        if placeholder_nodes is None:
            placeholder_nodes = {}
            all_groups = collections.deque()
            all_groups.append(nuke.thisGroup())
            while all_groups:
                group = all_groups.popleft()
                for node in group.nodes():
                    if isinstance(node, nuke.Group):
                        all_groups.append(node)

                    node_knobs = node.knobs()
                    if (
                        "is_placeholder" not in node_knobs
                        or not node.knob("is_placeholder").value()
                    ):
                        continue

                    if "empty" in node_knobs and node.knob("empty").value():
                        continue

                    placeholder_nodes[node.fullName()] = node

            self.builder.set_shared_populate_data(
                "placeholder_nodes", placeholder_nodes
            )
        return placeholder_nodes

    def create_placeholder(self, placeholder_data):
        placeholder_data["plugin_identifier"] = self.identifier

        placeholder = nuke.nodes.NoOp()
        placeholder.setName("PLACEHOLDER")
        placeholder.knob("tile_color").setValue(self.node_color)

        imprint(placeholder, placeholder_data)
        imprint(placeholder, {"is_placeholder": True})
        placeholder.knob("is_placeholder").setVisible(False)

    def update_placeholder(self, placeholder_item, placeholder_data):
        node = nuke.toNode(placeholder_item.scene_identifier)
        imprint(node, placeholder_data)

    def _parse_placeholder_node_data(self, node: nuke.Node):
        placeholder_data: dict[str, Any] = {}

        def _get_knob_value(knob):
            if isinstance(knob, (nuke.EvalString_Knob, nuke.String_Knob)):
                # Do not evaluate the contents; return the exact
                # text value we set
                return knob.getText()
            else:
                return knob.getValue()

        # collect current placeholder keys
        for key in self.get_placeholder_keys():
            if knob := node.knob(key):
                placeholder_data[key] = _get_knob_value(knob)
            else:
                placeholder_data[key] = None

        # collect legacy placeholder keys for backward compatibility
        for key in LEGACY_PLACEHOLDER_KEYS:

            if placeholder_data.get(key) is not None:
                continue

            if knob := node.knob(key):
                self.log.warning(
                    f"Legacy placeholder key '{key}' on '{node.fullName()}'"
                    " is deprecated and will be removed in the future."
                    "\nPlease recreate the placeholder to fix this."
                )
                placeholder_data[key] = _get_knob_value(knob)

        return placeholder_data

    def delete_placeholder(self, placeholder):
        """Remove placeholder if building was successful"""
        placeholder_node = nuke.toNode(placeholder.scene_identifier)
        nuke.delete(placeholder_node)

    def collect_placeholders(self):
        output = []
        scene_placeholders = self._collect_scene_placeholders()
        for node_name, node in scene_placeholders.items():
            plugin_identifier_knob = node.knob("plugin_identifier")
            if (
                plugin_identifier_knob is None
                or plugin_identifier_knob.getValue() != self.identifier
            ):
                continue

            placeholder_data = self._parse_placeholder_node_data(node)
            output.append(
                self.item_class(node_name, placeholder_data, self)
            )

        return output

class NukeTemplateBuilder(AbstractTemplateBuilder):
    """Concrete implementation of AbstractTemplateBuilder for nuke"""

    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

        nuke.nodePaste(path)
        reset_selection()

        return True