Merge branch 'develop' into enhancement/tycache-enhancement-cached-material

.github/ISSUE_TEMPLATE/bug_report.yml

@@ -1,6 +1,6 @@
 name: Bug Report
 description: File a bug report
-title: 'Bug: '
+title: 'Your issue title here'
 labels:
   - 'type: bug'
 body:

.github/ISSUE_TEMPLATE/enhancement_request.yml

@@ -1,6 +1,6 @@
 name: Enhancement Request
 description: Create a report to help us enhance a particular feature
-title: "Enhancement: "
+title: "Your issue title here"
 labels:
   - "type: enhancement"
 body:
@@ -49,4 +49,4 @@ body:
       label: "Additional context:"
       description: Add any other context or screenshots about the enhancement request here.
     validations:
-      required: false
+      required: false

.github/workflows/pr_linting.yml

@@ -0,0 +1,24 @@
+name: 📇 Code Linting
+
+on:
+  push:
+    branches: [ develop ]
+  pull_request:
+    branches: [ develop ]
+
+  workflow_dispatch:
+
+concurrency:
+  group: ${{ github.workflow }}-${{ github.event.pull_request.number}}
+  cancel-in-progress: true
+
+permissions:
+  contents: read
+  pull-requests: write
+
+jobs:
+  linting:
+    runs-on: ubuntu-latest
+    steps:
+      - uses: actions/checkout@v4
+      - uses: chartboost/ruff-action@v1

.gitignore

@@ -77,6 +77,7 @@ dump.sql
 
 # Poetry
 ########
+.poetry/
 .python-version
 .editorconfig
 .pre-commit-config.yaml

.hound.yml

@@ -1,3 +1,3 @@
-flake8:
-  enabled: true
-  config_file: setup.cfg
+flake8:
+  enabled: true
+  config_file: setup.cfg

.pre-commit-config.yaml

@@ -1,12 +1,27 @@
 # See https://pre-commit.com for more information
 # See https://pre-commit.com/hooks.html for more hooks
 repos:
--   repo: https://github.com/pre-commit/pre-commit-hooks
-    rev: v4.4.0
-    hooks:
-    -   id: trailing-whitespace
-    -   id: end-of-file-fixer
-    -   id: check-yaml
-    -   id: check-added-large-files
-    -   id: no-commit-to-branch
-        args: [ '--pattern', '^(?!((release|enhancement|feature|bugfix|documentation|tests|local|chore)\/[a-zA-Z0-9\-_]+)$).*' ]
+    - repo: https://github.com/pre-commit/pre-commit-hooks
+      rev: v4.4.0
+      hooks:
+            - id: trailing-whitespace
+            - id: end-of-file-fixer
+            - id: check-yaml
+            - id: check-added-large-files
+            - id: no-commit-to-branch
+              args: [ '--pattern', '^(?!((release|enhancement|feature|bugfix|documentation|tests|local|chore)\/[a-zA-Z0-9\-_]+)$).*' ]
+    - repo: https://github.com/codespell-project/codespell
+      rev: v2.2.6
+      hooks:
+      - id: codespell
+        additional_dependencies:
+          - tomli
+
+    - repo: https://github.com/astral-sh/ruff-pre-commit
+      # Ruff version.
+      rev: v0.3.3
+      hooks:
+        # Run the linter.
+        - id: ruff
+        # Run the formatter.
+        # - id: ruff-format

README.md

@@ -1,8 +1,8 @@
 
-AYON Core addon
-========
+AYON Core Addon
+===============
 
-AYON core provides the base building blocks for all other AYON addons and integrations and is responsible for discovery and initialization of other addons. 
+AYON core provides the base building blocks for all other AYON addons and integrations and is responsible for discovery and initialization of other addons.
 
 - Some of its key functions include:
 - It is used as the main command line handler in [ayon-launcher](https://github.com/ynput/ayon-launcher) application.
@@ -13,8 +13,20 @@ AYON core provides the base building blocks for all other AYON addons and integr
 - Defines pipeline API used by other integrations
 - Provides all graphical tools for artists
 - Defines AYON QT styling
-- A bunch more things   
+- A bunch more things
 
-Together with [ayon-launcher](https://github.com/ynput/ayon-launcher) , they form the base of AYON pipeline and is one of few compulsory addons for AYON pipeline to be useful in a meaningful way. 
+Together with [ayon-launcher](https://github.com/ynput/ayon-launcher) , they form the base of AYON pipeline and is one of few compulsory addons for AYON pipeline to be useful in a meaningful way.
 
-AYON-core is a successor to OpenPype repository (minus all the addons) and still in the process of cleaning up of all references. Please bear with us during this transitional phase. 
+AYON-core is a successor to [OpenPype repository](https://github.com/ynput/OpenPype) (minus all the addons) and still in the process of cleaning up of all references. Please bear with us during this transitional phase.
+
+Development and testing notes
+-----------------------------
+There is `pyproject.toml` file in the root of the repository. This file is used to define the development environment and is used by `poetry` to create a virtual environment.
+This virtual environment is used to run tests and to develop the code, to help with
+linting and formatting. Dependencies defined here are not used in actual addon
+deployment - for that you need to edit `./client/pyproject.toml` file. That file
+will be then processed [ayon-dependencies-tool](https://github.com/ynput/ayon-dependencies-tool)
+to create dependency package.
+
+Right now, this file needs to by synced with dependencies manually, but in the future
+we plan to automate process of development environment creation.

client/ayon_core/__init__.py

@@ -1,12 +1,28 @@
 import os
+from .version import __version__
 
 
 AYON_CORE_ROOT = os.path.dirname(os.path.abspath(__file__))
 
-# TODO remove after '1.x.x'
+# -------------------------
+# DEPRECATED - Remove before '1.x.x' release
+# -------------------------
 PACKAGE_DIR = AYON_CORE_ROOT
 PLUGINS_DIR = os.path.join(AYON_CORE_ROOT, "plugins")
 AYON_SERVER_ENABLED = True
 
 # Indicate if AYON entities should be used instead of OpenPype entities
-USE_AYON_ENTITIES = False
+USE_AYON_ENTITIES = True
+# -------------------------
+
+
+__all__ = (
+    "__version__",
+
+    # Deprecated
+    "AYON_CORE_ROOT",
+    "PACKAGE_DIR",
+    "PLUGINS_DIR",
+    "AYON_SERVER_ENABLED",
+    "USE_AYON_ENTITIES",
+)

client/ayon_core/addon/README.md

@@ -27,7 +27,7 @@ AYON addons should contain separated logic of specific kind of implementation, s
 - default interfaces are defined in `interfaces.py`
 
 ## IPluginPaths
-- addon wants to add directory path/s to avalon or publish plugins
+- addon wants to add directory path/s to publish, load, create or inventory plugins
 - addon must implement `get_plugin_paths` which must return dictionary with possible keys `"publish"`, `"load"`, `"create"` or `"actions"`
  - each key may contain list or string with a path to directory with plugins
 
@@ -89,4 +89,4 @@ AYON addons should contain separated logic of specific kind of implementation, s
 
 ### TrayAddonsManager
 - inherits from `AddonsManager`
-- has specific implementation for Pype Tray tool and handle `ITrayAddon` methods
+- has specific implementation for AYON Tray and handle `ITrayAddon` methods

client/ayon_core/addon/base.py

@@ -14,9 +14,11 @@ from abc import ABCMeta, abstractmethod
 
 import six
 import appdirs
+import ayon_api
+from semver import VersionInfo
 
+from ayon_core import AYON_CORE_ROOT
 from ayon_core.lib import Logger, is_dev_mode_enabled
-from ayon_core.client import get_ayon_server_api_connection
 from ayon_core.settings import get_studio_settings
 
 from .interfaces import (
@@ -45,6 +47,11 @@ IGNORED_HOSTS_IN_AYON = {
 }
 IGNORED_MODULES_IN_AYON = set()
 
+# When addon was moved from ayon-core codebase
+# - this is used to log the missing addon
+MOVED_ADDON_MILESTONE_VERSIONS = {
+    "applications": VersionInfo(0, 2, 0),
+}
 
 # Inherit from `object` for Python 2 hosts
 class _ModuleClass(object):
@@ -147,8 +154,7 @@ def load_addons(force=False):
 
 
 def _get_ayon_bundle_data():
-    con = get_ayon_server_api_connection()
-    bundles = con.get_bundles()["bundles"]
+    bundles = ayon_api.get_bundles()["bundles"]
 
     bundle_name = os.getenv("AYON_BUNDLE_NAME")
 
@@ -176,8 +182,7 @@ def _get_ayon_addons_information(bundle_info):
 
     output = []
     bundle_addons = bundle_info["addons"]
-    con = get_ayon_server_api_connection()
-    addons = con.get_addons_info()["addons"]
+    addons = ayon_api.get_addons_info()["addons"]
     for addon in addons:
         name = addon["name"]
         versions = addon.get("versions")
@@ -193,6 +198,45 @@ def _get_ayon_addons_information(bundle_info):
     return output
 
 
+def _handle_moved_addons(addon_name, milestone_version, log):
+    """Log message that addon version is not compatible with current core.
+
+    The function can return path to addon client code, but that can happen
+        only if ayon-core is used from code (for development), but still
+        logs a warning.
+
+    Args:
+        addon_name (str): Addon name.
+        milestone_version (str): Milestone addon version.
+        log (logging.Logger): Logger object.
+
+    Returns:
+        Union[str, None]: Addon dir or None.
+    """
+    # Handle addons which were moved out of ayon-core
+    # - Try to fix it by loading it directly from server addons dir in
+    #   ayon-core repository. But that will work only if ayon-core is
+    #   used from code.
+    addon_dir = os.path.join(
+        os.path.dirname(os.path.dirname(AYON_CORE_ROOT)),
+        "server_addon",
+        addon_name,
+        "client",
+    )
+    if not os.path.exists(addon_dir):
+        log.error((
+            "Addon '{}' is not be available."
+            " Please update applications addon to '{}' or higher."
+        ).format(addon_name, milestone_version))
+        return None
+
+    log.warning((
+        "Please update '{}' addon to '{}' or higher."
+        " Using client code from ayon-core repository."
+    ).format(addon_name, milestone_version))
+    return addon_dir
+
+
 def _load_ayon_addons(openpype_modules, modules_key, log):
     """Load AYON addons based on information from server.
 
@@ -250,6 +294,7 @@ def _load_ayon_addons(openpype_modules, modules_key, log):
         use_dev_path = dev_addon_info.get("enabled", False)
 
         addon_dir = None
+        milestone_version = MOVED_ADDON_MILESTONE_VERSIONS.get(addon_name)
         if use_dev_path:
             addon_dir = dev_addon_info["path"]
             if not addon_dir or not os.path.exists(addon_dir):
@@ -258,6 +303,16 @@ def _load_ayon_addons(openpype_modules, modules_key, log):
                 ).format(addon_name, addon_version, addon_dir))
                 continue
 
+        elif (
+            milestone_version is not None
+            and VersionInfo.parse(addon_version) < milestone_version
+        ):
+            addon_dir = _handle_moved_addons(
+                addon_name, milestone_version, log
+            )
+            if not addon_dir:
+                continue
+
         elif addons_dir_exists:
             folder_name = "{}_{}".format(addon_name, addon_version)
             addon_dir = os.path.join(addons_dir, folder_name)
@@ -342,9 +397,8 @@ def _load_addons_in_core(
 ):
     # Add current directory at first place
     #   - has small differences in import logic
-    current_dir = os.path.abspath(os.path.dirname(__file__))
-    hosts_dir = os.path.join(os.path.dirname(current_dir), "hosts")
-    modules_dir = os.path.join(os.path.dirname(current_dir), "modules")
+    hosts_dir = os.path.join(AYON_CORE_ROOT, "hosts")
+    modules_dir = os.path.join(AYON_CORE_ROOT, "modules")
 
     ignored_host_names = set(IGNORED_HOSTS_IN_AYON)
     ignored_module_dir_filenames = (
@@ -743,7 +797,7 @@ class AddonsManager:
 
         addon_classes = []
         for module in openpype_modules:
-            # Go through globals in `pype.modules`
+            # Go through globals in `ayon_core.modules`
             for name in dir(module):
                 modules_item = getattr(module, name, None)
                 # Filter globals that are not classes which inherit from
@@ -1077,7 +1131,7 @@ class AddonsManager:
         """Print out report of time spent on addons initialization parts.
 
         Reporting is not automated must be implemented for each initialization
-        part separatelly. Reports must be stored to `_report` attribute.
+        part separately. Reports must be stored to `_report` attribute.
         Print is skipped if `_report` is empty.
 
         Attribute `_report` is dictionary where key is "label" describing
@@ -1269,7 +1323,7 @@ class TrayAddonsManager(AddonsManager):
     def add_doubleclick_callback(self, addon, callback):
         """Register doubleclick callbacks on tray icon.
 
-        Currently there is no way how to determine which is launched. Name of
+        Currently, there is no way how to determine which is launched. Name of
         callback can be defined with `doubleclick_callback` attribute.
 
         Missing feature how to define default callback.

client/ayon_core/cli.py

@@ -4,6 +4,7 @@ import os
 import sys
 import code
 import traceback
+from pathlib import Path
 
 import click
 import acre
@@ -11,6 +12,7 @@ import acre
 from ayon_core import AYON_CORE_ROOT
 from ayon_core.addon import AddonsManager
 from ayon_core.settings import get_general_environments
+from ayon_core.lib import initialize_ayon_connection, is_running_from_build
 
 from .cli_commands import Commands
 
@@ -80,7 +82,7 @@ main_cli.set_alias("addon", "module")
 @main_cli.command()
 @click.argument("output_json_path")
 @click.option("--project", help="Project name", default=None)
-@click.option("--asset", help="Asset name", default=None)
+@click.option("--asset", help="Folder path", default=None)
 @click.option("--task", help="Task name", default=None)
 @click.option("--app", help="Application name", default=None)
 @click.option(
@@ -95,6 +97,10 @@ def extractenvironments(output_json_path, project, asset, task, app, envgroup):
     environments will be extracted.
 
     Context options are "project", "asset", "task", "app"
+
+    Deprecated:
+        This function is deprecated and will be removed in future. Please use
+        'addon applications extractenvironments ...' instead.
     """
     Commands.extractenvironments(
         output_json_path, project, asset, task, app, envgroup
@@ -102,19 +108,18 @@ def extractenvironments(output_json_path, project, asset, task, app, envgroup):
 
 
 @main_cli.command()
-@click.argument("paths", nargs=-1)
-@click.option("-t", "--targets", help="Targets module", default=None,
+@click.argument("path", required=True)
+@click.option("-t", "--targets", help="Targets", default=None,
               multiple=True)
 @click.option("-g", "--gui", is_flag=True,
               help="Show Publish UI", default=False)
-def publish(paths, targets, gui):
+def publish(path, targets, gui):
     """Start CLI publishing.
 
-    Publish collects json from paths provided as an argument.
-    More than one path is allowed.
+    Publish collects json from path provided as an argument.
+S
     """
-
-    Commands.publish(list(paths), targets, gui)
+    Commands.publish(path, targets, gui)
 
 
 @main_cli.command(context_settings={"ignore_unknown_options": True})
@@ -127,7 +132,7 @@ def publish_report_viewer():
 @main_cli.command()
 @click.argument("output_path")
 @click.option("--project", help="Define project context")
-@click.option("--asset", help="Define asset in project (project must be set)")
+@click.option("--folder", help="Define folder in project (project must be set)")
 @click.option(
     "--strict",
     is_flag=True,
@@ -136,18 +141,18 @@ def publish_report_viewer():
 def contextselection(
     output_path,
     project,
-    asset,
+    folder,
     strict
 ):
     """Show Qt dialog to select context.
 
-    Context is project name, asset name and task name. The result is stored
+    Context is project name, folder path and task name. The result is stored
     into json file which path is passed in first argument.
     """
     Commands.contextselection(
         output_path,
         project,
-        asset,
+        folder,
         strict
     )
 
@@ -163,16 +168,27 @@ def run(script):
 
     if not script:
         print("Error: missing path to script file.")
+        return
+
+    # Remove first argument if it is the same as AYON executable
+    # - Forward compatibility with future AYON versions.
+    # - Current AYON launcher keeps the arguments with first argument but
+    #     future versions might remove it.
+    first_arg = sys.argv[0]
+    if is_running_from_build():
+        comp_path = os.getenv("AYON_EXECUTABLE")
     else:
+        comp_path = os.path.join(os.environ["AYON_ROOT"], "start.py")
+    # Compare paths and remove first argument if it is the same as AYON
+    if Path(first_arg).resolve() == Path(comp_path).resolve():
+        sys.argv.pop(0)
 
-        args = sys.argv
-        args.remove("run")
-        args.remove(script)
-        sys.argv = args
+    # Remove 'run' command from sys.argv
+    sys.argv.remove("run")
 
-        args_string = " ".join(args[1:])
-        print(f"... running: {script} {args_string}")
-        runpy.run_path(script, run_name="__main__", )
+    args_string = " ".join(sys.argv[1:])
+    print(f"... running: {script} {args_string}")
+    runpy.run_path(script, run_name="__main__")
 
 
 @main_cli.command()
@@ -243,6 +259,7 @@ def _set_addons_environments():
 
 
 def main(*args, **kwargs):
+    initialize_ayon_connection()
     python_path = os.getenv("PYTHONPATH", "")
     split_paths = python_path.split(os.pathsep)
 

client/ayon_core/cli_commands.py

@@ -2,7 +2,7 @@
 """Implementation of AYON commands."""
 import os
 import sys
-import json
+import warnings
 
 
 class Commands:
@@ -41,38 +41,35 @@ class Commands:
         return click_func
 
     @staticmethod
-    def publish(paths, targets=None, gui=False):
+    def publish(path: str, targets: list=None, gui:bool=False) -> None:
         """Start headless publishing.
 
-        Publish use json from passed paths argument.
+        Publish use json from passed path argument.
 
         Args:
-            paths (list): Paths to jsons.
-            targets (string): What module should be targeted
-                (to choose validator for example)
+            path (str): Path to JSON.
+            targets (list of str): List of pyblish targets.
             gui (bool): Show publish UI.
 
         Raises:
             RuntimeError: When there is no path to process.
-        """
+            RuntimeError: When executed with list of JSON paths.
 
+        """
         from ayon_core.lib import Logger
-        from ayon_core.lib.applications import (
-            get_app_environments_for_context,
-            LaunchTypes,
-        )
+
         from ayon_core.addon import AddonsManager
         from ayon_core.pipeline import (
             install_ayon_plugins,
             get_global_context,
         )
-        from ayon_core.tools.utils.host_tools import show_publish
-        from ayon_core.tools.utils.lib import qt_app_context
 
         # Register target and host
-        import pyblish.api
         import pyblish.util
 
+        if not isinstance(path, str):
+            raise RuntimeError("Path to JSON must be a string.")
+
         # Fix older jobs
         for src_key, dst_key in (
             ("AVALON_PROJECT", "AYON_PROJECT_NAME"),
@@ -95,21 +92,16 @@ class Commands:
 
         publish_paths = manager.collect_plugin_paths()["publish"]
 
-        for path in publish_paths:
-            pyblish.api.register_plugin_path(path)
+        for plugin_path in publish_paths:
+            pyblish.api.register_plugin_path(plugin_path)
 
-        if not any(paths):
-            raise RuntimeError("No publish paths specified")
-
-        app_full_name = os.getenv("AYON_APP_NAME")
-        if app_full_name:
+        applications_addon = manager.get_enabled_addon("applications")
+        if applications_addon is not None:
             context = get_global_context()
-            env = get_app_environments_for_context(
+            env = applications_addon.get_farm_publish_environment_variables(
                 context["project_name"],
                 context["folder_path"],
                 context["task_name"],
-                app_full_name,
-                launch_type=LaunchTypes.farm_publish,
             )
             os.environ.update(env)
 
@@ -122,7 +114,7 @@ class Commands:
         else:
             pyblish.api.register_target("farm")
 
-        os.environ["AYON_PUBLISH_DATA"] = os.pathsep.join(paths)
+        os.environ["AYON_PUBLISH_DATA"] = path
         os.environ["HEADLESS_PUBLISH"] = 'true'  # to use in app lib
 
         log.info("Running publish ...")
@@ -133,6 +125,8 @@ class Commands:
             print(plugin)
 
         if gui:
+            from ayon_core.tools.utils.host_tools import show_publish
+            from ayon_core.tools.utils.lib import qt_app_context
             with qt_app_context():
                 show_publish()
         else:
@@ -149,39 +143,39 @@ class Commands:
         log.info("Publish finished.")
 
     @staticmethod
-    def extractenvironments(output_json_path, project, asset, task, app,
-                            env_group):
+    def extractenvironments(
+        output_json_path, project, asset, task, app, env_group
+    ):
         """Produces json file with environment based on project and app.
 
         Called by Deadline plugin to propagate environment into render jobs.
         """
 
-        from ayon_core.lib.applications import (
-            get_app_environments_for_context,
-            LaunchTypes,
+        from ayon_core.addon import AddonsManager
+
+        warnings.warn(
+            (
+                "Command 'extractenvironments' is deprecated and will be"
+                " removed in future. Please use "
+                "'addon applications extractenvironments ...' instead."
+            ),
+            DeprecationWarning
         )
 
-        if all((project, asset, task, app)):
-            env = get_app_environments_for_context(
-                project,
-                asset,
-                task,
-                app,
-                env_group=env_group,
-                launch_type=LaunchTypes.farm_render
+        addons_manager = AddonsManager()
+        applications_addon = addons_manager.get_enabled_addon("applications")
+        if applications_addon is None:
+            raise RuntimeError(
+                "Applications addon is not available or enabled."
             )
-        else:
-            env = os.environ.copy()
 
-        output_dir = os.path.dirname(output_json_path)
-        if not os.path.exists(output_dir):
-            os.makedirs(output_dir)
-
-        with open(output_json_path, "w") as file_stream:
-            json.dump(env, file_stream, indent=4)
+        # Please ignore the fact this is using private method
+        applications_addon._cli_extract_environments(
+            output_json_path, project, asset, task, app, env_group
+        )
 
     @staticmethod
-    def contextselection(output_path, project_name, asset_name, strict):
+    def contextselection(output_path, project_name, folder_path, strict):
         from ayon_core.tools.context_dialog import main
 
-        main(output_path, project_name, asset_name, strict)
+        main(output_path, project_name, folder_path, strict)

client/ayon_core/client/__init__.py

@@ -1,110 +0,0 @@
-from .utils import get_ayon_server_api_connection
-
-from .entities import (
-    get_projects,
-    get_project,
-    get_whole_project,
-
-    get_asset_by_id,
-    get_asset_by_name,
-    get_assets,
-    get_archived_assets,
-    get_asset_ids_with_subsets,
-
-    get_subset_by_id,
-    get_subset_by_name,
-    get_subsets,
-    get_subset_families,
-
-    get_version_by_id,
-    get_version_by_name,
-    get_versions,
-    get_hero_version_by_id,
-    get_hero_version_by_subset_id,
-    get_hero_versions,
-    get_last_versions,
-    get_last_version_by_subset_id,
-    get_last_version_by_subset_name,
-    get_output_link_versions,
-
-    version_is_latest,
-
-    get_representation_by_id,
-    get_representation_by_name,
-    get_representations,
-    get_representation_parents,
-    get_representations_parents,
-    get_archived_representations,
-
-    get_thumbnail,
-    get_thumbnails,
-    get_thumbnail_id_from_source,
-
-    get_workfile_info,
-
-    get_asset_name_identifier,
-)
-
-from .entity_links import (
-    get_linked_asset_ids,
-    get_linked_assets,
-    get_linked_representation_id,
-)
-
-from .operations import (
-    create_project,
-)
-
-
-__all__ = (
-    "get_ayon_server_api_connection",
-
-    "get_projects",
-    "get_project",
-    "get_whole_project",
-
-    "get_asset_by_id",
-    "get_asset_by_name",
-    "get_assets",
-    "get_archived_assets",
-    "get_asset_ids_with_subsets",
-
-    "get_subset_by_id",
-    "get_subset_by_name",
-    "get_subsets",
-    "get_subset_families",
-
-    "get_version_by_id",
-    "get_version_by_name",
-    "get_versions",
-    "get_hero_version_by_id",
-    "get_hero_version_by_subset_id",
-    "get_hero_versions",
-    "get_last_versions",
-    "get_last_version_by_subset_id",
-    "get_last_version_by_subset_name",
-    "get_output_link_versions",
-
-    "version_is_latest",
-
-    "get_representation_by_id",
-    "get_representation_by_name",
-    "get_representations",
-    "get_representation_parents",
-    "get_representations_parents",
-    "get_archived_representations",
-
-    "get_thumbnail",
-    "get_thumbnails",
-    "get_thumbnail_id_from_source",
-
-    "get_workfile_info",
-
-    "get_linked_asset_ids",
-    "get_linked_assets",
-    "get_linked_representation_id",
-
-    "create_project",
-
-    "get_asset_name_identifier",
-)

client/ayon_core/client/constants.py

@@ -1,28 +0,0 @@
-# --- Folders ---
-DEFAULT_FOLDER_FIELDS = {
-    "id",
-    "name",
-    "path",
-    "parentId",
-    "active",
-    "parents",
-    "thumbnailId"
-}
-
-REPRESENTATION_FILES_FIELDS = {
-    "files.name",
-    "files.hash",
-    "files.id",
-    "files.path",
-    "files.size",
-}
-
-CURRENT_PROJECT_SCHEMA = "openpype:project-3.0"
-CURRENT_PROJECT_CONFIG_SCHEMA = "openpype:config-2.0"
-CURRENT_ASSET_DOC_SCHEMA = "openpype:asset-3.0"
-CURRENT_SUBSET_SCHEMA = "openpype:subset-3.0"
-CURRENT_VERSION_SCHEMA = "openpype:version-3.0"
-CURRENT_HERO_VERSION_SCHEMA = "openpype:hero_version-1.0"
-CURRENT_REPRESENTATION_SCHEMA = "openpype:representation-2.0"
-CURRENT_WORKFILE_INFO_SCHEMA = "openpype:workfile-1.0"
-CURRENT_THUMBNAIL_SCHEMA = "openpype:thumbnail-1.0"

client/ayon_core/client/entities.py

@@ -1,741 +0,0 @@
-import collections
-
-from .constants import CURRENT_THUMBNAIL_SCHEMA
-from .utils import get_ayon_server_api_connection
-from .openpype_comp import get_folders_with_tasks
-from .conversion_utils import (
-    project_fields_v3_to_v4,
-    convert_v4_project_to_v3,
-
-    folder_fields_v3_to_v4,
-    convert_v4_folder_to_v3,
-
-    subset_fields_v3_to_v4,
-    convert_v4_subset_to_v3,
-
-    version_fields_v3_to_v4,
-    convert_v4_version_to_v3,
-
-    representation_fields_v3_to_v4,
-    convert_v4_representation_to_v3,
-
-    workfile_info_fields_v3_to_v4,
-    convert_v4_workfile_info_to_v3,
-)
-
-
-def get_asset_name_identifier(asset_doc):
-    """Get asset name identifier by asset document.
-
-    This function is added because of AYON implementation where name
-        identifier is not just a name but full path.
-
-    Asset document must have "name" key, and "data.parents" when in AYON mode.
-
-    Args:
-        asset_doc (dict[str, Any]): Asset document.
-    """
-
-    parents = list(asset_doc["data"]["parents"])
-    parents.append(asset_doc["name"])
-    return "/" + "/".join(parents)
-
-
-def get_projects(active=True, inactive=False, library=None, fields=None):
-    if not active and not inactive:
-        return
-
-    if active and inactive:
-        active = None
-    elif active:
-        active = True
-    elif inactive:
-        active = False
-
-    con = get_ayon_server_api_connection()
-    fields = project_fields_v3_to_v4(fields, con)
-    for project in con.get_projects(active, library, fields=fields):
-        yield convert_v4_project_to_v3(project)
-
-
-def get_project(project_name, active=True, inactive=False, fields=None):
-    # Skip if both are disabled
-    con = get_ayon_server_api_connection()
-    fields = project_fields_v3_to_v4(fields, con)
-    return convert_v4_project_to_v3(
-        con.get_project(project_name, fields=fields)
-    )
-
-
-def get_whole_project(*args, **kwargs):
-    raise NotImplementedError("'get_whole_project' not implemented")
-
-
-def _get_subsets(
-    project_name,
-    subset_ids=None,
-    subset_names=None,
-    folder_ids=None,
-    names_by_folder_ids=None,
-    archived=False,
-    fields=None
-):
-    # Convert fields and add minimum required fields
-    con = get_ayon_server_api_connection()
-    fields = subset_fields_v3_to_v4(fields, con)
-    if fields is not None:
-        for key in (
-            "id",
-            "active"
-        ):
-            fields.add(key)
-
-    active = True
-    if archived:
-        active = None
-
-    for subset in con.get_products(
-        project_name,
-        product_ids=subset_ids,
-        product_names=subset_names,
-        folder_ids=folder_ids,
-        names_by_folder_ids=names_by_folder_ids,
-        active=active,
-        fields=fields,
-    ):
-        yield convert_v4_subset_to_v3(subset)
-
-
-def _get_versions(
-    project_name,
-    version_ids=None,
-    subset_ids=None,
-    versions=None,
-    hero=True,
-    standard=True,
-    latest=None,
-    active=None,
-    fields=None
-):
-    con = get_ayon_server_api_connection()
-
-    fields = version_fields_v3_to_v4(fields, con)
-
-    # Make sure 'productId' and 'version' are available when hero versions
-    #   are queried
-    if fields and hero:
-        fields = set(fields)
-        fields |= {"productId", "version"}
-
-    queried_versions = con.get_versions(
-        project_name,
-        version_ids=version_ids,
-        product_ids=subset_ids,
-        versions=versions,
-        hero=hero,
-        standard=standard,
-        latest=latest,
-        active=active,
-        fields=fields
-    )
-
-    version_entities = []
-    hero_versions = []
-    for version in queried_versions:
-        if version["version"] < 0:
-            hero_versions.append(version)
-        else:
-            version_entities.append(convert_v4_version_to_v3(version))
-
-    if hero_versions:
-        subset_ids = set()
-        versions_nums = set()
-        for hero_version in hero_versions:
-            versions_nums.add(abs(hero_version["version"]))
-            subset_ids.add(hero_version["productId"])
-
-        hero_eq_versions = con.get_versions(
-            project_name,
-            product_ids=subset_ids,
-            versions=versions_nums,
-            hero=False,
-            fields=["id", "version", "productId"]
-        )
-        hero_eq_by_subset_id = collections.defaultdict(list)
-        for version in hero_eq_versions:
-            hero_eq_by_subset_id[version["productId"]].append(version)
-
-        for hero_version in hero_versions:
-            abs_version = abs(hero_version["version"])
-            subset_id = hero_version["productId"]
-            version_id = None
-            for version in hero_eq_by_subset_id.get(subset_id, []):
-                if version["version"] == abs_version:
-                    version_id = version["id"]
-                    break
-            conv_hero = convert_v4_version_to_v3(hero_version)
-            conv_hero["version_id"] = version_id
-            version_entities.append(conv_hero)
-
-    return version_entities
-
-
-def get_asset_by_id(project_name, asset_id, fields=None):
-    assets = get_assets(
-        project_name, asset_ids=[asset_id], fields=fields
-    )
-    for asset in assets:
-        return asset
-    return None
-
-
-def get_asset_by_name(project_name, asset_name, fields=None):
-    assets = get_assets(
-        project_name, asset_names=[asset_name], fields=fields
-    )
-    for asset in assets:
-        return asset
-    return None
-
-
-def _folders_query(project_name, con, fields, **kwargs):
-    if fields is None or "tasks" in fields:
-        folders = get_folders_with_tasks(
-            con, project_name, fields=fields, **kwargs
-        )
-
-    else:
-        folders = con.get_folders(project_name, fields=fields, **kwargs)
-
-    for folder in folders:
-        yield folder
-
-
-def get_assets(
-    project_name,
-    asset_ids=None,
-    asset_names=None,
-    parent_ids=None,
-    archived=False,
-    fields=None
-):
-    if not project_name:
-        return
-
-    active = True
-    if archived:
-        active = None
-
-    con = get_ayon_server_api_connection()
-    fields = folder_fields_v3_to_v4(fields, con)
-    kwargs = dict(
-        folder_ids=asset_ids,
-        parent_ids=parent_ids,
-        active=active,
-    )
-    if not asset_names:
-        for folder in _folders_query(project_name, con, fields, **kwargs):
-            yield convert_v4_folder_to_v3(folder, project_name)
-        return
-
-    new_asset_names = set()
-    folder_paths = set()
-    for name in asset_names:
-        if "/" in name:
-            folder_paths.add(name)
-        else:
-            new_asset_names.add(name)
-
-    yielded_ids = set()
-    if folder_paths:
-        for folder in _folders_query(
-            project_name, con, fields, folder_paths=folder_paths, **kwargs
-        ):
-            yielded_ids.add(folder["id"])
-            yield convert_v4_folder_to_v3(folder, project_name)
-
-    if not new_asset_names:
-        return
-
-    for folder in _folders_query(
-        project_name, con, fields, folder_names=new_asset_names, **kwargs
-    ):
-        if folder["id"] not in yielded_ids:
-            yielded_ids.add(folder["id"])
-            yield convert_v4_folder_to_v3(folder, project_name)
-
-
-def get_archived_assets(
-    project_name,
-    asset_ids=None,
-    asset_names=None,
-    parent_ids=None,
-    fields=None
-):
-    return get_assets(
-        project_name,
-        asset_ids,
-        asset_names,
-        parent_ids,
-        True,
-        fields
-    )
-
-
-def get_asset_ids_with_subsets(project_name, asset_ids=None):
-    con = get_ayon_server_api_connection()
-    return con.get_folder_ids_with_products(project_name, asset_ids)
-
-
-def get_subset_by_id(project_name, subset_id, fields=None):
-    subsets = get_subsets(
-        project_name, subset_ids=[subset_id], fields=fields
-    )
-    for subset in subsets:
-        return subset
-    return None
-
-
-def get_subset_by_name(project_name, subset_name, asset_id, fields=None):
-    subsets = get_subsets(
-        project_name,
-        subset_names=[subset_name],
-        asset_ids=[asset_id],
-        fields=fields
-    )
-    for subset in subsets:
-        return subset
-    return None
-
-
-def get_subsets(
-    project_name,
-    subset_ids=None,
-    subset_names=None,
-    asset_ids=None,
-    names_by_asset_ids=None,
-    archived=False,
-    fields=None
-):
-    return _get_subsets(
-        project_name,
-        subset_ids,
-        subset_names,
-        asset_ids,
-        names_by_asset_ids,
-        archived,
-        fields=fields
-    )
-
-
-def get_subset_families(project_name, subset_ids=None):
-    con = get_ayon_server_api_connection()
-    return con.get_product_type_names(project_name, subset_ids)
-
-
-def get_version_by_id(project_name, version_id, fields=None):
-    versions = get_versions(
-        project_name,
-        version_ids=[version_id],
-        fields=fields,
-        hero=True
-    )
-    for version in versions:
-        return version
-    return None
-
-
-def get_version_by_name(project_name, version, subset_id, fields=None):
-    versions = get_versions(
-        project_name,
-        subset_ids=[subset_id],
-        versions=[version],
-        fields=fields
-    )
-    for version in versions:
-        return version
-    return None
-
-
-def get_versions(
-    project_name,
-    version_ids=None,
-    subset_ids=None,
-    versions=None,
-    hero=False,
-    fields=None
-):
-    return _get_versions(
-        project_name,
-        version_ids,
-        subset_ids,
-        versions,
-        hero=hero,
-        standard=True,
-        fields=fields
-    )
-
-
-def get_hero_version_by_id(project_name, version_id, fields=None):
-    versions = get_hero_versions(
-        project_name,
-        version_ids=[version_id],
-        fields=fields
-    )
-    for version in versions:
-        return version
-    return None
-
-
-def get_hero_version_by_subset_id(
-    project_name, subset_id, fields=None
-):
-    versions = get_hero_versions(
-        project_name,
-        subset_ids=[subset_id],
-        fields=fields
-    )
-    for version in versions:
-        return version
-    return None
-
-
-def get_hero_versions(
-    project_name, subset_ids=None, version_ids=None, fields=None
-):
-    return _get_versions(
-        project_name,
-        version_ids=version_ids,
-        subset_ids=subset_ids,
-        hero=True,
-        standard=False,
-        fields=fields
-    )
-
-
-def get_last_versions(project_name, subset_ids, active=None, fields=None):
-    if fields:
-        fields = set(fields)
-        fields.add("parent")
-
-    versions = _get_versions(
-        project_name,
-        subset_ids=subset_ids,
-        latest=True,
-        hero=False,
-        active=active,
-        fields=fields
-    )
-    return {
-        version["parent"]: version
-        for version in versions
-    }
-
-
-def get_last_version_by_subset_id(project_name, subset_id, fields=None):
-    versions = _get_versions(
-        project_name,
-        subset_ids=[subset_id],
-        latest=True,
-        hero=False,
-        fields=fields
-    )
-    if not versions:
-        return None
-    return versions[0]
-
-
-def get_last_version_by_subset_name(
-    project_name,
-    subset_name,
-    asset_id=None,
-    asset_name=None,
-    fields=None
-):
-    if not asset_id and not asset_name:
-        return None
-
-    if not asset_id:
-        asset = get_asset_by_name(
-            project_name, asset_name, fields=["_id"]
-        )
-        if not asset:
-            return None
-        asset_id = asset["_id"]
-
-    subset = get_subset_by_name(
-        project_name, subset_name, asset_id, fields=["_id"]
-    )
-    if not subset:
-        return None
-    return get_last_version_by_subset_id(
-        project_name, subset["_id"], fields=fields
-    )
-
-
-def get_output_link_versions(project_name, version_id, fields=None):
-    if not version_id:
-        return []
-
-    con = get_ayon_server_api_connection()
-    version_links = con.get_version_links(
-        project_name, version_id, link_direction="out")
-
-    version_ids = {
-        link["entityId"]
-        for link in version_links
-        if link["entityType"] == "version"
-    }
-    if not version_ids:
-        return []
-
-    return get_versions(project_name, version_ids=version_ids, fields=fields)
-
-
-def version_is_latest(project_name, version_id):
-    con = get_ayon_server_api_connection()
-    return con.version_is_latest(project_name, version_id)
-
-
-def get_representation_by_id(project_name, representation_id, fields=None):
-    representations = get_representations(
-        project_name,
-        representation_ids=[representation_id],
-        fields=fields
-    )
-    for representation in representations:
-        return representation
-    return None
-
-
-def get_representation_by_name(
-    project_name, representation_name, version_id, fields=None
-):
-    representations = get_representations(
-        project_name,
-        representation_names=[representation_name],
-        version_ids=[version_id],
-        fields=fields
-    )
-    for representation in representations:
-        return representation
-    return None
-
-
-def get_representations(
-    project_name,
-    representation_ids=None,
-    representation_names=None,
-    version_ids=None,
-    context_filters=None,
-    names_by_version_ids=None,
-    archived=False,
-    standard=True,
-    fields=None
-):
-    if context_filters is not None:
-        # TODO should we add the support?
-        # - there was ability to fitler using regex
-        raise ValueError("OP v4 can't filter by representation context.")
-
-    if not archived and not standard:
-        return
-
-    if archived and not standard:
-        active = False
-    elif not archived and standard:
-        active = True
-    else:
-        active = None
-
-    con = get_ayon_server_api_connection()
-    fields = representation_fields_v3_to_v4(fields, con)
-    if fields and active is not None:
-        fields.add("active")
-
-    representations = con.get_representations(
-        project_name,
-        representation_ids=representation_ids,
-        representation_names=representation_names,
-        version_ids=version_ids,
-        names_by_version_ids=names_by_version_ids,
-        active=active,
-        fields=fields
-    )
-    for representation in representations:
-        yield convert_v4_representation_to_v3(representation)
-
-
-def get_representation_parents(project_name, representation):
-    if not representation:
-        return None
-
-    repre_id = representation["_id"]
-    parents_by_repre_id = get_representations_parents(
-        project_name, [representation]
-    )
-    return parents_by_repre_id[repre_id]
-
-
-def get_representations_parents(project_name, representations):
-    repre_ids = {
-        repre["_id"]
-        for repre in representations
-    }
-    con = get_ayon_server_api_connection()
-    parents_by_repre_id = con.get_representations_parents(project_name,
-                                                          repre_ids)
-    folder_ids = set()
-    for parents in parents_by_repre_id .values():
-        folder_ids.add(parents[2]["id"])
-
-    tasks_by_folder_id = {}
-
-    new_parents = {}
-    for repre_id, parents in parents_by_repre_id .items():
-        version, subset, folder, project = parents
-        folder_tasks = tasks_by_folder_id.get(folder["id"]) or {}
-        folder["tasks"] = folder_tasks
-        new_parents[repre_id] = (
-            convert_v4_version_to_v3(version),
-            convert_v4_subset_to_v3(subset),
-            convert_v4_folder_to_v3(folder, project_name),
-            project
-        )
-    return new_parents
-
-
-def get_archived_representations(
-    project_name,
-    representation_ids=None,
-    representation_names=None,
-    version_ids=None,
-    context_filters=None,
-    names_by_version_ids=None,
-    fields=None
-):
-    return get_representations(
-        project_name,
-        representation_ids=representation_ids,
-        representation_names=representation_names,
-        version_ids=version_ids,
-        context_filters=context_filters,
-        names_by_version_ids=names_by_version_ids,
-        archived=True,
-        standard=False,
-        fields=fields
-    )
-
-
-def get_thumbnail(
-    project_name, thumbnail_id, entity_type, entity_id, fields=None
-):
-    """Receive thumbnail entity data.
-
-    Args:
-        project_name (str): Name of project where to look for queried entities.
-        thumbnail_id (Union[str, ObjectId]): Id of thumbnail entity.
-        entity_type (str): Type of entity for which the thumbnail should be
-            received.
-        entity_id (str): Id of entity for which the thumbnail should be
-            received.
-        fields (Iterable[str]): Fields that should be returned. All fields are
-            returned if 'None' is passed.
-
-    Returns:
-        None: If thumbnail with specified id was not found.
-        Dict: Thumbnail entity data which can be reduced to specified 'fields'.
-    """
-
-    if not thumbnail_id or not entity_type or not entity_id:
-        return None
-
-    if entity_type == "asset":
-        entity_type = "folder"
-
-    elif entity_type == "hero_version":
-        entity_type = "version"
-
-    return {
-        "_id": thumbnail_id,
-        "type": "thumbnail",
-        "schema": CURRENT_THUMBNAIL_SCHEMA,
-        "data": {
-            "entity_type": entity_type,
-            "entity_id": entity_id
-        }
-    }
-
-
-def get_thumbnails(project_name, thumbnail_contexts, fields=None):
-    """Get thumbnail entities.
-
-    Warning:
-        This function is not OpenPype compatible. There is none usage of this
-            function in codebase so there is nothing to convert. The previous
-            implementation cannot be AYON compatible without entity types.
-    """
-
-    thumbnail_items = set()
-    for thumbnail_context in thumbnail_contexts:
-        thumbnail_id, entity_type, entity_id = thumbnail_context
-        thumbnail_item = get_thumbnail(
-            project_name, thumbnail_id, entity_type, entity_id
-        )
-        if thumbnail_item:
-            thumbnail_items.add(thumbnail_item)
-    return list(thumbnail_items)
-
-
-def get_thumbnail_id_from_source(project_name, src_type, src_id):
-    """Receive thumbnail id from source entity.
-
-    Args:
-        project_name (str): Name of project where to look for queried entities.
-        src_type (str): Type of source entity ('asset', 'version').
-        src_id (Union[str, ObjectId]): Id of source entity.
-
-    Returns:
-        ObjectId: Thumbnail id assigned to entity.
-        None: If Source entity does not have any thumbnail id assigned.
-    """
-
-    if not src_type or not src_id:
-        return None
-
-    if src_type == "version":
-        version = get_version_by_id(
-            project_name, src_id, fields=["data.thumbnail_id"]
-        ) or {}
-        return version.get("data", {}).get("thumbnail_id")
-
-    if src_type == "asset":
-        asset = get_asset_by_id(
-            project_name, src_id, fields=["data.thumbnail_id"]
-        ) or {}
-        return asset.get("data", {}).get("thumbnail_id")
-
-    return None
-
-
-def get_workfile_info(
-    project_name, asset_id, task_name, filename, fields=None
-):
-    if not asset_id or not task_name or not filename:
-        return None
-
-    con = get_ayon_server_api_connection()
-    task = con.get_task_by_name(
-        project_name, asset_id, task_name, fields=["id", "name", "folderId"]
-    )
-    if not task:
-        return None
-
-    fields = workfile_info_fields_v3_to_v4(fields)
-
-    for workfile_info in con.get_workfiles_info(
-        project_name, task_ids=[task["id"]], fields=fields
-    ):
-        if workfile_info["name"] == filename:
-            return convert_v4_workfile_info_to_v3(workfile_info, task)
-    return None

client/ayon_core/client/entity_links.py

@@ -1,157 +0,0 @@
-from .utils import get_ayon_server_api_connection
-from .entities import get_assets, get_representation_by_id
-
-
-def get_linked_asset_ids(project_name, asset_doc=None, asset_id=None):
-    """Extract linked asset ids from asset document.
-
-    One of asset document or asset id must be passed.
-
-    Note:
-        Asset links now works only from asset to assets.
-
-    Args:
-        project_name (str): Project where to look for asset.
-        asset_doc (dict): Asset document from DB.
-        asset_id (str): Asset id to find its document.
-
-    Returns:
-        List[Union[ObjectId, str]]: Asset ids of input links.
-    """
-
-    output = []
-    if not asset_doc and not asset_id:
-        return output
-
-    if not asset_id:
-        asset_id = asset_doc["_id"]
-
-    con = get_ayon_server_api_connection()
-    links = con.get_folder_links(project_name, asset_id, link_direction="in")
-    return [
-        link["entityId"]
-        for link in links
-        if link["entityType"] == "folder"
-    ]
-
-
-def get_linked_assets(
-    project_name, asset_doc=None, asset_id=None, fields=None
-):
-    """Return linked assets based on passed asset document.
-
-    One of asset document or asset id must be passed.
-
-    Args:
-        project_name (str): Name of project where to look for queried entities.
-        asset_doc (Dict[str, Any]): Asset document from database.
-        asset_id (Union[ObjectId, str]): Asset id. Can be used instead of
-            asset document.
-        fields (Iterable[str]): Fields that should be returned. All fields are
-            returned if 'None' is passed.
-
-    Returns:
-        List[Dict[str, Any]]: Asset documents of input links for passed
-            asset doc.
-    """
-
-    link_ids = get_linked_asset_ids(project_name, asset_doc, asset_id)
-    if not link_ids:
-        return []
-    return list(get_assets(project_name, asset_ids=link_ids, fields=fields))
-
-
-
-def get_linked_representation_id(
-    project_name, repre_doc=None, repre_id=None, link_type=None, max_depth=None
-):
-    """Returns list of linked ids of particular type (if provided).
-
-    One of representation document or representation id must be passed.
-    Note:
-        Representation links now works only from representation through version
-            back to representations.
-
-    Todos:
-        Missing depth query. Not sure how it did find more representations in
-            depth, probably links to version?
-
-    Args:
-        project_name (str): Name of project where look for links.
-        repre_doc (Dict[str, Any]): Representation document.
-        repre_id (Union[ObjectId, str]): Representation id.
-        link_type (str): Type of link (e.g. 'reference', ...).
-        max_depth (int): Limit recursion level. Default: 0
-
-    Returns:
-        List[ObjectId] Linked representation ids.
-    """
-
-    if repre_doc:
-        repre_id = repre_doc["_id"]
-
-    if not repre_id and not repre_doc:
-        return []
-
-    version_id = None
-    if repre_doc:
-        version_id = repre_doc.get("parent")
-
-    if not version_id:
-        repre_doc = get_representation_by_id(
-            project_name, repre_id, fields=["parent"]
-        )
-        if repre_doc:
-            version_id = repre_doc["parent"]
-
-    if not version_id:
-        return []
-
-    if max_depth is None or max_depth == 0:
-        max_depth = 1
-
-    link_types = None
-    if link_type:
-        link_types = [link_type]
-
-    con = get_ayon_server_api_connection()
-    # Store already found version ids to avoid recursion, and also to store
-    #   output -> Don't forget to remove 'version_id' at the end!!!
-    linked_version_ids = {version_id}
-    # Each loop of depth will reset this variable
-    versions_to_check = {version_id}
-    for _ in range(max_depth):
-        if not versions_to_check:
-            break
-
-        versions_links = con.get_versions_links(
-            project_name,
-            versions_to_check,
-            link_types=link_types,
-            link_direction="out")
-
-        versions_to_check = set()
-        for links in versions_links.values():
-            for link in links:
-                # Care only about version links
-                if link["entityType"] != "version":
-                    continue
-                entity_id = link["entityId"]
-                # Skip already found linked version ids
-                if entity_id in linked_version_ids:
-                    continue
-                linked_version_ids.add(entity_id)
-                versions_to_check.add(entity_id)
-
-    linked_version_ids.remove(version_id)
-    if not linked_version_ids:
-        return []
-    con = get_ayon_server_api_connection()
-    representations = con.get_representations(
-        project_name,
-        version_ids=linked_version_ids,
-        fields=["id"])
-    return [
-        repre["id"]
-        for repre in representations
-    ]

client/ayon_core/client/notes.md

@@ -1,39 +0,0 @@
-# Client functionality
-## Reason
-Preparation for OpenPype v4 server. Goal is to remove direct mongo calls in code to prepare a little bit for different source of data for code before. To start think about database calls less as mongo calls but more universally. To do so was implemented simple wrapper around database calls to not use pymongo specific code.
-
-Current goal is not to make universal database model which can be easily replaced with any different source of data but to make it close as possible. Current implementation of OpenPype is too tightly connected to pymongo and it's abilities so we're trying to get closer with long term changes that can be used even in current state.
-
-## Queries
-Query functions don't use full potential of mongo queries like very specific queries based on subdictionaries or unknown structures. We try to avoid these calls as much as possible because they'll probably won't be available in future. If it's really necessary a new function can be added but only if it's reasonable for overall logic. All query functions were moved to `~/client/entities.py`. Each function has arguments with available filters and possible reduce of returned keys for each entity.
-
-## Changes
-Changes are a little bit complicated. Mongo has many options how update can happen which had to be reduced also it would be at this stage complicated to validate values which are created or updated thus automation is at this point almost none. Changes can be made using operations available in `~/client/operations.py`. Each operation require project name and entity type, but may require operation specific data.
-
-### Create
-Create operations expect already prepared document data, for that are prepared functions creating skeletal structures of documents (do not fill all required data), except `_id` all data should be right. Existence of entity is not validated so if the same creation operation is send n times it will create the entity n times which can cause issues.
-
-### Update
-Update operation require entity id and keys that should be changed, update dictionary must have {"key": value}. If value should be set in nested dictionary the key must have also all subkeys joined with dot `.` (e.g. `{"data": {"fps": 25}}` -> `{"data.fps": 25}`). To simplify update dictionaries were prepared functions which does that for you, their name has template `prepare_<entity type>_update_data` - they work on comparison of previous document and new document. If there is missing function for requested entity type it is because we didn't need it yet and require implementation.
-
-### Delete
-Delete operation need entity id. Entity will be deleted from mongo.
-
-
-## What (probably) won't be replaced
-Some parts of code are still using direct mongo calls. In most of cases it is for very specific calls that are module specific or their usage will completely change in future.
-- Mongo calls that are not project specific (out of `avalon` collection) will be removed or will have to use different mechanism how the data are stored. At this moment it is related to OpenPype settings and logs, ftrack server events, some other data.
-- Sync server queries. They're complex and very specific for sync server module. Their replacement will require specific calls to OpenPype server in v4 thus their abstraction with wrapper is irrelevant and would complicate production in v3.
-- Project managers (ftrack, kitsu, shotgrid, embedded Project Manager, etc.). Project managers are creating, updating or removing assets in v3, but in v4 will create folders with different structure. Wrapping creation of assets would not help to prepare for v4 because of new data structures. The same can be said about editorial Extract Hierarchy Avalon plugin which create project structure.
-- Code parts that is marked as deprecated in v3 or will be deprecated in v4.
-    - integrate asset legacy publish plugin - already is legacy kept for safety
-    - integrate thumbnail - thumbnails will be stored in different way in v4
-    - input links - link will be stored in different way and will have different mechanism of linking. In v3 are links limited to same entity type "asset <-> asset" or "representation <-> representation".
-
-## Known missing replacements
-- change subset group in loader tool
-- integrate subset group
-- query input links in openpype lib
-- create project in openpype lib
-- save/create workfile doc in openpype lib
-- integrate hero version

client/ayon_core/client/openpype_comp.py

@@ -1,159 +0,0 @@
-import collections
-import json
-
-import six
-from ayon_api.graphql import GraphQlQuery, FIELD_VALUE, fields_to_dict
-
-from .constants import DEFAULT_FOLDER_FIELDS
-
-
-def folders_tasks_graphql_query(fields):
-    query = GraphQlQuery("FoldersQuery")
-    project_name_var = query.add_variable("projectName", "String!")
-    folder_ids_var = query.add_variable("folderIds", "[String!]")
-    parent_folder_ids_var = query.add_variable("parentFolderIds", "[String!]")
-    folder_paths_var = query.add_variable("folderPaths", "[String!]")
-    folder_names_var = query.add_variable("folderNames", "[String!]")
-    has_products_var = query.add_variable("folderHasProducts", "Boolean!")
-
-    project_field = query.add_field("project")
-    project_field.set_filter("name", project_name_var)
-
-    folders_field = project_field.add_field_with_edges("folders")
-    folders_field.set_filter("ids", folder_ids_var)
-    folders_field.set_filter("parentIds", parent_folder_ids_var)
-    folders_field.set_filter("names", folder_names_var)
-    folders_field.set_filter("paths", folder_paths_var)
-    folders_field.set_filter("hasProducts", has_products_var)
-
-    fields = set(fields)
-    fields.discard("tasks")
-    tasks_field = folders_field.add_field_with_edges("tasks")
-    tasks_field.add_field("name")
-    tasks_field.add_field("taskType")
-
-    nested_fields = fields_to_dict(fields)
-
-    query_queue = collections.deque()
-    for key, value in nested_fields.items():
-        query_queue.append((key, value, folders_field))
-
-    while query_queue:
-        item = query_queue.popleft()
-        key, value, parent = item
-        field = parent.add_field(key)
-        if value is FIELD_VALUE:
-            continue
-
-        for k, v in value.items():
-            query_queue.append((k, v, field))
-    return query
-
-
-def get_folders_with_tasks(
-    con,
-    project_name,
-    folder_ids=None,
-    folder_paths=None,
-    folder_names=None,
-    parent_ids=None,
-    active=True,
-    fields=None
-):
-    """Query folders with tasks from server.
-
-    This is for v4 compatibility where tasks were stored on assets. This is
-    an inefficient way how folders and tasks are queried so it was added only
-    as compatibility function.
-
-    Todos:
-        Folder name won't be unique identifier, so we should add folder path
-            filtering.
-
-    Notes:
-        Filter 'active' don't have direct filter in GraphQl.
-
-    Args:
-        con (ServerAPI): Connection to server.
-        project_name (str): Name of project where folders are.
-        folder_ids (Iterable[str]): Folder ids to filter.
-        folder_paths (Iterable[str]): Folder paths used for filtering.
-        folder_names (Iterable[str]): Folder names used for filtering.
-        parent_ids (Iterable[str]): Ids of folder parents. Use 'None'
-            if folder is direct child of project.
-        active (Union[bool, None]): Filter active/inactive folders. Both
-            are returned if is set to None.
-        fields (Union[Iterable(str), None]): Fields to be queried
-            for folder. All possible folder fields are returned if 'None'
-            is passed.
-
-    Yields:
-        Dict[str, Any]: Queried folder entities.
-    """
-
-    if not project_name:
-        return
-
-    filters = {
-        "projectName": project_name
-    }
-    if folder_ids is not None:
-        folder_ids = set(folder_ids)
-        if not folder_ids:
-            return
-        filters["folderIds"] = list(folder_ids)
-
-    if folder_paths is not None:
-        folder_paths = set(folder_paths)
-        if not folder_paths:
-            return
-        filters["folderPaths"] = list(folder_paths)
-
-    if folder_names is not None:
-        folder_names = set(folder_names)
-        if not folder_names:
-            return
-        filters["folderNames"] = list(folder_names)
-
-    if parent_ids is not None:
-        parent_ids = set(parent_ids)
-        if not parent_ids:
-            return
-        if None in parent_ids:
-            # Replace 'None' with '"root"' which is used during GraphQl
-            #   query for parent ids filter for folders without folder
-            #   parent
-            parent_ids.remove(None)
-            parent_ids.add("root")
-
-        if project_name in parent_ids:
-            # Replace project name with '"root"' which is used during
-            #   GraphQl query for parent ids filter for folders without
-            #   folder parent
-            parent_ids.remove(project_name)
-            parent_ids.add("root")
-
-        filters["parentFolderIds"] = list(parent_ids)
-
-    if fields:
-        fields = set(fields)
-    else:
-        fields = con.get_default_fields_for_type("folder")
-        fields |= DEFAULT_FOLDER_FIELDS
-
-    if active is not None:
-        fields.add("active")
-
-    query = folders_tasks_graphql_query(fields)
-    for attr, filter_value in filters.items():
-        query.set_variable_value(attr, filter_value)
-
-    parsed_data = query.query(con)
-    folders = parsed_data["project"]["folders"]
-    for folder in folders:
-        if active is not None and folder["active"] is not active:
-            continue
-        folder_data = folder.get("data")
-        if isinstance(folder_data, six.string_types):
-            folder["data"] = json.loads(folder_data)
-        yield folder

client/ayon_core/client/operations.py

@@ -1,880 +0,0 @@
-import copy
-import json
-import collections
-import uuid
-import datetime
-
-from ayon_api.server_api import (
-    PROJECT_NAME_ALLOWED_SYMBOLS,
-    PROJECT_NAME_REGEX,
-)
-
-from .constants import (
-    CURRENT_PROJECT_SCHEMA,
-    CURRENT_PROJECT_CONFIG_SCHEMA,
-    CURRENT_ASSET_DOC_SCHEMA,
-    CURRENT_SUBSET_SCHEMA,
-    CURRENT_VERSION_SCHEMA,
-    CURRENT_HERO_VERSION_SCHEMA,
-    CURRENT_REPRESENTATION_SCHEMA,
-    CURRENT_WORKFILE_INFO_SCHEMA,
-    CURRENT_THUMBNAIL_SCHEMA,
-)
-from .operations_base import (
-    REMOVED_VALUE,
-    CreateOperation,
-    UpdateOperation,
-    DeleteOperation,
-    BaseOperationsSession
-)
-from .conversion_utils import (
-    convert_create_asset_to_v4,
-    convert_create_task_to_v4,
-    convert_create_subset_to_v4,
-    convert_create_version_to_v4,
-    convert_create_hero_version_to_v4,
-    convert_create_representation_to_v4,
-    convert_create_workfile_info_to_v4,
-
-    convert_update_folder_to_v4,
-    convert_update_subset_to_v4,
-    convert_update_version_to_v4,
-    convert_update_hero_version_to_v4,
-    convert_update_representation_to_v4,
-    convert_update_workfile_info_to_v4,
-)
-from .utils import create_entity_id, get_ayon_server_api_connection
-
-
-def _create_or_convert_to_id(entity_id=None):
-    if entity_id is None:
-        return create_entity_id()
-
-    # Validate if can be converted to uuid
-    uuid.UUID(entity_id)
-    return entity_id
-
-
-def new_project_document(
-    project_name, project_code, config, data=None, entity_id=None
-):
-    """Create skeleton data of project document.
-
-    Args:
-        project_name (str): Name of project. Used as identifier of a project.
-        project_code (str): Shorter version of projet without spaces and
-            special characters (in most of cases). Should be also considered
-            as unique name across projects.
-        config (Dic[str, Any]): Project config consist of roots, templates,
-            applications and other project Anatomy related data.
-        data (Dict[str, Any]): Project data with information about it's
-            attributes (e.g. 'fps' etc.) or integration specific keys.
-        entity_id (Union[str, ObjectId]): Predefined id of document. New id is
-            created if not passed.
-
-    Returns:
-        Dict[str, Any]: Skeleton of project document.
-    """
-
-    if data is None:
-        data = {}
-
-    data["code"] = project_code
-
-    return {
-        "_id": _create_or_convert_to_id(entity_id),
-        "name": project_name,
-        "type": CURRENT_PROJECT_SCHEMA,
-        "entity_data": data,
-        "config": config
-    }
-
-
-def new_asset_document(
-    name, project_id, parent_id, parents, data=None, entity_id=None
-):
-    """Create skeleton data of asset document.
-
-    Args:
-        name (str): Is considered as unique identifier of asset in project.
-        project_id (Union[str, ObjectId]): Id of project doument.
-        parent_id (Union[str, ObjectId]): Id of parent asset.
-        parents (List[str]): List of parent assets names.
-        data (Dict[str, Any]): Asset document data. Empty dictionary is used
-            if not passed. Value of 'parent_id' is used to fill 'visualParent'.
-        entity_id (Union[str, ObjectId]): Predefined id of document. New id is
-            created if not passed.
-
-    Returns:
-        Dict[str, Any]: Skeleton of asset document.
-    """
-
-    if data is None:
-        data = {}
-    if parent_id is not None:
-        parent_id = _create_or_convert_to_id(parent_id)
-    data["visualParent"] = parent_id
-    data["parents"] = parents
-
-    return {
-        "_id": _create_or_convert_to_id(entity_id),
-        "type": "asset",
-        "name": name,
-        # This will be ignored
-        "parent": project_id,
-        "data": data,
-        "schema": CURRENT_ASSET_DOC_SCHEMA
-    }
-
-
-def new_subset_document(name, family, asset_id, data=None, entity_id=None):
-    """Create skeleton data of subset document.
-
-    Args:
-        name (str): Is considered as unique identifier of subset under asset.
-        family (str): Subset's family.
-        asset_id (Union[str, ObjectId]): Id of parent asset.
-        data (Dict[str, Any]): Subset document data. Empty dictionary is used
-            if not passed. Value of 'family' is used to fill 'family'.
-        entity_id (Union[str, ObjectId]): Predefined id of document. New id is
-            created if not passed.
-
-    Returns:
-        Dict[str, Any]: Skeleton of subset document.
-    """
-
-    if data is None:
-        data = {}
-    data["family"] = family
-    return {
-        "_id": _create_or_convert_to_id(entity_id),
-        "schema": CURRENT_SUBSET_SCHEMA,
-        "type": "subset",
-        "name": name,
-        "data": data,
-        "parent": _create_or_convert_to_id(asset_id)
-    }
-
-
-def new_version_doc(version, subset_id, data=None, entity_id=None):
-    """Create skeleton data of version document.
-
-    Args:
-        version (int): Is considered as unique identifier of version
-            under subset.
-        subset_id (Union[str, ObjectId]): Id of parent subset.
-        data (Dict[str, Any]): Version document data.
-        entity_id (Union[str, ObjectId]): Predefined id of document. New id is
-            created if not passed.
-
-    Returns:
-        Dict[str, Any]: Skeleton of version document.
-    """
-
-    if data is None:
-        data = {}
-
-    return {
-        "_id": _create_or_convert_to_id(entity_id),
-        "schema": CURRENT_VERSION_SCHEMA,
-        "type": "version",
-        "name": int(version),
-        "parent": _create_or_convert_to_id(subset_id),
-        "data": data
-    }
-
-
-def new_hero_version_doc(subset_id, data, version=None, entity_id=None):
-    """Create skeleton data of hero version document.
-
-    Args:
-        subset_id (Union[str, ObjectId]): Id of parent subset.
-        data (Dict[str, Any]): Version document data.
-        version (int): Version of source version.
-        entity_id (Union[str, ObjectId]): Predefined id of document. New id is
-            created if not passed.
-
-    Returns:
-        Dict[str, Any]: Skeleton of version document.
-    """
-
-    if version is None:
-        version = -1
-    elif version > 0:
-        version = -version
-
-    return {
-        "_id": _create_or_convert_to_id(entity_id),
-        "schema": CURRENT_HERO_VERSION_SCHEMA,
-        "type": "hero_version",
-        "version": version,
-        "parent": _create_or_convert_to_id(subset_id),
-        "data": data
-    }
-
-
-def new_representation_doc(
-    name, version_id, context, data=None, entity_id=None
-):
-    """Create skeleton data of representation document.
-
-    Args:
-        name (str): Representation name considered as unique identifier
-            of representation under version.
-        version_id (Union[str, ObjectId]): Id of parent version.
-        context (Dict[str, Any]): Representation context used for fill template
-            of to query.
-        data (Dict[str, Any]): Representation document data.
-        entity_id (Union[str, ObjectId]): Predefined id of document. New id is
-            created if not passed.
-
-    Returns:
-        Dict[str, Any]: Skeleton of version document.
-    """
-
-    if data is None:
-        data = {}
-
-    return {
-        "_id": _create_or_convert_to_id(entity_id),
-        "schema": CURRENT_REPRESENTATION_SCHEMA,
-        "type": "representation",
-        "parent": _create_or_convert_to_id(version_id),
-        "name": name,
-        "data": data,
-
-        # Imprint shortcut to context for performance reasons.
-        "context": context
-    }
-
-
-def new_thumbnail_doc(data=None, entity_id=None):
-    """Create skeleton data of thumbnail document.
-
-    Args:
-        data (Dict[str, Any]): Thumbnail document data.
-        entity_id (Union[str, ObjectId]): Predefined id of document. New id is
-            created if not passed.
-
-    Returns:
-        Dict[str, Any]: Skeleton of thumbnail document.
-    """
-
-    if data is None:
-        data = {}
-
-    return {
-        "_id": _create_or_convert_to_id(entity_id),
-        "type": "thumbnail",
-        "schema": CURRENT_THUMBNAIL_SCHEMA,
-        "data": data
-    }
-
-
-def new_workfile_info_doc(
-    filename, asset_id, task_name, files, data=None, entity_id=None
-):
-    """Create skeleton data of workfile info document.
-
-    Workfile document is at this moment used primarily for artist notes.
-
-    Args:
-        filename (str): Filename of workfile.
-        asset_id (Union[str, ObjectId]): Id of asset under which workfile live.
-        task_name (str): Task under which was workfile created.
-        files (List[str]): List of rootless filepaths related to workfile.
-        data (Dict[str, Any]): Additional metadata.
-
-    Returns:
-        Dict[str, Any]: Skeleton of workfile info document.
-    """
-
-    if not data:
-        data = {}
-
-    return {
-        "_id": _create_or_convert_to_id(entity_id),
-        "type": "workfile",
-        "parent": _create_or_convert_to_id(asset_id),
-        "task_name": task_name,
-        "filename": filename,
-        "data": data,
-        "files": files
-    }
-
-
-def _prepare_update_data(old_doc, new_doc, replace):
-    changes = {}
-    for key, value in new_doc.items():
-        if key not in old_doc or value != old_doc[key]:
-            changes[key] = value
-
-    if replace:
-        for key in old_doc.keys():
-            if key not in new_doc:
-                changes[key] = REMOVED_VALUE
-    return changes
-
-
-def prepare_subset_update_data(old_doc, new_doc, replace=True):
-    """Compare two subset documents and prepare update data.
-
-    Based on compared values will create update data for
-    'MongoUpdateOperation'.
-
-    Empty output means that documents are identical.
-
-    Returns:
-        Dict[str, Any]: Changes between old and new document.
-    """
-
-    return _prepare_update_data(old_doc, new_doc, replace)
-
-
-def prepare_version_update_data(old_doc, new_doc, replace=True):
-    """Compare two version documents and prepare update data.
-
-    Based on compared values will create update data for
-    'MongoUpdateOperation'.
-
-    Empty output means that documents are identical.
-
-    Returns:
-        Dict[str, Any]: Changes between old and new document.
-    """
-
-    return _prepare_update_data(old_doc, new_doc, replace)
-
-
-def prepare_hero_version_update_data(old_doc, new_doc, replace=True):
-    """Compare two hero version documents and prepare update data.
-
-    Based on compared values will create update data for 'UpdateOperation'.
-
-    Empty output means that documents are identical.
-
-    Returns:
-        Dict[str, Any]: Changes between old and new document.
-    """
-
-    changes = _prepare_update_data(old_doc, new_doc, replace)
-    changes.pop("version_id", None)
-    return changes
-
-
-def prepare_representation_update_data(old_doc, new_doc, replace=True):
-    """Compare two representation documents and prepare update data.
-
-    Based on compared values will create update data for
-    'MongoUpdateOperation'.
-
-    Empty output means that documents are identical.
-
-    Returns:
-        Dict[str, Any]: Changes between old and new document.
-    """
-
-    changes = _prepare_update_data(old_doc, new_doc, replace)
-    context = changes.get("data", {}).get("context")
-    # Make sure that both 'family' and 'subset' are in changes if
-    #   one of them changed (they'll both become 'product').
-    if (
-        context
-        and ("family" in context or "subset" in context)
-    ):
-        context["family"] = new_doc["data"]["context"]["family"]
-        context["subset"] = new_doc["data"]["context"]["subset"]
-
-    return changes
-
-
-def prepare_workfile_info_update_data(old_doc, new_doc, replace=True):
-    """Compare two workfile info documents and prepare update data.
-
-    Based on compared values will create update data for
-    'MongoUpdateOperation'.
-
-    Empty output means that documents are identical.
-
-    Returns:
-        Dict[str, Any]: Changes between old and new document.
-    """
-
-    return _prepare_update_data(old_doc, new_doc, replace)
-
-
-class FailedOperations(Exception):
-    pass
-
-
-def entity_data_json_default(value):
-    if isinstance(value, datetime.datetime):
-        return int(value.timestamp())
-
-    raise TypeError(
-        "Object of type {} is not JSON serializable".format(str(type(value)))
-    )
-
-
-def failed_json_default(value):
-    return "< Failed value {} > {}".format(type(value), str(value))
-
-
-class ServerCreateOperation(CreateOperation):
-    """Operation to create an entity.
-
-    Args:
-        project_name (str): On which project operation will happen.
-        entity_type (str): Type of entity on which change happens.
-            e.g. 'asset', 'representation' etc.
-        data (Dict[str, Any]): Data of entity that will be created.
-    """
-
-    def __init__(self, project_name, entity_type, data, session):
-        self._session = session
-
-        if not data:
-            data = {}
-        data = copy.deepcopy(data)
-        if entity_type == "project":
-            raise ValueError("Project cannot be created using operations")
-
-        tasks = None
-        if entity_type in "asset":
-            # TODO handle tasks
-            entity_type = "folder"
-            if "data" in data:
-                tasks = data["data"].get("tasks")
-
-            project = self._session.get_project(project_name)
-            new_data = convert_create_asset_to_v4(data, project, self.con)
-
-        elif entity_type == "task":
-            project = self._session.get_project(project_name)
-            new_data = convert_create_task_to_v4(data, project, self.con)
-
-        elif entity_type == "subset":
-            new_data = convert_create_subset_to_v4(data, self.con)
-            entity_type = "product"
-
-        elif entity_type == "version":
-            new_data = convert_create_version_to_v4(data, self.con)
-
-        elif entity_type == "hero_version":
-            new_data = convert_create_hero_version_to_v4(
-                data, project_name, self.con
-            )
-            entity_type = "version"
-
-        elif entity_type in ("representation", "archived_representation"):
-            new_data = convert_create_representation_to_v4(data, self.con)
-            entity_type = "representation"
-
-        elif entity_type == "workfile":
-            new_data = convert_create_workfile_info_to_v4(
-                data, project_name, self.con
-            )
-
-        else:
-            raise ValueError(
-                "Unhandled entity type \"{}\"".format(entity_type)
-            )
-
-        # Simple check if data can be dumped into json
-        #   - should raise error on 'ObjectId' object
-        try:
-            new_data = json.loads(
-                json.dumps(new_data, default=entity_data_json_default)
-            )
-
-        except:
-            raise ValueError("Couldn't json parse body: {}".format(
-                json.dumps(new_data, default=failed_json_default)
-            ))
-
-        super(ServerCreateOperation, self).__init__(
-            project_name, entity_type, new_data
-        )
-
-        if "id" not in self._data:
-            self._data["id"] = create_entity_id()
-
-        if tasks:
-            copied_tasks = copy.deepcopy(tasks)
-            for task_name, task in copied_tasks.items():
-                task["name"] = task_name
-                task["folderId"] = self._data["id"]
-                self.session.create_entity(
-                    project_name, "task", task, nested_id=self.id
-                )
-
-    @property
-    def con(self):
-        return self.session.con
-
-    @property
-    def session(self):
-        return self._session
-
-    @property
-    def entity_id(self):
-        return self._data["id"]
-
-    def to_server_operation(self):
-        return {
-            "id": self.id,
-            "type": "create",
-            "entityType": self.entity_type,
-            "entityId": self.entity_id,
-            "data": self._data
-        }
-
-
-class ServerUpdateOperation(UpdateOperation):
-    """Operation to update an entity.
-
-    Args:
-        project_name (str): On which project operation will happen.
-        entity_type (str): Type of entity on which change happens.
-            e.g. 'asset', 'representation' etc.
-        entity_id (Union[str, ObjectId]): Identifier of an entity.
-        update_data (Dict[str, Any]): Key -> value changes that will be set in
-            database. If value is set to 'REMOVED_VALUE' the key will be
-            removed. Only first level of dictionary is checked (on purpose).
-    """
-
-    def __init__(
-        self, project_name, entity_type, entity_id, update_data, session
-    ):
-        self._session = session
-
-        update_data = copy.deepcopy(update_data)
-        if entity_type == "project":
-            raise ValueError("Project cannot be created using operations")
-
-        if entity_type in ("asset", "archived_asset"):
-            new_update_data = convert_update_folder_to_v4(
-                project_name, entity_id, update_data, self.con
-            )
-            entity_type = "folder"
-
-        elif entity_type == "subset":
-            new_update_data = convert_update_subset_to_v4(
-                project_name, entity_id, update_data, self.con
-            )
-            entity_type = "product"
-
-        elif entity_type == "version":
-            new_update_data = convert_update_version_to_v4(
-                project_name, entity_id, update_data, self.con
-            )
-
-        elif entity_type == "hero_version":
-            new_update_data = convert_update_hero_version_to_v4(
-                project_name, entity_id, update_data, self.con
-            )
-            entity_type = "version"
-
-        elif entity_type in ("representation", "archived_representation"):
-            new_update_data = convert_update_representation_to_v4(
-                project_name, entity_id, update_data, self.con
-            )
-            entity_type = "representation"
-
-        elif entity_type == "workfile":
-            new_update_data = convert_update_workfile_info_to_v4(
-                project_name, entity_id, update_data, self.con
-            )
-
-        else:
-            raise ValueError(
-                "Unhandled entity type \"{}\"".format(entity_type)
-            )
-
-        try:
-            new_update_data = json.loads(
-                json.dumps(new_update_data, default=entity_data_json_default)
-            )
-
-        except:
-            raise ValueError("Couldn't json parse body: {}".format(
-                json.dumps(new_update_data, default=failed_json_default)
-            ))
-
-        super(ServerUpdateOperation, self).__init__(
-            project_name, entity_type, entity_id, new_update_data
-        )
-
-    @property
-    def con(self):
-        return self.session.con
-
-    @property
-    def session(self):
-        return self._session
-
-    def to_server_operation(self):
-        if not self._update_data:
-            return None
-
-        update_data = {}
-        for key, value in self._update_data.items():
-            if value is REMOVED_VALUE:
-                value = None
-            update_data[key] = value
-
-        return {
-            "id": self.id,
-            "type": "update",
-            "entityType": self.entity_type,
-            "entityId": self.entity_id,
-            "data": update_data
-        }
-
-
-class ServerDeleteOperation(DeleteOperation):
-    """Operation to delete an entity.
-
-    Args:
-        project_name (str): On which project operation will happen.
-        entity_type (str): Type of entity on which change happens.
-            e.g. 'asset', 'representation' etc.
-        entity_id (Union[str, ObjectId]): Entity id that will be removed.
-    """
-
-    def __init__(self, project_name, entity_type, entity_id, session):
-        self._session = session
-
-        if entity_type == "asset":
-            entity_type = "folder"
-
-        elif entity_type == "hero_version":
-            entity_type = "version"
-
-        elif entity_type == "subset":
-            entity_type = "product"
-
-        super(ServerDeleteOperation, self).__init__(
-            project_name, entity_type, entity_id
-        )
-
-    @property
-    def con(self):
-        return self.session.con
-
-    @property
-    def session(self):
-        return self._session
-
-    def to_server_operation(self):
-        return {
-            "id": self.id,
-            "type": self.operation_name,
-            "entityId": self.entity_id,
-            "entityType": self.entity_type,
-        }
-
-
-class OperationsSession(BaseOperationsSession):
-    def __init__(self, con=None, *args, **kwargs):
-        super(OperationsSession, self).__init__(*args, **kwargs)
-        if con is None:
-            con = get_ayon_server_api_connection()
-        self._con = con
-        self._project_cache = {}
-        self._nested_operations = collections.defaultdict(list)
-
-    @property
-    def con(self):
-        return self._con
-
-    def get_project(self, project_name):
-        if project_name not in self._project_cache:
-            self._project_cache[project_name] = self.con.get_project(
-                project_name)
-        return copy.deepcopy(self._project_cache[project_name])
-
-    def commit(self):
-        """Commit session operations."""
-
-        operations, self._operations = self._operations, []
-        if not operations:
-            return
-
-        operations_by_project = collections.defaultdict(list)
-        for operation in operations:
-            operations_by_project[operation.project_name].append(operation)
-
-        body_by_id = {}
-        results = []
-        for project_name, operations in operations_by_project.items():
-            operations_body = []
-            for operation in operations:
-                body = operation.to_server_operation()
-                if body is not None:
-                    try:
-                        json.dumps(body)
-                    except:
-                        raise ValueError("Couldn't json parse body: {}".format(
-                            json.dumps(
-                                body, indent=4, default=failed_json_default
-                            )
-                        ))
-
-                    body_by_id[operation.id] = body
-                    operations_body.append(body)
-
-            if operations_body:
-                result = self._con.post(
-                    "projects/{}/operations".format(project_name),
-                    operations=operations_body,
-                    canFail=False
-                )
-                results.append(result.data)
-
-        for result in results:
-            if result.get("success"):
-                continue
-
-            if "operations" not in result:
-                raise FailedOperations(
-                    "Operation failed. Content: {}".format(str(result))
-                )
-
-            for op_result in result["operations"]:
-                if not op_result["success"]:
-                    operation_id = op_result["id"]
-                    raise FailedOperations((
-                        "Operation \"{}\" failed with data:\n{}\nError: {}."
-                    ).format(
-                        operation_id,
-                        json.dumps(body_by_id[operation_id], indent=4),
-                        op_result.get("error", "unknown"),
-                    ))
-
-    def create_entity(self, project_name, entity_type, data, nested_id=None):
-        """Fast access to 'ServerCreateOperation'.
-
-        Args:
-            project_name (str): On which project the creation happens.
-            entity_type (str): Which entity type will be created.
-            data (Dicst[str, Any]): Entity data.
-            nested_id (str): Id of other operation from which is triggered
-                operation -> Operations can trigger suboperations but they
-                must be added to operations list after it's parent is added.
-
-        Returns:
-            ServerCreateOperation: Object of update operation.
-        """
-
-        operation = ServerCreateOperation(
-            project_name, entity_type, data, self
-        )
-
-        if nested_id:
-            self._nested_operations[nested_id].append(operation)
-        else:
-            self.add(operation)
-            if operation.id in self._nested_operations:
-                self.extend(self._nested_operations.pop(operation.id))
-
-        return operation
-
-    def update_entity(
-        self, project_name, entity_type, entity_id, update_data, nested_id=None
-    ):
-        """Fast access to 'ServerUpdateOperation'.
-
-        Returns:
-            ServerUpdateOperation: Object of update operation.
-        """
-
-        operation = ServerUpdateOperation(
-            project_name, entity_type, entity_id, update_data, self
-        )
-        if nested_id:
-            self._nested_operations[nested_id].append(operation)
-        else:
-            self.add(operation)
-            if operation.id in self._nested_operations:
-                self.extend(self._nested_operations.pop(operation.id))
-        return operation
-
-    def delete_entity(
-        self, project_name, entity_type, entity_id, nested_id=None
-    ):
-        """Fast access to 'ServerDeleteOperation'.
-
-        Returns:
-            ServerDeleteOperation: Object of delete operation.
-        """
-
-        operation = ServerDeleteOperation(
-            project_name, entity_type, entity_id, self
-        )
-        if nested_id:
-            self._nested_operations[nested_id].append(operation)
-        else:
-            self.add(operation)
-            if operation.id in self._nested_operations:
-                self.extend(self._nested_operations.pop(operation.id))
-        return operation
-
-
-def create_project(
-    project_name,
-    project_code,
-    library_project=False,
-    preset_name=None,
-    con=None
-):
-    """Create project using OpenPype settings.
-
-    This project creation function is not validating project document on
-    creation. It is because project document is created blindly with only
-    minimum required information about project which is it's name, code, type
-    and schema.
-
-    Entered project name must be unique and project must not exist yet.
-
-    Note:
-        This function is here to be OP v4 ready but in v3 has more logic
-            to do. That's why inner imports are in the body.
-
-    Args:
-        project_name (str): New project name. Should be unique.
-        project_code (str): Project's code should be unique too.
-        library_project (bool): Project is library project.
-        preset_name (str): Name of anatomy preset. Default is used if not
-            passed.
-        con (ServerAPI): Connection to server with logged user.
-
-    Raises:
-        ValueError: When project name already exists in MongoDB.
-
-    Returns:
-        dict: Created project document.
-    """
-
-    if con is None:
-        con = get_ayon_server_api_connection()
-
-    return con.create_project(
-        project_name,
-        project_code,
-        library_project,
-        preset_name
-    )
-
-
-def delete_project(project_name, con=None):
-    if con is None:
-        con = get_ayon_server_api_connection()
-
-    return con.delete_project(project_name)
-
-
-def create_thumbnail(project_name, src_filepath, thumbnail_id=None, con=None):
-    if con is None:
-        con = get_ayon_server_api_connection()
-    return con.create_thumbnail(project_name, src_filepath, thumbnail_id)

client/ayon_core/client/operations_base.py

@@ -1,289 +0,0 @@
-import uuid
-import copy
-from abc import ABCMeta, abstractmethod, abstractproperty
-import six
-
-REMOVED_VALUE = object()
-
-
-@six.add_metaclass(ABCMeta)
-class AbstractOperation(object):
-    """Base operation class.
-
-    Operation represent a call into database. The call can create, change or
-    remove data.
-
-    Args:
-        project_name (str): On which project operation will happen.
-        entity_type (str): Type of entity on which change happens.
-            e.g. 'asset', 'representation' etc.
-    """
-
-    def __init__(self, project_name, entity_type):
-        self._project_name = project_name
-        self._entity_type = entity_type
-        self._id = str(uuid.uuid4())
-
-    @property
-    def project_name(self):
-        return self._project_name
-
-    @property
-    def id(self):
-        """Identifier of operation."""
-
-        return self._id
-
-    @property
-    def entity_type(self):
-        return self._entity_type
-
-    @abstractproperty
-    def operation_name(self):
-        """Stringified type of operation."""
-
-        pass
-
-    def to_data(self):
-        """Convert operation to data that can be converted to json or others.
-
-        Warning:
-            Current state returns ObjectId objects which cannot be parsed by
-                json.
-
-        Returns:
-            Dict[str, Any]: Description of operation.
-        """
-
-        return {
-            "id": self._id,
-            "entity_type": self.entity_type,
-            "project_name": self.project_name,
-            "operation": self.operation_name
-        }
-
-
-class CreateOperation(AbstractOperation):
-    """Operation to create an entity.
-
-    Args:
-        project_name (str): On which project operation will happen.
-        entity_type (str): Type of entity on which change happens.
-            e.g. 'asset', 'representation' etc.
-        data (Dict[str, Any]): Data of entity that will be created.
-    """
-
-    operation_name = "create"
-
-    def __init__(self, project_name, entity_type, data):
-        super(CreateOperation, self).__init__(project_name, entity_type)
-
-        if not data:
-            data = {}
-        else:
-            data = copy.deepcopy(dict(data))
-        self._data = data
-
-    def __setitem__(self, key, value):
-        self.set_value(key, value)
-
-    def __getitem__(self, key):
-        return self.data[key]
-
-    def set_value(self, key, value):
-        self.data[key] = value
-
-    def get(self, key, *args, **kwargs):
-        return self.data.get(key, *args, **kwargs)
-
-    @abstractproperty
-    def entity_id(self):
-        pass
-
-    @property
-    def data(self):
-        return self._data
-
-    def to_data(self):
-        output = super(CreateOperation, self).to_data()
-        output["data"] = copy.deepcopy(self.data)
-        return output
-
-
-class UpdateOperation(AbstractOperation):
-    """Operation to update an entity.
-
-    Args:
-        project_name (str): On which project operation will happen.
-        entity_type (str): Type of entity on which change happens.
-            e.g. 'asset', 'representation' etc.
-        entity_id (Union[str, ObjectId]): Identifier of an entity.
-        update_data (Dict[str, Any]): Key -> value changes that will be set in
-            database. If value is set to 'REMOVED_VALUE' the key will be
-            removed. Only first level of dictionary is checked (on purpose).
-    """
-
-    operation_name = "update"
-
-    def __init__(self, project_name, entity_type, entity_id, update_data):
-        super(UpdateOperation, self).__init__(project_name, entity_type)
-
-        self._entity_id = entity_id
-        self._update_data = update_data
-
-    @property
-    def entity_id(self):
-        return self._entity_id
-
-    @property
-    def update_data(self):
-        return self._update_data
-
-    def to_data(self):
-        changes = {}
-        for key, value in self._update_data.items():
-            if value is REMOVED_VALUE:
-                value = None
-            changes[key] = value
-
-        output = super(UpdateOperation, self).to_data()
-        output.update({
-            "entity_id": self.entity_id,
-            "changes": changes
-        })
-        return output
-
-
-class DeleteOperation(AbstractOperation):
-    """Operation to delete an entity.
-
-    Args:
-        project_name (str): On which project operation will happen.
-        entity_type (str): Type of entity on which change happens.
-            e.g. 'asset', 'representation' etc.
-        entity_id (Union[str, ObjectId]): Entity id that will be removed.
-    """
-
-    operation_name = "delete"
-
-    def __init__(self, project_name, entity_type, entity_id):
-        super(DeleteOperation, self).__init__(project_name, entity_type)
-
-        self._entity_id = entity_id
-
-    @property
-    def entity_id(self):
-        return self._entity_id
-
-    def to_data(self):
-        output = super(DeleteOperation, self).to_data()
-        output["entity_id"] = self.entity_id
-        return output
-
-
-class BaseOperationsSession(object):
-    """Session storing operations that should happen in an order.
-
-    At this moment does not handle anything special can be considered as
-    stupid list of operations that will happen after each other. If creation
-    of same entity is there multiple times it's handled in any way and document
-    values are not validated.
-    """
-
-    def __init__(self):
-        self._operations = []
-
-    def __len__(self):
-        return len(self._operations)
-
-    def add(self, operation):
-        """Add operation to be processed.
-
-        Args:
-            operation (BaseOperation): Operation that should be processed.
-        """
-        if not isinstance(
-            operation,
-            (CreateOperation, UpdateOperation, DeleteOperation)
-        ):
-            raise TypeError("Expected Operation object got {}".format(
-                str(type(operation))
-            ))
-
-        self._operations.append(operation)
-
-    def append(self, operation):
-        """Add operation to be processed.
-
-        Args:
-            operation (BaseOperation): Operation that should be processed.
-        """
-
-        self.add(operation)
-
-    def extend(self, operations):
-        """Add operations to be processed.
-
-        Args:
-            operations (List[BaseOperation]): Operations that should be
-                processed.
-        """
-
-        for operation in operations:
-            self.add(operation)
-
-    def remove(self, operation):
-        """Remove operation."""
-
-        self._operations.remove(operation)
-
-    def clear(self):
-        """Clear all registered operations."""
-
-        self._operations = []
-
-    def to_data(self):
-        return [
-            operation.to_data()
-            for operation in self._operations
-        ]
-
-    @abstractmethod
-    def commit(self):
-        """Commit session operations."""
-        pass
-
-    def create_entity(self, project_name, entity_type, data):
-        """Fast access to 'CreateOperation'.
-
-        Returns:
-            CreateOperation: Object of update operation.
-        """
-
-        operation = CreateOperation(project_name, entity_type, data)
-        self.add(operation)
-        return operation
-
-    def update_entity(self, project_name, entity_type, entity_id, update_data):
-        """Fast access to 'UpdateOperation'.
-
-        Returns:
-            UpdateOperation: Object of update operation.
-        """
-
-        operation = UpdateOperation(
-            project_name, entity_type, entity_id, update_data
-        )
-        self.add(operation)
-        return operation
-
-    def delete_entity(self, project_name, entity_type, entity_id):
-        """Fast access to 'DeleteOperation'.
-
-        Returns:
-            DeleteOperation: Object of delete operation.
-        """
-
-        operation = DeleteOperation(project_name, entity_type, entity_id)
-        self.add(operation)
-        return operation

client/ayon_core/client/utils.py

@@ -1,134 +0,0 @@
-import os
-import uuid
-
-import ayon_api
-
-from ayon_core.client.operations_base import REMOVED_VALUE
-
-
-class _GlobalCache:
-    initialized = False
-
-
-def get_ayon_server_api_connection():
-    if _GlobalCache.initialized:
-        con = ayon_api.get_server_api_connection()
-    else:
-        from ayon_core.lib.local_settings import get_local_site_id
-
-        _GlobalCache.initialized = True
-        site_id = get_local_site_id()
-        version = os.getenv("AYON_VERSION")
-        if ayon_api.is_connection_created():
-            con = ayon_api.get_server_api_connection()
-            con.set_site_id(site_id)
-            con.set_client_version(version)
-        else:
-            con = ayon_api.create_connection(site_id, version)
-    return con
-
-
-def create_entity_id():
-    return uuid.uuid1().hex
-
-
-def prepare_attribute_changes(old_entity, new_entity, replace=False):
-    """Prepare changes of attributes on entities.
-
-    Compare 'attrib' of old and new entity data to prepare only changed
-    values that should be sent to server for update.
-
-    Example:
-        >>> # Limited entity data to 'attrib'
-        >>> old_entity = {
-        ...     "attrib": {"attr_1": 1, "attr_2": "MyString", "attr_3": True}
-        ... }
-        >>> new_entity = {
-        ...     "attrib": {"attr_1": 2, "attr_3": True, "attr_4": 3}
-        ... }
-        >>> # Changes if replacement should not happen
-        >>> expected_changes = {
-        ...   "attr_1": 2,
-        ...   "attr_4": 3
-        ... }
-        >>> changes = prepare_attribute_changes(old_entity, new_entity)
-        >>> changes == expected_changes
-        True
-
-        >>> # Changes if replacement should happen
-        >>> expected_changes_replace = {
-        ...   "attr_1": 2,
-        ...   "attr_2": REMOVED_VALUE,
-        ...   "attr_4": 3
-        ... }
-        >>> changes_replace = prepare_attribute_changes(
-        ...     old_entity, new_entity, True)
-        >>> changes_replace == expected_changes_replace
-        True
-
-    Args:
-        old_entity (dict[str, Any]): Data of entity queried from server.
-        new_entity (dict[str, Any]): Entity data with applied changes.
-        replace (bool): New entity should fully replace all old entity values.
-
-    Returns:
-        Dict[str, Any]: Values from new entity only if value has changed.
-    """
-
-    attrib_changes = {}
-    new_attrib = new_entity.get("attrib")
-    old_attrib = old_entity.get("attrib")
-    if new_attrib is None:
-        if not replace:
-            return attrib_changes
-        new_attrib = {}
-
-    if old_attrib is None:
-        return new_attrib
-
-    for attr, new_attr_value in new_attrib.items():
-        old_attr_value = old_attrib.get(attr)
-        if old_attr_value != new_attr_value:
-            attrib_changes[attr] = new_attr_value
-
-    if replace:
-        for attr in old_attrib:
-            if attr not in new_attrib:
-                attrib_changes[attr] = REMOVED_VALUE
-
-    return attrib_changes
-
-
-def prepare_entity_changes(old_entity, new_entity, replace=False):
-    """Prepare changes of AYON entities.
-
-    Compare old and new entity to filter values from new data that changed.
-
-    Args:
-        old_entity (dict[str, Any]): Data of entity queried from server.
-        new_entity (dict[str, Any]): Entity data with applied changes.
-        replace (bool): All attributes should be replaced by new values. So
-            all attribute values that are not on new entity will be removed.
-
-    Returns:
-        Dict[str, Any]: Only values from new entity that changed.
-    """
-
-    changes = {}
-    for key, new_value in new_entity.items():
-        if key == "attrib":
-            continue
-
-        old_value = old_entity.get(key)
-        if old_value != new_value:
-            changes[key] = new_value
-
-    if replace:
-        for key in old_entity:
-            if key not in new_entity:
-                changes[key] = REMOVED_VALUE
-
-    attr_changes = prepare_attribute_changes(old_entity, new_entity, replace)
-    if attr_changes:
-        changes["attrib"] = attr_changes
-    return changes

client/ayon_core/hooks/pre_add_last_workfile_arg.py

@@ -1,6 +1,6 @@
 import os
 
-from ayon_core.lib.applications import PreLaunchHook, LaunchTypes
+from ayon_applications import PreLaunchHook, LaunchTypes
 
 
 class AddLastWorkfileToLaunchArgs(PreLaunchHook):

client/ayon_core/hooks/pre_copy_template_workfile.py

@@ -1,7 +1,7 @@
 import os
 import shutil
 from ayon_core.settings import get_project_settings
-from ayon_core.lib.applications import PreLaunchHook, LaunchTypes
+from ayon_applications import PreLaunchHook, LaunchTypes
 from ayon_core.pipeline.workfile import (
     get_custom_workfile_template,
     get_custom_workfile_template_by_string_context
@@ -54,21 +54,22 @@ class CopyTemplateWorkfile(PreLaunchHook):
         self.log.info("Last workfile does not exist.")
 
         project_name = self.data["project_name"]
-        asset_name = self.data["folder_path"]
+        folder_path = self.data["folder_path"]
         task_name = self.data["task_name"]
         host_name = self.application.host_name
 
         project_settings = get_project_settings(project_name)
 
-        project_doc = self.data.get("project_doc")
-        asset_doc = self.data.get("asset_doc")
+        project_entity = self.data.get("project_entity")
+        folder_entity = self.data.get("folder_entity")
+        task_entity = self.data.get("task_entity")
         anatomy = self.data.get("anatomy")
-        if project_doc and asset_doc:
+        if project_entity and folder_entity and task_entity:
             self.log.debug("Started filtering of custom template paths.")
             template_path = get_custom_workfile_template(
-                project_doc,
-                asset_doc,
-                task_name,
+                project_entity,
+                folder_entity,
+                task_entity,
                 host_name,
                 anatomy,
                 project_settings
@@ -81,7 +82,7 @@ class CopyTemplateWorkfile(PreLaunchHook):
             ))
             template_path = get_custom_workfile_template_by_string_context(
                 project_name,
-                asset_name,
+                folder_path,
                 task_name,
                 host_name,
                 anatomy,

client/ayon_core/hooks/pre_create_extra_workdir_folders.py

@@ -1,5 +1,5 @@
 import os
-from ayon_core.lib.applications import PreLaunchHook, LaunchTypes
+from ayon_applications import PreLaunchHook, LaunchTypes
 from ayon_core.pipeline.workfile import create_workdir_extra_folders
 
 

client/ayon_core/hooks/pre_global_host_data.py

@@ -1,6 +1,7 @@
-from ayon_core.client import get_project, get_asset_by_name
-from ayon_core.lib.applications import (
-    PreLaunchHook,
+from ayon_api import get_project, get_folder_by_path, get_task_by_name
+
+from ayon_applications import PreLaunchHook
+from ayon_applications.utils import (
     EnvironmentPrepData,
     prepare_app_environments,
     prepare_context_environments
@@ -16,7 +17,7 @@ class GlobalHostDataHook(PreLaunchHook):
         """Prepare global objects to `data` that will be used for sure."""
         self.prepare_global_data()
 
-        if not self.data.get("asset_doc"):
+        if not self.data.get("folder_entity"):
             return
 
         app = self.launch_context.application
@@ -27,8 +28,9 @@ class GlobalHostDataHook(PreLaunchHook):
 
             "app": app,
 
-            "project_doc": self.data["project_doc"],
-            "asset_doc": self.data["asset_doc"],
+            "project_entity": self.data["project_entity"],
+            "folder_entity": self.data["folder_entity"],
+            "task_entity": self.data["task_entity"],
 
             "anatomy": self.data["anatomy"],
 
@@ -59,19 +61,37 @@ class GlobalHostDataHook(PreLaunchHook):
             return
 
         self.log.debug("Project name is set to \"{}\"".format(project_name))
+
+        # Project Entity
+        project_entity = get_project(project_name)
+        self.data["project_entity"] = project_entity
+
         # Anatomy
-        self.data["anatomy"] = Anatomy(project_name)
+        self.data["anatomy"] = Anatomy(
+            project_name, project_entity=project_entity
+        )
 
-        # Project document
-        project_doc = get_project(project_name)
-        self.data["project_doc"] = project_doc
-
-        asset_name = self.data.get("folder_path")
-        if not asset_name:
+        folder_path = self.data.get("folder_path")
+        if not folder_path:
             self.log.warning(
-                "Asset name was not set. Skipping asset document query."
+                "Folder path is not set. Skipping folder query."
             )
             return
 
-        asset_doc = get_asset_by_name(project_name, asset_name)
-        self.data["asset_doc"] = asset_doc
+        folder_entity = get_folder_by_path(project_name, folder_path)
+        self.data["folder_entity"] = folder_entity
+
+        task_name = self.data.get("task_name")
+        if not task_name:
+            self.log.warning(
+                "Task name is not set. Skipping task query."
+            )
+            return
+
+        if not folder_entity:
+            return
+
+        task_entity = get_task_by_name(
+            project_name, folder_entity["id"], task_name
+        )
+        self.data["task_entity"] = task_entity

client/ayon_core/hooks/pre_mac_launch.py

@@ -1,5 +1,5 @@
 import os
-from ayon_core.lib.applications import PreLaunchHook, LaunchTypes
+from ayon_applications import PreLaunchHook, LaunchTypes
 
 
 class LaunchWithTerminal(PreLaunchHook):

client/ayon_core/hooks/pre_new_console_apps.py

@@ -1,5 +1,5 @@
 import subprocess
-from ayon_core.lib.applications import PreLaunchHook, LaunchTypes
+from ayon_applications import PreLaunchHook, LaunchTypes
 
 
 class LaunchNewConsoleApps(PreLaunchHook):

client/ayon_core/hooks/pre_non_python_host_launch.py

@@ -1,58 +0,0 @@
-import os
-
-from ayon_core.lib import get_ayon_launcher_args
-from ayon_core.lib.applications import (
-    get_non_python_host_kwargs,
-    PreLaunchHook,
-    LaunchTypes,
-)
-
-from ayon_core import AYON_CORE_ROOT
-
-
-class NonPythonHostHook(PreLaunchHook):
-    """Launch arguments preparation.
-
-    Non python host implementation do not launch host directly but use
-    python script which launch the host. For these cases it is necessary to
-    prepend python (or ayon) executable and script path before application's.
-    """
-    app_groups = {"harmony", "photoshop", "aftereffects"}
-
-    order = 20
-    launch_types = {LaunchTypes.local}
-
-    def execute(self):
-        # Pop executable
-        executable_path = self.launch_context.launch_args.pop(0)
-
-        # Pop rest of launch arguments - There should not be other arguments!
-        remainders = []
-        while self.launch_context.launch_args:
-            remainders.append(self.launch_context.launch_args.pop(0))
-
-        script_path = os.path.join(
-            AYON_CORE_ROOT,
-            "scripts",
-            "non_python_host_launch.py"
-        )
-
-        new_launch_args = get_ayon_launcher_args(
-            "run", script_path, executable_path
-        )
-        # Add workfile path if exists
-        workfile_path = self.data["last_workfile_path"]
-        if (
-                self.data.get("start_last_workfile")
-                and workfile_path
-                and os.path.exists(workfile_path)):
-            new_launch_args.append(workfile_path)
-
-        # Append as whole list as these areguments should not be separated
-        self.launch_context.launch_args.append(new_launch_args)
-
-        if remainders:
-            self.launch_context.launch_args.extend(remainders)
-
-        self.launch_context.kwargs = \
-            get_non_python_host_kwargs(self.launch_context.kwargs)

client/ayon_core/hooks/pre_ocio_hook.py

@@ -1,4 +1,4 @@
-from ayon_core.lib.applications import PreLaunchHook
+from ayon_applications import PreLaunchHook
 
 from ayon_core.pipeline.colorspace import get_imageio_config
 from ayon_core.pipeline.template_data import get_template_data_with_names
@@ -28,7 +28,7 @@ class OCIOEnvHook(PreLaunchHook):
 
         template_data = get_template_data_with_names(
             project_name=self.data["project_name"],
-            asset_name=self.data["folder_path"],
+            folder_path=self.data["folder_path"],
             task_name=self.data["task_name"],
             host_name=self.host_name,
             settings=self.data["project_settings"]

client/ayon_core/host/dirmap.py

@@ -36,23 +36,23 @@ class HostDirmap(object):
         host_name,
         project_name,
         project_settings=None,
-        sync_module=None
+        sitesync_addon=None
     ):
         self.host_name = host_name
         self.project_name = project_name
         self._project_settings = project_settings
-        self._sync_module = sync_module
+        self._sitesync_addon = sitesync_addon
         # to limit reinit of Modules
-        self._sync_module_discovered = sync_module is not None
+        self._sitesync_addon_discovered = sitesync_addon is not None
         self._log = None
 
     @property
-    def sync_module(self):
-        if not self._sync_module_discovered:
-            self._sync_module_discovered = True
+    def sitesync_addon(self):
+        if not self._sitesync_addon_discovered:
+            self._sitesync_addon_discovered = True
             manager = AddonsManager()
-            self._sync_module = manager.get("sync_server")
-        return self._sync_module
+            self._sitesync_addon = manager.get("sitesync")
+        return self._sitesync_addon
 
     @property
     def project_settings(self):
@@ -158,25 +158,25 @@ class HostDirmap(object):
         """
         project_name = self.project_name
 
-        sync_module = self.sync_module
+        sitesync_addon = self.sitesync_addon
         mapping = {}
         if (
-            sync_module is None
-            or not sync_module.enabled
-            or project_name not in sync_module.get_enabled_projects()
+            sitesync_addon is None
+            or not sitesync_addon.enabled
+            or project_name not in sitesync_addon.get_enabled_projects()
         ):
             return mapping
 
-        active_site = sync_module.get_local_normalized_site(
-            sync_module.get_active_site(project_name))
-        remote_site = sync_module.get_local_normalized_site(
-            sync_module.get_remote_site(project_name))
+        active_site = sitesync_addon.get_local_normalized_site(
+            sitesync_addon.get_active_site(project_name))
+        remote_site = sitesync_addon.get_local_normalized_site(
+            sitesync_addon.get_remote_site(project_name))
         self.log.debug(
             "active {} - remote {}".format(active_site, remote_site)
         )
 
         if active_site == "local" and active_site != remote_site:
-            sync_settings = sync_module.get_sync_project_setting(
+            sync_settings = sitesync_addon.get_sync_project_setting(
                 project_name,
                 exclude_locals=False,
                 cached=False)
@@ -194,7 +194,7 @@ class HostDirmap(object):
             self.log.debug("remote overrides {}".format(remote_overrides))
 
             current_platform = platform.system().lower()
-            remote_provider = sync_module.get_provider_for_site(
+            remote_provider = sitesync_addon.get_provider_for_site(
                 project_name, remote_site
             )
             # dirmap has sense only with regular disk provider, in the workfile

client/ayon_core/host/host.py

@@ -18,7 +18,7 @@ class HostBase(object):
     Compared to 'avalon' concept:
     What was before considered as functions in host implementation folder. The
     host implementation should primarily care about adding ability of creation
-    (mark subsets to be published) and optionally about referencing published
+    (mark products to be published) and optionally about referencing published
     representations as containers.
 
     Host may need extend some functionality like working with workfiles
@@ -108,7 +108,7 @@ class HostBase(object):
 
         return os.environ.get("AYON_PROJECT_NAME")
 
-    def get_current_asset_name(self):
+    def get_current_folder_path(self):
         """
         Returns:
             Union[str, None]: Current asset name.
@@ -139,7 +139,7 @@ class HostBase(object):
 
         return {
             "project_name": self.get_current_project_name(),
-            "folder_path": self.get_current_asset_name(),
+            "folder_path": self.get_current_folder_path(),
             "task_name": self.get_current_task_name()
         }
 
@@ -161,13 +161,13 @@ class HostBase(object):
         # Use current context to fill the context title
         current_context = self.get_current_context()
         project_name = current_context["project_name"]
-        asset_name = current_context["folder_path"]
+        folder_path = current_context["folder_path"]
         task_name = current_context["task_name"]
         items = []
         if project_name:
             items.append(project_name)
-            if asset_name:
-                items.append(asset_name.lstrip("/"))
+            if folder_path:
+                items.append(folder_path.lstrip("/"))
                 if task_name:
                     items.append(task_name)
         if items:

client/ayon_core/hosts/aftereffects/__init__.py

@@ -1,6 +1,12 @@
-from .addon import AfterEffectsAddon
+from .addon import (
+    AFTEREFFECTS_ADDON_ROOT,
+    AfterEffectsAddon,
+    get_launch_script_path,
+)
 
 
 __all__ = (
+    "AFTEREFFECTS_ADDON_ROOT",
     "AfterEffectsAddon",
+    "get_launch_script_path",
 )

client/ayon_core/hosts/aftereffects/addon.py

@@ -1,5 +1,9 @@
+import os
+
 from ayon_core.addon import AYONAddon, IHostAddon
 
+AFTEREFFECTS_ADDON_ROOT = os.path.dirname(os.path.abspath(__file__))
+
 
 class AfterEffectsAddon(AYONAddon, IHostAddon):
     name = "aftereffects"
@@ -17,3 +21,16 @@ class AfterEffectsAddon(AYONAddon, IHostAddon):
 
     def get_workfile_extensions(self):
         return [".aep"]
+
+    def get_launch_hook_paths(self, app):
+        if app.host_name != self.host_name:
+            return []
+        return [
+            os.path.join(AFTEREFFECTS_ADDON_ROOT, "hooks")
+        ]
+
+
+def get_launch_script_path():
+    return os.path.join(
+        AFTEREFFECTS_ADDON_ROOT, "api", "launch_script.py"
+    )

client/ayon_core/hosts/aftereffects/api/__init__.py

@@ -17,7 +17,7 @@ from .pipeline import (
 from .lib import (
     maintained_selection,
     get_extension_manifest_path,
-    get_asset_settings,
+    get_folder_settings,
     set_settings
 )
 
@@ -31,13 +31,14 @@ __all__ = [
     "get_stub",
 
     # pipeline
+    "AfterEffectsHost",
     "ls",
     "containerise",
 
     # lib
     "maintained_selection",
     "get_extension_manifest_path",
-    "get_asset_settings",
+    "get_folder_settings",
     "set_settings",
 
     # plugin

client/ayon_core/hosts/aftereffects/api/launch_logic.py

@@ -7,7 +7,6 @@ import asyncio
 import functools
 import traceback
 
-
 from wsrpc_aiohttp import (
     WebSocketRoute,
     WebSocketAsync
@@ -286,20 +285,21 @@ class AfterEffectsRoute(WebSocketRoute):
 
     # This method calls function on the client side
     # client functions
-    async def set_context(self, project, asset, task):
+    async def set_context(self, project, folder, task):
         """
-            Sets 'project' and 'asset' to envs, eg. setting context
+            Sets 'project', 'folder' and 'task' to envs, eg. setting context
 
             Args:
                 project (str)
-                asset (str)
+                folder (str)
+                task (str)
         """
         log.info("Setting context change")
-        log.info("project {} asset {} ".format(project, asset))
+        log.info("project {} folder {} ".format(project, folder))
         if project:
             os.environ["AYON_PROJECT_NAME"] = project
-        if asset:
-            os.environ["AYON_FOLDER_PATH"] = asset
+        if folder:
+            os.environ["AYON_FOLDER_PATH"] = folder
         if task:
             os.environ["AYON_TASK_NAME"] = task
 

client/ayon_core/hosts/aftereffects/api/launch_script.py

@@ -1,4 +1,4 @@
-"""Script wraps launch mechanism of non python host implementations.
+"""Script wraps launch mechanism of AfterEffects implementations.
 
 Arguments passed to the script are passed to launch function in host
 implementation. In all cases requires host app executable and may contain
@@ -8,6 +8,8 @@ workfile or others.
 import os
 import sys
 
+from ayon_core.hosts.aftereffects.api.launch_logic import main as host_main
+
 # Get current file to locate start point of sys.argv
 CURRENT_FILE = os.path.abspath(__file__)
 
@@ -79,26 +81,9 @@ def main(argv):
     if after_script_idx is not None:
         launch_args = sys_args[after_script_idx:]
 
-    host_name = os.environ["AYON_HOST_NAME"].lower()
-    if host_name == "photoshop":
-        # TODO refactor launch logic according to AE
-        from ayon_core.hosts.photoshop.api.lib import main
-    elif host_name == "aftereffects":
-        from ayon_core.hosts.aftereffects.api.launch_logic import main
-    elif host_name == "harmony":
-        from ayon_core.hosts.harmony.api.lib import main
-    else:
-        title = "Unknown host name"
-        message = (
-            "BUG: Environment variable AYON_HOST_NAME contains unknown"
-            " host name \"{}\""
-        ).format(host_name)
-        show_error_messagebox(title, message)
-        return
-
     if launch_args:
         # Launch host implementation
-        main(*launch_args)
+        host_main(*launch_args)
     else:
         # Show message box
         on_invalid_args(after_script_idx is None)

client/ayon_core/hosts/aftereffects/api/lib.py

@@ -4,8 +4,10 @@ import json
 import contextlib
 import logging
 
+import ayon_api
+
 from ayon_core.pipeline.context_tools import get_current_context
-from ayon_core.client import get_asset_by_name
+
 from .ws_stub import get_stub
 
 log = logging.getLogger(__name__)
@@ -85,21 +87,21 @@ def get_background_layers(file_url):
     return layers
 
 
-def get_asset_settings(asset_doc):
-    """Get settings on current asset from database.
+def get_folder_settings(folder_entity):
+    """Get settings of current folder.
 
     Returns:
         dict: Scene data.
 
     """
-    asset_data = asset_doc["data"]
-    fps = asset_data.get("fps", 0)
-    frame_start = asset_data.get("frameStart", 0)
-    frame_end = asset_data.get("frameEnd", 0)
-    handle_start = asset_data.get("handleStart", 0)
-    handle_end = asset_data.get("handleEnd", 0)
-    resolution_width = asset_data.get("resolutionWidth", 0)
-    resolution_height = asset_data.get("resolutionHeight", 0)
+    folder_attributes = folder_entity["attrib"]
+    fps = folder_attributes.get("fps", 0)
+    frame_start = folder_attributes.get("frameStart", 0)
+    frame_end = folder_attributes.get("frameEnd", 0)
+    handle_start = folder_attributes.get("handleStart", 0)
+    handle_end = folder_attributes.get("handleEnd", 0)
+    resolution_width = folder_attributes.get("resolutionWidth", 0)
+    resolution_height = folder_attributes.get("resolutionHeight", 0)
     duration = (frame_end - frame_start + 1) + handle_start + handle_end
 
     return {
@@ -127,9 +129,11 @@ def set_settings(frames, resolution, comp_ids=None, print_msg=True):
     frame_start = frames_duration = fps = width = height = None
     current_context = get_current_context()
 
-    asset_doc = get_asset_by_name(current_context["project_name"],
-                                  current_context["folder_path"])
-    settings = get_asset_settings(asset_doc)
+    folder_entity = ayon_api.get_folder_by_path(
+        current_context["project_name"],
+        current_context["folder_path"]
+    )
+    settings = get_folder_settings(folder_entity)
 
     msg = ''
     if frames:

client/ayon_core/hosts/aftereffects/api/pipeline.py

@@ -271,7 +271,7 @@ def containerise(name,
         "name": name,
         "namespace": namespace,
         "loader": str(loader),
-        "representation": str(context["representation"]["_id"]),
+        "representation": context["representation"]["id"],
         "members": comp.members or [comp.id]
     }
 

client/ayon_core/hosts/aftereffects/hooks/pre_launch_args.py

@@ -0,0 +1,88 @@
+import os
+import platform
+import subprocess
+
+from ayon_core.lib import (
+    get_ayon_launcher_args,
+    is_using_ayon_console,
+)
+from ayon_applications import PreLaunchHook, LaunchTypes
+from ayon_core.hosts.aftereffects import get_launch_script_path
+
+
+def get_launch_kwargs(kwargs):
+    """Explicit setting of kwargs for Popen for AfterEffects.
+
+    Expected behavior
+    - ayon_console opens window with logs
+    - ayon has stdout/stderr available for capturing
+
+    Args:
+        kwargs (Union[dict, None]): Current kwargs or None.
+
+    """
+    if kwargs is None:
+        kwargs = {}
+
+    if platform.system().lower() != "windows":
+        return kwargs
+
+    if is_using_ayon_console():
+        kwargs.update({
+            "creationflags": subprocess.CREATE_NEW_CONSOLE
+        })
+    else:
+        kwargs.update({
+            "creationflags": subprocess.CREATE_NO_WINDOW,
+            "stdout": subprocess.DEVNULL,
+            "stderr": subprocess.DEVNULL
+        })
+    return kwargs
+
+
+class AEPrelaunchHook(PreLaunchHook):
+    """Launch arguments preparation.
+
+    Hook add python executable and script path to AE implementation before
+    AE executable and add last workfile path to launch arguments.
+
+    Existence of last workfile is checked. If workfile does not exists tries
+    to copy templated workfile from predefined path.
+    """
+    app_groups = {"aftereffects"}
+
+    order = 20
+    launch_types = {LaunchTypes.local}
+
+    def execute(self):
+        # Pop executable
+        executable_path = self.launch_context.launch_args.pop(0)
+
+        # Pop rest of launch arguments - There should not be other arguments!
+        remainders = []
+        while self.launch_context.launch_args:
+            remainders.append(self.launch_context.launch_args.pop(0))
+
+        script_path = get_launch_script_path()
+
+        new_launch_args = get_ayon_launcher_args(
+            "run", script_path, executable_path
+        )
+        # Add workfile path if exists
+        workfile_path = self.data["last_workfile_path"]
+        if (
+            self.data.get("start_last_workfile")
+            and workfile_path
+            and os.path.exists(workfile_path)
+        ):
+            new_launch_args.append(workfile_path)
+
+        # Append as whole list as these arguments should not be separated
+        self.launch_context.launch_args.append(new_launch_args)
+
+        if remainders:
+            self.launch_context.launch_args.extend(remainders)
+
+        self.launch_context.kwargs = get_launch_kwargs(
+            self.launch_context.kwargs
+        )

client/ayon_core/hosts/aftereffects/plugins/create/create_render.py

@@ -218,7 +218,13 @@ class RenderCreator(Creator):
         """
 
     def get_dynamic_data(
-        self, project_name, asset_doc, task_name, variant, host_name, instance
+        self,
+        project_name,
+        folder_entity,
+        task_entity,
+        variant,
+        host_name,
+        instance
     ):
         dynamic_data = {}
         if instance is not None:

client/ayon_core/hosts/aftereffects/plugins/create/workfile_creator.py

@@ -1,5 +1,6 @@
+import ayon_api
+
 import ayon_core.hosts.aftereffects.api as api
-from ayon_core.client import get_asset_by_name
 from ayon_core.pipeline import (
     AutoCreator,
     CreatedInstance
@@ -39,32 +40,37 @@ class AEWorkfileCreator(AutoCreator):
 
         context = self.create_context
         project_name = context.get_current_project_name()
-        asset_name = context.get_current_asset_name()
+        folder_path = context.get_current_folder_path()
         task_name = context.get_current_task_name()
         host_name = context.host_name
 
-        existing_asset_name = None
+        existing_folder_path = None
         if existing_instance is not None:
-            existing_asset_name = existing_instance.get("folderPath")
+            existing_folder_path = existing_instance.get("folderPath")
 
         if existing_instance is None:
-            asset_doc = get_asset_by_name(project_name, asset_name)
+            folder_entity = ayon_api.get_folder_by_path(
+                project_name, folder_path
+            )
+            task_entity = ayon_api.get_task_by_name(
+                project_name, folder_entity["id"], task_name
+            )
             product_name = self.get_product_name(
                 project_name,
-                asset_doc,
-                task_name,
+                folder_entity,
+                task_entity,
                 self.default_variant,
                 host_name,
             )
             data = {
-                "folderPath": asset_name,
+                "folderPath": folder_path,
                 "task": task_name,
                 "variant": self.default_variant,
             }
             data.update(self.get_dynamic_data(
                 project_name,
-                asset_doc,
-                task_name,
+                folder_entity,
+                task_entity,
                 self.default_variant,
                 host_name,
                 None,
@@ -79,17 +85,22 @@ class AEWorkfileCreator(AutoCreator):
                                    new_instance.data_to_store())
 
         elif (
-            existing_asset_name != asset_name
+            existing_folder_path != folder_path
             or existing_instance["task"] != task_name
         ):
-            asset_doc = get_asset_by_name(project_name, asset_name)
+            folder_entity = ayon_api.get_folder_by_path(
+                project_name, folder_path
+            )
+            task_entity = ayon_api.get_task_by_name(
+                project_name, folder_entity["id"], task_name
+            )
             product_name = self.get_product_name(
                 project_name,
-                asset_doc,
-                task_name,
+                folder_entity,
+                task_entity,
                 self.default_variant,
                 host_name,
             )
-            existing_instance["folderPath"] = asset_name
+            existing_instance["folderPath"] = folder_path
             existing_instance["task"] = task_name
             existing_instance["productName"] = product_name

client/ayon_core/hosts/aftereffects/plugins/load/load_background.py

@@ -20,8 +20,8 @@ class BackgroundLoader(api.AfterEffectsLoader):
         metadata
     """
     label = "Load JSON Background"
-    families = ["background"]
-    representations = ["json"]
+    product_types = {"background"}
+    representations = {"json"}
 
     def load(self, context, name=None, namespace=None, data=None):
         stub = self.get_stub()
@@ -31,7 +31,7 @@ class BackgroundLoader(api.AfterEffectsLoader):
 
         comp_name = get_unique_layer_name(
             existing_items,
-            "{}_{}".format(context["asset"]["name"], name))
+            "{}_{}".format(context["folder"]["name"], name))
 
         path = self.filepath_from_context(context)
         layers = get_background_layers(path)
@@ -56,16 +56,19 @@ class BackgroundLoader(api.AfterEffectsLoader):
             self.__class__.__name__
         )
 
-    def update(self, container, representation):
+    def update(self, container, context):
         """ Switch asset or change version """
         stub = self.get_stub()
-        context = representation.get("context", {})
+        folder_name = context["folder"]["name"]
+        product_name = context["product"]["name"]
+        repre_entity = context["representation"]
+
         _ = container.pop("layer")
 
         # without iterator number (_001, 002...)
         namespace_from_container = re.sub(r'_\d{3}$', '',
                                           container["namespace"])
-        comp_name = "{}_{}".format(context["asset"], context["subset"])
+        comp_name = "{}_{}".format(folder_name, product_name)
 
         # switching assets
         if namespace_from_container != comp_name:
@@ -73,11 +76,11 @@ class BackgroundLoader(api.AfterEffectsLoader):
             existing_items = [layer.name for layer in items]
             comp_name = get_unique_layer_name(
                 existing_items,
-                "{}_{}".format(context["asset"], context["subset"]))
+                "{}_{}".format(folder_name, product_name))
         else:  # switching version - keep same name
             comp_name = container["namespace"]
 
-        path = get_representation_path(representation)
+        path = get_representation_path(repre_entity)
 
         layers = get_background_layers(path)
         comp = stub.reload_background(container["members"][1],
@@ -85,8 +88,8 @@ class BackgroundLoader(api.AfterEffectsLoader):
                                       layers)
 
         # update container
-        container["representation"] = str(representation["_id"])
-        container["name"] = context["subset"]
+        container["representation"] = repre_entity["id"]
+        container["name"] = product_name
         container["namespace"] = comp_name
         container["members"] = comp.members
 
@@ -104,5 +107,5 @@ class BackgroundLoader(api.AfterEffectsLoader):
         stub.imprint(layer.id, {})
         stub.delete_item(layer.id)
 
-    def switch(self, container, representation):
-        self.update(container, representation)
+    def switch(self, container, context):
+        self.update(container, context)

client/ayon_core/hosts/aftereffects/plugins/load/load_file.py

@@ -12,20 +12,25 @@ class FileLoader(api.AfterEffectsLoader):
     """
     label = "Load file"
 
-    families = ["image",
-                "plate",
-                "render",
-                "prerender",
-                "review",
-                "audio"]
-    representations = ["*"]
+    product_types = {
+        "image",
+        "plate",
+        "render",
+        "prerender",
+        "review",
+        "audio",
+    }
+    representations = {"*"}
 
     def load(self, context, name=None, namespace=None, data=None):
         stub = self.get_stub()
         layers = stub.get_items(comps=True, folders=True, footages=True)
         existing_layers = [layer.name for layer in layers]
         comp_name = get_unique_layer_name(
-            existing_layers, "{}_{}".format(context["asset"]["name"], name))
+            existing_layers, "{}_{}".format(
+                context["folder"]["name"], name
+            )
+        )
 
         import_options = {}
 
@@ -35,7 +40,7 @@ class FileLoader(api.AfterEffectsLoader):
             import_options['sequence'] = True
 
         if not path:
-            repr_id = context["representation"]["_id"]
+            repr_id = context["representation"]["id"]
             self.log.warning(
                 "Representation id `{}` is failing to load".format(repr_id))
             return
@@ -64,31 +69,33 @@ class FileLoader(api.AfterEffectsLoader):
             self.__class__.__name__
         )
 
-    def update(self, container, representation):
+    def update(self, container, context):
         """ Switch asset or change version """
         stub = self.get_stub()
         layer = container.pop("layer")
 
-        context = representation.get("context", {})
+        folder_name = context["folder"]["name"]
+        product_name = context["product"]["name"]
+        repre_entity = context["representation"]
 
         namespace_from_container = re.sub(r'_\d{3}$', '',
                                           container["namespace"])
-        layer_name = "{}_{}".format(context["asset"], context["subset"])
+        layer_name = "{}_{}".format(folder_name, product_name)
         # switching assets
         if namespace_from_container != layer_name:
             layers = stub.get_items(comps=True)
             existing_layers = [layer.name for layer in layers]
             layer_name = get_unique_layer_name(
                 existing_layers,
-                "{}_{}".format(context["asset"], context["subset"]))
+                "{}_{}".format(folder_name, product_name))
         else:  # switching version - keep same name
             layer_name = container["namespace"]
-        path = get_representation_path(representation)
+        path = get_representation_path(repre_entity)
         # with aftereffects.maintained_selection():  # TODO
         stub.replace_item(layer.id, path, stub.LOADED_ICON + layer_name)
         stub.imprint(
-            layer.id, {"representation": str(representation["_id"]),
-                       "name": context["subset"],
+            layer.id, {"representation": repre_entity["id"],
+                       "name": product_name,
                        "namespace": layer_name}
         )
 
@@ -103,5 +110,5 @@ class FileLoader(api.AfterEffectsLoader):
         stub.imprint(layer.id, {})
         stub.delete_item(layer.id)
 
-    def switch(self, container, representation):
-        self.update(container, representation)
+    def switch(self, container, context):
+        self.update(container, context)

client/ayon_core/hosts/aftereffects/plugins/publish/collect_render.py

@@ -1,14 +1,11 @@
 import os
-import re
 import tempfile
-import attr
 
+import attr
 import pyblish.api
 
-from ayon_core.settings import get_project_settings
 from ayon_core.pipeline import publish
 from ayon_core.pipeline.publish import RenderInstance
-
 from ayon_core.hosts.aftereffects.api import get_stub
 
 
@@ -44,7 +41,6 @@ class CollectAERender(publish.AbstractCollectRender):
 
     def get_instances(self, context):
         instances = []
-        instances_to_remove = []
 
         app_version = CollectAERender.get_stub().get_app_version()
         app_version = app_version[0:4]
@@ -120,7 +116,10 @@ class CollectAERender(publish.AbstractCollectRender):
                 fps=fps,
                 app_version=app_version,
                 publish_attributes=inst.data.get("publish_attributes", {}),
-                file_names=[item.file_name for item in render_q]
+                file_names=[item.file_name for item in render_q],
+
+                # The source instance this render instance replaces
+                source_instance=inst
             )
 
             comp = compositions_by_id.get(comp_id)
@@ -148,10 +147,7 @@ class CollectAERender(publish.AbstractCollectRender):
                     instance.families.remove("review")
 
             instances.append(instance)
-            instances_to_remove.append(inst)
 
-        for instance in instances_to_remove:
-            context.remove(instance)
         return instances
 
     def get_expected_files(self, render_instance):

client/ayon_core/hosts/aftereffects/plugins/publish/help/validate_instance_asset.xml

@@ -1,7 +1,7 @@
 <?xml version="1.0" encoding="UTF-8"?>
 <root>
 <error id="main">
-<title>Subset context</title>
+<title>Product context</title>
 <description>
 ## Invalid product context
 
@@ -15,7 +15,7 @@ You can fix this with "repair" button on the right and refresh Publish at the bo
 ### __Detailed Info__ (optional)
 
 This might happen if you are reuse old workfile and open it in different context.
-(Eg. you created product name "renderCompositingDefault" from folder "Robot' in "your_project_Robot_compositing.aep", now you opened this workfile in a context "Sloth" but existing product for "Robot" asset stayed in the workfile.)
+(Eg. you created product name "renderCompositingDefault" from folder "Robot' in "your_project_Robot_compositing.aep", now you opened this workfile in a context "Sloth" but existing product for "Robot" folder stayed in the workfile.)
 </detail>
 </error>
 </root>

client/ayon_core/hosts/aftereffects/plugins/publish/help/validate_scene_settings.xml

@@ -5,20 +5,20 @@
 <description>
 ## Invalid scene setting found
 
-One of the settings in a scene doesn't match to asset settings in database.
+One of the settings in a scene doesn't match to folder settings in database.
 
 {invalid_setting_str}
 
 ### How to repair?
 
-Change values for {invalid_keys_str} in the scene OR change them in the asset database if they are wrong there.
+Change values for {invalid_keys_str} in the scene OR change them in the folder database if they are wrong there.
 
     In the scene it is right mouse click on published composition > `Composition Settings`.
 </description>
 <detail>
 ### __Detailed Info__ (optional)
 
-This error is shown when for example resolution in the scene doesn't match to resolution set on the asset in the database.
+This error is shown when for example resolution in the scene doesn't match to resolution set on the folder in the database.
 Either value in the database or in the scene is wrong.
 </detail>
 </error>

client/ayon_core/hosts/aftereffects/plugins/publish/validate_instance_asset.py

@@ -1,6 +1,6 @@
 import pyblish.api
 
-from ayon_core.pipeline import get_current_asset_name
+from ayon_core.pipeline import get_current_folder_path
 from ayon_core.pipeline.publish import (
     ValidateContentsOrder,
     PublishXmlValidationError,
@@ -8,8 +8,8 @@ from ayon_core.pipeline.publish import (
 from ayon_core.hosts.aftereffects.api import get_stub
 
 
-class ValidateInstanceAssetRepair(pyblish.api.Action):
-    """Repair the instance asset with value from Context."""
+class ValidateInstanceFolderRepair(pyblish.api.Action):
+    """Repair the instance folder with value from Context."""
 
     label = "Repair"
     icon = "wrench"
@@ -30,35 +30,35 @@ class ValidateInstanceAssetRepair(pyblish.api.Action):
         for instance in instances:
             data = stub.read(instance[0])
 
-            data["folderPath"] = get_current_asset_name()
+            data["folderPath"] = get_current_folder_path()
             stub.imprint(instance[0].instance_id, data)
 
 
-class ValidateInstanceAsset(pyblish.api.InstancePlugin):
-    """Validate the instance asset is the current selected context asset.
+class ValidateInstanceFolder(pyblish.api.InstancePlugin):
+    """Validate the instance folder is the current selected context folder.
 
         As it might happen that multiple worfiles are opened at same time,
         switching between them would mess with selected context. (From Launcher
         or Ftrack).
 
-        In that case outputs might be output under wrong asset!
+        In that case outputs might be output under wrong folder!
 
-        Repair action will use Context asset value (from Workfiles or Launcher)
+        Repair action will use Context folder value (from Workfiles or Launcher)
         Closing and reopening with Workfiles will refresh  Context value.
     """
 
-    label = "Validate Instance Asset"
+    label = "Validate Instance Folder"
     hosts = ["aftereffects"]
-    actions = [ValidateInstanceAssetRepair]
+    actions = [ValidateInstanceFolderRepair]
     order = ValidateContentsOrder
 
     def process(self, instance):
-        instance_asset = instance.data["folderPath"]
-        current_asset = get_current_asset_name()
+        instance_folder = instance.data["folderPath"]
+        current_folder = get_current_folder_path()
         msg = (
-            f"Instance asset {instance_asset} is not the same "
-            f"as current context {current_asset}."
+            f"Instance folder {instance_folder} is not the same "
+            f"as current context {current_folder}."
         )
 
-        if instance_asset != current_asset:
+        if instance_folder != current_folder:
             raise PublishXmlValidationError(self, msg)

client/ayon_core/hosts/aftereffects/plugins/publish/validate_scene_settings.py

@@ -1,7 +1,7 @@
 # -*- coding: utf-8 -*-
 """Validate scene settings.
 Requires:
-    instance    -> assetEntity
+    instance    -> folderEntity
     instance    -> anatomyData
 """
 import os
@@ -13,7 +13,7 @@ from ayon_core.pipeline import (
     PublishXmlValidationError,
     OptionalPyblishPluginMixin
 )
-from ayon_core.hosts.aftereffects.api import get_asset_settings
+from ayon_core.hosts.aftereffects.api import get_folder_settings
 
 
 class ValidateSceneSettings(OptionalPyblishPluginMixin,
@@ -48,7 +48,7 @@ class ValidateSceneSettings(OptionalPyblishPluginMixin,
             fps
             handleStart
             handleEnd
-        skip_resolution_check - fill entity type ('asset') to skip validation
+        skip_resolution_check - fill entity type ('folder') to skip validation
             resolutionWidth
             resolutionHeight
             TODO support in extension is missing for now
@@ -71,11 +71,11 @@ class ValidateSceneSettings(OptionalPyblishPluginMixin,
         if not self.is_active(instance.data):
             return
 
-        asset_doc = instance.data["assetEntity"]
-        expected_settings = get_asset_settings(asset_doc)
+        folder_entity = instance.data["folderEntity"]
+        expected_settings = get_folder_settings(folder_entity)
         self.log.info("config from DB::{}".format(expected_settings))
 
-        task_name = instance.data["anatomyData"]["task"]["name"]
+        task_name = instance.data["task"]
         if any(re.search(pattern, task_name)
                 for pattern in self.skip_resolution_check):
             expected_settings.pop("resolutionWidth")

client/ayon_core/hosts/blender/addon.py

@@ -55,8 +55,7 @@ class BlenderAddon(AYONAddon, IHostAddon):
         )
 
         # Define Qt binding if not defined
-        if not env.get("QT_PREFERRED_BINDING"):
-            env["QT_PREFERRED_BINDING"] = "PySide2"
+        env.pop("QT_PREFERRED_BINDING", None)
 
     def get_launch_hook_paths(self, app):
         if app.host_name != self.host_name:

client/ayon_core/hosts/blender/api/ops.py

@@ -16,7 +16,7 @@ import bpy
 import bpy.utils.previews
 
 from ayon_core import style
-from ayon_core.pipeline import get_current_asset_name, get_current_task_name
+from ayon_core.pipeline import get_current_folder_path, get_current_task_name
 from ayon_core.tools.utils import host_tools
 
 from .workio import OpenFileCacher
@@ -191,7 +191,7 @@ def _process_app_events() -> Optional[float]:
 
 
 class LaunchQtApp(bpy.types.Operator):
-    """A Base class for opertors to launch a Qt app."""
+    """A Base class for operators to launch a Qt app."""
 
     _app: QtWidgets.QApplication
     _window = Union[QtWidgets.QDialog, ModuleType]
@@ -355,7 +355,7 @@ class SetFrameRange(bpy.types.Operator):
     bl_label = "Set Frame Range"
 
     def execute(self, context):
-        data = pipeline.get_asset_data()
+        data = pipeline.get_folder_attributes()
         pipeline.set_frame_range(data)
         return {"FINISHED"}
 
@@ -365,7 +365,7 @@ class SetResolution(bpy.types.Operator):
     bl_label = "Set Resolution"
 
     def execute(self, context):
-        data = pipeline.get_asset_data()
+        data = pipeline.get_folder_attributes()
         pipeline.set_resolution(data)
         return {"FINISHED"}
 
@@ -388,9 +388,9 @@ class TOPBAR_MT_avalon(bpy.types.Menu):
         else:
             pyblish_menu_icon_id = 0
 
-        asset = get_current_asset_name()
-        task = get_current_task_name()
-        context_label = f"{asset}, {task}"
+        folder_path = get_current_folder_path()
+        task_name = get_current_task_name()
+        context_label = f"{folder_path}, {task_name}"
         context_label_item = layout.row()
         context_label_item.operator(
             LaunchWorkFiles.bl_idname, text=context_label

client/ayon_core/hosts/blender/api/pipeline.py

@@ -9,6 +9,7 @@ from . import lib
 from . import ops
 
 import pyblish.api
+import ayon_api
 
 from ayon_core.host import (
     HostBase,
@@ -16,11 +17,10 @@ from ayon_core.host import (
     IPublishHost,
     ILoadHost
 )
-from ayon_core.client import get_asset_by_name
 from ayon_core.pipeline import (
     schema,
     get_current_project_name,
-    get_current_asset_name,
+    get_current_folder_path,
     register_loader_plugin_path,
     register_creator_plugin_path,
     deregister_loader_plugin_path,
@@ -221,12 +221,12 @@ def message_window(title, message):
     _process_app_events()
 
 
-def get_asset_data():
+def get_folder_attributes():
     project_name = get_current_project_name()
-    asset_name = get_current_asset_name()
-    asset_doc = get_asset_by_name(project_name, asset_name)
+    folder_path = get_current_folder_path()
+    folder_entity = ayon_api.get_folder_by_path(project_name, folder_path)
 
-    return asset_doc.get("data")
+    return folder_entity["attrib"]
 
 
 def set_frame_range(data):
@@ -279,7 +279,7 @@ def on_new():
     set_resolution_startup = settings.get("set_resolution_startup")
     set_frames_startup = settings.get("set_frames_startup")
 
-    data = get_asset_data()
+    data = get_folder_attributes()
 
     if set_resolution_startup:
         set_resolution(data)
@@ -300,7 +300,7 @@ def on_open():
     set_resolution_startup = settings.get("set_resolution_startup")
     set_frames_startup = settings.get("set_frames_startup")
 
-    data = get_asset_data()
+    data = get_folder_attributes()
 
     if set_resolution_startup:
         set_resolution(data)
@@ -468,7 +468,7 @@ def containerise(name: str,
 
     """
 
-    node_name = f"{context['asset']['name']}_{name}"
+    node_name = f"{context['folder']['name']}_{name}"
     if namespace:
         node_name = f"{namespace}:{node_name}"
     if suffix:
@@ -484,7 +484,7 @@ def containerise(name: str,
         "name": name,
         "namespace": namespace or '',
         "loader": str(loader),
-        "representation": str(context["representation"]["_id"]),
+        "representation": context["representation"]["id"],
     }
 
     metadata_update(container, data)
@@ -523,7 +523,7 @@ def containerise_existing(
         "name": name,
         "namespace": namespace or '',
         "loader": str(loader),
-        "representation": str(context["representation"]["_id"]),
+        "representation": context["representation"]["id"],
     }
 
     metadata_update(container, data)

client/ayon_core/hosts/blender/api/plugin.py

@@ -49,7 +49,7 @@ def prepare_scene_name(
 def get_unique_number(
     folder_name: str, product_name: str
 ) -> str:
-    """Return a unique number based on the asset name."""
+    """Return a unique number based on the folder name."""
     avalon_container = bpy.data.collections.get(AVALON_CONTAINERS)
     if not avalon_container:
         return "01"
@@ -220,9 +220,9 @@ class BaseCreator(Creator):
         Create new instance and store it.
 
         Args:
-            product_name(str): Subset name of created instance.
-            instance_data(dict): Instance base data.
-            pre_create_data(dict): Data based on pre creation attributes.
+            product_name (str): Product name of created instance.
+            instance_data (dict): Instance base data.
+            pre_create_data (dict): Data based on pre creation attributes.
                 Those may affect how creator works.
         """
         # Get Instance Container or create it if it does not exist
@@ -232,9 +232,9 @@ class BaseCreator(Creator):
             bpy.context.scene.collection.children.link(instances)
 
         # Create asset group
-        asset_name = instance_data["folderPath"].split("/")[-1]
+        folder_name = instance_data["folderPath"].split("/")[-1]
 
-        name = prepare_scene_name(asset_name, product_name)
+        name = prepare_scene_name(folder_name, product_name)
         if self.create_as_asset_group:
             # Create instance as empty
             instance_node = bpy.data.objects.new(name=name, object_data=None)
@@ -312,9 +312,9 @@ class BaseCreator(Creator):
                 "productName" in changes.changed_keys
                 or "folderPath" in changes.changed_keys
             ) and created_instance.product_type != "workfile":
-                asset_name = data["folderPath"].split("/")[-1]
+                folder_name = data["folderPath"].split("/")[-1]
                 name = prepare_scene_name(
-                    asset_name, data["productName"]
+                    folder_name, data["productName"]
                 )
                 node.name = name
 
@@ -346,7 +346,7 @@ class BaseCreator(Creator):
         """Fill instance data with required items.
 
         Args:
-            product_name(str): Subset name of created instance.
+            product_name(str): Product name of created instance.
             instance_data(dict): Instance base data.
             instance_node(bpy.types.ID): Instance node in blender scene.
         """
@@ -465,8 +465,8 @@ class AssetLoader(LoaderPlugin):
         filepath = self.filepath_from_context(context)
         assert Path(filepath).exists(), f"{filepath} doesn't exist."
 
-        folder_name = context["asset"]["name"]
-        product_name = context["subset"]["name"]
+        folder_name = context["folder"]["name"]
+        product_name = context["product"]["name"]
         unique_number = get_unique_number(
             folder_name, product_name
         )
@@ -498,21 +498,21 @@ class AssetLoader(LoaderPlugin):
         #         loader=self.__class__.__name__,
         #     )
 
-        # folder_name = context["asset"]["name"]
-        # product_name = context["subset"]["name"]
+        # folder_name = context["folder"]["name"]
+        # product_name = context["product"]["name"]
         # instance_name = prepare_scene_name(
         #     folder_name, product_name, unique_number
         # ) + '_CON'
 
         # return self._get_instance_collection(instance_name, nodes)
 
-    def exec_update(self, container: Dict, representation: Dict):
+    def exec_update(self, container: Dict, context: Dict):
         """Must be implemented by a sub-class"""
         raise NotImplementedError("Must be implemented by a sub-class")
 
-    def update(self, container: Dict, representation: Dict):
+    def update(self, container: Dict, context: Dict):
         """ Run the update on Blender main thread"""
-        mti = MainThreadItem(self.exec_update, container, representation)
+        mti = MainThreadItem(self.exec_update, container, context)
         execute_in_main_thread(mti)
 
     def exec_remove(self, container: Dict) -> bool:

client/ayon_core/hosts/blender/hooks/pre_add_run_python_script_arg.py

@@ -1,6 +1,6 @@
 from pathlib import Path
 
-from ayon_core.lib.applications import PreLaunchHook, LaunchTypes
+from ayon_applications import PreLaunchHook, LaunchTypes
 
 
 class AddPythonScriptToLaunchArgs(PreLaunchHook):

client/ayon_core/hosts/blender/hooks/pre_pyside_install.py

@@ -2,7 +2,7 @@ import os
 import re
 import subprocess
 from platform import system
-from ayon_core.lib.applications import PreLaunchHook, LaunchTypes
+from ayon_applications import PreLaunchHook, LaunchTypes
 
 
 class InstallPySideToBlender(PreLaunchHook):
@@ -31,7 +31,7 @@ class InstallPySideToBlender(PreLaunchHook):
 
     def inner_execute(self):
         # Get blender's python directory
-        version_regex = re.compile(r"^[2-4]\.[0-9]+$")
+        version_regex = re.compile(r"^([2-4])\.[0-9]+$")
 
         platform = system().lower()
         executable = self.launch_context.executable.executable_path
@@ -42,7 +42,8 @@ class InstallPySideToBlender(PreLaunchHook):
         if os.path.basename(executable).lower() != expected_executable:
             self.log.info((
                 f"Executable does not lead to {expected_executable} file."
-                "Can't determine blender's python to check/install PySide2."
+                "Can't determine blender's python to check/install"
+                " Qt binding."
             ))
             return
 
@@ -73,6 +74,15 @@ class InstallPySideToBlender(PreLaunchHook):
             return
 
         version_subfolder = version_subfolders[0]
+        before_blender_4 = False
+        if int(version_regex.match(version_subfolder).group(1)) < 4:
+            before_blender_4 = True
+        # Blender 4 has Python 3.11 which does not support 'PySide2'
+        # QUESTION could we always install PySide6?
+        qt_binding = "PySide2" if before_blender_4 else "PySide6"
+        # Use PySide6 6.6.3 because 6.7.0 had a bug
+        #   - 'QTextEdit' can't be added to 'QBoxLayout'
+        qt_binding_version = None if before_blender_4 else "6.6.3"
 
         python_dir = os.path.join(versions_dir, version_subfolder, "python")
         python_lib = os.path.join(python_dir, "lib")
@@ -116,22 +126,41 @@ class InstallPySideToBlender(PreLaunchHook):
             return
 
         # Check if PySide2 is installed and skip if yes
-        if self.is_pyside_installed(python_executable):
+        if self.is_pyside_installed(python_executable, qt_binding):
             self.log.debug("Blender has already installed PySide2.")
             return
 
         # Install PySide2 in blender's python
         if platform == "windows":
-            result = self.install_pyside_windows(python_executable)
+            result = self.install_pyside_windows(
+                python_executable,
+                qt_binding,
+                qt_binding_version,
+                before_blender_4,
+            )
         else:
-            result = self.install_pyside(python_executable)
+            result = self.install_pyside(
+                python_executable,
+                qt_binding,
+                qt_binding_version,
+            )
 
         if result:
-            self.log.info("Successfully installed PySide2 module to blender.")
+            self.log.info(
+                f"Successfully installed {qt_binding} module to blender."
+            )
         else:
-            self.log.warning("Failed to install PySide2 module to blender.")
+            self.log.warning(
+                f"Failed to install {qt_binding} module to blender."
+            )
 
-    def install_pyside_windows(self, python_executable):
+    def install_pyside_windows(
+        self,
+        python_executable,
+        qt_binding,
+        qt_binding_version,
+        before_blender_4,
+    ):
         """Install PySide2 python module to blender's python.
 
         Installation requires administration rights that's why it is required
@@ -139,7 +168,6 @@ class InstallPySideToBlender(PreLaunchHook):
         administration rights.
         """
         try:
-            import win32api
             import win32con
             import win32process
             import win32event
@@ -150,12 +178,37 @@ class InstallPySideToBlender(PreLaunchHook):
             self.log.warning("Couldn't import \"pywin32\" modules")
             return
 
+        if qt_binding_version:
+            qt_binding = f"{qt_binding}=={qt_binding_version}"
+
         try:
             # Parameters
             # - use "-m pip" as module pip to install PySide2 and argument
             #   "--ignore-installed" is to force install module to blender's
             #   site-packages and make sure it is binary compatible
-            parameters = "-m pip install --ignore-installed PySide2"
+            fake_exe = "fake.exe"
+            site_packages_prefix = os.path.dirname(
+                os.path.dirname(python_executable)
+            )
+            args = [
+                fake_exe,
+                "-m",
+                "pip",
+                "install",
+                "--ignore-installed",
+                qt_binding,
+            ]
+            if not before_blender_4:
+                # Define prefix for site package
+                # Python in blender 4.x is installing packages in AppData and
+                #   not in blender's directory.
+                args.extend(["--prefix", site_packages_prefix])
+
+            parameters = (
+                subprocess.list2cmdline(args)
+                .lstrip(fake_exe)
+                .lstrip(" ")
+            )
 
             # Execute command and ask for administrator's rights
             process_info = ShellExecuteEx(
@@ -173,20 +226,29 @@ class InstallPySideToBlender(PreLaunchHook):
         except pywintypes.error:
             pass
 
-    def install_pyside(self, python_executable):
-        """Install PySide2 python module to blender's python."""
+    def install_pyside(
+        self,
+        python_executable,
+        qt_binding,
+        qt_binding_version,
+    ):
+        """Install Qt binding python module to blender's python."""
+        if qt_binding_version:
+            qt_binding = f"{qt_binding}=={qt_binding_version}"
         try:
             # Parameters
-            # - use "-m pip" as module pip to install PySide2 and argument
+            # - use "-m pip" as module pip to install qt binding and argument
             #   "--ignore-installed" is to force install module to blender's
             #   site-packages and make sure it is binary compatible
+            # TODO find out if blender 4.x on linux/darwin does install
+            #   qt binding to correct place.
             args = [
                 python_executable,
                 "-m",
                 "pip",
                 "install",
                 "--ignore-installed",
-                "PySide2",
+                qt_binding,
             ]
             process = subprocess.Popen(
                 args, stdout=subprocess.PIPE, universal_newlines=True
@@ -203,13 +265,15 @@ class InstallPySideToBlender(PreLaunchHook):
         except subprocess.SubprocessError:
             pass
 
-    def is_pyside_installed(self, python_executable):
+    def is_pyside_installed(self, python_executable, qt_binding):
         """Check if PySide2 module is in blender's pip list.
 
         Check that PySide2 is installed directly in blender's site-packages.
         It is possible that it is installed in user's site-packages but that
         may be incompatible with blender's python.
         """
+
+        qt_binding_low = qt_binding.lower()
         # Get pip list from blender's python executable
         args = [python_executable, "-m", "pip", "list"]
         process = subprocess.Popen(args, stdout=subprocess.PIPE)
@@ -226,6 +290,6 @@ class InstallPySideToBlender(PreLaunchHook):
             if not line:
                 continue
             package_name = line[0:package_len].strip()
-            if package_name.lower() == "pyside2":
+            if package_name.lower() == qt_binding_low:
                 return True
         return False

client/ayon_core/hosts/blender/hooks/pre_windows_console.py

@@ -1,5 +1,5 @@
 import subprocess
-from ayon_core.lib.applications import PreLaunchHook, LaunchTypes
+from ayon_applications import PreLaunchHook, LaunchTypes
 
 
 class BlenderConsoleWindows(PreLaunchHook):

client/ayon_core/hosts/blender/plugins/create/convert_legacy.py

@@ -1,10 +1,10 @@
 # -*- coding: utf-8 -*-
 """Converter for legacy Houdini products."""
-from ayon_core.pipeline.create.creator_plugins import SubsetConvertorPlugin
+from ayon_core.pipeline.create.creator_plugins import ProductConvertorPlugin
 from ayon_core.hosts.blender.api.lib import imprint
 
 
-class BlenderLegacyConvertor(SubsetConvertorPlugin):
+class BlenderLegacyConvertor(ProductConvertorPlugin):
     """Find and convert any legacy products in the scene.
 
     This Converter will find all legacy products in the scene and will

client/ayon_core/hosts/blender/plugins/create/create_workfile.py

@@ -1,7 +1,7 @@
 import bpy
+import ayon_api
 
 from ayon_core.pipeline import CreatedInstance, AutoCreator
-from ayon_core.client import get_asset_by_name
 from ayon_core.hosts.blender.api.plugin import BaseCreator
 from ayon_core.hosts.blender.api.pipeline import (
     AVALON_PROPERTY,
@@ -33,33 +33,38 @@ class CreateWorkfile(BaseCreator, AutoCreator):
         )
 
         project_name = self.project_name
-        asset_name = self.create_context.get_current_asset_name()
+        folder_path = self.create_context.get_current_folder_path()
         task_name = self.create_context.get_current_task_name()
         host_name = self.create_context.host_name
 
-        existing_asset_name = None
+        existing_folder_path = None
         if workfile_instance is not None:
-            existing_asset_name = workfile_instance.get("folderPath")
+            existing_folder_path = workfile_instance.get("folderPath")
 
         if not workfile_instance:
-            asset_doc = get_asset_by_name(project_name, asset_name)
+            folder_entity = ayon_api.get_folder_by_path(
+                project_name, folder_path
+            )
+            task_entity = ayon_api.get_task_by_name(
+                project_name, folder_entity["id"], task_name
+            )
             product_name = self.get_product_name(
                 project_name,
-                asset_doc,
-                task_name,
+                folder_entity,
+                task_entity,
                 task_name,
                 host_name,
             )
             data = {
-                "folderPath": asset_name,
+                "folderPath": folder_path,
                 "task": task_name,
                 "variant": task_name,
             }
             data.update(
                 self.get_dynamic_data(
                     project_name,
-                    asset_doc,
-                    task_name,
+                    folder_entity,
+                    task_entity,
                     task_name,
                     host_name,
                     workfile_instance,
@@ -72,20 +77,25 @@ class CreateWorkfile(BaseCreator, AutoCreator):
             self._add_instance_to_context(workfile_instance)
 
         elif (
-            existing_asset_name != asset_name
+            existing_folder_path != folder_path
             or workfile_instance["task"] != task_name
         ):
             # Update instance context if it's different
-            asset_doc = get_asset_by_name(project_name, asset_name)
+            folder_entity = ayon_api.get_folder_by_path(
+                project_name, folder_path
+            )
+            task_entity = ayon_api.get_task_by_name(
+                project_name, folder_entity["id"], task_name
+            )
             product_name = self.get_product_name(
                 project_name,
-                asset_doc,
-                task_name,
+                folder_entity,
+                task_entity,
                 self.default_variant,
                 host_name,
             )
 
-            workfile_instance["folderPath"] = asset_name
+            workfile_instance["folderPath"] = folder_path
             workfile_instance["task"] = task_name
             workfile_instance["productName"] = product_name
 

client/ayon_core/hosts/blender/plugins/load/import_workfile.py

@@ -4,8 +4,8 @@ from ayon_core.hosts.blender.api import plugin
 
 
 def append_workfile(context, fname, do_import):
-    folder_name = context['asset']['name']
-    product_name = context['subset']['name']
+    folder_name = context["folder"]["name"]
+    product_name = context["product"]["name"]
 
     group_name = plugin.prepare_scene_name(folder_name, product_name)
 
@@ -43,8 +43,8 @@ class AppendBlendLoader(plugin.AssetLoader):
         so you could also use it as a new base.
     """
 
-    representations = ["blend"]
-    families = ["workfile"]
+    representations = {"blend"}
+    product_types = {"workfile"}
 
     label = "Append Workfile"
     order = 9
@@ -68,8 +68,8 @@ class ImportBlendLoader(plugin.AssetLoader):
         so you could also use it as a new base.
     """
 
-    representations = ["blend"]
-    families = ["workfile"]
+    representations = {"blend"}
+    product_types = {"workfile"}
 
     label = "Import Workfile"
     order = 9

client/ayon_core/hosts/blender/plugins/load/load_abc.py

@@ -26,8 +26,8 @@ class CacheModelLoader(plugin.AssetLoader):
     Note:
         At least for now it only supports Alembic files.
     """
-    families = ["model", "pointcache", "animation"]
-    representations = ["abc"]
+    product_types = {"model", "pointcache", "animation"}
+    representations = {"abc"}
 
     label = "Load Alembic"
     icon = "code-fork"
@@ -134,8 +134,8 @@ class CacheModelLoader(plugin.AssetLoader):
         """
 
         libpath = self.filepath_from_context(context)
-        folder_name = context["asset"]["name"]
-        product_name = context["subset"]["name"]
+        folder_name = context["folder"]["name"]
+        product_name = context["product"]["name"]
 
         asset_name = plugin.prepare_scene_name(folder_name, product_name)
         unique_number = plugin.get_unique_number(folder_name, product_name)
@@ -161,17 +161,17 @@ class CacheModelLoader(plugin.AssetLoader):
 
         self._link_objects(objects, asset_group, containers, asset_group)
 
-        product_type = context["subset"]["data"]["family"]
+        product_type = context["product"]["productType"]
         asset_group[AVALON_PROPERTY] = {
             "schema": "openpype:container-2.0",
             "id": AVALON_CONTAINER_ID,
             "name": name,
             "namespace": namespace or '',
             "loader": str(self.__class__.__name__),
-            "representation": str(context["representation"]["_id"]),
+            "representation": context["representation"]["id"],
             "libpath": libpath,
             "asset_name": asset_name,
-            "parent": str(context["representation"]["parent"]),
+            "parent": context["representation"]["versionId"],
             "productType": product_type,
             "objectName": group_name
         }
@@ -179,7 +179,7 @@ class CacheModelLoader(plugin.AssetLoader):
         self[:] = objects
         return objects
 
-    def exec_update(self, container: Dict, representation: Dict):
+    def exec_update(self, container: Dict, context: Dict):
         """Update the loaded asset.
 
         This will remove all objects of the current collection, load the new
@@ -191,15 +191,16 @@ class CacheModelLoader(plugin.AssetLoader):
         Warning:
             No nested collections are supported at the moment!
         """
+        repre_entity = context["representation"]
         object_name = container["objectName"]
         asset_group = bpy.data.objects.get(object_name)
-        libpath = Path(get_representation_path(representation))
+        libpath = Path(get_representation_path(repre_entity))
         extension = libpath.suffix.lower()
 
         self.log.info(
             "Container: %s\nRepresentation: %s",
             pformat(container, indent=2),
-            pformat(representation, indent=2),
+            pformat(repre_entity, indent=2),
         )
 
         assert asset_group, (
@@ -244,7 +245,7 @@ class CacheModelLoader(plugin.AssetLoader):
         asset_group.matrix_basis = mat
 
         metadata["libpath"] = str(libpath)
-        metadata["representation"] = str(representation["_id"])
+        metadata["representation"] = repre_entity["id"]
 
     def exec_remove(self, container: Dict) -> bool:
         """Remove an existing container from a Blender scene.

client/ayon_core/hosts/blender/plugins/load/load_action.py

@@ -24,8 +24,8 @@ class BlendActionLoader(plugin.AssetLoader):
         moment.
     """
 
-    families = ["action"]
-    representations = ["blend"]
+    product_types = {"action"}
+    representations = {"blend"}
 
     label = "Link Action"
     icon = "code-fork"
@@ -44,8 +44,8 @@ class BlendActionLoader(plugin.AssetLoader):
         """
 
         libpath = self.filepath_from_context(context)
-        folder_name = context["asset"]["name"]
-        product_name = context["subset"]["name"]
+        folder_name = context["folder"]["name"]
+        product_name = context["product"]["name"]
         lib_container = plugin.prepare_scene_name(folder_name, product_name)
         container_name = plugin.prepare_scene_name(
             folder_name, product_name, namespace
@@ -114,7 +114,7 @@ class BlendActionLoader(plugin.AssetLoader):
         self[:] = nodes
         return nodes
 
-    def update(self, container: Dict, representation: Dict):
+    def update(self, container: Dict, context: Dict):
         """Update the loaded asset.
 
         This will remove all objects of the current collection, load the new
@@ -126,18 +126,18 @@ class BlendActionLoader(plugin.AssetLoader):
         Warning:
             No nested collections are supported at the moment!
         """
-
+        repre_entity = context["representation"]
         collection = bpy.data.collections.get(
             container["objectName"]
         )
 
-        libpath = Path(get_representation_path(representation))
+        libpath = Path(get_representation_path(repre_entity))
         extension = libpath.suffix.lower()
 
         logger.info(
             "Container: %s\nRepresentation: %s",
             pformat(container, indent=2),
-            pformat(representation, indent=2),
+            pformat(repre_entity, indent=2),
         )
 
         assert collection, (
@@ -241,7 +241,7 @@ class BlendActionLoader(plugin.AssetLoader):
         # Save the list of objects in the metadata container
         collection_metadata["objects"] = objects_list
         collection_metadata["libpath"] = str(libpath)
-        collection_metadata["representation"] = str(representation["_id"])
+        collection_metadata["representation"] = repre_entity["id"]
 
         bpy.ops.object.select_all(action='DESELECT')
 

client/ayon_core/hosts/blender/plugins/load/load_animation.py

@@ -16,8 +16,8 @@ class BlendAnimationLoader(plugin.AssetLoader):
         moment.
     """
 
-    families = ["animation"]
-    representations = ["blend"]
+    product_types = {"animation"}
+    representations = {"blend"}
 
     label = "Link Animation"
     icon = "code-fork"

client/ayon_core/hosts/blender/plugins/load/load_audio.py

@@ -20,8 +20,8 @@ from ayon_core.hosts.blender.api.pipeline import (
 class AudioLoader(plugin.AssetLoader):
     """Load audio in Blender."""
 
-    families = ["audio"]
-    representations = ["wav"]
+    product_types = {"audio"}
+    representations = {"wav"}
 
     label = "Load Audio"
     icon = "volume-up"
@@ -39,8 +39,8 @@ class AudioLoader(plugin.AssetLoader):
             options: Additional settings dictionary
         """
         libpath = self.filepath_from_context(context)
-        folder_name = context["asset"]["name"]
-        product_name = context["subset"]["name"]
+        folder_name = context["folder"]["name"]
+        product_name = context["product"]["name"]
 
         asset_name = plugin.prepare_scene_name(folder_name, product_name)
         unique_number = plugin.get_unique_number(folder_name, product_name)
@@ -83,11 +83,11 @@ class AudioLoader(plugin.AssetLoader):
             "name": name,
             "namespace": namespace or '',
             "loader": str(self.__class__.__name__),
-            "representation": str(context["representation"]["_id"]),
+            "representation": context["representation"]["id"],
             "libpath": libpath,
             "asset_name": asset_name,
-            "parent": str(context["representation"]["parent"]),
-            "productType": context["subset"]["data"]["family"],
+            "parent": context["representation"]["versionId"],
+            "productType": context["product"]["productType"],
             "objectName": group_name,
             "audio": audio
         }
@@ -96,7 +96,7 @@ class AudioLoader(plugin.AssetLoader):
         self[:] = objects
         return [objects]
 
-    def exec_update(self, container: Dict, representation: Dict):
+    def exec_update(self, container: Dict, context: Dict):
         """Update an audio strip in the sequence editor.
 
         Arguments:
@@ -105,14 +105,15 @@ class AudioLoader(plugin.AssetLoader):
             representation (openpype:representation-1.0): Representation to
                 update, from `host.ls()`.
         """
+        repre_entity = context["representation"]
         object_name = container["objectName"]
         asset_group = bpy.data.objects.get(object_name)
-        libpath = Path(get_representation_path(representation))
+        libpath = Path(get_representation_path(repre_entity))
 
         self.log.info(
             "Container: %s\nRepresentation: %s",
             pformat(container, indent=2),
-            pformat(representation, indent=2),
+            pformat(repre_entity, indent=2),
         )
 
         assert asset_group, (
@@ -175,8 +176,8 @@ class AudioLoader(plugin.AssetLoader):
         window_manager.windows[-1].screen.areas[0].type = old_type
 
         metadata["libpath"] = str(libpath)
-        metadata["representation"] = str(representation["_id"])
-        metadata["parent"] = str(representation["parent"])
+        metadata["representation"] = repre_entity["id"]
+        metadata["parent"] = repre_entity["versionId"]
         metadata["audio"] = new_audio
 
     def exec_remove(self, container: Dict) -> bool:

client/ayon_core/hosts/blender/plugins/load/load_blend.py

@@ -20,8 +20,8 @@ from ayon_core.hosts.blender.api.pipeline import (
 class BlendLoader(plugin.AssetLoader):
     """Load assets from a .blend file."""
 
-    families = ["model", "rig", "layout", "camera"]
-    representations = ["blend"]
+    product_types = {"model", "rig", "layout", "camera"}
+    representations = {"blend"}
 
     label = "Append Blend"
     icon = "code-fork"
@@ -127,15 +127,15 @@ class BlendLoader(plugin.AssetLoader):
             options: Additional settings dictionary
         """
         libpath = self.filepath_from_context(context)
-        folder_name = context["asset"]["name"]
-        product_name = context["subset"]["name"]
+        folder_name = context["folder"]["name"]
+        product_name = context["product"]["name"]
 
         try:
-            product_type = context["subset"]["data"]["family"]
+            product_type = context["product"]["productType"]
         except ValueError:
             product_type = "model"
 
-        representation = str(context["representation"]["_id"])
+        representation = context["representation"]["id"]
 
         asset_name = plugin.prepare_scene_name(folder_name, product_name)
         unique_number = plugin.get_unique_number(folder_name, product_name)
@@ -162,11 +162,11 @@ class BlendLoader(plugin.AssetLoader):
             "name": name,
             "namespace": namespace or '',
             "loader": str(self.__class__.__name__),
-            "representation": str(context["representation"]["_id"]),
+            "representation": context["representation"]["id"],
             "libpath": libpath,
             "asset_name": asset_name,
-            "parent": str(context["representation"]["parent"]),
-            "productType": context["subset"]["data"]["family"],
+            "parent": context["representation"]["versionId"],
+            "productType": context["product"]["productType"],
             "objectName": group_name,
             "members": members,
         }
@@ -181,13 +181,14 @@ class BlendLoader(plugin.AssetLoader):
         self[:] = objects
         return objects
 
-    def exec_update(self, container: Dict, representation: Dict):
+    def exec_update(self, container: Dict, context: Dict):
         """
         Update the loaded asset.
         """
+        repre_entity = context["representation"]
         group_name = container["objectName"]
         asset_group = bpy.data.objects.get(group_name)
-        libpath = Path(get_representation_path(representation)).as_posix()
+        libpath = Path(get_representation_path(repre_entity)).as_posix()
 
         assert asset_group, (
             f"The asset is not loaded: {container['objectName']}"
@@ -226,7 +227,7 @@ class BlendLoader(plugin.AssetLoader):
                     obj.animation_data_create()
                 obj.animation_data.action = actions[obj.name]
 
-        # Restore the old data, but reset memebers, as they don't exist anymore
+        # Restore the old data, but reset members, as they don't exist anymore
         # This avoids a crash, because the memory addresses of those members
         # are not valid anymore
         old_data["members"] = []
@@ -234,8 +235,8 @@ class BlendLoader(plugin.AssetLoader):
 
         new_data = {
             "libpath": libpath,
-            "representation": str(representation["_id"]),
-            "parent": str(representation["parent"]),
+            "representation": repre_entity["id"],
+            "parent": repre_entity["versionId"],
             "members": members,
         }
 

client/ayon_core/hosts/blender/plugins/load/load_blendscene.py

@@ -18,8 +18,8 @@ from ayon_core.hosts.blender.api.pipeline import (
 class BlendSceneLoader(plugin.AssetLoader):
     """Load assets from a .blend file."""
 
-    families = ["blendScene"]
-    representations = ["blend"]
+    product_types = {"blendScene"}
+    representations = {"blend"}
 
     label = "Append Blend"
     icon = "code-fork"
@@ -82,11 +82,11 @@ class BlendSceneLoader(plugin.AssetLoader):
             options: Additional settings dictionary
         """
         libpath = self.filepath_from_context(context)
-        folder_name = context["asset"]["name"]
-        product_name = context["subset"]["name"]
+        folder_name = context["folder"]["name"]
+        product_name = context["product"]["name"]
 
         try:
-            product_type = context["subset"]["data"]["family"]
+            product_type = context["product"]["productType"]
         except ValueError:
             product_type = "model"
 
@@ -114,11 +114,11 @@ class BlendSceneLoader(plugin.AssetLoader):
             "name": name,
             "namespace": namespace or '',
             "loader": str(self.__class__.__name__),
-            "representation": str(context["representation"]["_id"]),
+            "representation": context["representation"]["id"],
             "libpath": libpath,
             "asset_name": asset_name,
-            "parent": str(context["representation"]["parent"]),
-            "productType": context["subset"]["data"]["family"],
+            "parent": context["representation"]["versionId"],
+            "productType": context["product"]["productType"],
             "objectName": group_name,
             "members": members,
         }
@@ -133,13 +133,14 @@ class BlendSceneLoader(plugin.AssetLoader):
         self[:] = objects
         return objects
 
-    def exec_update(self, container: Dict, representation: Dict):
+    def exec_update(self, container: Dict, context: Dict):
         """
         Update the loaded asset.
         """
+        repre_entity = context["representation"]
         group_name = container["objectName"]
         asset_group = bpy.data.collections.get(group_name)
-        libpath = Path(get_representation_path(representation)).as_posix()
+        libpath = Path(get_representation_path(repre_entity)).as_posix()
 
         assert asset_group, (
             f"The asset is not loaded: {container['objectName']}"
@@ -201,8 +202,8 @@ class BlendSceneLoader(plugin.AssetLoader):
 
         new_data = {
             "libpath": libpath,
-            "representation": str(representation["_id"]),
-            "parent": str(representation["parent"]),
+            "representation": repre_entity["id"],
+            "parent": repre_entity["versionId"],
             "members": members,
         }
 

client/ayon_core/hosts/blender/plugins/load/load_camera_abc.py

@@ -23,8 +23,8 @@ class AbcCameraLoader(plugin.AssetLoader):
     Stores the imported asset in an empty named after the asset.
     """
 
-    families = ["camera"]
-    representations = ["abc"]
+    product_types = {"camera"}
+    representations = {"abc"}
 
     label = "Load Camera (ABC)"
     icon = "code-fork"
@@ -84,8 +84,8 @@ class AbcCameraLoader(plugin.AssetLoader):
 
         libpath = self.filepath_from_context(context)
 
-        folder_name = context["asset"]["name"]
-        product_name = context["subset"]["name"]
+        folder_name = context["folder"]["name"]
+        product_name = context["product"]["name"]
 
         asset_name = plugin.prepare_scene_name(folder_name, product_name)
         unique_number = plugin.get_unique_number(folder_name, product_name)
@@ -119,18 +119,18 @@ class AbcCameraLoader(plugin.AssetLoader):
             "name": name,
             "namespace": namespace or "",
             "loader": str(self.__class__.__name__),
-            "representation": str(context["representation"]["_id"]),
+            "representation": context["representation"]["id"],
             "libpath": libpath,
             "asset_name": asset_name,
-            "parent": str(context["representation"]["parent"]),
-            "productType": context["subset"]["data"]["family"],
+            "parent": context["representation"]["versionId"],
+            "productType": context["product"]["productType"],
             "objectName": group_name,
         }
 
         self[:] = objects
         return objects
 
-    def exec_update(self, container: Dict, representation: Dict):
+    def exec_update(self, container: Dict, context: Dict):
         """Update the loaded asset.
 
         This will remove all objects of the current collection, load the new
@@ -142,15 +142,16 @@ class AbcCameraLoader(plugin.AssetLoader):
         Warning:
             No nested collections are supported at the moment!
         """
+        repre_entity = context["representation"]
         object_name = container["objectName"]
         asset_group = bpy.data.objects.get(object_name)
-        libpath = Path(get_representation_path(representation))
+        libpath = Path(get_representation_path(repre_entity))
         extension = libpath.suffix.lower()
 
         self.log.info(
             "Container: %s\nRepresentation: %s",
             pformat(container, indent=2),
-            pformat(representation, indent=2),
+            pformat(repre_entity, indent=2),
         )
 
         assert asset_group, (
@@ -185,7 +186,7 @@ class AbcCameraLoader(plugin.AssetLoader):
         asset_group.matrix_basis = mat
 
         metadata["libpath"] = str(libpath)
-        metadata["representation"] = str(representation["_id"])
+        metadata["representation"] = repre_entity["id"]
 
     def exec_remove(self, container: Dict) -> bool:
         """Remove an existing container from a Blender scene.

client/ayon_core/hosts/blender/plugins/load/load_camera_fbx.py

@@ -23,8 +23,8 @@ class FbxCameraLoader(plugin.AssetLoader):
     Stores the imported asset in an empty named after the asset.
     """
 
-    families = ["camera"]
-    representations = ["fbx"]
+    product_types = {"camera"}
+    representations = {"fbx"}
 
     label = "Load Camera (FBX)"
     icon = "code-fork"
@@ -87,8 +87,8 @@ class FbxCameraLoader(plugin.AssetLoader):
             options: Additional settings dictionary
         """
         libpath = self.filepath_from_context(context)
-        folder_name = context["asset"]["name"]
-        product_name = context["subset"]["name"]
+        folder_name = context["folder"]["name"]
+        product_name = context["product"]["name"]
 
         asset_name = plugin.prepare_scene_name(folder_name, product_name)
         unique_number = plugin.get_unique_number(folder_name, product_name)
@@ -122,18 +122,18 @@ class FbxCameraLoader(plugin.AssetLoader):
             "name": name,
             "namespace": namespace or '',
             "loader": str(self.__class__.__name__),
-            "representation": str(context["representation"]["_id"]),
+            "representation": context["representation"]["id"],
             "libpath": libpath,
             "asset_name": asset_name,
-            "parent": str(context["representation"]["parent"]),
-            "productType": context["subset"]["data"]["family"],
+            "parent": context["representation"]["versionId"],
+            "productType": context["product"]["productType"],
             "objectName": group_name
         }
 
         self[:] = objects
         return objects
 
-    def exec_update(self, container: Dict, representation: Dict):
+    def exec_update(self, container: Dict, context: Dict):
         """Update the loaded asset.
 
         This will remove all objects of the current collection, load the new
@@ -145,15 +145,16 @@ class FbxCameraLoader(plugin.AssetLoader):
         Warning:
             No nested collections are supported at the moment!
         """
+        repre_entity = context["representation"]
         object_name = container["objectName"]
         asset_group = bpy.data.objects.get(object_name)
-        libpath = Path(get_representation_path(representation))
+        libpath = Path(get_representation_path(repre_entity))
         extension = libpath.suffix.lower()
 
         self.log.info(
             "Container: %s\nRepresentation: %s",
             pformat(container, indent=2),
-            pformat(representation, indent=2),
+            pformat(repre_entity, indent=2),
         )
 
         assert asset_group, (
@@ -195,7 +196,7 @@ class FbxCameraLoader(plugin.AssetLoader):
         asset_group.matrix_basis = mat
 
         metadata["libpath"] = str(libpath)
-        metadata["representation"] = str(representation["_id"])
+        metadata["representation"] = repre_entity["id"]
 
     def exec_remove(self, container: Dict) -> bool:
         """Remove an existing container from a Blender scene.

client/ayon_core/hosts/blender/plugins/load/load_fbx.py

@@ -23,8 +23,8 @@ class FbxModelLoader(plugin.AssetLoader):
     Stores the imported asset in an empty named after the asset.
     """
 
-    families = ["model", "rig"]
-    representations = ["fbx"]
+    product_types = {"model", "rig"}
+    representations = {"fbx"}
 
     label = "Load FBX"
     icon = "code-fork"
@@ -131,8 +131,8 @@ class FbxModelLoader(plugin.AssetLoader):
             options: Additional settings dictionary
         """
         libpath = self.filepath_from_context(context)
-        folder_name = context["asset"]["name"]
-        product_name = context["subset"]["name"]
+        folder_name = context["folder"]["name"]
+        product_name = context["product"]["name"]
 
         asset_name = plugin.prepare_scene_name(folder_name, product_name)
         unique_number = plugin.get_unique_number(folder_name, product_name)
@@ -166,18 +166,18 @@ class FbxModelLoader(plugin.AssetLoader):
             "name": name,
             "namespace": namespace or '',
             "loader": str(self.__class__.__name__),
-            "representation": str(context["representation"]["_id"]),
+            "representation": context["representation"]["id"],
             "libpath": libpath,
             "asset_name": asset_name,
-            "parent": str(context["representation"]["parent"]),
-            "productType": context["subset"]["data"]["family"],
+            "parent": context["representation"]["versionId"],
+            "productType": context["product"]["productType"],
             "objectName": group_name
         }
 
         self[:] = objects
         return objects
 
-    def exec_update(self, container: Dict, representation: Dict):
+    def exec_update(self, container: Dict, context: Dict):
         """Update the loaded asset.
 
         This will remove all objects of the current collection, load the new
@@ -189,15 +189,16 @@ class FbxModelLoader(plugin.AssetLoader):
         Warning:
             No nested collections are supported at the moment!
         """
+        repre_entity = context["representation"]
         object_name = container["objectName"]
         asset_group = bpy.data.objects.get(object_name)
-        libpath = Path(get_representation_path(representation))
+        libpath = Path(get_representation_path(repre_entity))
         extension = libpath.suffix.lower()
 
         self.log.info(
             "Container: %s\nRepresentation: %s",
             pformat(container, indent=2),
-            pformat(representation, indent=2),
+            pformat(repre_entity, indent=2),
         )
 
         assert asset_group, (
@@ -250,7 +251,7 @@ class FbxModelLoader(plugin.AssetLoader):
         asset_group.matrix_basis = mat
 
         metadata["libpath"] = str(libpath)
-        metadata["representation"] = str(representation["_id"])
+        metadata["representation"] = repre_entity["id"]
 
     def exec_remove(self, container: Dict) -> bool:
         """Remove an existing container from a Blender scene.

client/ayon_core/hosts/blender/plugins/load/load_layout_json.py

@@ -26,8 +26,8 @@ from ayon_core.hosts.blender.api import plugin
 class JsonLayoutLoader(plugin.AssetLoader):
     """Load layout published from Unreal."""
 
-    families = ["layout"]
-    representations = ["json"]
+    product_types = {"layout"}
+    representations = {"json"}
 
     label = "Load Layout"
     icon = "code-fork"
@@ -132,7 +132,7 @@ class JsonLayoutLoader(plugin.AssetLoader):
         #     # name=f"{unique_number}_{product[name]}_animation",
         #     asset=asset,
         #     options={"useSelection": False}
-        #     # data={"dependencies": str(context["representation"]["_id"])}
+        #     # data={"dependencies": context["representation"]["id"]}
         # )
 
     def process_asset(self,
@@ -148,8 +148,8 @@ class JsonLayoutLoader(plugin.AssetLoader):
             options: Additional settings dictionary
         """
         libpath = self.filepath_from_context(context)
-        folder_name = context["asset"]["name"]
-        product_name = context["subset"]["name"]
+        folder_name = context["folder"]["name"]
+        product_name = context["product"]["name"]
 
         asset_name = plugin.prepare_scene_name(folder_name, product_name)
         unique_number = plugin.get_unique_number(folder_name, product_name)
@@ -167,7 +167,7 @@ class JsonLayoutLoader(plugin.AssetLoader):
         asset_group.empty_display_type = 'SINGLE_ARROW'
         avalon_container.objects.link(asset_group)
 
-        self._process(libpath, asset, asset_group, None)
+        self._process(libpath, asset_name, asset_group, None)
 
         bpy.context.scene.collection.objects.link(asset_group)
 
@@ -177,18 +177,18 @@ class JsonLayoutLoader(plugin.AssetLoader):
             "name": name,
             "namespace": namespace or '',
             "loader": str(self.__class__.__name__),
-            "representation": str(context["representation"]["_id"]),
+            "representation": context["representation"]["id"],
             "libpath": libpath,
             "asset_name": asset_name,
-            "parent": str(context["representation"]["parent"]),
-            "productType": context["subset"]["data"]["family"],
+            "parent": context["representation"]["versionId"],
+            "productType": context["product"]["productType"],
             "objectName": group_name
         }
 
         self[:] = asset_group.children
         return asset_group.children
 
-    def exec_update(self, container: Dict, representation: Dict):
+    def exec_update(self, container: Dict, context: Dict):
         """Update the loaded asset.
 
         This will remove all objects of the current collection, load the new
@@ -197,15 +197,16 @@ class JsonLayoutLoader(plugin.AssetLoader):
         will not be removed, only unlinked. Normally this should not be the
         case though.
         """
+        repre_entity = context["representation"]
         object_name = container["objectName"]
         asset_group = bpy.data.objects.get(object_name)
-        libpath = Path(get_representation_path(representation))
+        libpath = Path(get_representation_path(repre_entity))
         extension = libpath.suffix.lower()
 
         self.log.info(
             "Container: %s\nRepresentation: %s",
             pformat(container, indent=2),
-            pformat(representation, indent=2),
+            pformat(repre_entity, indent=2),
         )
 
         assert asset_group, (
@@ -269,7 +270,7 @@ class JsonLayoutLoader(plugin.AssetLoader):
         asset_group.matrix_basis = mat
 
         metadata["libpath"] = str(libpath)
-        metadata["representation"] = str(representation["_id"])
+        metadata["representation"] = repre_entity["id"]
 
     def exec_remove(self, container: Dict) -> bool:
         """Remove an existing container from a Blender scene.

client/ayon_core/hosts/blender/plugins/load/load_look.py

@@ -23,8 +23,8 @@ class BlendLookLoader(plugin.AssetLoader):
     contains the model. There is no further need to 'containerise' it.
     """
 
-    families = ["look"]
-    representations = ["json"]
+    product_types = {"look"}
+    representations = {"json"}
 
     label = "Load Look"
     icon = "code-fork"
@@ -93,8 +93,8 @@ class BlendLookLoader(plugin.AssetLoader):
         """
 
         libpath = self.filepath_from_context(context)
-        folder_name = context["asset"]["name"]
-        product_name = context["subset"]["name"]
+        folder_name = context["folder"]["name"]
+        product_name = context["product"]["name"]
 
         lib_container = plugin.prepare_scene_name(
             folder_name, product_name
@@ -130,23 +130,24 @@ class BlendLookLoader(plugin.AssetLoader):
         metadata["objects"] = objects
         metadata["materials"] = materials
 
-        metadata["parent"] = str(context["representation"]["parent"])
-        metadata["product_type"] = context["subset"]["data"]["family"]
+        metadata["parent"] = context["representation"]["versionId"]
+        metadata["product_type"] = context["product"]["productType"]
 
         nodes = list(container.objects)
         nodes.append(container)
         self[:] = nodes
         return nodes
 
-    def update(self, container: Dict, representation: Dict):
+    def update(self, container: Dict, context: Dict):
         collection = bpy.data.collections.get(container["objectName"])
-        libpath = Path(get_representation_path(representation))
+        repre_entity = context["representation"]
+        libpath = Path(get_representation_path(repre_entity))
         extension = libpath.suffix.lower()
 
         self.log.info(
             "Container: %s\nRepresentation: %s",
             pformat(container, indent=2),
-            pformat(representation, indent=2),
+            pformat(repre_entity, indent=2),
         )
 
         assert collection, (
@@ -201,7 +202,7 @@ class BlendLookLoader(plugin.AssetLoader):
         collection_metadata["objects"] = objects
         collection_metadata["materials"] = materials
         collection_metadata["libpath"] = str(libpath)
-        collection_metadata["representation"] = str(representation["_id"])
+        collection_metadata["representation"] = repre_entity["id"]
 
     def remove(self, container: Dict) -> bool:
         collection = bpy.data.collections.get(container["objectName"])

client/ayon_core/hosts/blender/plugins/publish/extract_abc.py

@@ -2,6 +2,7 @@ import os
 
 import bpy
 
+from ayon_core.lib import BoolDef
 from ayon_core.pipeline import publish
 from ayon_core.hosts.blender.api import plugin
 
@@ -17,9 +18,11 @@ class ExtractABC(publish.Extractor, publish.OptionalPyblishPluginMixin):
         if not self.is_active(instance.data):
             return
 
+        attr_values = self.get_attr_values_from_data(instance.data)
+
         # Define extract output file path
         stagingdir = self.staging_dir(instance)
-        folder_name = instance.data["assetEntity"]["name"]
+        folder_name = instance.data["folderEntity"]["name"]
         product_name = instance.data["productName"]
         instance_name = f"{folder_name}_{product_name}"
         filename = f"{instance_name}.abc"
@@ -46,7 +49,8 @@ class ExtractABC(publish.Extractor, publish.OptionalPyblishPluginMixin):
             bpy.ops.wm.alembic_export(
                 filepath=filepath,
                 selected=True,
-                flatten=False
+                flatten=False,
+                subdiv_schema=attr_values.get("subdiv_schema", False)
             )
 
         plugin.deselect_all()
@@ -65,6 +69,21 @@ class ExtractABC(publish.Extractor, publish.OptionalPyblishPluginMixin):
         self.log.debug("Extracted instance '%s' to: %s",
                        instance.name, representation)
 
+    @classmethod
+    def get_attribute_defs(cls):
+        return [
+            BoolDef(
+                "subdiv_schema",
+                label="Alembic Mesh Subdiv Schema",
+                tooltip="Export Meshes using Alembic's subdivision schema.\n"
+                        "Enabling this includes creases with the export but "
+                        "excludes the mesh's normals.\n"
+                        "Enabling this usually result in smaller file size "
+                        "due to lack of normals.",
+                default=False
+            )
+        ]
+
 
 class ExtractModelABC(ExtractABC):
     """Extract model as ABC."""

client/ayon_core/hosts/blender/plugins/publish/extract_abc_animation.py

@@ -23,7 +23,7 @@ class ExtractAnimationABC(
 
         # Define extract output file path
         stagingdir = self.staging_dir(instance)
-        folder_name = instance.data["assetEntity"]["name"]
+        folder_name = instance.data["folderEntity"]["name"]
         product_name = instance.data["productName"]
         instance_name = f"{folder_name}_{product_name}"
         filename = f"{instance_name}.abc"

client/ayon_core/hosts/blender/plugins/publish/extract_blend.py

@@ -13,6 +13,9 @@ class ExtractBlend(publish.Extractor, publish.OptionalPyblishPluginMixin):
     families = ["model", "camera", "rig", "action", "layout", "blendScene"]
     optional = True
 
+    # From settings
+    compress = False
+
     def process(self, instance):
         if not self.is_active(instance.data):
             return
@@ -20,7 +23,7 @@ class ExtractBlend(publish.Extractor, publish.OptionalPyblishPluginMixin):
         # Define extract output file path
 
         stagingdir = self.staging_dir(instance)
-        folder_name = instance.data["assetEntity"]["name"]
+        folder_name = instance.data["folderEntity"]["name"]
         product_name = instance.data["productName"]
         instance_name = f"{folder_name}_{product_name}"
         filename = f"{instance_name}.blend"
@@ -53,7 +56,7 @@ class ExtractBlend(publish.Extractor, publish.OptionalPyblishPluginMixin):
                     if node.image and node.image.packed_file is None:
                         node.image.pack()
 
-        bpy.data.libraries.write(filepath, data_blocks)
+        bpy.data.libraries.write(filepath, data_blocks, compress=self.compress)
 
         if "representations" not in instance.data:
             instance.data["representations"] = []

client/ayon_core/hosts/blender/plugins/publish/extract_blend_animation.py

@@ -16,6 +16,9 @@ class ExtractBlendAnimation(
     families = ["animation"]
     optional = True
 
+    # From settings
+    compress = False
+
     def process(self, instance):
         if not self.is_active(instance.data):
             return
@@ -23,7 +26,7 @@ class ExtractBlendAnimation(
         # Define extract output file path
 
         stagingdir = self.staging_dir(instance)
-        folder_name = instance.data["assetEntity"]["name"]
+        folder_name = instance.data["folderEntity"]["name"]
         product_name = instance.data["productName"]
         instance_name = f"{folder_name}_{product_name}"
         filename = f"{instance_name}.blend"
@@ -46,7 +49,7 @@ class ExtractBlendAnimation(
                         data_blocks.add(child.animation_data.action)
                         data_blocks.add(obj)
 
-        bpy.data.libraries.write(filepath, data_blocks)
+        bpy.data.libraries.write(filepath, data_blocks, compress=self.compress)
 
         if "representations" not in instance.data:
             instance.data["representations"] = []

client/ayon_core/hosts/blender/plugins/publish/extract_camera_abc.py

@@ -4,7 +4,6 @@ import bpy
 
 from ayon_core.pipeline import publish
 from ayon_core.hosts.blender.api import plugin
-from ayon_core.hosts.blender.api.pipeline import AVALON_PROPERTY
 
 
 class ExtractCameraABC(publish.Extractor, publish.OptionalPyblishPluginMixin):
@@ -21,7 +20,7 @@ class ExtractCameraABC(publish.Extractor, publish.OptionalPyblishPluginMixin):
 
         # Define extract output file path
         stagingdir = self.staging_dir(instance)
-        folder_name = instance.data["assetEntity"]["name"]
+        folder_name = instance.data["folderEntity"]["name"]
         product_name = instance.data["productName"]
         instance_name = f"{folder_name}_{product_name}"
         filename = f"{instance_name}.abc"

client/ayon_core/hosts/blender/plugins/publish/extract_camera_fbx.py

@@ -20,7 +20,7 @@ class ExtractCamera(publish.Extractor, publish.OptionalPyblishPluginMixin):
 
         # Define extract output file path
         stagingdir = self.staging_dir(instance)
-        folder_name = instance.data["assetEntity"]["name"]
+        folder_name = instance.data["folderEntity"]["name"]
         product_name = instance.data["productName"]
         instance_name = f"{folder_name}_{product_name}"
         filename = f"{instance_name}.fbx"

client/ayon_core/hosts/blender/plugins/publish/extract_fbx.py

@@ -4,7 +4,6 @@ import bpy
 
 from ayon_core.pipeline import publish
 from ayon_core.hosts.blender.api import plugin
-from ayon_core.hosts.blender.api.pipeline import AVALON_PROPERTY
 
 
 class ExtractFBX(publish.Extractor, publish.OptionalPyblishPluginMixin):
@@ -21,7 +20,7 @@ class ExtractFBX(publish.Extractor, publish.OptionalPyblishPluginMixin):
 
         # Define extract output file path
         stagingdir = self.staging_dir(instance)
-        folder_name = instance.data["assetEntity"]["name"]
+        folder_name = instance.data["folderEntity"]["name"]
         product_name = instance.data["productName"]
         instance_name = f"{folder_name}_{product_name}"
         filename = f"{instance_name}.fbx"

client/ayon_core/hosts/blender/plugins/publish/extract_fbx_animation.py

@@ -145,7 +145,7 @@ class ExtractAnimationFBX(
 
         root.select_set(True)
         armature.select_set(True)
-        folder_name = instance.data["assetEntity"]["name"]
+        folder_name = instance.data["folderEntity"]["name"]
         product_name = instance.data["productName"]
         instance_name = f"{folder_name}_{product_name}"
         fbx_filename = f"{instance_name}_{armature.name}.fbx"

client/ayon_core/hosts/blender/plugins/publish/extract_layout.py

@@ -5,7 +5,8 @@ import bpy
 import bpy_extras
 import bpy_extras.anim_utils
 
-from ayon_core.client import get_representation_by_name
+from ayon_api import get_representations
+
 from ayon_core.pipeline import publish
 from ayon_core.hosts.blender.api import plugin
 from ayon_core.hosts.blender.api.pipeline import AVALON_PROPERTY
@@ -134,6 +135,8 @@ class ExtractLayout(publish.Extractor, publish.OptionalPyblishPluginMixin):
         fbx_count = 0
 
         project_name = instance.context.data["projectName"]
+        version_ids = set()
+        filtered_assets = []
         for asset in asset_group.children:
             metadata = asset.get(AVALON_PROPERTY)
             if not metadata:
@@ -146,42 +149,47 @@ class ExtractLayout(publish.Extractor, publish.OptionalPyblishPluginMixin):
                 )
                 continue
 
+            filtered_assets.append((asset, metadata))
+            version_ids.add(metadata["parent"])
+
+        repre_entities = get_representations(
+            project_name,
+            representation_names={"blend", "fbx", "abc"},
+            version_ids=version_ids,
+            fields={"id", "versionId", "name"}
+        )
+        repre_mapping_by_version_id = {
+            version_id: {}
+            for version_id in version_ids
+        }
+        for repre_entity in repre_entities:
+            version_id = repre_entity["versionId"]
+            repre_mapping_by_version_id[version_id][repre_entity["name"]] = (
+                repre_entity
+            )
+
+        for asset, metadata in filtered_assets:
             version_id = metadata["parent"]
             product_type = metadata.get("product_type")
             if product_type is None:
                 product_type = metadata["family"]
 
+            repres_by_name = repre_mapping_by_version_id[version_id]
+
             self.log.debug("Parent: {}".format(version_id))
-            # Get blend reference
-            blend = get_representation_by_name(
-                project_name, "blend", version_id, fields=["_id"]
-            )
-            blend_id = None
-            if blend:
-                blend_id = blend["_id"]
-            # Get fbx reference
-            fbx = get_representation_by_name(
-                project_name, "fbx", version_id, fields=["_id"]
-            )
-            fbx_id = None
-            if fbx:
-                fbx_id = fbx["_id"]
-            # Get abc reference
-            abc = get_representation_by_name(
-                project_name, "abc", version_id, fields=["_id"]
-            )
-            abc_id = None
-            if abc:
-                abc_id = abc["_id"]
-
-            json_element = {}
-            if blend_id:
-                json_element["reference"] = str(blend_id)
-            if fbx_id:
-                json_element["reference_fbx"] = str(fbx_id)
-            if abc_id:
-                json_element["reference_abc"] = str(abc_id)
-
+            # Get blend, fbx and abc reference
+            blend_id = repres_by_name.get("blend", {}).get("id")
+            fbx_id = repres_by_name.get("fbx", {}).get("id")
+            abc_id = repres_by_name.get("abc", {}).get("id")
+            json_element = {
+                key: value
+                for key, value in (
+                    ("reference", blend_id),
+                    ("reference_fbx", fbx_id),
+                    ("reference_abc", abc_id),
+                )
+                if value
+            }
             json_element["product_type"] = product_type
             json_element["instance_name"] = asset.name
             json_element["asset_name"] = metadata["asset_name"]
@@ -228,7 +236,7 @@ class ExtractLayout(publish.Extractor, publish.OptionalPyblishPluginMixin):
 
             json_data.append(json_element)
 
-        folder_name = instance.data["assetEntity"]["name"]
+        folder_name = instance.data["folderEntity"]["name"]
         product_name = instance.data["productName"]
         instance_name = f"{folder_name}_{product_name}"
         json_filename = f"{instance_name}.json"

client/ayon_core/hosts/blender/plugins/publish/extract_playblast.py

@@ -55,7 +55,7 @@ class ExtractPlayblast(publish.Extractor, publish.OptionalPyblishPluginMixin):
 
         # get output path
         stagingdir = self.staging_dir(instance)
-        folder_name = instance.data["assetEntity"]["name"]
+        folder_name = instance.data["folderEntity"]["name"]
         product_name = instance.data["productName"]
         filename = f"{folder_name}_{product_name}"
 

client/ayon_core/hosts/blender/plugins/publish/extract_thumbnail.py

@@ -32,7 +32,7 @@ class ExtractThumbnail(publish.Extractor):
             return
 
         stagingdir = self.staging_dir(instance)
-        folder_name = instance.data["assetEntity"]["name"]
+        folder_name = instance.data["folderEntity"]["name"]
         product_name = instance.data["productName"]
         filename = f"{folder_name}_{product_name}"
 

client/ayon_core/hosts/blender/plugins/publish/integrate_animation.py

@@ -44,7 +44,7 @@ class IntegrateAnimation(
                     break
             if not rep:
                 continue
-            obj_id = rep["representation"]["_id"]
+            obj_id = rep["representation"]["id"]
 
             if obj_id:
                 json_dict["representation_id"] = str(obj_id)

client/ayon_core/hosts/blender/plugins/publish/validate_deadline_publish.py

@@ -32,7 +32,7 @@ class ValidateDeadlinePublish(pyblish.api.InstancePlugin,
         tree = bpy.context.scene.node_tree
         output_type = "CompositorNodeOutputFile"
         output_node = None
-        # Remove all output nodes that inlcude "AYON" in the name.
+        # Remove all output nodes that include "AYON" in the name.
         # There should be only one.
         for node in tree.nodes:
             if node.bl_idname == output_type and "AYON" in node.name:

client/ayon_core/hosts/blender/plugins/publish/validate_file_saved.py

@@ -37,7 +37,8 @@ class ValidateFileSaved(pyblish.api.ContextPlugin,
         if not context.data["currentFile"]:
             # File has not been saved at all and has no filename
             raise PublishValidationError(
-                "Current file is empty. Save the file before continuing."
+                "Current workfile has not been saved yet.\n"
+                "Save the workfile before continuing."
             )
 
         # Do not validate workfile has unsaved changes if only instances

client/ayon_core/hosts/blender/plugins/publish/validate_mesh_no_negative_scale.py

@@ -12,7 +12,7 @@ from ayon_core.pipeline.publish import (
 import ayon_core.hosts.blender.api.action
 
 
-class ValidateMeshNoNegativeScale(pyblish.api.Validator,
+class ValidateMeshNoNegativeScale(pyblish.api.InstancePlugin,
                                   OptionalPyblishPluginMixin):
     """Ensure that meshes don't have a negative scale."""
 

client/ayon_core/hosts/blender/plugins/publish/validate_model_uv_map1.py

@@ -0,0 +1,94 @@
+import inspect
+from typing import List
+
+import bpy
+
+import pyblish.api
+
+from ayon_core.pipeline.publish import (
+    ValidateContentsOrder,
+    OptionalPyblishPluginMixin,
+    PublishValidationError,
+    RepairAction
+)
+import ayon_core.hosts.blender.api.action
+
+
+class ValidateModelMeshUvMap1(
+        pyblish.api.InstancePlugin,
+        OptionalPyblishPluginMixin,
+):
+    """Validate model mesh uvs are named `map1`.
+
+    This is solely to get them to work nicely for the Maya pipeline.
+    """
+
+    order = ValidateContentsOrder
+    hosts = ["blender"]
+    families = ["model"]
+    label = "Mesh UVs named map1"
+    actions = [ayon_core.hosts.blender.api.action.SelectInvalidAction,
+               RepairAction]
+    optional = True
+    enabled = False
+
+    @classmethod
+    def get_invalid(cls, instance) -> List:
+
+        invalid = []
+        for obj in instance:
+            if obj.mode != "OBJECT":
+                cls.log.warning(
+                    f"Mesh object {obj.name} should be in 'OBJECT' mode"
+                    " to be properly checked."
+                )
+
+            obj_data = obj.data
+            if isinstance(obj_data, bpy.types.Mesh):
+                mesh = obj_data
+
+                # Ignore mesh without UVs
+                if not mesh.uv_layers:
+                    continue
+
+                # If mesh has map1 all is ok
+                if mesh.uv_layers.get("map1"):
+                    continue
+
+                cls.log.warning(
+                    f"Mesh object {obj.name} should be in 'OBJECT' mode"
+                    " to be properly checked."
+                )
+                invalid.append(obj)
+
+        return invalid
+
+    @classmethod
+    def repair(cls, instance):
+        for obj in cls.get_invalid(instance):
+            mesh = obj.data
+
+            # Rename the first UV set to map1
+            mesh.uv_layers[0].name = "map1"
+
+    def process(self, instance):
+        if not self.is_active(instance.data):
+            return
+
+        invalid = self.get_invalid(instance)
+        if invalid:
+            raise PublishValidationError(
+                f"Meshes found in instance without valid UV's: {invalid}",
+                description=self.get_description()
+            )
+
+    def get_description(self):
+        return inspect.cleandoc(
+            """## Meshes must have map1 uv set
+
+            To accompany a better Maya-focused pipeline with Alembics it is
+            expected that a Mesh has a `map1` UV set. Blender defaults to
+            a UV set named `UVMap` and thus needs to be renamed.
+
+            """
+        )

client/ayon_core/hosts/blender/plugins/publish/validate_transform_zero.py

@@ -1,3 +1,4 @@
+import inspect
 from typing import List
 
 import mathutils
@@ -5,29 +6,26 @@ import bpy
 
 import pyblish.api
 
+from ayon_core.hosts.blender.api import plugin, lib
 import ayon_core.hosts.blender.api.action
 from ayon_core.pipeline.publish import (
     ValidateContentsOrder,
     OptionalPyblishPluginMixin,
-    PublishValidationError
+    PublishValidationError,
+    RepairAction
 )
 
 
 class ValidateTransformZero(pyblish.api.InstancePlugin,
                             OptionalPyblishPluginMixin):
-    """Transforms can't have any values
-
-    To solve this issue, try freezing the transforms. So long
-    as the transforms, rotation and scale values are zero,
-    you're all good.
-
-    """
+    """Transforms can't have any values"""
 
     order = ValidateContentsOrder
     hosts = ["blender"]
     families = ["model"]
     label = "Transform Zero"
-    actions = [ayon_core.hosts.blender.api.action.SelectInvalidAction]
+    actions = [ayon_core.hosts.blender.api.action.SelectInvalidAction,
+               RepairAction]
 
     _identity = mathutils.Matrix()
 
@@ -51,5 +49,46 @@ class ValidateTransformZero(pyblish.api.InstancePlugin,
             names = ", ".join(obj.name for obj in invalid)
             raise PublishValidationError(
                 "Objects found in instance which do not"
-                f" have transform set to zero: {names}"
+                f" have transform set to zero: {names}",
+                description=self.get_description()
             )
+
+    @classmethod
+    def repair(cls, instance):
+
+        invalid = cls.get_invalid(instance)
+        if not invalid:
+            return
+
+        context = plugin.create_blender_context(
+            active=invalid[0], selected=invalid
+        )
+        with lib.maintained_selection():
+            with bpy.context.temp_override(**context):
+                plugin.deselect_all()
+                for obj in invalid:
+                    obj.select_set(True)
+
+                # TODO: Preferably this does allow custom pivot point locations
+                #  and if so, this should likely apply to the delta instead
+                #  using `bpy.ops.object.transforms_to_deltas(mode="ALL")`
+                bpy.ops.object.transform_apply(location=True,
+                                               rotation=True,
+                                               scale=True)
+
+    def get_description(self):
+        return inspect.cleandoc(
+            """## Transforms can't have any values.
+
+            The location, rotation and scale on the transform must be at
+            the default values. This also goes for the delta transforms.
+
+            To solve this issue, try freezing the transforms:
+            - `Object` > `Apply` > `All Transforms`
+
+            Using the Repair action directly will do the same.
+
+            So long as the transforms, rotation and scale values are zero,
+            you're all good.
+            """
+        )

client/ayon_core/hosts/celaction/hooks/pre_celaction_setup.py

@@ -3,7 +3,7 @@ import shutil
 import winreg
 import subprocess
 from ayon_core.lib import get_ayon_launcher_args
-from ayon_core.lib.applications import PreLaunchHook, LaunchTypes
+from ayon_applications import PreLaunchHook, LaunchTypes
 from ayon_core.hosts.celaction import CELACTION_ROOT_DIR
 
 
@@ -16,9 +16,9 @@ class CelactionPrelaunchHook(PreLaunchHook):
     launch_types = {LaunchTypes.local}
 
     def execute(self):
-        asset_doc = self.data["asset_doc"]
-        width = asset_doc["data"]["resolutionWidth"]
-        height = asset_doc["data"]["resolutionHeight"]
+        folder_attributes = self.data["folder_entity"]["attrib"]
+        width = folder_attributes["resolutionWidth"]
+        height = folder_attributes["resolutionHeight"]
 
         # Add workfile path to launch arguments
         workfile_path = self.workfile_path()
@@ -118,7 +118,7 @@ class CelactionPrelaunchHook(PreLaunchHook):
     def workfile_path(self):
         workfile_path = self.data["last_workfile_path"]
 
-        # copy workfile from template if doesnt exist any on path
+        # copy workfile from template if doesn't exist any on path
         if not os.path.exists(workfile_path):
             # TODO add ability to set different template workfile path via
             # settings

client/ayon_core/hosts/celaction/plugins/publish/collect_celaction_cli_kwargs.py

@@ -3,11 +3,11 @@ import sys
 from pprint import pformat
 
 
-class CollectCelactionCliKwargs(pyblish.api.Collector):
+class CollectCelactionCliKwargs(pyblish.api.ContextPlugin):
     """ Collects all keyword arguments passed from the terminal """
 
     label = "Collect Celaction Cli Kwargs"
-    order = pyblish.api.Collector.order - 0.1
+    order = pyblish.api.CollectorOrder - 0.1
 
     def process(self, context):
         args = list(sys.argv[1:])

client/ayon_core/hosts/celaction/plugins/publish/collect_celaction_instances.py

@@ -1,8 +1,6 @@
 import os
 import pyblish.api
 
-from ayon_core.client import get_asset_name_identifier
-
 
 class CollectCelactionInstances(pyblish.api.ContextPlugin):
     """ Adds the celaction render instances """
@@ -16,24 +14,20 @@ class CollectCelactionInstances(pyblish.api.ContextPlugin):
         staging_dir = os.path.dirname(current_file)
         scene_file = os.path.basename(current_file)
         version = context.data["version"]
-        asset_entity = context.data["assetEntity"]
-        project_entity = context.data["projectEntity"]
 
-        asset_name = get_asset_name_identifier(asset_entity)
+        folder_entity = context.data["folderEntity"]
+
+        folder_attributes = folder_entity["attrib"]
 
         shared_instance_data = {
-            "folderPath": asset_name,
-            "frameStart": asset_entity["data"]["frameStart"],
-            "frameEnd": asset_entity["data"]["frameEnd"],
-            "handleStart": asset_entity["data"]["handleStart"],
-            "handleEnd": asset_entity["data"]["handleEnd"],
-            "fps": asset_entity["data"]["fps"],
-            "resolutionWidth": asset_entity["data"].get(
-                "resolutionWidth",
-                project_entity["data"]["resolutionWidth"]),
-            "resolutionHeight": asset_entity["data"].get(
-                "resolutionHeight",
-                project_entity["data"]["resolutionHeight"]),
+            "folderPath": folder_entity["path"],
+            "frameStart": folder_attributes["frameStart"],
+            "frameEnd": folder_attributes["frameEnd"],
+            "handleStart": folder_attributes["handleStart"],
+            "handleEnd": folder_attributes["handleEnd"],
+            "fps": folder_attributes["fps"],
+            "resolutionWidth": folder_attributes["resolutionWidth"],
+            "resolutionHeight": folder_attributes["resolutionHeight"],
             "pixelAspect": 1,
             "step": 1,
             "version": version
@@ -83,7 +77,7 @@ class CollectCelactionInstances(pyblish.api.ContextPlugin):
         # getting instance state
         instance.data["publish"] = True
 
-        # add assetEntity data into instance
+        # add folderEntity data into instance
         instance.data.update({
             "label": "{} - farm".format(product_name),
             "productType": product_type,

client/ayon_core/hosts/celaction/plugins/publish/collect_render_path.py

@@ -18,7 +18,7 @@ class CollectRenderPath(pyblish.api.InstancePlugin):
     def process(self, instance):
         anatomy = instance.context.data["anatomy"]
         anatomy_data = copy.deepcopy(instance.data["anatomyData"])
-        padding = anatomy.templates.get("frame_padding", 4)
+        padding = anatomy.templates_obj.frame_padding
         product_type = "render"
         anatomy_data.update({
             "frame": f"%0{padding}d",
@@ -28,18 +28,17 @@ class CollectRenderPath(pyblish.api.InstancePlugin):
         })
         anatomy_data["product"]["type"] = product_type
 
-        anatomy_filled = anatomy.format(anatomy_data)
-
         # get anatomy rendering keys
         r_anatomy_key = self.anatomy_template_key_render_files
         m_anatomy_key = self.anatomy_template_key_metadata
 
         # get folder and path for rendering images from celaction
-        render_dir = anatomy_filled[r_anatomy_key]["folder"]
-        render_path = anatomy_filled[r_anatomy_key]["path"]
+        r_template_item = anatomy.get_template_item("publish", r_anatomy_key)
+        render_dir = r_template_item["directory"].format_strict(anatomy_data)
+        render_path = r_template_item["path"].format_strict(anatomy_data)
         self.log.debug("__ render_path: `{}`".format(render_path))
 
-        # create dir if it doesnt exists
+        # create dir if it doesn't exists
         try:
             if not os.path.isdir(render_dir):
                 os.makedirs(render_dir, exist_ok=True)
@@ -51,11 +50,14 @@ class CollectRenderPath(pyblish.api.InstancePlugin):
         instance.data["path"] = render_path
 
         # get anatomy for published renders folder path
-        if anatomy_filled.get(m_anatomy_key):
-            instance.data["publishRenderMetadataFolder"] = anatomy_filled[
-                m_anatomy_key]["folder"]
-            self.log.info("Metadata render path: `{}`".format(
-                instance.data["publishRenderMetadataFolder"]
-            ))
+        m_template_item = anatomy.get_template_item(
+            "publish", m_anatomy_key, default=None
+        )
+        if m_template_item is not None:
+            metadata_path = m_template_item["directory"].format_strict(
+                anatomy_data
+            )
+            instance.data["publishRenderMetadataFolder"] = metadata_path
+            self.log.info("Metadata render path: `{}`".format(metadata_path))
 
         self.log.info(f"Render output path set to: `{render_path}`")

client/ayon_core/hosts/flame/api/__init__.py

@@ -1,5 +1,5 @@
 """
-OpenPype Autodesk Flame api
+AYON Autodesk Flame api
 """
 from .constants import (
     COLOR_MAP,
@@ -23,7 +23,7 @@ from .lib import (
     reset_segment_selection,
     get_segment_attributes,
     get_clips_in_reels,
-    get_reformated_filename,
+    get_reformatted_filename,
     get_frame_from_filename,
     get_padding_from_filename,
     maintained_object_duplication,
@@ -101,7 +101,7 @@ __all__ = [
     "reset_segment_selection",
     "get_segment_attributes",
     "get_clips_in_reels",
-    "get_reformated_filename",
+    "get_reformatted_filename",
     "get_frame_from_filename",
     "get_padding_from_filename",
     "maintained_object_duplication",

client/ayon_core/hosts/flame/api/constants.py

@@ -1,14 +1,14 @@
 
 """
-OpenPype Flame api constances
+AYON Flame api constances
 """
-# OpenPype marker workflow variables
+# AYON marker workflow variables
 MARKER_NAME = "OpenPypeData"
 MARKER_DURATION = 0
 MARKER_COLOR = "cyan"
 MARKER_PUBLISH_DEFAULT = False
 
-# OpenPype color definitions
+# AYON color definitions
 COLOR_MAP = {
     "red": (1.0, 0.0, 0.0),
     "orange": (1.0, 0.5, 0.0),

client/ayon_core/hosts/flame/api/lib.py

@@ -607,7 +607,7 @@ def get_clips_in_reels(project):
     return output_clips
 
 
-def get_reformated_filename(filename, padded=True):
+def get_reformatted_filename(filename, padded=True):
     """
     Return fixed python expression path
 
@@ -615,10 +615,10 @@ def get_reformated_filename(filename, padded=True):
         filename (str): file name
 
     Returns:
-        type: string with reformated path
+        type: string with reformatted path
 
     Example:
-        get_reformated_filename("plate.1001.exr") > plate.%04d.exr
+        get_reformatted_filename("plate.1001.exr") > plate.%04d.exr
 
     """
     found = FRAME_PATTERN.search(filename)
@@ -980,7 +980,7 @@ class MediaInfoFile(object):
 
     @property
     def file_pattern(self):
-        """Clips file patter
+        """Clips file pattern.
 
         Returns:
             str: file pattern. ex. file.[1-2].exr

client/ayon_core/hosts/flame/api/pipeline.py

@@ -38,12 +38,12 @@ def install():
     pyblish.register_plugin_path(PUBLISH_PATH)
     register_loader_plugin_path(LOAD_PATH)
     register_creator_plugin_path(CREATE_PATH)
-    log.info("OpenPype Flame plug-ins registered ...")
+    log.info("AYON Flame plug-ins registered ...")
 
     # register callback for switching publishable
     pyblish.register_callback("instanceToggled", on_pyblish_instance_toggled)
 
-    log.info("OpenPype Flame host installed ...")
+    log.info("AYON Flame host installed ...")
 
 
 def uninstall():
@@ -57,7 +57,7 @@ def uninstall():
     # register callback for switching publishable
     pyblish.deregister_callback("instanceToggled", on_pyblish_instance_toggled)
 
-    log.info("OpenPype Flame host uninstalled ...")
+    log.info("AYON Flame host uninstalled ...")
 
 
 def containerise(flame_clip_segment,
@@ -73,7 +73,7 @@ def containerise(flame_clip_segment,
         "name": str(name),
         "namespace": str(namespace),
         "loader": str(loader),
-        "representation": str(context["representation"]["_id"]),
+        "representation": context["representation"]["id"],
     }
 
     if data:

client/ayon_core/hosts/flame/api/plugin.py

@@ -38,7 +38,7 @@ class CreatorWidget(QtWidgets.QDialog):
             | QtCore.Qt.WindowCloseButtonHint
             | QtCore.Qt.WindowStaysOnTopHint
         )
-        self.setWindowTitle(name or "Pype Creator Input")
+        self.setWindowTitle(name or "AYON Creator Input")
         self.resize(500, 700)
 
         # Where inputs and labels are set
@@ -644,13 +644,13 @@ class PublishableClip:
             "families": [self.base_product_type, self.product_type]
         }
 
-    def _convert_to_entity(self, type, template):
+    def _convert_to_entity(self, src_type, template):
         """ Converting input key to key with type. """
         # convert to entity type
-        entity_type = self.types.get(type, None)
+        folder_type = self.types.get(src_type, None)
 
-        assert entity_type, "Missing entity type for `{}`".format(
-            type
+        assert folder_type, "Missing folder type for `{}`".format(
+            src_type
         )
 
         # first collect formatting data to use for formatting template
@@ -661,7 +661,7 @@ class PublishableClip:
             formatting_data[_k] = value
 
         return {
-            "entity_type": entity_type,
+            "folder_type": folder_type,
             "entity_name": template.format(
                 **formatting_data
             )
@@ -748,18 +748,16 @@ class ClipLoader(LoaderPlugin):
         Returns:
             str: colorspace name or None
         """
-        version = context['version']
-        version_data = version.get("data", {})
-        colorspace = version_data.get(
-            "colorspace", None
-        )
+        version_entity = context["version"]
+        version_attributes = version_entity["attrib"]
+        colorspace = version_attributes.get("colorSpace")
 
         if (
             not colorspace
             or colorspace == "Unknown"
         ):
             colorspace = context["representation"]["data"].get(
-                "colorspace", None)
+                "colorspace")
 
         return colorspace
 
@@ -1020,7 +1018,7 @@ class OpenClipSolver(flib.MediaInfoFile):
                             self.feed_version_name))
                 else:
                     self.log.debug("adding new track element ..")
-                    # create new track as it doesnt exists yet
+                    # create new track as it doesn't exist yet
                     # set current version to feeds on tmp
                     tmp_xml_feeds = tmp_xml_track.find('feeds')
                     tmp_xml_feeds.set('currentVersion', self.feed_version_name)

client/ayon_core/hosts/flame/api/scripts/wiretap_com.py

@@ -61,7 +61,7 @@ class WireTapCom(object):
 
     def get_launch_args(
             self, project_name, project_data, user_name, *args, **kwargs):
-        """Forming launch arguments for OpenPype launcher.
+        """Forming launch arguments for AYON launcher.
 
         Args:
             project_name (str): name of project

client/ayon_core/hosts/flame/api/utils.py

@@ -11,7 +11,7 @@ log = Logger.get_logger(__name__)
 def _sync_utility_scripts(env=None):
     """ Synchronizing basic utlility scripts for flame.
 
-    To be able to run start OpenPype within Flame we have to copy
+    To be able to run start AYON within Flame we have to copy
     all utility_scripts and additional FLAME_SCRIPT_DIR into
     `/opt/Autodesk/shared/python`. This will be always synchronizing those
     folders.
@@ -124,7 +124,7 @@ def setup(env=None):
     # synchronize resolve utility scripts
     _sync_utility_scripts(env)
 
-    log.info("Flame OpenPype wrapper has been installed")
+    log.info("Flame AYON wrapper has been installed")
 
 
 def get_flame_version():

client/ayon_core/hosts/flame/hooks/pre_flame_setup.py

@@ -9,7 +9,7 @@ from ayon_core.lib import (
     get_ayon_username,
     run_subprocess,
 )
-from ayon_core.lib.applications import PreLaunchHook, LaunchTypes
+from ayon_applications import PreLaunchHook, LaunchTypes
 from ayon_core.hosts import flame as opflame
 
 
@@ -36,8 +36,8 @@ class FlamePrelaunch(PreLaunchHook):
         self.flame_pythonpath = _env["AYON_FLAME_PYTHONPATH"]
 
         """Hook entry method."""
-        project_doc = self.data["project_doc"]
-        project_name = project_doc["name"]
+        project_entity = self.data["project_entity"]
+        project_name = project_entity["name"]
         volume_name = _env.get("FLAME_WIRETAP_VOLUME")
 
         # get image io
@@ -63,20 +63,22 @@ class FlamePrelaunch(PreLaunchHook):
         hostname = socket.gethostname()  # not returning wiretap host name
 
         self.log.debug("Collected user \"{}\"".format(user_name))
-        self.log.info(pformat(project_doc))
-        _db_p_data = project_doc["data"]
-        width = _db_p_data["resolutionWidth"]
-        height = _db_p_data["resolutionHeight"]
-        fps = float(_db_p_data["fps"])
+        self.log.info(pformat(project_entity))
+        project_attribs = project_entity["attrib"]
+        width = project_attribs["resolutionWidth"]
+        height = project_attribs["resolutionHeight"]
+        fps = float(project_attribs["fps"])
 
         project_data = {
-            "Name": project_doc["name"],
-            "Nickname": _db_p_data["code"],
-            "Description": "Created by OpenPype",
-            "SetupDir": project_doc["name"],
+            "Name": project_entity["name"],
+            "Nickname": project_entity["code"],
+            "Description": "Created by AYON",
+            "SetupDir": project_entity["name"],
             "FrameWidth": int(width),
             "FrameHeight": int(height),
-            "AspectRatio": float((width / height) * _db_p_data["pixelAspect"]),
+            "AspectRatio": float(
+                (width / height) * project_attribs["pixelAspect"]
+            ),
             "FrameRate": self._get_flame_fps(fps)
         }
 

client/ayon_core/hosts/flame/otio/flame_export.py

@@ -256,7 +256,7 @@ def create_otio_reference(clip_data, fps=None):
 
     if not otio_ex_ref_item:
         dirname, file_name = os.path.split(path)
-        file_name = utils.get_reformated_filename(file_name, padded=False)
+        file_name = utils.get_reformatted_filename(file_name, padded=False)
         reformated_path = os.path.join(dirname, file_name)
         # in case old OTIO or video file create `ExternalReference`
         otio_ex_ref_item = otio.schema.ExternalReference(