diff --git a/client/ayon_core/pipeline/template_data.py b/client/ayon_core/pipeline/template_data.py index 8ecba828a6..526c7d35c5 100644 --- a/client/ayon_core/pipeline/template_data.py +++ b/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 )