Merge branch 'develop' into task-type-short-name

Author: martastain

.github/workflows/release_trigger.yml

@@ -2,10 +2,23 @@ name: 🚀 Release Trigger
 
 on:
   workflow_dispatch:
+    inputs:
+      draft:
+        type: boolean
+        description: "Create Release Draft"
+        required: false
+        default: false
+      release_overwrite:
+        type: string
+        description: "Set Version Release Tag"
+        required: false
 
 jobs:
   call-release-trigger:
     uses: ynput/ops-repo-automation/.github/workflows/release_trigger.yml@main
+    with:
+      draft: ${{ inputs.draft }}
+      release_overwrite: ${{ inputs.release_overwrite }}
     secrets:
       token: ${{ secrets.YNPUT_BOT_TOKEN }}
       email: ${{ secrets.CI_EMAIL }}

.github/workflows/upload_to_ynput_cloud.yml

@@ -0,0 +1,16 @@
+name: 📤 Upload to Ynput Cloud
+
+on:
+  workflow_dispatch:
+  release:
+    types: [published]
+
+jobs:
+  call-upload-to-ynput-cloud:
+    uses: ynput/ops-repo-automation/.github/workflows/upload_to_ynput_cloud.yml@main
+    secrets:
+      CI_EMAIL: ${{ secrets.CI_EMAIL }}
+      CI_USER: ${{ secrets.CI_USER }}
+      YNPUT_BOT_TOKEN: ${{ secrets.YNPUT_BOT_TOKEN }}
+      YNPUT_CLOUD_URL: ${{ secrets.YNPUT_CLOUD_URL }}
+      YNPUT_CLOUD_TOKEN: ${{ secrets.YNPUT_CLOUD_TOKEN }}

server/kitsu/anatomy.py

@@ -1,13 +1,16 @@
 import contextlib
 from typing import TYPE_CHECKING, Any
 
+from ayon_server.entities import ProjectEntity
 from ayon_server.exceptions import AyonException
 from ayon_server.lib.postgres import Postgres
 from ayon_server.settings.anatomy import Anatomy
 from ayon_server.settings.anatomy.statuses import Status
 from ayon_server.settings.anatomy.task_types import TaskType
+from nxtools import logging
 
 from .addon_helpers import create_short_name, remove_accents
+from .extract_ayon_project_anatomy import extract_ayon_project_anatomy
 
 if TYPE_CHECKING:
     from .. import KitsuAddon
@@ -199,6 +202,7 @@ async def get_primary_anatomy_preset() -> Anatomy:
 async def get_kitsu_project_anatomy(
     addon: "KitsuAddon",
     kitsu_project_id: str,
+    ayon_project: ProjectEntity | None = None,
 ) -> Anatomy:
     kitsu_project_response = await addon.kitsu.get(
         f"data/projects/{kitsu_project_id}"
@@ -212,13 +216,29 @@ async def get_kitsu_project_anatomy(
     statuses = await parse_statuses(addon, kitsu_project_id)
     task_types = await parse_task_types(addon, kitsu_project_id)
 
-    anatomy_preset = await get_primary_anatomy_preset()
-    anatomy_dict = anatomy_preset.dict()
+    if ayon_project:
+        anatomy = extract_ayon_project_anatomy(ayon_project)
+    else:
+        anatomy = await get_primary_anatomy_preset()
+
+    if ayon_project:
+        prj_name = ayon_project.name
+    else:
+        prj_name = "new project"
+
+    anatomy_dict = anatomy.dict()
     for key in anatomy_dict["attributes"]:
         if key in attributes:
-            anatomy_dict["attributes"][key]=attributes[key]
+            anatomy_dict["attributes"][key] = attributes[key]
+            logging.debug(
+                "updated project",
+                prj_name,
+                "anatomy attribute",
+                key,
+                "to",
+                attributes[key],
+            )
 
-    #anatomy_dict["attributes"] = attributes
     anatomy_dict["statuses"] = statuses
     anatomy_dict["task_types"] = task_types
 

server/kitsu/extract_ayon_project_anatomy.py

@@ -0,0 +1,71 @@
+"""Extract Anatomy object from ayon ProjectEntity.
+
+This file is for the backwards compatibility with Ayon server.
+
+This funciton is a part of the server from version 1.5.1, so we
+can remove this file after a grace period.
+
+```
+from ayon_server.helpers.extract_anatomy import extract_project_anatomy
+```
+
+"""
+
+from typing import Any
+from ayon_server.entities import ProjectEntity
+from ayon_server.entities.models.submodels import LinkTypeModel
+from ayon_server.settings.anatomy import Anatomy
+
+
+def dict2list(src) -> list[dict[str, Any]]:
+    return [{"name": k, "original_name": k, **v} for k, v in src.items()]
+
+
+def process_aux_table(src: list[dict[str, Any]]) -> list[dict[str, Any]]:
+    """Process auxiliary table."""
+    result = []
+    for data in src:
+        result.append({**data, "original_name": data["name"]})
+    return result
+
+
+def process_link_types(src: list[LinkTypeModel]) -> list[dict[str, Any]]:
+    """Convert project linktypes submodel to anatomy-style linktypes."""
+    result = []
+    for ltdata in src:
+        row = {
+            "link_type": ltdata.link_type,
+            "input_type": ltdata.input_type,
+            "output_type": ltdata.output_type,
+        }
+        for key in ["color", "style"]:
+            if value := ltdata.data.get(key):
+                row[key] = value
+        result.append(row)
+    return result
+
+
+def extract_ayon_project_anatomy(project: ProjectEntity) -> Anatomy:
+    """Extract Anatomy object from ayon ProjectEntity."""
+
+    templates = project.config.get("templates", {}).get("common", {})
+    for template_group, template_group_def in project.config.get(
+        "templates", {}
+    ).items():
+        if template_group == "common":
+            continue
+        templates[template_group] = dict2list(template_group_def)
+
+    result = {
+        "templates": templates,
+        "roots": dict2list(project.config.get("roots", {})),
+        "folder_types": process_aux_table(project.folder_types),
+        "task_types": process_aux_table(project.task_types),
+        "link_types": process_link_types(project.link_types),
+        "statuses": process_aux_table(project.statuses),
+        "tags": process_aux_table(project.tags),
+        "attributes": project.attrib,
+    }
+
+    return Anatomy(**result)
+

server/kitsu/push.py

@@ -330,7 +330,7 @@ async def sync_project(
         return
 
     await addon.ensure_kitsu(mock)
-    anatomy = await get_kitsu_project_anatomy(addon, entity_id)
+    anatomy = await get_kitsu_project_anatomy(addon, entity_id, project)
     anatomy_data = anatomy_to_project_data(anatomy)
 
     await update_project(project.name, **anatomy_data)
@@ -552,6 +552,13 @@ async def sync_task(
                 return
 
         logging.info(f"Creating {entity_dict['type']} '{entity_dict['name']}'")
+
+        if "task_type_name" not in entity_dict:
+            logging.warning(
+                f"Task type not found for {entity_dict['name']}'"
+            )
+            return
+
         target_task = await create_task(
             project_name=project.name,
             folder_id=parent_id,