create_render

class CreateRenderlayer(TVPaintCreator):
    """Mark layer group as Render layer instance.

    All TVPaint layers in the scene with the color group id are rendered in the
    beauty pass. To create sub passes use Render Layer creator which is
    dependent on existence of render layer instance.
    """

    label = "Render Layer"
    product_type = "render"
    product_template_product_type = "renderLayer"
    identifier = "render.layer"
    icon = "fa5.images"

    # George script to change color group
    rename_script_template = (
        "tv_layercolor \"setcolor\""
        " {clip_id} {group_id} {r} {g} {b} \"{name}\""
    )
    # Order to be executed before Render Pass creator
    order = 90
    description = "Mark TVPaint color group as one Render Layer."
    detailed_description = RENDER_LAYER_DETAILED_DESCRIPTIONS

    # Settings
    # - Default render pass name for beauty
    default_pass_name = "beauty"
    # - Mark by default instance for review
    mark_for_review = True

    def apply_settings(self, project_settings):
        super().apply_settings(project_settings)
        plugin_settings = (
            project_settings["tvpaint"]["create"]["create_render_layer"]
        )
        self.default_variant = plugin_settings["default_variant"]
        self.default_variants = plugin_settings["default_variants"]
        self.default_pass_name = plugin_settings["default_pass_name"]
        self.mark_for_review = plugin_settings["mark_for_review"]
        self.create_allow_context_change = not self._use_current_context

    def get_dynamic_data(
        self,
        project_name,
        folder_entity,
        task_entity,
        variant,
        host_name,
        instance
    ):
        return {
            "renderpass": self.default_pass_name,
            "renderlayer": variant,
        }

    def _get_selected_group_ids(self):
        return {
            layer["group_id"]
            for layer in get_layers_data()
            if layer["selected"]
        }

    def create(self, product_name, instance_data, pre_create_data):
        self.log.debug("Query data from workfile.")

        group_name = instance_data["variant"]

        if self._use_current_context:
            project_name = self.create_context.get_current_project_name()
            folder_entity = self.create_context.get_current_folder_entity()
            task_entity = self.create_context.get_current_task_entity()
            project_entity = self.create_context.get_current_project_entity()

            product_name = self.get_product_name(
                project_name=project_name,
                project_entity=project_entity,
                folder_entity=folder_entity,
                task_entity=task_entity,
                variant=group_name,
            )

            instance_data["folderPath"] = folder_entity["path"]
            instance_data["task"] = task_entity["name"]
            instance_data["productName"] = product_name

        group_id = pre_create_data.get("group_id")
        # This creator should run only on one group
        if group_id is None or group_id == -1:
            selected_groups = self._get_selected_group_ids()
            selected_groups.discard(0)
            if len(selected_groups) > 1:
                raise CreatorError("You have selected more than one group")

            if len(selected_groups) == 0:
                raise CreatorError("You don't have selected any group")
            group_id = tuple(selected_groups)[0]

        self.log.debug("Querying groups data from workfile.")
        groups_data = get_groups_data()
        group_item = None
        for group_data in groups_data:
            if group_data["group_id"] == group_id:
                group_item = group_data

        for instance in self.create_context.instances:
            if (
                instance.creator_identifier == self.identifier
                and instance["creator_attributes"]["group_id"] == group_id
            ):
                raise CreatorError((
                    f"Group \"{group_item.get('name')}\" is already used"
                    f" by another render layer \"{instance['productName']}\""
                ))

        self.log.debug(f"Selected group id is \"{group_id}\".")
        creator_attributes = instance_data.setdefault(
            "creator_attributes", {}
        )
        mark_for_review = pre_create_data.get("mark_for_review")
        if mark_for_review is None:
            mark_for_review = self.mark_for_review
        creator_attributes["group_id"] = group_id
        creator_attributes["mark_for_review"] = mark_for_review

        self.log.info(f"Product name is {product_name}")
        new_instance = CreatedInstance(
            self.product_type,
            product_name,
            instance_data,
            self
        )
        self._store_new_instance(new_instance)

        if not group_id or group_item["name"] == group_name:
            return new_instance

        self.log.debug("Changing name of the group.")
        # Rename TVPaint group (keep color same)
        # - groups can't contain spaces
        rename_script = self.rename_script_template.format(
            clip_id=group_item["clip_id"],
            group_id=group_item["group_id"],
            r=group_item["red"],
            g=group_item["green"],
            b=group_item["blue"],
            name=group_name
        )
        execute_george_through_file(rename_script)

        self.log.info((
            f"Name of group with index {group_id}"
            f" was changed to \"{group_name}\"."
        ))
        return new_instance

    def _get_groups_enum(self):
        groups_enum = []
        empty_groups = []
        for group in get_groups_data():
            group_name = group["name"]
            item = {
                "label": group_name,
                "value": group["group_id"]
            }
            # TVPaint have defined how many color groups is available, but
            #   the count is not consistent across versions. It is not possible
            #   to know how many groups there is.
            #
            if group_name and group_name != "0":
                if empty_groups:
                    groups_enum.extend(empty_groups)
                    empty_groups = []
                groups_enum.append(item)
            else:
                empty_groups.append(item)
        return groups_enum

    def get_pre_create_attr_defs(self):
        groups_enum = self._get_groups_enum()
        groups_enum.insert(0, {"label": "<Use selection>", "value": -1})

        return [
            EnumDef(
                "group_id",
                label="Group",
                items=groups_enum
            ),
            BoolDef(
                "mark_for_review",
                label="Review",
                default=self.mark_for_review
            )
        ]

    def get_instance_attr_defs(self):
        groups_enum = self._get_groups_enum()
        return [
            EnumDef(
                "group_id",
                label="Group",
                items=groups_enum
            ),
            BoolDef(
                "mark_for_review",
                label="Review",
                default=self.mark_for_review
            )
        ]

    def collect_instances(self):
        super().collect_instances()
        if not self._use_current_context:
            return

        for instance in self.create_context.instances:
            if instance.creator_identifier == self.identifier:
                self._update_instance_context(instance)

    def update_instances(self, update_list):
        self._update_color_groups()
        self._update_renderpass_groups()

        super().update_instances(update_list)

    def _update_color_groups(self):
        render_layer_instances = []
        for instance in self.create_context.instances:
            if instance.creator_identifier == self.identifier:
                render_layer_instances.append(instance)

        if not render_layer_instances:
            return

        groups_by_id = {
            group["group_id"]: group
            for group in get_groups_data()
        }
        grg_script_lines = []
        for instance in render_layer_instances:
            group_id = instance["creator_attributes"]["group_id"]
            variant = instance["variant"]
            group = groups_by_id[group_id]
            if group["name"] == variant:
                continue

            grg_script_lines.append(self.rename_script_template.format(
                clip_id=group["clip_id"],
                group_id=group["group_id"],
                r=group["red"],
                g=group["green"],
                b=group["blue"],
                name=variant
            ))

        if grg_script_lines:
            execute_george_through_file("\n".join(grg_script_lines))

    def _update_renderpass_groups(self):
        render_layer_instances = {}
        render_pass_instances = collections.defaultdict(list)

        for instance in self.create_context.instances:
            if instance.creator_identifier == CreateRenderPass.identifier:
                render_layer_id = (
                    instance["creator_attributes"]["render_layer_instance_id"]
                )
                render_pass_instances[render_layer_id].append(instance)
            elif instance.creator_identifier == self.identifier:
                render_layer_instances[instance.id] = instance

        if not render_pass_instances or not render_layer_instances:
            return

        layers_data = get_layers_data()
        layers_by_name = collections.defaultdict(list)
        for layer in layers_data:
            layers_by_name[layer["name"]].append(layer)

        george_lines = []
        for render_layer_id, instances in render_pass_instances.items():
            render_layer_inst = render_layer_instances.get(render_layer_id)
            if render_layer_inst is None:
                continue
            group_id = render_layer_inst["creator_attributes"]["group_id"]
            layer_names = set()
            for instance in instances:
                layer_names |= set(instance["layer_names"])

            for layer_name in layer_names:
                george_lines.extend(
                    f"tv_layercolor \"set\" {layer['layer_id']} {group_id}"
                    for layer in layers_by_name[layer_name]
                    if layer["group_id"] != group_id
                )
        if george_lines:
            execute_george_through_file("\n".join(george_lines))

class TVPaintAutoDetectRenderCreator(TVPaintCreator):
    """Create Render Layer and Render Pass instances based on scene data.

    This is auto-detection creator which can be triggered by user to create
    instances based on information in scene. Each used color group in scene
    will be created as Render Layer where group name is used as variant and
    each TVPaint layer as Render Pass where layer name is used as variant.

    Never will have any instances, all instances belong to different creators.
    """

    product_type = "render"
    label = "Render Layer/Passes"
    identifier = "render.auto.detect.creator"
    order = CreateRenderPass.order + 10
    description = (
        "Create Render Layers and Render Passes based on scene setup"
    )
    detailed_description = AUTODETECT_RENDER_DETAILED_DESCRIPTION

    # Settings
    enabled = False
    allow_group_rename = True
    group_name_template = "G{group_index}"
    group_idx_offset = 10
    group_idx_padding = 3
    layer_name_template = {"enabled": False}

    def apply_settings(self, project_settings):
        super().apply_settings(project_settings)
        plugin_settings = (
            project_settings
            ["tvpaint"]
            ["create"]
            ["auto_detect_render"]
        )
        self.enabled = plugin_settings.get("enabled", False)
        self.allow_group_rename = plugin_settings["allow_group_rename"]
        self.group_name_template = plugin_settings["group_name_template"]
        self.group_idx_offset = plugin_settings["group_idx_offset"]
        self.group_idx_padding = plugin_settings["group_idx_padding"]
        self.create_allow_context_change = not self._use_current_context

        render_pass_settings = (
            project_settings["tvpaint"]["create"]["create_render_pass"]
        )
        self.layer_name_template = copy.deepcopy(
            render_pass_settings["layer_name_template"]
        )

    def _rename_groups(
        self,
        groups_order: list[int],
        scene_groups: list[dict[str, Any]]
    ):
        new_group_name_by_id: dict[int, str] = {}
        groups_by_id: dict[int, dict[str, Any]] = {
            group["group_id"]: group
            for group in scene_groups
        }
        # Count only renamed groups
        group_template = "{}"
        if self.group_idx_padding:
            group_template = f"{{:0>{self.group_idx_padding}}}"

        for idx, group_id in enumerate(groups_order):

            group_index_value: str = (
                group_template.format((idx + 1) * self.group_idx_offset)
            )
            group_name_fill_values: dict[str, str] = {
                "groupIdx": group_index_value,
                "groupidx": group_index_value,
                "group_idx": group_index_value,
                "group_index": group_index_value,
            }

            group_name: str = self.group_name_template.format(
                **group_name_fill_values
            )
            group: dict[str, Any] = groups_by_id[group_id]
            if group["name"] != group_name:
                new_group_name_by_id[group_id] = group_name

        grg_lines: list[str] = []
        for group_id, group_name in new_group_name_by_id.items():
            group: dict[str, Any] = groups_by_id[group_id]
            grg_line: str = (
                "tv_layercolor \"setcolor\" {} {} {} {} {} \"{}\""
            ).format(
                group["clip_id"],
                group_id,
                group["red"],
                group["green"],
                group["blue"],
                group_name
            )
            grg_lines.append(grg_line)
            group["name"] = group_name

        if grg_lines:
            execute_george_through_file("\n".join(grg_lines))

    def _prepare_render_layer(
        self,
        project_entity: dict[str, Any],
        folder_entity: dict[str, Any],
        task_entity: dict[str, Any],
        group_id: int,
        groups: list[dict[str, Any]],
        mark_for_review: bool,
        existing_instance: Optional[CreatedInstance] = None,
    ) -> Union[CreatedInstance, None]:
        match_group: Optional[dict[str, Any]] = next(
            (
                group
                for group in groups
                if group["group_id"] == group_id
            ),
            None
        )
        if not match_group:
            return None

        task_name = task_entity["name"]
        variant: str = match_group["name"]
        creator: CreateRenderlayer = (
            self.create_context.creators[CreateRenderlayer.identifier]
        )
        product_name: str = creator.get_product_name(
            project_name=project_entity["name"],
            folder_entity=folder_entity,
            task_entity=task_entity,
            variant=variant,
            host_name=self.create_context.host_name,
            project_entity=project_entity,
        )
        if existing_instance is not None:
            existing_instance["folderPath"] = folder_entity["path"]
            existing_instance["task"] = task_name
            existing_instance["productName"] = product_name
            return existing_instance

        instance_data: dict[str, str] = {
            "folderPath": folder_entity["path"],
            "task": task_name,
            "productType": creator.product_type,
            "variant": variant,
        }
        pre_create_data: dict[str, Any] = {
            "group_id": group_id,
            "mark_for_review": mark_for_review
        }
        return creator.create(product_name, instance_data, pre_create_data)

    def _prepare_render_passes(
        self,
        project_entity: dict[str, Any],
        folder_entity: dict[str, Any],
        task_entity: dict[str, Any],
        render_layer_instance: CreatedInstance,
        layers: list[dict[str, Any]],
        mark_for_review: bool,
        existing_render_passes: list[CreatedInstance]
    ):
        task_name = task_entity["name"]
        creator: CreateRenderPass = (
            self.create_context.creators[CreateRenderPass.identifier]
        )
        render_pass_by_layer_name = {}
        for render_pass in existing_render_passes:
            for layer_name in render_pass["layer_names"]:
                render_pass_by_layer_name[layer_name] = render_pass

        # Use renaming template to parse correct variant from existing layer
        #   names.
        name_regex = None
        if self.layer_name_template["enabled"]:
            template = self.layer_name_template["template"]
            fake_group = "___group___"
            fake_layer = "___layer___"
            fake_variant = "___variant___"
            try:
                name_regex = template.format(
                    layer_index=fake_layer,
                    group_index=fake_group,
                    variant=fake_variant,
                )
            except Exception:
                self.log.error(
                    "Failed to fill name regex template.", exc_info=True
                )
                name_regex = ""

            for src, regex in (
                (fake_group, r"(?P<group>\d+)"),
                (fake_layer, r"(?P<layer>\d+)"),
                (fake_variant, r"(?P<variant>.*)"),
            ):
                name_regex = name_regex.replace(src, regex)
            name_regex = re.compile(name_regex)

        for layer in layers:
            layer_name = layer["name"]
            variant = None
            render_pass = render_pass_by_layer_name.get(layer_name)
            if render_pass is not None and len(render_pass["layer_names"]) > 0:
                variant = render_pass["variant"]
            elif name_regex is not None:
                result = name_regex.match(layer_name)
                groups = {}
                if result is not None:
                    groups = result.groupdict()
                variant = groups.get("variant")

            if not variant:
                variant = layer_name

            product_name = creator.get_product_name(
                project_name=project_entity["name"],
                folder_entity=folder_entity,
                task_entity=task_entity,
                variant=variant,
                host_name=self.create_context.host_name,
                instance=render_pass,
                project_entity=project_entity,
            )

            if render_pass is not None:
                render_pass["folderPath"] = folder_entity["path"]
                render_pass["task"] = task_name
                render_pass["productName"] = product_name
                continue

            instance_data: dict[str, str] = {
                "folderPath": folder_entity["path"],
                "task": task_name,
                "productType": creator.product_type,
                "variant": variant
            }

            pre_create_data: dict[str, Any] = {
                "render_layer_instance_id": render_layer_instance.id,
                "layer_names": [layer_name],
                "mark_for_review": mark_for_review
            }
            creator.create(product_name, instance_data, pre_create_data)

    def _filter_groups(
        self,
        layers_by_group_id,
        groups_order,
        only_visible_groups
    ):
        new_groups_order = []
        for group_id in groups_order:
            layers: list[dict[str, Any]] = layers_by_group_id[group_id]
            if not layers:
                continue

            if (
                only_visible_groups
                and not any(
                    layer
                    for layer in layers
                    if layer["visible"]
                )
            ):
                continue
            new_groups_order.append(group_id)
        return new_groups_order

    def create(self, product_name, instance_data, pre_create_data):
        project_entity = self.create_context.get_current_project_entity()
        if self._use_current_context:
            folder_path: str = self.create_context.get_current_folder_path()
            task_name: str = self.create_context.get_current_task_name()
        else:
            folder_path: str = instance_data["folderPath"]
            task_name: str = instance_data["task"]
        folder_entity: dict[str, Any] = self.create_context.get_folder_entity(
            folder_path
        )
        task_entity: dict[str, Any] = self.create_context.get_task_entity(
            folder_path, task_name
        )

        render_layers_by_group_id: dict[int, CreatedInstance] = {}
        render_passes_by_render_layer_id: dict[int, list[CreatedInstance]] = (
            collections.defaultdict(list)
        )
        for instance in self.create_context.instances:
            if instance.creator_identifier == CreateRenderlayer.identifier:
                group_id = instance["creator_attributes"]["group_id"]
                render_layers_by_group_id[group_id] = instance
            elif instance.creator_identifier == CreateRenderPass.identifier:
                render_layer_id = (
                    instance
                    ["creator_attributes"]
                    ["render_layer_instance_id"]
                )
                render_passes_by_render_layer_id[render_layer_id].append(
                    instance
                )

        layers_by_group_id: dict[int, list[dict[str, Any]]] = (
            collections.defaultdict(list)
        )
        scene_layers: list[dict[str, Any]] = get_layers_data()
        scene_groups: list[dict[str, Any]] = get_groups_data()
        groups_order: list[int] = []
        for layer in scene_layers:
            group_id: int = layer["group_id"]
            # Skip 'default' group
            if group_id == 0:
                continue

            layers_by_group_id[group_id].append(layer)
            if group_id not in groups_order:
                groups_order.append(group_id)

        groups_order.reverse()

        mark_layers_for_review = pre_create_data.get(
            "mark_layers_for_review", False
        )
        mark_passes_for_review = pre_create_data.get(
            "mark_passes_for_review", False
        )
        rename_groups = pre_create_data.get("rename_groups", False)
        only_visible_groups = pre_create_data.get("only_visible_groups", False)
        groups_order = self._filter_groups(
            layers_by_group_id,
            groups_order,
            only_visible_groups
        )
        if not groups_order:
            return

        if rename_groups:
            self._rename_groups(groups_order, scene_groups)

        # Make sure  all render layers are created
        for group_id in groups_order:
            instance: Union[CreatedInstance, None] = (
                self._prepare_render_layer(
                    project_entity,
                    folder_entity,
                    task_entity,
                    group_id,
                    scene_groups,
                    mark_layers_for_review,
                    render_layers_by_group_id.get(group_id),
                )
            )
            if instance is not None:
                render_layers_by_group_id[group_id] = instance

        for group_id in groups_order:
            layers: list[dict[str, Any]] = layers_by_group_id[group_id]
            render_layer_instance: Union[CreatedInstance, None] = (
                render_layers_by_group_id.get(group_id)
            )
            if not layers or render_layer_instance is None:
                continue

            self._prepare_render_passes(
                project_entity,
                folder_entity,
                task_entity,
                render_layer_instance,
                layers,
                mark_passes_for_review,
                render_passes_by_render_layer_id[render_layer_instance.id]
            )

    def get_pre_create_attr_defs(self) -> list[AbstractAttrDef]:
        render_layer_creator: CreateRenderlayer = (
            self.create_context.creators[CreateRenderlayer.identifier]
        )
        render_pass_creator: CreateRenderPass = (
            self.create_context.creators[CreateRenderPass.identifier]
        )
        output = []
        if self.allow_group_rename:
            output.extend([
                BoolDef(
                    "rename_groups",
                    label="Rename color groups",
                    tooltip="Will rename color groups using studio template",
                    default=True
                ),
                BoolDef(
                    "only_visible_groups",
                    label="Only visible color groups",
                    tooltip=(
                        "Render Layers and rename will happen only on color"
                        " groups with visible layers."
                    ),
                    default=True
                ),
                UISeparatorDef()
            ])
        output.extend([
            BoolDef(
                "mark_layers_for_review",
                label="Mark RenderLayers for review",
                default=render_layer_creator.mark_for_review
            ),
            BoolDef(
                "mark_passes_for_review",
                label="Mark RenderPasses for review",
                default=render_pass_creator.mark_for_review
            )
        ])
        return output