modified how template data are prepared

client/ayon_core/pipeline/template_data.py

@@ -1,5 +1,5 @@
 import ayon_api
-from ayon_core.client import get_asset_by_name
+
 from ayon_core.settings import get_studio_settings
 from ayon_core.lib.local_settings import get_ayon_username
 
@@ -31,8 +31,7 @@ def get_general_template_data(settings=None):
 def get_project_template_data(project_entity=None, project_name=None):
     """Extract data from project document that are used in templates.
 
-    Project document must have 'name' and (at this moment) optional
-        key 'data.code'.
+    Project document must have 'name' and 'code'.
 
     One of 'project_name' or 'project_entity' must be passed. With prepared
     project document is function much faster because don't have to query.
@@ -52,7 +51,7 @@ def get_project_template_data(project_entity=None, project_name=None):
     if not project_name:
         project_name = project_entity["name"]
 
-    if not project_entity:
+    elif not project_entity:
         project_entity = ayon_api.get_project(project_name, fields=["code"])
 
     project_code = project_entity["code"]
@@ -64,87 +63,74 @@ def get_project_template_data(project_entity=None, project_name=None):
     }
 
 
-def get_asset_template_data(asset_doc, project_name):
-    """Extract data from asset document that are used in templates.
+def get_folder_template_data(folder_entity, project_name):
+    """Extract data from folder entity that are used in templates.
 
     Output dictionary contains keys:
-    - 'asset'       - asset name
-    - 'hierarchy'   - parent asset names joined with '/'
-    - 'parent'      - direct parent name, project name used if is under project
+    - 'folder'      - dictionary with 'name' key filled with folder name
+    - 'asset'       - folder name
+    - 'hierarchy'   - parent folder names joined with '/'
+    - 'parent'      - direct parent name, project name used if is under
+                      project
 
     Required document fields:
-        Asset: 'name', 'data.parents'
+        Folder: 'path' -> Plan to require: 'folderType'
 
     Args:
-        asset_doc (Dict[str, Any]): Queried asset document.
-        project_name (str): Is used for 'parent' key if asset doc does not have
-            any.
+        folder_entity (Dict[str, Any]): Folder entity.
+        project_name (str): Is used for 'parent' key if folder entity
+            does not have any.
 
     Returns:
-        Dict[str, str]: Data that are based on asset document and can be used
+        Dict[str, str]: Data that are based on folder entity and can be used
             in templates.
     """
 
-    asset_parents = asset_doc["data"]["parents"]
-    hierarchy = "/".join(asset_parents)
-    if asset_parents:
-        parent_name = asset_parents[-1]
+    path = folder_entity["path"]
+    hierarchy_parts = path.split("/")
+    # Remove empty string from the beginning
+    hierarchy_parts.pop(0)
+    # Remove last part which is folder name
+    folder_name = hierarchy_parts.pop(-1)
+    hierarchy = "/".join(hierarchy_parts)
+    if hierarchy_parts:
+        parent_name = hierarchy_parts[-1]
     else:
         parent_name = project_name
 
     return {
-        "asset": asset_doc["name"],
         "folder": {
-            "name": asset_doc["name"]
+            "name": folder_name,
         },
+        "asset": folder_name,
         "hierarchy": hierarchy,
         "parent": parent_name
     }
 
 
-def get_task_type(asset_doc, task_name):
-    """Get task type based on asset document and task name.
-
-    Required document fields:
-        Asset: 'data.tasks'
-
-    Args:
-        asset_doc (Dict[str, Any]): Queried asset document.
-        task_name (str): Task name which is under asset.
-
-    Returns:
-        str: Task type name.
-        None: Task was not found on asset document.
-    """
-
-    asset_tasks_info = asset_doc["data"]["tasks"]
-    return asset_tasks_info.get(task_name, {}).get("type")
-
-
-def get_task_template_data(project_entity, asset_doc, task_name):
-    """"Extract task specific data from project and asset documents.
+def get_task_template_data(project_entity, task_entity):
+    """Prepare task template data.
 
     Required document fields:
         Project: 'tasksTypes'
-        Asset: 'data.tasks'.
+        Task: 'type'
 
     Args:
-        project_entity (Dict[str, Any]): Queried project entity.
-        asset_doc (Dict[str, Any]): Queried asset document.
-        task_name (str): Name of task for which data should be returned.
+        project_entity (Dict[str, Any]): Project entity.
+        task_entity (Dict[str, Any]): Task entity.
 
     Returns:
         Dict[str, Dict[str, str]]: Template data
-    """
 
+    """
     project_task_types = project_entity["taskTypes"]
     task_types_by_name = {task["name"]: task for task in project_task_types}
-    task_type = get_task_type(asset_doc, task_name)
+    task_type = task_entity["taskType"]
     task_code = task_types_by_name.get(task_type, {}).get("shortName")
 
     return {
         "task": {
-            "name": task_name,
+            "name": task_entity["name"],
             "type": task_type,
             "short": task_code,
         }
@@ -153,10 +139,10 @@ def get_task_template_data(project_entity, asset_doc, task_name):
 
 def get_template_data(
     project_entity,
-    asset_doc=None,
-    task_name=None,
+    folder_entity=None,
+    task_entity=None,
     host_name=None,
-    settings=None
+    settings=None,
 ):
     """Prepare data for templates filling from entered documents and info.
 
@@ -169,13 +155,14 @@ def get_template_data(
 
     Required document fields:
         Project: 'name', 'code', 'taskTypes.name'
-        Asset: 'name', 'data.parents', 'data.tasks'
+        Folder: 'name', 'path'
+        Task: 'type'
 
     Args:
         project_entity (Dict[str, Any]): Project entity.
-        asset_doc (Dict[str, Any]): Mongo document of asset from MongoDB.
-        task_name (Union[str, None]): Task name under passed asset.
-        host_name (Union[str, None]): Used to fill '{app}' key.
+        folder_entity (Optional[Dict[str, Any]]): Folder entity.
+        task_entity (Optional[Dict[str, Any]): Task entity.
+        host_name (Optional[str]): Used to fill '{app}' key.
         settings (Union[Dict, None]): Prepared studio or project settings.
             They're queried if not passed (may be slower).
 
@@ -185,13 +172,13 @@ def get_template_data(
 
     template_data = get_general_template_data(settings)
     template_data.update(get_project_template_data(project_entity))
-    if asset_doc:
-        template_data.update(get_asset_template_data(
-            asset_doc, project_entity["name"]
+    if folder_entity:
+        template_data.update(get_folder_template_data(
+            folder_entity, project_entity["name"]
         ))
-        if task_name:
+        if task_entity:
             template_data.update(get_task_template_data(
-                project_entity, asset_doc, task_name
+                project_entity, task_entity
             ))
 
     if host_name:
@@ -202,7 +189,7 @@ def get_template_data(
 
 def get_template_data_with_names(
     project_name,
-    asset_name=None,
+    folder_path=None,
     task_name=None,
     host_name=None,
     settings=None
@@ -213,14 +200,12 @@ def get_template_data_with_names(
     Only difference is that documents are queried.
 
     Args:
-        project_name (str): Project name for which template data are
-            calculated.
-        asset_name (Union[str, None]): Asset name for which template data are
-            calculated.
-        task_name (Union[str, None]): Task name under passed asset.
-        host_name (Union[str, None]):Used to fill '{app}' key.
+        project_name (str): Project name.
+        folder_path (Optional[str]): Folder path.
+        task_name (Optional[str]): Task name.
+        host_name (Optional[str]):Used to fill '{app}' key.
             because workdir template may contain `{app}` key.
-        settings (Union[Dict, None]): Prepared studio or project settings.
+        settings (Optional[Dict]): Prepared studio or project settings.
             They're queried if not passed.
 
     Returns:
@@ -228,13 +213,18 @@ def get_template_data_with_names(
     """
 
     project_entity = ayon_api.get_project(project_name)
-    asset_doc = None
-    if asset_name:
-        asset_doc = get_asset_by_name(
+    folder_entity = None
+    task_entity = None
+    if folder_path:
+        folder_entity = ayon_api.get_folder_by_path(
             project_name,
-            asset_name,
-            fields=["name", "data.parents", "data.tasks"]
+            folder_path,
+            fields={"id", "path", "folderType"}
         )
+        if task_name and folder_entity:
+            task_entity = ayon_api.get_task_by_name(
+                project_name, folder_entity["id"], task_name
+            )
     return get_template_data(
-        project_entity, asset_doc, task_name, host_name, settings
+        project_entity, folder_entity, task_entity, host_name, settings
     )