Merge branch 'develop' of https://github.com/ynput/ayon-core into enhancement/maya_template_add_assign_look_placeholder

# Conflicts:
#	server_addon/maya/client/ayon_maya/plugins/workfile_build/assign_look_placeholder.py

client/ayon_core/addon/base.py

@@ -8,7 +8,6 @@ import inspect
 import logging
 import threading
 import collections
-
 from uuid import uuid4
 from abc import ABCMeta, abstractmethod
 
@@ -51,8 +50,22 @@ IGNORED_MODULES_IN_AYON = set()
 # - this is used to log the missing addon
 MOVED_ADDON_MILESTONE_VERSIONS = {
     "applications": VersionInfo(0, 2, 0),
+    "celaction": VersionInfo(0, 2, 0),
+    "clockify": VersionInfo(0, 2, 0),
+    "flame": VersionInfo(0, 2, 0),
+    "fusion": VersionInfo(0, 2, 0),
+    "max": VersionInfo(0, 2, 0),
+    "photoshop": VersionInfo(0, 2, 0),
+    "traypublisher": VersionInfo(0, 2, 0),
+    "tvpaint": VersionInfo(0, 2, 0),
+    "maya": VersionInfo(0, 2, 0),
+    "nuke": VersionInfo(0, 2, 0),
+    "resolve": VersionInfo(0, 2, 0),
+    "substancepainter": VersionInfo(0, 2, 0),
+    "houdini": VersionInfo(0, 3, 0),
 }
 
+
 # Inherit from `object` for Python 2 hosts
 class _ModuleClass(object):
     """Fake module class for storing AYON addons.
@@ -538,6 +551,9 @@ class AYONAddon(object):
     enabled = True
     _id = None
 
+    # Temporary variable for 'version' property
+    _missing_version_warned = False
+
     def __init__(self, manager, settings):
         self.manager = manager
 
@@ -568,6 +584,26 @@ class AYONAddon(object):
 
         pass
 
+    @property
+    def version(self):
+        """Addon version.
+
+        Todo:
+            Should be abstract property (required). Introduced in
+                ayon-core 0.3.3 .
+
+        Returns:
+            str: Addon version as semver compatible string.
+
+        """
+        if not self.__class__._missing_version_warned:
+            self.__class__._missing_version_warned = True
+            print(
+                f"DEV WARNING: Addon '{self.name}' does not have"
+                f" defined version."
+            )
+        return "0.0.0"
+
     def initialize(self, settings):
         """Initialization of addon attributes.
 
@@ -683,6 +719,30 @@ class OpenPypeAddOn(OpenPypeModule):
     enabled = True
 
 
+class _AddonReportInfo:
+    def __init__(
+        self, class_name, name, version, report_value_by_label
+    ):
+        self.class_name = class_name
+        self.name = name
+        self.version = version
+        self.report_value_by_label = report_value_by_label
+
+    @classmethod
+    def from_addon(cls, addon, report):
+        class_name = addon.__class__.__name__
+        report_value_by_label = {
+            label: reported.get(class_name)
+            for label, reported in report.items()
+        }
+        return cls(
+            addon.__class__.__name__,
+            addon.name,
+            addon.version,
+            report_value_by_label
+        )
+
+
 class AddonsManager:
     """Manager of addons that helps to load and prepare them to work.
 
@@ -859,10 +919,6 @@ class AddonsManager:
                 name_alias = getattr(addon, "openpype_alias", None)
                 if name_alias:
                     aliased_names.append((name_alias, addon))
-                enabled_str = "X"
-                if not addon.enabled:
-                    enabled_str = " "
-                self.log.debug("[{}] {}".format(enabled_str, name))
 
                 now = time.time()
                 report[addon.__class__.__name__] = now - prev_start_time
@@ -874,6 +930,13 @@ class AddonsManager:
                     exc_info=True
                 )
 
+        for addon_name in sorted(self._addons_by_name.keys()):
+            addon = self._addons_by_name[addon_name]
+            enabled_str = "X" if addon.enabled else " "
+            self.log.debug(
+                f"[{enabled_str}] {addon.name} ({addon.version})"
+            )
+
         for item in aliased_names:
             name_alias, addon = item
             if name_alias not in self._addons_by_name:
@@ -1162,39 +1225,55 @@ class AddonsManager:
             available_col_names |= set(addon_names.keys())
 
         # Prepare ordered dictionary for columns
-        cols = collections.OrderedDict()
-        # Add addon names to first columnt
-        cols["Addon name"] = list(sorted(
-            addon.__class__.__name__
+        addons_info = [
+            _AddonReportInfo.from_addon(addon, self._report)
             for addon in self.addons
             if addon.__class__.__name__ in available_col_names
-        ))
+        ]
+        addons_info.sort(key=lambda x: x.name)
+
+        addon_name_rows = [
+            addon_info.name
+            for addon_info in addons_info
+        ]
+        addon_version_rows = [
+            addon_info.version
+            for addon_info in addons_info
+        ]
+
         # Add total key (as last addon)
-        cols["Addon name"].append(self._report_total_key)
+        addon_name_rows.append(self._report_total_key)
+        addon_version_rows.append(f"({len(addons_info)})")
+
+        cols = collections.OrderedDict()
+        # Add addon names to first columnt
+        cols["Addon name"] = addon_name_rows
+        cols["Version"] = addon_version_rows
 
         # Add columns from report
+        total_by_addon = {
+            row: 0
+            for row in addon_name_rows
+        }
         for label in self._report.keys():
-            cols[label] = []
-
-        total_addon_times = {}
-        for addon_name in cols["Addon name"]:
-            total_addon_times[addon_name] = 0
-
-        for label, reported in self._report.items():
-            for addon_name in cols["Addon name"]:
-                col_time = reported.get(addon_name)
-                if col_time is None:
-                    cols[label].append("N/A")
+            rows = []
+            col_total = 0
+            for addon_info in addons_info:
+                value = addon_info.report_value_by_label.get(label)
+                if value is None:
+                    rows.append("N/A")
                     continue
-                cols[label].append("{:.3f}".format(col_time))
-                total_addon_times[addon_name] += col_time
-
+                rows.append("{:.3f}".format(value))
+                total_by_addon[addon_info.name] += value
+                col_total += value
+            total_by_addon[self._report_total_key] += col_total
+            rows.append("{:.3f}".format(col_total))
+            cols[label] = rows
         # Add to also total column that should sum the row
-        cols[self._report_total_key] = []
-        for addon_name in cols["Addon name"]:
-            cols[self._report_total_key].append(
-                "{:.3f}".format(total_addon_times[addon_name])
-            )
+        cols[self._report_total_key] = [
+            "{:.3f}".format(total_by_addon[addon_name])
+            for addon_name in cols["Addon name"]
+        ]
 
         # Prepare column widths and total row count
         # - column width is by
@@ -1321,7 +1400,7 @@ class TrayAddonsManager(AddonsManager):
         self.doubleclick_callback = None
 
     def add_doubleclick_callback(self, addon, callback):
-        """Register doubleclick callbacks on tray icon.
+        """Register double-click callbacks on tray icon.
 
         Currently, there is no way how to determine which is launched. Name of
         callback can be defined with `doubleclick_callback` attribute.

client/ayon_core/hooks/pre_ocio_hook.py

@@ -1,7 +1,7 @@
 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
+from ayon_core.pipeline.colorspace import get_imageio_config_preset
+from ayon_core.pipeline.template_data import get_template_data
 
 
 class OCIOEnvHook(PreLaunchHook):
@@ -26,32 +26,38 @@ class OCIOEnvHook(PreLaunchHook):
     def execute(self):
         """Hook entry method."""
 
-        template_data = get_template_data_with_names(
-            project_name=self.data["project_name"],
-            folder_path=self.data["folder_path"],
-            task_name=self.data["task_name"],
+        folder_entity = self.data["folder_entity"]
+
+        template_data = get_template_data(
+            self.data["project_entity"],
+            folder_entity=folder_entity,
+            task_entity=self.data["task_entity"],
             host_name=self.host_name,
-            settings=self.data["project_settings"]
+            settings=self.data["project_settings"],
         )
 
-        config_data = get_imageio_config(
-            project_name=self.data["project_name"],
-            host_name=self.host_name,
-            project_settings=self.data["project_settings"],
-            anatomy_data=template_data,
+        config_data = get_imageio_config_preset(
+            self.data["project_name"],
+            self.data["folder_path"],
+            self.data["task_name"],
+            self.host_name,
             anatomy=self.data["anatomy"],
+            project_settings=self.data["project_settings"],
+            template_data=template_data,
             env=self.launch_context.env,
+            folder_id=folder_entity["id"],
         )
 
-        if config_data:
-            ocio_path = config_data["path"]
-
-            if self.host_name in ["nuke", "hiero"]:
-                ocio_path = ocio_path.replace("\\", "/")
-
-            self.log.info(
-                f"Setting OCIO environment to config path: {ocio_path}")
-
-            self.launch_context.env["OCIO"] = ocio_path
-        else:
+        if not config_data:
             self.log.debug("OCIO not set or enabled")
+            return
+
+        ocio_path = config_data["path"]
+
+        if self.host_name in ["nuke", "hiero"]:
+            ocio_path = ocio_path.replace("\\", "/")
+
+        self.log.info(
+            f"Setting OCIO environment to config path: {ocio_path}")
+
+        self.launch_context.env["OCIO"] = ocio_path

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

@@ -60,7 +60,7 @@ def main(*subprocess_args):
             )
         )
 
-    elif os.environ.get("AVALON_PHOTOSHOP_WORKFILES_ON_LAUNCH", True):
+    elif os.environ.get("AVALON_AFTEREFFECTS_WORKFILES_ON_LAUNCH", True):
         save = False
         if os.getenv("WORKFILES_SAVE_AS"):
             save = True

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

@@ -24,7 +24,7 @@ class AERenderInstance(RenderInstance):
 
 class CollectAERender(publish.AbstractCollectRender):
 
-    order = pyblish.api.CollectorOrder + 0.405
+    order = pyblish.api.CollectorOrder + 0.100
     label = "Collect After Effects Render Layers"
     hosts = ["aftereffects"]
 
@@ -145,6 +145,7 @@ class CollectAERender(publish.AbstractCollectRender):
                 if "review" in instance.families:
                     # to skip ExtractReview locally
                     instance.families.remove("review")
+                instance.deadline = inst.data.get("deadline")
 
             instances.append(instance)
 

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

@@ -33,7 +33,7 @@ def load_scripts(paths):
         if register:
             try:
                 register()
-            except:
+            except:  # noqa E722
                 traceback.print_exc()
         else:
             print("\nWarning! '%s' has no register function, "
@@ -45,7 +45,7 @@ def load_scripts(paths):
         if unregister:
             try:
                 unregister()
-            except:
+            except:  # noqa E722
                 traceback.print_exc()
 
     def test_reload(mod):
@@ -57,7 +57,7 @@ def load_scripts(paths):
 
         try:
             return importlib.reload(mod)
-        except:
+        except:  # noqa E722
             traceback.print_exc()
 
     def test_register(mod):
@@ -365,3 +365,62 @@ def maintained_time():
         yield
     finally:
         bpy.context.scene.frame_current = current_time
+
+
+def get_all_parents(obj):
+    """Get all recursive parents of object.
+
+    Arguments:
+        obj (bpy.types.Object): Object to get all parents for.
+
+    Returns:
+        List[bpy.types.Object]: All parents of object
+
+    """
+    result = []
+    while True:
+        obj = obj.parent
+        if not obj:
+            break
+        result.append(obj)
+    return result
+
+
+def get_highest_root(objects):
+    """Get the highest object (the least parents) among the objects.
+
+    If multiple objects have the same amount of parents (or no parents) the
+    first object found in the input iterable will be returned.
+
+    Note that this will *not* return objects outside of the input list, as
+    such it will not return the root of node from a child node. It is purely
+    intended to find the highest object among a list of objects. To instead
+    get the root from one object use, e.g. `get_all_parents(obj)[-1]`
+
+    Arguments:
+        objects (List[bpy.types.Object]): Objects to find the highest root in.
+
+    Returns:
+        Optional[bpy.types.Object]: First highest root found or None if no
+            `bpy.types.Object` found in input list.
+
+    """
+    included_objects = {obj.name_full for obj in objects}
+    num_parents_to_obj = {}
+    for obj in objects:
+        if isinstance(obj, bpy.types.Object):
+            parents = get_all_parents(obj)
+            # included parents
+            parents = [parent for parent in parents if
+                       parent.name_full in included_objects]
+            if not parents:
+                # A node without parents must be a highest root
+                return obj
+
+            num_parents_to_obj.setdefault(len(parents), obj)
+
+    if not num_parents_to_obj:
+        return
+
+    minimum_parent = min(num_parents_to_obj)
+    return num_parents_to_obj[minimum_parent]

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

@@ -26,7 +26,8 @@ from .ops import (
 )
 from .lib import imprint
 
-VALID_EXTENSIONS = [".blend", ".json", ".abc", ".fbx"]
+VALID_EXTENSIONS = [".blend", ".json", ".abc", ".fbx",
+                    ".usd", ".usdc", ".usda"]
 
 
 def prepare_scene_name(
@@ -143,13 +144,19 @@ def deselect_all():
         if obj.mode != 'OBJECT':
             modes.append((obj, obj.mode))
             bpy.context.view_layer.objects.active = obj
-            bpy.ops.object.mode_set(mode='OBJECT')
+            context_override = create_blender_context(active=obj)
+            with bpy.context.temp_override(**context_override):
+                bpy.ops.object.mode_set(mode='OBJECT')
 
-    bpy.ops.object.select_all(action='DESELECT')
+    context_override = create_blender_context()
+    with bpy.context.temp_override(**context_override):
+        bpy.ops.object.select_all(action='DESELECT')
 
     for p in modes:
         bpy.context.view_layer.objects.active = p[0]
-        bpy.ops.object.mode_set(mode=p[1])
+        context_override = create_blender_context(active=p[0])
+        with bpy.context.temp_override(**context_override):
+            bpy.ops.object.mode_set(mode=p[1])
 
     bpy.context.view_layer.objects.active = active
 

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

@@ -0,0 +1,30 @@
+"""Create a USD Export."""
+
+from ayon_core.hosts.blender.api import plugin, lib
+
+
+class CreateUSD(plugin.BaseCreator):
+    """Create USD Export"""
+
+    identifier = "io.openpype.creators.blender.usd"
+    name = "usdMain"
+    label = "USD"
+    product_type = "usd"
+    icon = "gears"
+
+    def create(
+        self, product_name: str, instance_data: dict, pre_create_data: dict
+    ):
+        # Run parent create method
+        collection = super().create(
+            product_name, instance_data, pre_create_data
+        )
+
+        if pre_create_data.get("use_selection"):
+            objects = lib.get_selection()
+            for obj in objects:
+                collection.objects.link(obj)
+                if obj.type == 'EMPTY':
+                    objects.extend(obj.children)
+
+        return collection

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

@@ -26,10 +26,10 @@ class CacheModelLoader(plugin.AssetLoader):
     Note:
         At least for now it only supports Alembic files.
     """
-    product_types = {"model", "pointcache", "animation"}
-    representations = {"abc"}
+    product_types = {"model", "pointcache", "animation", "usd"}
+    representations = {"abc", "usd"}
 
-    label = "Load Alembic"
+    label = "Load Cache"
     icon = "code-fork"
     color = "orange"
 
@@ -53,10 +53,21 @@ class CacheModelLoader(plugin.AssetLoader):
         plugin.deselect_all()
 
         relative = bpy.context.preferences.filepaths.use_relative_paths
-        bpy.ops.wm.alembic_import(
-            filepath=libpath,
-            relative_path=relative
-        )
+
+        if any(libpath.lower().endswith(ext)
+               for ext in [".usd", ".usda", ".usdc"]):
+            # USD
+            bpy.ops.wm.usd_import(
+                filepath=libpath,
+                relative_path=relative
+            )
+
+        else:
+            # Alembic
+            bpy.ops.wm.alembic_import(
+                filepath=libpath,
+                relative_path=relative
+            )
 
         imported = lib.get_selection()
 

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

@@ -43,7 +43,10 @@ class AbcCameraLoader(plugin.AssetLoader):
     def _process(self, libpath, asset_group, group_name):
         plugin.deselect_all()
 
-        bpy.ops.wm.alembic_import(filepath=libpath)
+        # Force the creation of the transform cache even if the camera
+        # doesn't have an animation. We use the cache to update the camera.
+        bpy.ops.wm.alembic_import(
+            filepath=libpath, always_add_cache_reader=True)
 
         objects = lib.get_selection()
 
@@ -178,12 +181,33 @@ class AbcCameraLoader(plugin.AssetLoader):
             self.log.info("Library already loaded, not updating...")
             return
 
-        mat = asset_group.matrix_basis.copy()
+        for obj in asset_group.children:
+            found = False
+            for constraint in obj.constraints:
+                if constraint.type == "TRANSFORM_CACHE":
+                    constraint.cache_file.filepath = libpath.as_posix()
+                    found = True
+                    break
+            if not found:
+                # This is to keep compatibility with cameras loaded with
+                # the old loader
+                # Create a new constraint for the cache file
+                constraint = obj.constraints.new("TRANSFORM_CACHE")
+                bpy.ops.cachefile.open(filepath=libpath.as_posix())
+                constraint.cache_file = bpy.data.cache_files[-1]
+                constraint.cache_file.scale = 1.0
 
-        self._remove(asset_group)
-        self._process(str(libpath), asset_group, object_name)
+                # This is a workaround to set the object path. Blender doesn't
+                # load the list of object paths until the object is evaluated.
+                # This is a hack to force the object to be evaluated.
+                # The modifier doesn't need to be removed because camera
+                # objects don't have modifiers.
+                obj.modifiers.new(
+                    name='MeshSequenceCache', type='MESH_SEQUENCE_CACHE')
+                bpy.context.evaluated_depsgraph_get()
 
-        asset_group.matrix_basis = mat
+                constraint.object_path = (
+                    constraint.cache_file.object_paths[0].path)
 
         metadata["libpath"] = str(libpath)
         metadata["representation"] = repre_entity["id"]

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

@@ -12,7 +12,7 @@ class CollectBlenderInstanceData(pyblish.api.InstancePlugin):
     order = pyblish.api.CollectorOrder
     hosts = ["blender"]
     families = ["model", "pointcache", "animation", "rig", "camera", "layout",
-                "blendScene"]
+                "blendScene", "usd"]
     label = "Collect Instance"
 
     def process(self, instance):

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

@@ -0,0 +1,90 @@
+import os
+
+import bpy
+
+from ayon_core.pipeline import publish
+from ayon_core.hosts.blender.api import plugin, lib
+
+
+class ExtractUSD(publish.Extractor):
+    """Extract as USD."""
+
+    label = "Extract USD"
+    hosts = ["blender"]
+    families = ["usd"]
+
+    def process(self, instance):
+
+        # Ignore runtime instances (e.g. USD layers)
+        # TODO: This is better done via more specific `families`
+        if not instance.data.get("transientData", {}).get("instance_node"):
+            return
+
+        # Define extract output file path
+        stagingdir = self.staging_dir(instance)
+        filename = f"{instance.name}.usd"
+        filepath = os.path.join(stagingdir, filename)
+
+        # Perform extraction
+        self.log.debug("Performing extraction..")
+
+        # Select all members to "export selected"
+        plugin.deselect_all()
+
+        selected = []
+        for obj in instance:
+            if isinstance(obj, bpy.types.Object):
+                obj.select_set(True)
+                selected.append(obj)
+
+        root = lib.get_highest_root(objects=instance[:])
+        if not root:
+            instance_node = instance.data["transientData"]["instance_node"]
+            raise publish.KnownPublishError(
+                f"No root object found in instance: {instance_node.name}"
+            )
+        self.log.debug(f"Exporting using active root: {root.name}")
+
+        context = plugin.create_blender_context(
+            active=root, selected=selected)
+
+        # Export USD
+        with bpy.context.temp_override(**context):
+            bpy.ops.wm.usd_export(
+                filepath=filepath,
+                selected_objects_only=True,
+                export_textures=False,
+                relative_paths=False,
+                export_animation=False,
+                export_hair=False,
+                export_uvmaps=True,
+                # TODO: add for new version of Blender (4+?)
+                # export_mesh_colors=True,
+                export_normals=True,
+                export_materials=True,
+                use_instancing=True
+            )
+
+        plugin.deselect_all()
+
+        # Add representation
+        representation = {
+            'name': 'usd',
+            'ext': 'usd',
+            'files': filename,
+            "stagingDir": stagingdir,
+        }
+        instance.data.setdefault("representations", []).append(representation)
+        self.log.debug("Extracted instance '%s' to: %s",
+                       instance.name, representation)
+
+
+class ExtractModelUSD(ExtractUSD):
+    """Extract model as USD."""
+
+    label = "Extract USD (Model)"
+    hosts = ["blender"]
+    families = ["model"]
+
+    # Driven by settings
+    optional = True

client/ayon_core/hosts/flame/__init__.py

@@ -1,10 +0,0 @@
-from .addon import (
-    HOST_DIR,
-    FlameAddon,
-)
-
-
-__all__ = (
-    "HOST_DIR",
-    "FlameAddon",
-)

client/ayon_core/hosts/harmony/plugins/publish/collect_farm_render.py

@@ -177,7 +177,10 @@ class CollectFarmRender(publish.AbstractCollectRender):
                 outputFormat=info[1],
                 outputStartFrame=info[3],
                 leadingZeros=info[2],
-                ignoreFrameHandleCheck=True
+                ignoreFrameHandleCheck=True,
+                #todo: inst is not available, must be determined, fix when
+                #reworking to Publisher
+                # deadline=inst.data.get("deadline")
 
             )
             render_instance.context = context

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

@@ -1110,10 +1110,7 @@ def apply_colorspace_project():
     '''
     # backward compatibility layer
     # TODO: remove this after some time
-    config_data = get_imageio_config(
-        project_name=get_current_project_name(),
-        host_name="hiero"
-    )
+    config_data = get_current_context_imageio_config_preset()
 
     if config_data:
         presets.update({

client/ayon_core/hosts/houdini/plugins/publish/collect_pointcache_type.py

@@ -1,21 +0,0 @@
-"""Collector for pointcache types.
-
-This will add additional family to pointcache instance based on
-the creator_identifier parameter.
-"""
-import pyblish.api
-
-
-class CollectPointcacheType(pyblish.api.InstancePlugin):
-    """Collect data type for pointcache instance."""
-
-    order = pyblish.api.CollectorOrder
-    hosts = ["houdini"]
-    families = ["pointcache"]
-    label = "Collect type of pointcache"
-
-    def process(self, instance):
-        if instance.data["creator_identifier"] == "io.openpype.creators.houdini.bgeo":  # noqa: E501
-            instance.data["families"] += ["bgeo"]
-        elif instance.data["creator_identifier"] == "io.openpype.creators.houdini.pointcache":  # noqa: E501
-            instance.data["families"] += ["abc"]

client/ayon_core/hosts/maya/plugins/publish/validate_alembic_options_defaults.py

@@ -1,98 +0,0 @@
-import pyblish.api
-
-from ayon_core.pipeline import OptionalPyblishPluginMixin
-from ayon_core.pipeline.publish import RepairAction, PublishValidationError
-
-
-class ValidateAlembicDefaultsPointcache(
-    pyblish.api.InstancePlugin, OptionalPyblishPluginMixin
-):
-    """Validate the attributes on the instance are defaults.
-
-    The defaults are defined in the project settings.
-    """
-
-    order = pyblish.api.ValidatorOrder
-    families = ["pointcache"]
-    hosts = ["maya"]
-    label = "Validate Alembic Options Defaults"
-    actions = [RepairAction]
-    optional = True
-
-    plugin_name = "ExtractAlembic"
-
-    @classmethod
-    def _get_settings(cls, context):
-        maya_settings = context.data["project_settings"]["maya"]
-        settings = maya_settings["publish"]["ExtractAlembic"]
-        return settings
-
-    @classmethod
-    def _get_publish_attributes(cls, instance):
-        attributes = instance.data["publish_attributes"][
-            cls.plugin_name(
-                instance.data["publish_attributes"]
-            )
-        ]
-
-        return attributes
-
-    def process(self, instance):
-        if not self.is_active(instance.data):
-            return
-
-        settings = self._get_settings(instance.context)
-
-        attributes = self._get_publish_attributes(instance)
-
-        msg = (
-            "Alembic Extract setting \"{}\" is not the default value:"
-            "\nCurrent: {}"
-            "\nDefault Value: {}\n"
-        )
-        errors = []
-        for key, value in attributes.items():
-            default_value = settings[key]
-
-            # Lists are best to compared sorted since we cant rely on the order
-            # of the items.
-            if isinstance(value, list):
-                value = sorted(value)
-                default_value = sorted(default_value)
-
-            if value != default_value:
-                errors.append(msg.format(key, value, default_value))
-
-        if errors:
-            raise PublishValidationError("\n".join(errors))
-
-    @classmethod
-    def repair(cls, instance):
-        # Find create instance twin.
-        create_context = instance.context.data["create_context"]
-        create_instance = create_context.get_instance_by_id(
-            instance.data["instance_id"]
-        )
-
-        # Set the settings values on the create context then save to workfile.
-        publish_attributes = instance.data["publish_attributes"]
-        plugin_name = cls.plugin_name(publish_attributes)
-        attributes = cls._get_publish_attributes(instance)
-        settings = cls._get_settings(instance.context)
-        create_publish_attributes = create_instance.data["publish_attributes"]
-        for key in attributes:
-            create_publish_attributes[plugin_name][key] = settings[key]
-
-        create_context.save_changes()
-
-
-class ValidateAlembicDefaultsAnimation(
-    ValidateAlembicDefaultsPointcache
-):
-    """Validate the attributes on the instance are defaults.
-
-    The defaults are defined in the project settings.
-    """
-    label = "Validate Alembic Options   Defaults"
-    families = ["animation"]
-    plugin_name = "ExtractAnimation"

client/ayon_core/hosts/maya/plugins/publish/validate_animated_reference.py

@@ -1,71 +0,0 @@
-import pyblish.api
-import ayon_core.hosts.maya.api.action
-from ayon_core.pipeline.publish import (
-    PublishValidationError,
-    ValidateContentsOrder,
-    OptionalPyblishPluginMixin
-)
-from maya import cmds
-
-
-class ValidateAnimatedReferenceRig(pyblish.api.InstancePlugin,
-                                   OptionalPyblishPluginMixin):
-    """Validate all nodes in skeletonAnim_SET are referenced"""
-
-    order = ValidateContentsOrder
-    hosts = ["maya"]
-    families = ["animation.fbx"]
-    label = "Animated Reference Rig"
-    accepted_controllers = ["transform", "locator"]
-    actions = [ayon_core.hosts.maya.api.action.SelectInvalidAction]
-    optional = False
-
-    def process(self, instance):
-        if not self.is_active(instance.data):
-            return
-        animated_sets = instance.data.get("animated_skeleton", [])
-        if not animated_sets:
-            self.log.debug(
-                "No nodes found in skeletonAnim_SET. "
-                "Skipping validation of animated reference rig..."
-            )
-            return
-
-        for animated_reference in animated_sets:
-            is_referenced = cmds.referenceQuery(
-                animated_reference, isNodeReferenced=True)
-            if not bool(is_referenced):
-                raise PublishValidationError(
-                    "All the content in skeletonAnim_SET"
-                    " should be referenced nodes"
-                )
-        invalid_controls = self.validate_controls(animated_sets)
-        if invalid_controls:
-            raise PublishValidationError(
-                "All the content in skeletonAnim_SET"
-                " should be transforms"
-            )
-
-    @classmethod
-    def validate_controls(self, set_members):
-        """Check if the controller set contains only accepted node types.
-
-        Checks if all its set members are within the hierarchy of the root
-        Checks if the node types of the set members valid
-
-        Args:
-            set_members: list of nodes of the skeleton_anim_set
-            hierarchy: list of nodes which reside under the root node
-
-        Returns:
-            errors (list)
-        """
-
-        # Validate control types
-        invalid = []
-        set_members = cmds.ls(set_members, long=True)
-        for node in set_members:
-            if cmds.nodeType(node) not in self.accepted_controllers:
-                invalid.append(node)
-
-        return invalid

client/ayon_core/hosts/resolve/__init__.py

@@ -1,6 +0,0 @@
-from .addon import ResolveAddon
-
-
-__all__ = (
-    "ResolveAddon",
-)

client/ayon_core/hosts/unreal/lib.py

@@ -80,17 +80,21 @@ def get_engine_versions(env=None):
 def get_editor_exe_path(engine_path: Path, engine_version: str) -> Path:
     """Get UE Editor executable path."""
     ue_path = engine_path / "Engine/Binaries"
+
+    ue_name = "UnrealEditor"
+
+    # handle older versions of Unreal Engine
+    if engine_version.split(".")[0] == "4":
+        ue_name = "UE4Editor"
+
     if platform.system().lower() == "windows":
-        if engine_version.split(".")[0] == "4":
-            ue_path /= "Win64/UE4Editor.exe"
-        elif engine_version.split(".")[0] == "5":
-            ue_path /= "Win64/UnrealEditor.exe"
+            ue_path /= f"Win64/{ue_name}.exe"
 
     elif platform.system().lower() == "linux":
-        ue_path /= "Linux/UE4Editor"
+        ue_path /= f"Linux/{ue_name}"
 
     elif platform.system().lower() == "darwin":
-        ue_path /= "Mac/UE4Editor"
+        ue_path /= f"Mac/{ue_name}"
 
     return ue_path
 

client/ayon_core/lib/__init__.py

@@ -139,6 +139,7 @@ from .path_tools import (
 )
 
 from .ayon_info import (
+    is_in_ayon_launcher_process,
     is_running_from_build,
     is_using_ayon_console,
     is_staging_enabled,
@@ -248,6 +249,7 @@ __all__ = [
 
     "Logger",
 
+    "is_in_ayon_launcher_process",
     "is_running_from_build",
     "is_using_ayon_console",
     "is_staging_enabled",

client/ayon_core/lib/ayon_info.py

@@ -1,4 +1,5 @@
 import os
+import sys
 import json
 import datetime
 import platform
@@ -25,6 +26,18 @@ def get_ayon_launcher_version():
     return content["__version__"]
 
 
+def is_in_ayon_launcher_process():
+    """Determine if current process is running from AYON launcher.
+
+    Returns:
+        bool: True if running from AYON launcher.
+
+    """
+    ayon_executable_path = os.path.normpath(os.environ["AYON_EXECUTABLE"])
+    executable_path = os.path.normpath(sys.executable)
+    return ayon_executable_path == executable_path
+
+
 def is_running_from_build():
     """Determine if current process is running from build or code.
 

client/ayon_core/modules/clockify/__init__.py

@@ -1,5 +0,0 @@
-from .clockify_module import ClockifyModule
-
-__all__ = (
-    "ClockifyModule",
-)

client/ayon_core/modules/deadline/__init__.py

@@ -1,6 +1,8 @@
 from .deadline_module import DeadlineModule
+from .version import __version__
 
 
 __all__ = (
     "DeadlineModule",
+    "__version__"
 )

client/ayon_core/modules/deadline/abstract_submit_deadline.py

@@ -29,15 +29,11 @@ from ayon_core.pipeline.publish.lib import (
 JSONDecodeError = getattr(json.decoder, "JSONDecodeError", ValueError)
 
 
-# TODO both 'requests_post' and 'requests_get' should not set 'verify' based
-#   on environment variable. This should be done in a more controlled way,
-#   e.g. each deadline url could have checkbox to enabled/disable
-#   ssl verification.
 def requests_post(*args, **kwargs):
     """Wrap request post method.
 
-    Disabling SSL certificate validation if ``DONT_VERIFY_SSL`` environment
-    variable is found. This is useful when Deadline server is
+    Disabling SSL certificate validation if ``verify`` kwarg is set to False.
+    This is useful when Deadline server is
     running with self-signed certificates and its certificate is not
     added to trusted certificates on client machines.
 
@@ -46,9 +42,9 @@ def requests_post(*args, **kwargs):
         of defense SSL is providing, and it is not recommended.
 
     """
-    if 'verify' not in kwargs:
-        kwargs['verify'] = False if os.getenv("OPENPYPE_DONT_VERIFY_SSL",
-                                              True) else True  # noqa
+    auth = kwargs.get("auth")
+    if auth:
+        kwargs["auth"] = tuple(auth)  # explicit cast to tuple
     # add 10sec timeout before bailing out
     kwargs['timeout'] = 10
     return requests.post(*args, **kwargs)
@@ -57,8 +53,8 @@ def requests_post(*args, **kwargs):
 def requests_get(*args, **kwargs):
     """Wrap request get method.
 
-    Disabling SSL certificate validation if ``DONT_VERIFY_SSL`` environment
-    variable is found. This is useful when Deadline server is
+    Disabling SSL certificate validation if ``verify`` kwarg is set to False.
+    This is useful when Deadline server is
     running with self-signed certificates and its certificate is not
     added to trusted certificates on client machines.
 
@@ -67,9 +63,9 @@ def requests_get(*args, **kwargs):
         of defense SSL is providing, and it is not recommended.
 
     """
-    if 'verify' not in kwargs:
-        kwargs['verify'] = False if os.getenv("OPENPYPE_DONT_VERIFY_SSL",
-                                              True) else True  # noqa
+    auth = kwargs.get("auth")
+    if auth:
+        kwargs["auth"] = tuple(auth)
     # add 10sec timeout before bailing out
     kwargs['timeout'] = 10
     return requests.get(*args, **kwargs)
@@ -434,9 +430,7 @@ class AbstractSubmitDeadline(pyblish.api.InstancePlugin,
         """Plugin entry point."""
         self._instance = instance
         context = instance.context
-        self._deadline_url = context.data.get("defaultDeadline")
-        self._deadline_url = instance.data.get(
-            "deadlineUrl", self._deadline_url)
+        self._deadline_url = instance.data["deadline"]["url"]
 
         assert self._deadline_url, "Requires Deadline Webservice URL"
 
@@ -460,7 +454,9 @@ class AbstractSubmitDeadline(pyblish.api.InstancePlugin,
         self.plugin_info = self.get_plugin_info()
         self.aux_files = self.get_aux_files()
 
-        job_id = self.process_submission()
+        auth = instance.data["deadline"]["auth"]
+        verify = instance.data["deadline"]["verify"]
+        job_id = self.process_submission(auth, verify)
         self.log.info("Submitted job to Deadline: {}.".format(job_id))
 
         # TODO: Find a way that's more generic and not render type specific
@@ -473,10 +469,10 @@ class AbstractSubmitDeadline(pyblish.api.InstancePlugin,
                 job_info=render_job_info,
                 plugin_info=render_plugin_info
             )
-            render_job_id = self.submit(payload)
+            render_job_id = self.submit(payload, auth, verify)
             self.log.info("Render job id: %s", render_job_id)
 
-    def process_submission(self):
+    def process_submission(self, auth=None, verify=True):
         """Process data for submission.
 
         This takes Deadline JobInfo, PluginInfo, AuxFile, creates payload
@@ -487,7 +483,7 @@ class AbstractSubmitDeadline(pyblish.api.InstancePlugin,
 
         """
         payload = self.assemble_payload()
-        return self.submit(payload)
+        return self.submit(payload, auth, verify)
 
     @abstractmethod
     def get_job_info(self):
@@ -577,7 +573,7 @@ class AbstractSubmitDeadline(pyblish.api.InstancePlugin,
             "AuxFiles": aux_files or self.aux_files
         }
 
-    def submit(self, payload):
+    def submit(self, payload, auth, verify):
         """Submit payload to Deadline API end-point.
 
         This takes payload in the form of JSON file and POST it to
@@ -585,6 +581,8 @@ class AbstractSubmitDeadline(pyblish.api.InstancePlugin,
 
         Args:
             payload (dict): dict to become json in deadline submission.
+            auth (tuple): (username, password)
+            verify (bool): verify SSL certificate if present
 
         Returns:
             str: resulting Deadline job id.
@@ -594,7 +592,8 @@ class AbstractSubmitDeadline(pyblish.api.InstancePlugin,
 
         """
         url = "{}/api/jobs".format(self._deadline_url)
-        response = requests_post(url, json=payload)
+        response = requests_post(
+            url, json=payload, auth=auth, verify=verify)
         if not response.ok:
             self.log.error("Submission failed!")
             self.log.error(response.status_code)

client/ayon_core/modules/deadline/deadline_module.py

@@ -7,6 +7,8 @@ import six
 from ayon_core.lib import Logger
 from ayon_core.modules import AYONAddon, IPluginPaths
 
+from .version import __version__
+
 
 class DeadlineWebserviceError(Exception):
     """
@@ -16,26 +18,27 @@ class DeadlineWebserviceError(Exception):
 
 class DeadlineModule(AYONAddon, IPluginPaths):
     name = "deadline"
+    version = __version__
 
     def initialize(self, studio_settings):
         # This module is always enabled
-        deadline_urls = {}
+        deadline_servers_info = {}
         enabled = self.name in studio_settings
         if enabled:
             deadline_settings = studio_settings[self.name]
-            deadline_urls = {
-                url_item["name"]: url_item["value"]
+            deadline_servers_info = {
+                url_item["name"]: url_item
                 for url_item in deadline_settings["deadline_urls"]
             }
 
-        if enabled and not deadline_urls:
+        if enabled and not deadline_servers_info:
             enabled = False
             self.log.warning((
                 "Deadline Webservice URLs are not specified. Disabling addon."
             ))
 
         self.enabled = enabled
-        self.deadline_urls = deadline_urls
+        self.deadline_servers_info = deadline_servers_info
 
     def get_plugin_paths(self):
         """Deadline plugin paths."""
@@ -45,13 +48,15 @@ class DeadlineModule(AYONAddon, IPluginPaths):
         }
 
     @staticmethod
-    def get_deadline_pools(webservice, log=None):
+    def get_deadline_pools(webservice, auth=None, log=None):
         """Get pools from Deadline.
         Args:
             webservice (str): Server url.
-            log (Logger)
+             auth (Optional[Tuple[str, str]]): Tuple containing username,
+                password
+            log (Optional[Logger]): Logger to log errors to, if provided.
         Returns:
-            list: Pools.
+            List[str]: Pools.
         Throws:
             RuntimeError: If deadline webservice is unreachable.
 
@@ -63,7 +68,10 @@ class DeadlineModule(AYONAddon, IPluginPaths):
 
         argument = "{}/api/pools?NamesOnly=true".format(webservice)
         try:
-            response = requests_get(argument)
+            kwargs = {}
+            if auth:
+                kwargs["auth"] = auth
+            response = requests_get(argument, **kwargs)
         except requests.exceptions.ConnectionError as exc:
             msg = 'Cannot connect to DL web service {}'.format(webservice)
             log.error(msg)

client/ayon_core/modules/deadline/plugins/publish/collect_deadline_server_from_instance.py

@@ -13,17 +13,45 @@ class CollectDeadlineServerFromInstance(pyblish.api.InstancePlugin):
     """Collect Deadline Webservice URL from instance."""
 
     # Run before collect_render.
-    order = pyblish.api.CollectorOrder + 0.005
+    order = pyblish.api.CollectorOrder + 0.225
     label = "Deadline Webservice from the Instance"
-    families = ["rendering", "renderlayer"]
-    hosts = ["maya"]
+    targets = ["local"]
+    families = ["render",
+                "rendering",
+                "render.farm",
+                "renderFarm",
+                "renderlayer",
+                "maxrender",
+                "usdrender",
+                "redshift_rop",
+                "arnold_rop",
+                "mantra_rop",
+                "karma_rop",
+                "vray_rop",
+                "publish.hou",
+                "image"]  # for Fusion
 
     def process(self, instance):
-        instance.data["deadlineUrl"] = self._collect_deadline_url(instance)
-        instance.data["deadlineUrl"] = \
-            instance.data["deadlineUrl"].strip().rstrip("/")
+        if not instance.data.get("farm"):
+            self.log.debug("Should not be processed on farm, skipping.")
+            return
+
+        if not instance.data.get("deadline"):
+            instance.data["deadline"] = {}
+
+        # todo: separate logic should be removed, all hosts should have same
+        host_name = instance.context.data["hostName"]
+        if host_name == "maya":
+            deadline_url = self._collect_deadline_url(instance)
+        else:
+            deadline_url = (instance.data.get("deadlineUrl") or  # backwards
+                            instance.data.get("deadline", {}).get("url"))
+        if deadline_url:
+            instance.data["deadline"]["url"] = deadline_url.strip().rstrip("/")
+        else:
+            instance.data["deadline"]["url"] = instance.context.data["deadline"]["defaultUrl"]  # noqa
         self.log.debug(
-            "Using {} for submission.".format(instance.data["deadlineUrl"]))
+            "Using {} for submission".format(instance.data["deadline"]["url"]))
 
     def _collect_deadline_url(self, render_instance):
         # type: (pyblish.api.Instance) -> str
@@ -49,13 +77,13 @@ class CollectDeadlineServerFromInstance(pyblish.api.InstancePlugin):
             ["project_settings"]
             ["deadline"]
         )
-
-        default_server = render_instance.context.data["defaultDeadline"]
+        default_server_url = (render_instance.context.data["deadline"]
+                                                          ["defaultUrl"])
         # QUESTION How and where is this is set? Should be removed?
         instance_server = render_instance.data.get("deadlineServers")
         if not instance_server:
             self.log.debug("Using default server.")
-            return default_server
+            return default_server_url
 
         # Get instance server as sting.
         if isinstance(instance_server, int):
@@ -66,7 +94,7 @@ class CollectDeadlineServerFromInstance(pyblish.api.InstancePlugin):
 
         default_servers = {
             url_item["name"]: url_item["value"]
-            for url_item in deadline_settings["deadline_urls"]
+            for url_item in deadline_settings["deadline_servers_info"]
         }
         project_servers = (
             render_instance.context.data

client/ayon_core/modules/deadline/plugins/publish/collect_default_deadline_server.py

@@ -18,10 +18,9 @@ class CollectDefaultDeadlineServer(pyblish.api.ContextPlugin):
     """
 
     # Run before collect_deadline_server_instance.
-    order = pyblish.api.CollectorOrder + 0.0025
+    order = pyblish.api.CollectorOrder + 0.200
     label = "Default Deadline Webservice"
-
-    pass_mongo_url = False
+    targets = ["local"]
 
     def process(self, context):
         try:
@@ -33,15 +32,17 @@ class CollectDefaultDeadlineServer(pyblish.api.ContextPlugin):
         deadline_settings = context.data["project_settings"]["deadline"]
         deadline_server_name = deadline_settings["deadline_server"]
 
-        deadline_webservice = None
+        dl_server_info = None
         if deadline_server_name:
-            deadline_webservice = deadline_module.deadline_urls.get(
+            dl_server_info = deadline_module.deadline_servers_info.get(
                 deadline_server_name)
 
-        default_deadline_webservice = deadline_module.deadline_urls["default"]
-        deadline_webservice = (
-            deadline_webservice
-            or default_deadline_webservice
-        )
+        if dl_server_info:
+            deadline_url = dl_server_info["value"]
+        else:
+            default_dl_server_info = deadline_module.deadline_servers_info[0]
+            deadline_url = default_dl_server_info["value"]
 
-        context.data["defaultDeadline"] = deadline_webservice.strip().rstrip("/")  # noqa
+        context.data["deadline"] = {}
+        context.data["deadline"]["defaultUrl"] = (
+            deadline_url.strip().rstrip("/"))

client/ayon_core/modules/deadline/plugins/publish/collect_pools.py

@@ -26,27 +26,32 @@ class CollectDeadlinePools(pyblish.api.InstancePlugin,
 
     order = pyblish.api.CollectorOrder + 0.420
     label = "Collect Deadline Pools"
-    hosts = ["aftereffects",
-             "fusion",
-             "harmony"
-             "nuke",
-             "maya",
-             "max",
-             "houdini"]
+    hosts = [
+        "aftereffects",
+        "fusion",
+        "harmony",
+        "maya",
+        "max",
+        "houdini",
+        "nuke",
+    ]
 
-    families = ["render",
-                "rendering",
-                "render.farm",
-                "renderFarm",
-                "renderlayer",
-                "maxrender",
-                "usdrender",
-                "redshift_rop",
-                "arnold_rop",
-                "mantra_rop",
-                "karma_rop",
-                "vray_rop",
-                "publish.hou"]
+    families = [
+        "render",
+        "prerender",
+        "rendering",
+        "render.farm",
+        "renderFarm",
+        "renderlayer",
+        "maxrender",
+        "usdrender",
+        "redshift_rop",
+        "arnold_rop",
+        "mantra_rop",
+        "karma_rop",
+        "vray_rop",
+        "publish.hou",
+    ]
 
     primary_pool = None
     secondary_pool = None

client/ayon_core/modules/deadline/plugins/publish/collect_user_credentials.py

@@ -0,0 +1,92 @@
+# -*- coding: utf-8 -*-
+"""Collect user credentials
+
+Requires:
+    context -> project_settings
+    instance.data["deadline"]["url"]
+
+Provides:
+    instance.data["deadline"] -> require_authentication (bool)
+    instance.data["deadline"] -> auth (tuple (str, str)) -
+        (username, password) or None
+"""
+import pyblish.api
+
+from ayon_api import get_server_api_connection
+from ayon_core.modules.deadline.deadline_module import DeadlineModule
+from ayon_core.modules.deadline import __version__
+
+
+class CollectDeadlineUserCredentials(pyblish.api.InstancePlugin):
+    """Collects user name and password for artist if DL requires authentication
+    """
+    order = pyblish.api.CollectorOrder + 0.250
+    label = "Collect Deadline User Credentials"
+
+    targets = ["local"]
+    hosts = ["aftereffects",
+             "blender",
+             "fusion",
+             "harmony",
+             "nuke",
+             "maya",
+             "max",
+             "houdini"]
+
+    families = ["render",
+                "rendering",
+                "render.farm",
+                "renderFarm",
+                "renderlayer",
+                "maxrender",
+                "usdrender",
+                "redshift_rop",
+                "arnold_rop",
+                "mantra_rop",
+                "karma_rop",
+                "vray_rop",
+                "publish.hou"]
+
+    def process(self, instance):
+        if not instance.data.get("farm"):
+            self.log.debug("Should not be processed on farm, skipping.")
+            return
+
+        collected_deadline_url = instance.data["deadline"]["url"]
+        if not collected_deadline_url:
+            raise ValueError("Instance doesn't have '[deadline][url]'.")
+        context_data = instance.context.data
+        deadline_settings = context_data["project_settings"]["deadline"]
+
+        deadline_server_name = None
+        # deadline url might be set directly from instance, need to find
+        # metadata for it
+        for deadline_info in deadline_settings["deadline_urls"]:
+            dl_settings_url = deadline_info["value"].strip().rstrip("/")
+            if dl_settings_url == collected_deadline_url:
+                deadline_server_name = deadline_info["name"]
+                break
+
+        if not deadline_server_name:
+            raise ValueError(f"Collected {collected_deadline_url} doesn't " 
+                              "match any site configured in Studio Settings")
+
+        instance.data["deadline"]["require_authentication"] = (
+            deadline_info["require_authentication"]
+        )
+        instance.data["deadline"]["auth"] = None
+
+        instance.data["deadline"]["verify"] = (
+            not deadline_info["not_verify_ssl"])
+
+        if not deadline_info["require_authentication"]:
+            return
+        # TODO import 'get_addon_site_settings' when available 
+        #   in public 'ayon_api'
+        local_settings = get_server_api_connection().get_addon_site_settings(
+            DeadlineModule.name, __version__)
+        local_settings = local_settings["local_settings"]
+        for server_info in local_settings:
+            if deadline_server_name == server_info["server_name"]:
+                instance.data["deadline"]["auth"] = (server_info["username"],
+                                                     server_info["password"])

client/ayon_core/modules/deadline/plugins/publish/help/validate_deadline_connection.xml

@@ -0,0 +1,17 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<root>
+    <error id="main">
+        <title>Deadline Authentication</title>
+        <description>
+## Deadline authentication is required
+
+This project has set in Settings that Deadline requires authentication.
+
+### How to repair?
+
+Please go to Ayon Server > Site Settings and provide your Deadline username and password.
+In some cases the password may be empty if Deadline is configured to allow that. Ask your administrator.
+
+        </description>
+    </error>
+</root>

client/ayon_core/modules/deadline/plugins/publish/submit_blender_deadline.py

@@ -174,7 +174,9 @@ class BlenderSubmitDeadline(abstract_submit_deadline.AbstractSubmitDeadline,
         instance.data["toBeRenderedOn"] = "deadline"
 
         payload = self.assemble_payload()
-        return self.submit(payload)
+        auth = instance.data["deadline"]["auth"]
+        verify = instance.data["deadline"]["verify"]
+        return self.submit(payload, auth=auth, verify=verify)
 
     def from_published_scene(self):
         """

client/ayon_core/modules/deadline/plugins/publish/submit_celaction_deadline.py

@@ -2,9 +2,10 @@ import os
 import re
 import json
 import getpass
-import requests
 import pyblish.api
 
+from openpype_modules.deadline.abstract_submit_deadline import requests_post
+
 
 class CelactionSubmitDeadline(pyblish.api.InstancePlugin):
     """Submit CelAction2D scene to Deadline
@@ -30,11 +31,7 @@ class CelactionSubmitDeadline(pyblish.api.InstancePlugin):
 
         context = instance.context
 
-        # get default deadline webservice url from deadline module
-        deadline_url = instance.context.data["defaultDeadline"]
-        # if custom one is set in instance, use that
-        if instance.data.get("deadlineUrl"):
-            deadline_url = instance.data.get("deadlineUrl")
+        deadline_url = instance.data["deadline"]["url"]
         assert deadline_url, "Requires Deadline Webservice URL"
 
         self.deadline_url = "{}/api/jobs".format(deadline_url)
@@ -196,8 +193,11 @@ class CelactionSubmitDeadline(pyblish.api.InstancePlugin):
         self.expected_files(instance, render_path)
         self.log.debug("__ expectedFiles: `{}`".format(
             instance.data["expectedFiles"]))
-
-        response = requests.post(self.deadline_url, json=payload)
+        auth = instance.data["deadline"]["auth"]
+        verify = instance.data["deadline"]["verify"]
+        response = requests_post(self.deadline_url, json=payload,
+                                 auth=auth,
+                                 verify=verify)
 
         if not response.ok:
             self.log.error(

client/ayon_core/modules/deadline/plugins/publish/submit_fusion_deadline.py

@@ -2,17 +2,13 @@ import os
 import json
 import getpass
 
-import requests
-
 import pyblish.api
 
+from openpype_modules.deadline.abstract_submit_deadline import requests_post
 from ayon_core.pipeline.publish import (
     AYONPyblishPluginMixin
 )
-from ayon_core.lib import (
-    BoolDef,
-    NumberDef,
-)
+from ayon_core.lib import NumberDef
 
 
 class FusionSubmitDeadline(
@@ -64,11 +60,6 @@ class FusionSubmitDeadline(
                 decimals=0,
                 minimum=1,
                 maximum=10
-            ),
-            BoolDef(
-                "suspend_publish",
-                default=False,
-                label="Suspend publish"
             )
         ]
 
@@ -80,10 +71,6 @@ class FusionSubmitDeadline(
         attribute_values = self.get_attr_values_from_data(
             instance.data)
 
-        # add suspend_publish attributeValue to instance data
-        instance.data["suspend_publish"] = attribute_values[
-            "suspend_publish"]
-
         context = instance.context
 
         key = "__hasRun{}".format(self.__class__.__name__)
@@ -92,13 +79,9 @@ class FusionSubmitDeadline(
         else:
             context.data[key] = True
 
-        from ayon_core.hosts.fusion.api.lib import get_frame_path
+        from ayon_fusion.api.lib import get_frame_path
 
-        # get default deadline webservice url from deadline module
-        deadline_url = instance.context.data["defaultDeadline"]
-        # if custom one is set in instance, use that
-        if instance.data.get("deadlineUrl"):
-            deadline_url = instance.data.get("deadlineUrl")
+        deadline_url = instance.data["deadline"]["url"]
         assert deadline_url, "Requires Deadline Webservice URL"
 
         # Collect all saver instances in context that are to be rendered
@@ -258,7 +241,9 @@ class FusionSubmitDeadline(
 
         # E.g. http://192.168.0.1:8082/api/jobs
         url = "{}/api/jobs".format(deadline_url)
-        response = requests.post(url, json=payload)
+        auth = instance.data["deadline"]["auth"]
+        verify = instance.data["deadline"]["verify"]
+        response = requests_post(url, json=payload, auth=auth, verify=verify)
         if not response.ok:
             raise Exception(response.text)
 

client/ayon_core/modules/deadline/plugins/publish/submit_houdini_render_deadline.py

@@ -10,7 +10,6 @@ from openpype_modules.deadline import abstract_submit_deadline
 from openpype_modules.deadline.abstract_submit_deadline import DeadlineJobInfo
 from ayon_core.lib import (
     is_in_tests,
-    BoolDef,
     TextDef,
     NumberDef
 )
@@ -86,15 +85,10 @@ class HoudiniSubmitDeadline(
     priority = 50
     chunk_size = 1
     group = ""
-    
+
     @classmethod
     def get_attribute_defs(cls):
         return [
-            BoolDef(
-                "suspend_publish",
-                default=False,
-                label="Suspend publish"
-            ),
             NumberDef(
                 "priority",
                 label="Priority",
@@ -194,7 +188,7 @@ class HoudiniSubmitDeadline(
 
         job_info.Pool = instance.data.get("primaryPool")
         job_info.SecondaryPool = instance.data.get("secondaryPool")
-        
+
         if split_render_job and is_export_job:
             job_info.Priority = attribute_values.get(
                 "export_priority", self.export_priority
@@ -315,6 +309,11 @@ class HoudiniSubmitDeadline(
         return attr.asdict(plugin_info)
 
     def process(self, instance):
+        if not instance.data["farm"]:
+            self.log.debug("Render on farm is disabled. "
+                           "Skipping deadline submission.")
+            return
+
         super(HoudiniSubmitDeadline, self).process(instance)
 
         # TODO: Avoid the need for this logic here, needed for submit publish

client/ayon_core/modules/deadline/plugins/publish/submit_max_deadline.py

@@ -15,11 +15,11 @@ from ayon_core.pipeline.publish.lib import (
     replace_with_published_scene_path
 )
 from ayon_core.pipeline.publish import KnownPublishError
-from ayon_core.hosts.max.api.lib import (
+from ayon_max.api.lib import (
     get_current_renderer,
     get_multipass_setting
 )
-from ayon_core.hosts.max.api.lib_rendersettings import RenderSettings
+from ayon_max.api.lib_rendersettings import RenderSettings
 from openpype_modules.deadline import abstract_submit_deadline
 from openpype_modules.deadline.abstract_submit_deadline import DeadlineJobInfo
 
@@ -181,25 +181,35 @@ class MaxSubmitDeadline(abstract_submit_deadline.AbstractSubmitDeadline,
 
         self.log.debug("Submitting 3dsMax render..")
         project_settings = instance.context.data["project_settings"]
+        auth = instance.data["deadline"]["auth"]
+        verify = instance.data["deadline"]["verify"]
         if instance.data.get("multiCamera"):
             self.log.debug("Submitting jobs for multiple cameras..")
             payload = self._use_published_name_for_multiples(
                 payload_data, project_settings)
             job_infos, plugin_infos = payload
             for job_info, plugin_info in zip(job_infos, plugin_infos):
-                self.submit(self.assemble_payload(job_info, plugin_info))
+                self.submit(
+                    self.assemble_payload(job_info, plugin_info),
+                    auth=auth,
+                    verify=verify
+                )
         else:
             payload = self._use_published_name(payload_data, project_settings)
             job_info, plugin_info = payload
-            self.submit(self.assemble_payload(job_info, plugin_info))
+            self.submit(
+                self.assemble_payload(job_info, plugin_info),
+                auth=auth,
+                verify=verify
+            )
 
     def _use_published_name(self, data, project_settings):
         # Not all hosts can import these modules.
-        from ayon_core.hosts.max.api.lib import (
+        from ayon_max.api.lib import (
             get_current_renderer,
             get_multipass_setting
         )
-        from ayon_core.hosts.max.api.lib_rendersettings import RenderSettings
+        from ayon_max.api.lib_rendersettings import RenderSettings
 
         instance = self._instance
         job_info = copy.deepcopy(self.job_info)

client/ayon_core/modules/deadline/plugins/publish/submit_maya_deadline.py

@@ -39,8 +39,8 @@ from ayon_core.lib import (
     EnumDef,
     is_in_tests,
 )
-from ayon_core.hosts.maya.api.lib_rendersettings import RenderSettings
-from ayon_core.hosts.maya.api.lib import get_attr_in_layer
+from ayon_maya.api.lib_rendersettings import RenderSettings
+from ayon_maya.api.lib import get_attr_in_layer
 
 from openpype_modules.deadline import abstract_submit_deadline
 from openpype_modules.deadline.abstract_submit_deadline import DeadlineJobInfo
@@ -292,7 +292,7 @@ class MayaSubmitDeadline(abstract_submit_deadline.AbstractSubmitDeadline,
 
         return plugin_payload
 
-    def process_submission(self):
+    def process_submission(self, auth=None, verify=True):
         from maya import cmds
         instance = self._instance
 
@@ -332,7 +332,10 @@ class MayaSubmitDeadline(abstract_submit_deadline.AbstractSubmitDeadline,
         if "vrayscene" in instance.data["families"]:
             self.log.debug("Submitting V-Ray scene render..")
             vray_export_payload = self._get_vray_export_payload(payload_data)
-            export_job = self.submit(vray_export_payload)
+
+            export_job = self.submit(vray_export_payload,
+                                     auth=auth,
+                                     verify=verify)
 
             payload = self._get_vray_render_payload(payload_data)
 
@@ -351,7 +354,9 @@ class MayaSubmitDeadline(abstract_submit_deadline.AbstractSubmitDeadline,
         else:
             # Submit main render job
             job_info, plugin_info = payload
-            self.submit(self.assemble_payload(job_info, plugin_info))
+            self.submit(self.assemble_payload(job_info, plugin_info),
+                        auth=auth,
+                        verify=verify)
 
     def _tile_render(self, payload):
         """Submit as tile render per frame with dependent assembly jobs."""
@@ -451,7 +456,8 @@ class MayaSubmitDeadline(abstract_submit_deadline.AbstractSubmitDeadline,
         # Submit frame tile jobs
         frame_tile_job_id = {}
         for frame, tile_job_payload in frame_payloads.items():
-            job_id = self.submit(tile_job_payload)
+            job_id = self.submit(tile_job_payload,
+                                 instance.data["deadline"]["auth"])
             frame_tile_job_id[frame] = job_id
 
         # Define assembly payloads
@@ -554,12 +560,18 @@ class MayaSubmitDeadline(abstract_submit_deadline.AbstractSubmitDeadline,
         # Submit assembly jobs
         assembly_job_ids = []
         num_assemblies = len(assembly_payloads)
+        auth = instance.data["deadline"]["auth"]
+        verify = instance.data["deadline"]["verify"]
         for i, payload in enumerate(assembly_payloads):
             self.log.debug(
                 "submitting assembly job {} of {}".format(i + 1,
                                                           num_assemblies)
             )
-            assembly_job_id = self.submit(payload)
+            assembly_job_id = self.submit(
+                payload,
+                auth=auth,
+                verify=verify
+            )
             assembly_job_ids.append(assembly_job_id)
 
         instance.data["assemblySubmissionJobs"] = assembly_job_ids

client/ayon_core/modules/deadline/plugins/publish/submit_nuke_deadline.py

@@ -4,9 +4,9 @@ import json
 import getpass
 from datetime import datetime
 
-import requests
 import pyblish.api
 
+from openpype_modules.deadline.abstract_submit_deadline import requests_post
 from ayon_core.pipeline.publish import (
     AYONPyblishPluginMixin
 )
@@ -76,11 +76,6 @@ class NukeSubmitDeadline(pyblish.api.InstancePlugin,
                 default=cls.use_gpu,
                 label="Use GPU"
             ),
-            BoolDef(
-                "suspend_publish",
-                default=False,
-                label="Suspend publish"
-            ),
             BoolDef(
                 "workfile_dependency",
                 default=cls.workfile_dependency,
@@ -100,20 +95,12 @@ class NukeSubmitDeadline(pyblish.api.InstancePlugin,
         instance.data["attributeValues"] = self.get_attr_values_from_data(
             instance.data)
 
-        # add suspend_publish attributeValue to instance data
-        instance.data["suspend_publish"] = instance.data["attributeValues"][
-            "suspend_publish"]
-
         families = instance.data["families"]
 
         node = instance.data["transientData"]["node"]
         context = instance.context
 
-        # get default deadline webservice url from deadline module
-        deadline_url = instance.context.data["defaultDeadline"]
-        # if custom one is set in instance, use that
-        if instance.data.get("deadlineUrl"):
-            deadline_url = instance.data.get("deadlineUrl")
+        deadline_url = instance.data["deadline"]["url"]
         assert deadline_url, "Requires Deadline Webservice URL"
 
         self.deadline_url = "{}/api/jobs".format(deadline_url)
@@ -436,7 +423,13 @@ class NukeSubmitDeadline(pyblish.api.InstancePlugin,
 
         self.log.debug("__ expectedFiles: `{}`".format(
             instance.data["expectedFiles"]))
-        response = requests.post(self.deadline_url, json=payload, timeout=10)
+        auth = instance.data["deadline"]["auth"]
+        verify = instance.data["deadline"]["verify"]
+        response = requests_post(self.deadline_url,
+                                 json=payload,
+                                 timeout=10,
+                                 auth=auth,
+                                 verify=verify)
 
         if not response.ok:
             raise Exception(response.text)

client/ayon_core/modules/deadline/plugins/publish/submit_publish_cache_job.py

@@ -5,10 +5,10 @@ import json
 import re
 from copy import deepcopy
 
-import requests
 import ayon_api
 import pyblish.api
 
+from openpype_modules.deadline.abstract_submit_deadline import requests_post
 from ayon_core.pipeline import publish
 from ayon_core.lib import EnumDef, is_in_tests
 from ayon_core.pipeline.version_start import get_versioning_start
@@ -147,9 +147,6 @@ class ProcessSubmittedCacheJobOnFarm(pyblish.api.InstancePlugin,
 
         instance_settings = self.get_attr_values_from_data(instance.data)
         initial_status = instance_settings.get("publishJobState", "Active")
-        # TODO: Remove this backwards compatibility of `suspend_publish`
-        if instance.data.get("suspend_publish"):
-            initial_status = "Suspended"
 
         args = [
             "--headless",
@@ -212,7 +209,10 @@ class ProcessSubmittedCacheJobOnFarm(pyblish.api.InstancePlugin,
         self.log.debug("Submitting Deadline publish job ...")
 
         url = "{}/api/jobs".format(self.deadline_url)
-        response = requests.post(url, json=payload, timeout=10)
+        auth = instance.data["deadline"]["auth"]
+        verify = instance.data["deadline"]["verify"]
+        response = requests_post(
+            url, json=payload, timeout=10, auth=auth, verify=verify)
         if not response.ok:
             raise Exception(response.text)
 
@@ -344,11 +344,7 @@ class ProcessSubmittedCacheJobOnFarm(pyblish.api.InstancePlugin,
 
         deadline_publish_job_id = None
         if submission_type == "deadline":
-            # get default deadline webservice url from deadline module
-            self.deadline_url = instance.context.data["defaultDeadline"]
-            # if custom one is set in instance, use that
-            if instance.data.get("deadlineUrl"):
-                self.deadline_url = instance.data.get("deadlineUrl")
+            self.deadline_url = instance.data["deadline"]["url"]
             assert self.deadline_url, "Requires Deadline Webservice URL"
 
             deadline_publish_job_id = \
@@ -356,7 +352,9 @@ class ProcessSubmittedCacheJobOnFarm(pyblish.api.InstancePlugin,
 
             # Inject deadline url to instances.
             for inst in instances:
-                inst["deadlineUrl"] = self.deadline_url
+                if "deadline" not in inst:
+                    inst["deadline"] = {}
+                inst["deadline"] = instance.data["deadline"]
 
         # publish job file
         publish_job = {

client/ayon_core/modules/deadline/plugins/publish/submit_publish_job.py

@@ -5,11 +5,11 @@ import json
 import re
 from copy import deepcopy
 
-import requests
 import clique
 import ayon_api
 import pyblish.api
 
+from openpype_modules.deadline.abstract_submit_deadline import requests_post
 from ayon_core.pipeline import publish
 from ayon_core.lib import EnumDef, is_in_tests
 from ayon_core.pipeline.version_start import get_versioning_start
@@ -88,9 +88,9 @@ class ProcessSubmittedJobOnFarm(pyblish.api.InstancePlugin,
     hosts = ["fusion", "max", "maya", "nuke", "houdini",
              "celaction", "aftereffects", "harmony", "blender"]
 
-    families = ["render.farm", "render.frames_farm",
-                "prerender.farm", "prerender.frames_farm",
-                "renderlayer", "imagesequence",
+    families = ["render", "render.farm", "render.frames_farm",
+                "prerender", "prerender.farm", "prerender.frames_farm",
+                "renderlayer", "imagesequence", "image",
                 "vrayscene", "maxrender",
                 "arnold_rop", "mantra_rop",
                 "karma_rop", "vray_rop",
@@ -224,9 +224,6 @@ class ProcessSubmittedJobOnFarm(pyblish.api.InstancePlugin,
 
         instance_settings = self.get_attr_values_from_data(instance.data)
         initial_status = instance_settings.get("publishJobState", "Active")
-        # TODO: Remove this backwards compatibility of `suspend_publish`
-        if instance.data.get("suspend_publish"):
-            initial_status = "Suspended"
 
         args = [
             "--headless",
@@ -306,7 +303,10 @@ class ProcessSubmittedJobOnFarm(pyblish.api.InstancePlugin,
         self.log.debug("Submitting Deadline publish job ...")
 
         url = "{}/api/jobs".format(self.deadline_url)
-        response = requests.post(url, json=payload, timeout=10)
+        auth = instance.data["deadline"]["auth"]
+        verify = instance.data["deadline"]["verify"]
+        response = requests_post(
+            url, json=payload, timeout=10, auth=auth, verify=verify)
         if not response.ok:
             raise Exception(response.text)
 
@@ -314,7 +314,6 @@ class ProcessSubmittedJobOnFarm(pyblish.api.InstancePlugin,
 
         return deadline_publish_job_id
 
-
     def process(self, instance):
         # type: (pyblish.api.Instance) -> None
         """Process plugin.
@@ -461,18 +460,15 @@ class ProcessSubmittedJobOnFarm(pyblish.api.InstancePlugin,
             }
 
         # get default deadline webservice url from deadline module
-        self.deadline_url = instance.context.data["defaultDeadline"]
-        # if custom one is set in instance, use that
-        if instance.data.get("deadlineUrl"):
-            self.deadline_url = instance.data.get("deadlineUrl")
+        self.deadline_url = instance.data["deadline"]["url"]
         assert self.deadline_url, "Requires Deadline Webservice URL"
 
         deadline_publish_job_id = \
             self._submit_deadline_post_job(instance, render_job, instances)
 
-        # Inject deadline url to instances.
+        # Inject deadline url to instances to query DL for job id for overrides
         for inst in instances:
-            inst["deadlineUrl"] = self.deadline_url
+            inst["deadline"] = instance.data["deadline"]
 
         # publish job file
         publish_job = {

client/ayon_core/modules/deadline/plugins/publish/validate_deadline_connection.py

@@ -1,5 +1,7 @@
 import pyblish.api
 
+from ayon_core.pipeline import PublishXmlValidationError
+
 from openpype_modules.deadline.abstract_submit_deadline import requests_get
 
 
@@ -8,27 +10,42 @@ class ValidateDeadlineConnection(pyblish.api.InstancePlugin):
 
     label = "Validate Deadline Web Service"
     order = pyblish.api.ValidatorOrder
-    hosts = ["maya", "nuke"]
-    families = ["renderlayer", "render"]
+    hosts = ["maya", "nuke", "aftereffects", "harmony", "fusion"]
+    families = ["renderlayer", "render", "render.farm"]
 
     # cache
     responses = {}
 
     def process(self, instance):
-        # get default deadline webservice url from deadline module
-        deadline_url = instance.context.data["defaultDeadline"]
-        # if custom one is set in instance, use that
-        if instance.data.get("deadlineUrl"):
-            deadline_url = instance.data.get("deadlineUrl")
-            self.log.debug(
-                "We have deadline URL on instance {}".format(deadline_url)
-            )
+        if not instance.data.get("farm"):
+            self.log.debug("Should not be processed on farm, skipping.")
+            return
+
+        deadline_url = instance.data["deadline"]["url"]
         assert deadline_url, "Requires Deadline Webservice URL"
 
+        kwargs = {}
+        if instance.data["deadline"]["require_authentication"]:
+            auth = instance.data["deadline"]["auth"]
+            kwargs["auth"] = auth
+
+            if not auth[0]:
+                raise PublishXmlValidationError(
+                    self,
+                    "Deadline requires authentication. "
+                    "At least username is required to be set in "
+                    "Site Settings.")
+
         if deadline_url not in self.responses:
-            self.responses[deadline_url] = requests_get(deadline_url)
+            self.responses[deadline_url] = requests_get(deadline_url, **kwargs)
 
         response = self.responses[deadline_url]
+        if response.status_code == 401:
+            raise PublishXmlValidationError(
+                self,
+                "Deadline requires authentication. "
+                "Provided credentials are not working. "
+                "Please change them in Site Settings")
         assert response.ok, "Response must be ok"
         assert response.text.startswith("Deadline Web Service "), (
             "Web service did not respond with 'Deadline Web Service'"

client/ayon_core/modules/deadline/plugins/publish/validate_deadline_pools.py

@@ -37,8 +37,9 @@ class ValidateDeadlinePools(OptionalPyblishPluginMixin,
             self.log.debug("Skipping local instance.")
             return
 
-        deadline_url = self.get_deadline_url(instance)
-        pools = self.get_pools(deadline_url)
+        deadline_url = instance.data["deadline"]["url"]
+        pools = self.get_pools(deadline_url,
+                               instance.data["deadline"].get("auth"))
 
         invalid_pools = {}
         primary_pool = instance.data.get("primaryPool")
@@ -61,22 +62,18 @@ class ValidateDeadlinePools(OptionalPyblishPluginMixin,
                 formatting_data={"pools_str": ", ".join(pools)}
             )
 
-    def get_deadline_url(self, instance):
-        # get default deadline webservice url from deadline module
-        deadline_url = instance.context.data["defaultDeadline"]
-        if instance.data.get("deadlineUrl"):
-            # if custom one is set in instance, use that
-            deadline_url = instance.data.get("deadlineUrl")
-        return deadline_url
-
-    def get_pools(self, deadline_url):
+    def get_pools(self, deadline_url, auth):
         if deadline_url not in self.pools_per_url:
             self.log.debug(
                 "Querying available pools for Deadline url: {}".format(
                     deadline_url)
             )
             pools = DeadlineModule.get_deadline_pools(deadline_url,
+                                                      auth=auth,
                                                       log=self.log)
+            # some DL return "none" as a pool name
+            if "none" not in pools:
+                pools.append("none")
             self.log.info("Available pools: {}".format(pools))
             self.pools_per_url[deadline_url] = pools
 

client/ayon_core/modules/deadline/plugins/publish/validate_expected_and_rendered_files.py

@@ -199,16 +199,16 @@ class ValidateExpectedFiles(pyblish.api.InstancePlugin):
             (dict): Job info from Deadline
 
         """
-        # get default deadline webservice url from deadline module
-        deadline_url = instance.context.data["defaultDeadline"]
-        # if custom one is set in instance, use that
-        if instance.data.get("deadlineUrl"):
-            deadline_url = instance.data.get("deadlineUrl")
+        deadline_url = instance.data["deadline"]["url"]
         assert deadline_url, "Requires Deadline Webservice URL"
 
         url = "{}/api/jobs?JobID={}".format(deadline_url, job_id)
         try:
-            response = requests_get(url)
+            kwargs = {}
+            auth = instance.data["deadline"]["auth"]
+            if auth:
+                kwargs["auth"] = auth
+            response = requests_get(url, **kwargs)
         except requests.exceptions.ConnectionError:
             self.log.error("Deadline is not accessible at "
                            "{}".format(deadline_url))

client/ayon_core/modules/deadline/version.py

@@ -0,0 +1 @@
+__version__ = "0.1.12"

client/ayon_core/modules/job_queue/__init__.py

@@ -1,6 +1,9 @@
+from .version import __version__
 from .addon import JobQueueAddon
 
 
 __all__ = (
+    "__version__",
+
     "JobQueueAddon",
 )

client/ayon_core/modules/job_queue/addon.py

@@ -44,9 +44,12 @@ import platform
 from ayon_core.addon import AYONAddon, click_wrap
 from ayon_core.settings import get_studio_settings
 
+from .version import __version__
+
 
 class JobQueueAddon(AYONAddon):
     name = "job_queue"
+    version = __version__
 
     def initialize(self, studio_settings):
         addon_settings = studio_settings.get(self.name) or {}

client/ayon_core/modules/job_queue/version.py

@@ -0,0 +1 @@
+__version__ = "1.0.0"

client/ayon_core/modules/launcher_action.py

@@ -7,6 +7,7 @@ from ayon_core.addon import AYONAddon, ITrayAction
 class LauncherAction(AYONAddon, ITrayAction):
     label = "Launcher"
     name = "launcher_tool"
+    version = "1.0.0"
 
     def initialize(self, settings):
 

client/ayon_core/modules/loader_action.py

@@ -3,6 +3,7 @@ from ayon_core.addon import AYONAddon, ITrayAddon
 
 class LoaderAddon(AYONAddon, ITrayAddon):
     name = "loader_tool"
+    version = "1.0.0"
 
     def initialize(self, settings):
         # Tray attributes

client/ayon_core/modules/python_console_interpreter/addon.py

@@ -4,6 +4,7 @@ from ayon_core.addon import AYONAddon, ITrayAction
 class PythonInterpreterAction(AYONAddon, ITrayAction):
     label = "Console"
     name = "python_interpreter"
+    version = "1.0.0"
     admin_action = True
 
     def initialize(self, settings):

client/ayon_core/modules/royalrender/__init__.py

@@ -1,6 +1,9 @@
+from .version import __version__
 from .addon import RoyalRenderAddon
 
 
 __all__ = (
+    "__version__",
+
     "RoyalRenderAddon",
 )

client/ayon_core/modules/royalrender/addon.py

@@ -4,10 +4,13 @@ import os
 
 from ayon_core.addon import AYONAddon, IPluginPaths
 
+from .version import __version__
+
 
 class RoyalRenderAddon(AYONAddon, IPluginPaths):
     """Class providing basic Royal Render implementation logic."""
     name = "royalrender"
+    version = __version__
 
     # _rr_api = None
     # @property

client/ayon_core/modules/royalrender/api.py

@@ -7,7 +7,7 @@ from ayon_core.lib import Logger, run_subprocess, AYONSettingsRegistry
 from ayon_core.lib.vendor_bin_utils import find_tool_in_custom_paths
 
 from .rr_job import SubmitFile
-from .rr_job import RRjob, SubmitterParameter # noqa F401
+from .rr_job import RRJob, SubmitterParameter # noqa F401
 
 
 class Api:

client/ayon_core/modules/royalrender/version.py

@@ -0,0 +1 @@
+__version__ = "0.1.1"

client/ayon_core/modules/timers_manager/__init__.py

@@ -1,7 +1,10 @@
+from .version import __version__
 from .timers_manager import (
     TimersManager
 )
 
 __all__ = (
+    "__version__",
+
     "TimersManager",
 )

client/ayon_core/modules/timers_manager/timers_manager.py

@@ -10,6 +10,7 @@ from ayon_core.addon import (
 )
 from ayon_core.lib.events import register_event_callback
 
+from .version import __version__
 from .exceptions import InvalidContextError
 
 TIMER_MODULE_DIR = os.path.dirname(os.path.abspath(__file__))
@@ -96,6 +97,7 @@ class TimersManager(
     See `ExampleTimersManagerConnector`.
     """
     name = "timers_manager"
+    version = __version__
     label = "Timers Service"
 
     _required_methods = (

client/ayon_core/modules/timers_manager/version.py

@@ -0,0 +1 @@
+__version__ = "0.1.1"

client/ayon_core/modules/webserver/__init__.py

@@ -1,8 +1,11 @@
+from .version import __version__
 from .webserver_module import (
     WebServerAddon
 )
 
 
 __all__ = (
+    "__version__",
+
     "WebServerAddon",
 )

client/ayon_core/modules/webserver/version.py

@@ -0,0 +1 @@
+__version__ = "1.0.0"

client/ayon_core/modules/webserver/webserver_module.py

@@ -26,9 +26,12 @@ import socket
 from ayon_core import resources
 from ayon_core.addon import AYONAddon, ITrayService
 
+from .version import __version__
+
 
 class WebServerAddon(AYONAddon, ITrayService):
     name = "webserver"
+    version = __version__
     label = "WebServer"
 
     webserver_url_env = "AYON_WEBSERVER_URL"

client/ayon_core/pipeline/context_tools.py

@@ -459,36 +459,6 @@ def is_representation_from_latest(representation):
     )
 
 
-def get_template_data_from_session(session=None, settings=None):
-    """Template data for template fill from session keys.
-
-    Args:
-        session (Union[Dict[str, str], None]): The Session to use. If not
-            provided use the currently active global Session.
-        settings (Optional[Dict[str, Any]]): Prepared studio or project
-            settings.
-
-    Returns:
-        Dict[str, Any]: All available data from session.
-    """
-
-    if session is not None:
-        project_name = session["AYON_PROJECT_NAME"]
-        folder_path = session["AYON_FOLDER_PATH"]
-        task_name = session["AYON_TASK_NAME"]
-        host_name = session["AYON_HOST_NAME"]
-    else:
-        context = get_current_context()
-        project_name = context["project_name"]
-        folder_path = context["folder_path"]
-        task_name = context["task_name"]
-        host_name = get_current_host_name()
-
-    return get_template_data_with_names(
-        project_name, folder_path, task_name, host_name, settings
-    )
-
-
 def get_current_context_template_data(settings=None):
     """Prepare template data for current context.
 

client/ayon_core/pipeline/create/context.py

@@ -681,7 +681,7 @@ class PublishAttributeValues(AttributeValues):
 
     @property
     def parent(self):
-        self.publish_attributes.parent
+        return self.publish_attributes.parent
 
 
 class PublishAttributes:
@@ -1987,12 +1987,12 @@ class CreateContext:
                     "Folder '{}' was not found".format(folder_path)
                 )
 
-        task_name = None
         if task_entity is None:
-            task_name = self.get_current_task_name()
-            task_entity = ayon_api.get_task_by_name(
-                project_name, folder_entity["id"], task_name
-            )
+            current_task_name = self.get_current_task_name()
+            if current_task_name:
+                task_entity = ayon_api.get_task_by_name(
+                    project_name, folder_entity["id"], current_task_name
+                )
 
         if pre_create_data is None:
             pre_create_data = {}
@@ -2018,7 +2018,7 @@ class CreateContext:
 
         instance_data = {
             "folderPath": folder_entity["path"],
-            "task": task_name,
+            "task": task_entity["name"] if task_entity else None,
             "productType": creator.product_type,
             "variant": variant
         }
@@ -2053,7 +2053,7 @@ class CreateContext:
             exc_info = sys.exc_info()
             self.log.warning(error_message.format(identifier, exc_info[1]))
 
-        except:
+        except:  # noqa: E722
             add_traceback = True
             exc_info = sys.exc_info()
             self.log.warning(
@@ -2163,7 +2163,7 @@ class CreateContext:
                 exc_info = sys.exc_info()
                 self.log.warning(error_message.format(identifier, exc_info[1]))
 
-            except:
+            except:  # noqa: E722
                 failed = True
                 add_traceback = True
                 exc_info = sys.exc_info()
@@ -2197,7 +2197,7 @@ class CreateContext:
             try:
                 convertor.find_instances()
 
-            except:
+            except:  # noqa: E722
                 failed_info.append(
                     prepare_failed_convertor_operation_info(
                         convertor.identifier, sys.exc_info()
@@ -2373,7 +2373,7 @@ class CreateContext:
                 exc_info = sys.exc_info()
                 self.log.warning(error_message.format(identifier, exc_info[1]))
 
-            except:
+            except:  # noqa: E722
                 failed = True
                 add_traceback = True
                 exc_info = sys.exc_info()
@@ -2440,7 +2440,7 @@ class CreateContext:
                     error_message.format(identifier, exc_info[1])
                 )
 
-            except:
+            except:  # noqa: E722
                 failed = True
                 add_traceback = True
                 exc_info = sys.exc_info()
@@ -2546,7 +2546,7 @@ class CreateContext:
             try:
                 self.run_convertor(convertor_identifier)
 
-            except:
+            except:  # noqa: E722
                 failed_info.append(
                     prepare_failed_convertor_operation_info(
                         convertor_identifier, sys.exc_info()

client/ayon_core/pipeline/publish/abstract_collect_render.py

@@ -80,6 +80,7 @@ class RenderInstance(object):
     anatomyData = attr.ib(default=None)
     outputDir = attr.ib(default=None)
     context = attr.ib(default=None)
+    deadline = attr.ib(default=None)
 
     # The source instance the data of this render instance should merge into
     source_instance = attr.ib(default=None, type=pyblish.api.Instance)
@@ -215,13 +216,12 @@ class AbstractCollectRender(pyblish.api.ContextPlugin):
 
             # add additional data
             data = self.add_additional_data(data)
-            render_instance_dict = attr.asdict(render_instance)
 
-            # Merge into source instance if provided, otherwise create instance
-            instance = render_instance_dict.pop("source_instance", None)
+            instance = render_instance.source_instance
             if instance is None:
                 instance = context.create_instance(render_instance.name)
 
+            render_instance_dict = attr.asdict(render_instance)
             instance.data.update(render_instance_dict)
             instance.data.update(data)
 

client/ayon_core/pipeline/publish/lib.py

@@ -336,17 +336,16 @@ def get_plugin_settings(plugin, project_settings, log, category=None):
     settings_category = getattr(plugin, "settings_category", None)
     if settings_category:
         try:
-            return (
-                project_settings
-                [settings_category]
-                ["publish"]
-                [plugin.__name__]
-            )
+            category_settings = project_settings[settings_category]
         except KeyError:
             log.warning((
-                "Couldn't find plugin '{}' settings"
-                " under settings category '{}'"
-            ).format(plugin.__name__, settings_category))
+                "Couldn't find settings category '{}' in project settings"
+            ).format(settings_category))
+            return {}
+
+        try:
+            return category_settings["publish"][plugin.__name__]
+        except KeyError:
             return {}
 
     # Use project settings based on a category name

client/ayon_core/pipeline/template_data.py

@@ -73,8 +73,8 @@ def get_folder_template_data(folder_entity, project_name):
     - 'parent'      - direct parent name, project name used if is under
                       project
 
-    Required document fields:
-        Folder: 'path' -> Plan to require: 'folderType'
+    Required entity fields:
+        Folder: 'path', 'folderType'
 
     Args:
         folder_entity (Dict[str, Any]): Folder entity.
@@ -101,6 +101,8 @@ def get_folder_template_data(folder_entity, project_name):
     return {
         "folder": {
             "name": folder_name,
+            "type": folder_entity["folderType"],
+            "path": path,
         },
         "asset": folder_name,
         "hierarchy": hierarchy,

client/ayon_core/pipeline/thumbnails.py

@@ -0,0 +1,263 @@
+import os
+import time
+import collections
+
+import ayon_api
+
+from ayon_core.lib.local_settings import get_ayon_appdirs
+
+
+FileInfo = collections.namedtuple(
+    "FileInfo",
+    ("path", "size", "modification_time")
+)
+
+
+class ThumbnailsCache:
+    """Cache of thumbnails on local storage.
+
+    Thumbnails are cached to appdirs to predefined directory. Each project has
+    own subfolder with thumbnails -> that's because each project has own
+    thumbnail id validation and file names are thumbnail ids with matching
+    extension. Extensions are predefined (.png and .jpeg).
+
+    Cache has cleanup mechanism which is triggered on initialized by default.
+
+    The cleanup has 2 levels:
+    1. soft cleanup which remove all files that are older then 'days_alive'
+    2. max size cleanup which remove all files until the thumbnails folder
+        contains less then 'max_filesize'
+        - this is time consuming so it's not triggered automatically
+
+    Args:
+        cleanup (bool): Trigger soft cleanup (Cleanup expired thumbnails).
+    """
+
+    # Lifetime of thumbnails (in seconds)
+    # - default 3 days
+    days_alive = 3
+    # Max size of thumbnail directory (in bytes)
+    # - default 2 Gb
+    max_filesize = 2 * 1024 * 1024 * 1024
+
+    def __init__(self, cleanup=True):
+        self._thumbnails_dir = None
+        self._days_alive_secs = self.days_alive * 24 * 60 * 60
+        if cleanup:
+            self.cleanup()
+
+    def get_thumbnails_dir(self):
+        """Root directory where thumbnails are stored.
+
+        Returns:
+            str: Path to thumbnails root.
+        """
+
+        if self._thumbnails_dir is None:
+            self._thumbnails_dir = get_ayon_appdirs("thumbnails")
+        return self._thumbnails_dir
+
+    thumbnails_dir = property(get_thumbnails_dir)
+
+    def get_thumbnails_dir_file_info(self):
+        """Get information about all files in thumbnails directory.
+
+        Returns:
+            List[FileInfo]: List of file information about all files.
+        """
+
+        thumbnails_dir = self.thumbnails_dir
+        files_info = []
+        if not os.path.exists(thumbnails_dir):
+            return files_info
+
+        for root, _, filenames in os.walk(thumbnails_dir):
+            for filename in filenames:
+                path = os.path.join(root, filename)
+                files_info.append(FileInfo(
+                    path, os.path.getsize(path), os.path.getmtime(path)
+                ))
+        return files_info
+
+    def get_thumbnails_dir_size(self, files_info=None):
+        """Got full size of thumbnail directory.
+
+        Args:
+            files_info (List[FileInfo]): Prepared file information about
+                files in thumbnail directory.
+
+        Returns:
+            int: File size of all files in thumbnail directory.
+        """
+
+        if files_info is None:
+            files_info = self.get_thumbnails_dir_file_info()
+
+        if not files_info:
+            return 0
+
+        return sum(
+            file_info.size
+            for file_info in files_info
+        )
+
+    def cleanup(self, check_max_size=False):
+        """Cleanup thumbnails directory.
+
+        Args:
+            check_max_size (bool): Also cleanup files to match max size of
+                thumbnails directory.
+        """
+
+        thumbnails_dir = self.get_thumbnails_dir()
+        # Skip if thumbnails dir does not exist yet
+        if not os.path.exists(thumbnails_dir):
+            return
+
+        self._soft_cleanup(thumbnails_dir)
+        if check_max_size:
+            self._max_size_cleanup(thumbnails_dir)
+
+    def _soft_cleanup(self, thumbnails_dir):
+        current_time = time.time()
+        for root, _, filenames in os.walk(thumbnails_dir):
+            for filename in filenames:
+                path = os.path.join(root, filename)
+                modification_time = os.path.getmtime(path)
+                if current_time - modification_time > self._days_alive_secs:
+                    os.remove(path)
+
+    def _max_size_cleanup(self, thumbnails_dir):
+        files_info = self.get_thumbnails_dir_file_info()
+        size = self.get_thumbnails_dir_size(files_info)
+        if size < self.max_filesize:
+            return
+
+        sorted_file_info = collections.deque(
+            sorted(files_info, key=lambda item: item.modification_time)
+        )
+        diff = size - self.max_filesize
+        while diff > 0:
+            if not sorted_file_info:
+                break
+
+            file_info = sorted_file_info.popleft()
+            diff -= file_info.size
+            os.remove(file_info.path)
+
+    def get_thumbnail_filepath(self, project_name, thumbnail_id):
+        """Get thumbnail by thumbnail id.
+
+        Args:
+            project_name (str): Name of project.
+            thumbnail_id (str): Thumbnail id.
+
+        Returns:
+            Union[str, None]: Path to thumbnail image or None if thumbnail
+                is not cached yet.
+        """
+
+        if not thumbnail_id:
+            return None
+
+        for ext in (
+            ".png",
+            ".jpeg",
+        ):
+            filepath = os.path.join(
+                self.thumbnails_dir, project_name, thumbnail_id + ext
+            )
+            if os.path.exists(filepath):
+                return filepath
+        return None
+
+    def get_project_dir(self, project_name):
+        """Path to root directory for specific project.
+
+        Args:
+            project_name (str): Name of project for which root directory path
+                should be returned.
+
+        Returns:
+            str: Path to root of project's thumbnails.
+        """
+
+        return os.path.join(self.thumbnails_dir, project_name)
+
+    def make_sure_project_dir_exists(self, project_name):
+        project_dir = self.get_project_dir(project_name)
+        if not os.path.exists(project_dir):
+            os.makedirs(project_dir)
+        return project_dir
+
+    def store_thumbnail(self, project_name, thumbnail_id, content, mime_type):
+        """Store thumbnail to cache folder.
+
+        Args:
+            project_name (str): Project where the thumbnail belong to.
+            thumbnail_id (str): Thumbnail id.
+            content (bytes): Byte content of thumbnail file.
+            mime_type (str): Type of content.
+
+        Returns:
+            str: Path to cached thumbnail image file.
+        """
+
+        if mime_type == "image/png":
+            ext = ".png"
+        elif mime_type == "image/jpeg":
+            ext = ".jpeg"
+        else:
+            raise ValueError(
+                "Unknown mime type for thumbnail \"{}\"".format(mime_type))
+
+        project_dir = self.make_sure_project_dir_exists(project_name)
+        thumbnail_path = os.path.join(project_dir, thumbnail_id + ext)
+        with open(thumbnail_path, "wb") as stream:
+            stream.write(content)
+
+        current_time = time.time()
+        os.utime(thumbnail_path, (current_time, current_time))
+
+        return thumbnail_path
+
+
+class _CacheItems:
+    thumbnails_cache = ThumbnailsCache()
+
+
+def get_thumbnail_path(project_name, thumbnail_id):
+    """Get path to thumbnail image.
+
+    Args:
+        project_name (str): Project where thumbnail belongs to.
+        thumbnail_id (Union[str, None]): Thumbnail id.
+
+    Returns:
+        Union[str, None]: Path to thumbnail image or None if thumbnail
+            id is not valid or thumbnail was not possible to receive.
+
+    """
+    if not thumbnail_id:
+        return None
+
+    filepath = _CacheItems.thumbnails_cache.get_thumbnail_filepath(
+        project_name, thumbnail_id
+    )
+    if filepath is not None:
+        return filepath
+
+    # 'ayon_api' had a bug, public function
+    #   'get_thumbnail_by_id' did not return output of
+    #   'ServerAPI' method.
+    con = ayon_api.get_server_api_connection()
+    result = con.get_thumbnail_by_id(project_name, thumbnail_id)
+
+    if result is not None and result.is_valid:
+        return _CacheItems.thumbnails_cache.store_thumbnail(
+            project_name,
+            thumbnail_id,
+            result.content,
+            result.content_type
+        )
+    return None

client/ayon_core/plugins/publish/collect_anatomy_instance_data.py

@@ -33,6 +33,7 @@ import collections
 import pyblish.api
 import ayon_api
 
+from ayon_core.pipeline.template_data import get_folder_template_data
 from ayon_core.pipeline.version_start import get_versioning_start
 
 
@@ -383,24 +384,11 @@ class CollectAnatomyInstanceData(pyblish.api.ContextPlugin):
         # - 'folder', 'hierarchy', 'parent', 'folder'
         folder_entity = instance.data.get("folderEntity")
         if folder_entity:
-            folder_name = folder_entity["name"]
-            folder_path = folder_entity["path"]
-            hierarchy_parts = folder_path.split("/")
-            hierarchy_parts.pop(0)
-            hierarchy_parts.pop(-1)
-            parent_name = project_entity["name"]
-            if hierarchy_parts:
-                parent_name = hierarchy_parts[-1]
-
-            hierarchy = "/".join(hierarchy_parts)
-            anatomy_data.update({
-                "asset": folder_name,
-                "hierarchy": hierarchy,
-                "parent": parent_name,
-                "folder": {
-                    "name": folder_name,
-                },
-            })
+            folder_data = get_folder_template_data(
+                folder_entity,
+                project_entity["name"]
+            )
+            anatomy_data.update(folder_data)
             return
 
         if instance.data.get("newAssetPublishing"):
@@ -418,6 +406,11 @@ class CollectAnatomyInstanceData(pyblish.api.ContextPlugin):
                 "parent": parent_name,
                 "folder": {
                     "name": folder_name,
+                    "path": instance.data["folderPath"],
+                    # TODO get folder type from hierarchy
+                    #   Using 'Shot' is current default behavior of editorial
+                    #   (or 'newAssetPublishing') publishing.
+                    "type": "Shot",
                 },
             })
 

client/ayon_core/plugins/publish/integrate.py

@@ -42,7 +42,7 @@ def prepare_changes(old_entity, new_entity):
 
     Returns:
         dict[str, Any]: Changes that have new entity.
-        
+
     """
     changes = {}
     for key in set(new_entity.keys()):
@@ -108,68 +108,6 @@ class IntegrateAsset(pyblish.api.InstancePlugin):
 
     label = "Integrate Asset"
     order = pyblish.api.IntegratorOrder
-    families = ["workfile",
-                "pointcache",
-                "pointcloud",
-                "proxyAbc",
-                "camera",
-                "animation",
-                "model",
-                "maxScene",
-                "mayaAscii",
-                "mayaScene",
-                "setdress",
-                "layout",
-                "ass",
-                "vdbcache",
-                "scene",
-                "vrayproxy",
-                "vrayscene_layer",
-                "render",
-                "prerender",
-                "imagesequence",
-                "review",
-                "rendersetup",
-                "rig",
-                "plate",
-                "look",
-                "ociolook",
-                "audio",
-                "yetiRig",
-                "yeticache",
-                "nukenodes",
-                "gizmo",
-                "source",
-                "matchmove",
-                "image",
-                "assembly",
-                "fbx",
-                "gltf",
-                "textures",
-                "action",
-                "harmony.template",
-                "harmony.palette",
-                "editorial",
-                "background",
-                "camerarig",
-                "redshiftproxy",
-                "effect",
-                "xgen",
-                "hda",
-                "usd",
-                "staticMesh",
-                "skeletalMesh",
-                "mvLook",
-                "mvUsd",
-                "mvUsdComposition",
-                "mvUsdOverride",
-                "online",
-                "uasset",
-                "blendScene",
-                "yeticacheUE",
-                "tycache",
-                "csv_ingest_file",
-                ]
 
     default_template_name = "publish"
 
@@ -359,7 +297,7 @@ class IntegrateAsset(pyblish.api.InstancePlugin):
 
         # Compute the resource file infos once (files belonging to the
         # version instance instead of an individual representation) so
-        # we can re-use those file infos per representation
+        # we can reuse those file infos per representation
         resource_file_infos = self.get_files_info(
             resource_destinations, anatomy
         )

client/ayon_core/plugins/publish/validate_containers.py

@@ -1,6 +1,11 @@
 import pyblish.api
+
+from ayon_core.lib import filter_profiles
+from ayon_core.host import ILoadHost
 from ayon_core.pipeline.load import any_outdated_containers
 from ayon_core.pipeline import (
+    get_current_host_name,
+    registered_host,
     PublishXmlValidationError,
     OptionalPyblishPluginMixin
 )
@@ -18,17 +23,50 @@ class ShowInventory(pyblish.api.Action):
         host_tools.show_scene_inventory()
 
 
-class ValidateContainers(OptionalPyblishPluginMixin,
-                         pyblish.api.ContextPlugin):
-
+class ValidateOutdatedContainers(
+    OptionalPyblishPluginMixin,
+    pyblish.api.ContextPlugin
+):
     """Containers are must be updated to latest version on publish."""
 
     label = "Validate Outdated Containers"
     order = pyblish.api.ValidatorOrder
-    hosts = ["maya", "houdini", "nuke", "harmony", "photoshop", "aftereffects"]
+
     optional = True
     actions = [ShowInventory]
 
+    @classmethod
+    def apply_settings(cls, settings):
+        # Disable plugin if host does not inherit from 'ILoadHost'
+        # - not a host that can load containers
+        host = registered_host()
+        if not isinstance(host, ILoadHost):
+            cls.enabled = False
+            return
+
+        # Disable if no profile is found for the current host
+        profiles = (
+            settings
+            ["core"]
+            ["publish"]
+            ["ValidateOutdatedContainers"]
+            ["plugin_state_profiles"]
+        )
+        profile = filter_profiles(
+            profiles, {"host_names": get_current_host_name()}
+        )
+        if not profile:
+            cls.enabled = False
+            return
+
+        # Apply settings from profile
+        for attr_name in {
+            "enabled",
+            "optional",
+            "active",
+        }:
+            setattr(cls, attr_name, profile[attr_name])
+
     def process(self, context):
         if not self.is_active(context.data):
             return

client/ayon_core/plugins/publish/validate_version.py

@@ -1,8 +1,14 @@
 import pyblish.api
-from ayon_core.pipeline.publish import PublishValidationError
+
+from ayon_core.lib import filter_profiles
+from ayon_core.pipeline.publish import (
+    PublishValidationError,
+    OptionalPyblishPluginMixin
+)
+from ayon_core.pipeline import get_current_host_name
 
 
-class ValidateVersion(pyblish.api.InstancePlugin):
+class ValidateVersion(pyblish.api.InstancePlugin, OptionalPyblishPluginMixin):
     """Validate instance version.
 
     AYON does not allow overwriting previously published versions.
@@ -11,13 +17,39 @@ class ValidateVersion(pyblish.api.InstancePlugin):
     order = pyblish.api.ValidatorOrder
 
     label = "Validate Version"
-    hosts = ["nuke", "maya", "houdini", "blender",
-             "photoshop", "aftereffects"]
 
     optional = False
     active = True
 
+    @classmethod
+    def apply_settings(cls, settings):
+        # Disable if no profile is found for the current host
+        profiles = (
+            settings
+            ["core"]
+            ["publish"]
+            ["ValidateVersion"]
+            ["plugin_state_profiles"]
+        )
+        profile = filter_profiles(
+            profiles, {"host_names": get_current_host_name()}
+        )
+        if not profile:
+            cls.enabled = False
+            return
+
+        # Apply settings from profile
+        for attr_name in {
+            "enabled",
+            "optional",
+            "active",
+        }:
+            setattr(cls, attr_name, profile[attr_name])
+
     def process(self, instance):
+        if not self.is_active(instance.data):
+            return
+
         version = instance.data.get("version")
         latest_version = instance.data.get("latestVersion")
 

client/ayon_core/scripts/ocio_wrapper.py

@@ -1,28 +1,31 @@
 """OpenColorIO Wrapper.
 
-Only to be interpreted by Python 3. It is run in subprocess in case
-Python 2 hosts needs to use it. Or it is used as module for Python 3
-processing.
-
-Providing functionality:
-- get_colorspace - console command - python 2
-                 - returning all available color spaces
-                   found in input config path.
-- _get_colorspace_data - python 3 - module function
-                      - returning all available colorspaces
-                        found in input config path.
-- get_views - console command - python 2
-            - returning all available viewers
-              found in input config path.
-- _get_views_data - python 3 - module function
-                 - returning all available viewers
-                   found in input config path.
+Receive OpenColorIO information and store it in JSON format for processed
+that don't have access to OpenColorIO or their version of OpenColorIO is
+not compatible.
 """
 
-import click
 import json
 from pathlib import Path
-import PyOpenColorIO as ocio
+
+import click
+
+from ayon_core.pipeline.colorspace import (
+    has_compatible_ocio_package,
+    get_display_view_colorspace_name,
+    get_config_file_rules_colorspace_from_filepath,
+    get_config_version_data,
+    get_ocio_config_views,
+    get_ocio_config_colorspaces,
+)
+
+
+def _save_output_to_json_file(output, output_path):
+    json_path = Path(output_path)
+    with open(json_path, "w") as stream:
+        json.dump(output, stream)
+
+    print(f"Data are saved to '{json_path}'")
 
 
 @click.group()
@@ -30,404 +33,185 @@ def main():
     pass  # noqa: WPS100
 
 
-@main.group()
-def config():
-    """Config related commands group
-
-    Example of use:
-    > pyton.exe ./ocio_wrapper.py config <command> *args
-    """
-    pass  # noqa: WPS100
-
-
-@main.group()
-def colorspace():
-    """Colorspace related commands group
-
-    Example of use:
-    > pyton.exe ./ocio_wrapper.py config <command> *args
-    """
-    pass  # noqa: WPS100
-
-
-@config.command(
-    name="get_colorspace",
-    help=(
-        "return all colorspaces from config file "
-        "--path input arg is required"
-    )
-)
-@click.option("--in_path", required=True,
-              help="path where to read ocio config file",
-              type=click.Path(exists=True))
-@click.option("--out_path", required=True,
-              help="path where to write output json file",
-              type=click.Path())
-def get_colorspace(in_path, out_path):
+@main.command(
+    name="get_ocio_config_colorspaces",
+    help="return all colorspaces from config file")
+@click.option(
+    "--config_path",
+    required=True,
+    help="OCIO config path to read ocio config file.",
+    type=click.Path(exists=True))
+@click.option(
+    "--output_path",
+    required=True,
+    help="path where to write output json file",
+    type=click.Path())
+def _get_ocio_config_colorspaces(config_path, output_path):
     """Aggregate all colorspace to file.
 
-    Python 2 wrapped console command
-
     Args:
-        in_path (str): config file path string
-        out_path (str): temp json file path string
+        config_path (str): config file path string
+        output_path (str): temp json file path string
 
     Example of use:
     > pyton.exe ./ocio_wrapper.py config get_colorspace
-        --in_path=<path> --out_path=<path>
+        --config_path <path> --output_path <path>
     """
-    json_path = Path(out_path)
-
-    out_data = _get_colorspace_data(in_path)
-
-    with open(json_path, "w") as f_:
-        json.dump(out_data, f_)
-
-    print(f"Colorspace data are saved to '{json_path}'")
-
-
-def _get_colorspace_data(config_path):
-    """Return all found colorspace data.
-
-    Args:
-        config_path (str): path string leading to config.ocio
-
-    Raises:
-        IOError: Input config does not exist.
-
-    Returns:
-        dict: aggregated available colorspaces
-    """
-    config_path = Path(config_path)
-
-    if not config_path.is_file():
-        raise IOError(
-            f"Input path `{config_path}` should be `config.ocio` file")
-
-    config = ocio.Config().CreateFromFile(str(config_path))
-
-    colorspace_data = {
-        "roles": {},
-        "colorspaces": {
-            color.getName(): {
-                "family": color.getFamily(),
-                "categories": list(color.getCategories()),
-                "aliases": list(color.getAliases()),
-                "equalitygroup": color.getEqualityGroup(),
-            }
-            for color in config.getColorSpaces()
-        },
-        "displays_views": {
-            f"{view} ({display})": {
-                "display": display,
-                "view": view
-
-            }
-            for display in config.getDisplays()
-            for view in config.getViews(display)
-        },
-        "looks": {}
-    }
-
-    # add looks
-    looks = config.getLooks()
-    if looks:
-        colorspace_data["looks"] = {
-            look.getName(): {"process_space": look.getProcessSpace()}
-            for look in looks
-        }
-
-    # add roles
-    roles = config.getRoles()
-    if roles:
-        colorspace_data["roles"] = {
-            role: {"colorspace": colorspace}
-            for (role, colorspace) in roles
-        }
-
-    return colorspace_data
-
-
-@config.command(
-    name="get_views",
-    help=(
-        "return all viewers from config file "
-        "--path input arg is required"
+    _save_output_to_json_file(
+        get_ocio_config_colorspaces(config_path),
+        output_path
     )
-)
-@click.option("--in_path", required=True,
-              help="path where to read ocio config file",
-              type=click.Path(exists=True))
-@click.option("--out_path", required=True,
-              help="path where to write output json file",
-              type=click.Path())
-def get_views(in_path, out_path):
+
+
+@main.command(
+    name="get_ocio_config_views",
+    help="All viewers from config file")
+@click.option(
+    "--config_path",
+    required=True,
+    help="OCIO config path to read ocio config file.",
+    type=click.Path(exists=True))
+@click.option(
+    "--output_path",
+    required=True,
+    help="path where to write output json file",
+    type=click.Path())
+def _get_ocio_config_views(config_path, output_path):
     """Aggregate all viewers to file.
 
-    Python 2 wrapped console command
-
     Args:
-        in_path (str): config file path string
-        out_path (str): temp json file path string
+        config_path (str): config file path string
+        output_path (str): temp json file path string
 
     Example of use:
     > pyton.exe ./ocio_wrapper.py config get_views \
-        --in_path=<path> --out_path=<path>
+        --config_path <path> --output <path>
     """
-    json_path = Path(out_path)
-
-    out_data = _get_views_data(in_path)
-
-    with open(json_path, "w") as f_:
-        json.dump(out_data, f_)
-
-    print(f"Viewer data are saved to '{json_path}'")
-
-
-def _get_views_data(config_path):
-    """Return all found viewer data.
-
-    Args:
-        config_path (str): path string leading to config.ocio
-
-    Raises:
-        IOError: Input config does not exist.
-
-    Returns:
-        dict: aggregated available viewers
-    """
-    config_path = Path(config_path)
-
-    if not config_path.is_file():
-        raise IOError("Input path should be `config.ocio` file")
-
-    config = ocio.Config().CreateFromFile(str(config_path))
-
-    data_ = {}
-    for display in config.getDisplays():
-        for view in config.getViews(display):
-            colorspace = config.getDisplayViewColorSpaceName(display, view)
-            # Special token. See https://opencolorio.readthedocs.io/en/latest/guides/authoring/authoring.html#shared-views # noqa
-            if colorspace == "<USE_DISPLAY_NAME>":
-                colorspace = display
-
-            data_[f"{display}/{view}"] = {
-                "display": display,
-                "view": view,
-                "colorspace": colorspace
-            }
-
-    return data_
-
-
-@config.command(
-    name="get_version",
-    help=(
-        "return major and minor version from config file "
-        "--config_path input arg is required"
-        "--out_path input arg is required"
+    _save_output_to_json_file(
+        get_ocio_config_views(config_path),
+        output_path
     )
-)
-@click.option("--config_path", required=True,
-              help="path where to read ocio config file",
-              type=click.Path(exists=True))
-@click.option("--out_path", required=True,
-              help="path where to write output json file",
-              type=click.Path())
-def get_version(config_path, out_path):
-    """Get version of config.
 
-    Python 2 wrapped console command
+
+@main.command(
+    name="get_config_version_data",
+    help="Get major and minor version from config file")
+@click.option(
+    "--config_path",
+    required=True,
+    help="OCIO config path to read ocio config file.",
+    type=click.Path(exists=True))
+@click.option(
+    "--output_path",
+    required=True,
+    help="path where to write output json file",
+    type=click.Path())
+def _get_config_version_data(config_path, output_path):
+    """Get version of config.
 
     Args:
         config_path (str): ocio config file path string
-        out_path (str): temp json file path string
+        output_path (str): temp json file path string
 
     Example of use:
     > pyton.exe ./ocio_wrapper.py config get_version \
-        --config_path=<path> --out_path=<path>
+        --config_path <path> --output_path <path>
     """
-    json_path = Path(out_path)
-
-    out_data = _get_version_data(config_path)
-
-    with open(json_path, "w") as f_:
-        json.dump(out_data, f_)
-
-    print(f"Config version data are saved to '{json_path}'")
-
-
-def _get_version_data(config_path):
-    """Return major and minor version info.
-
-    Args:
-        config_path (str): path string leading to config.ocio
-
-    Raises:
-        IOError: Input config does not exist.
-
-    Returns:
-        dict: minor and major keys with values
-    """
-    config_path = Path(config_path)
-
-    if not config_path.is_file():
-        raise IOError("Input path should be `config.ocio` file")
-
-    config = ocio.Config().CreateFromFile(str(config_path))
-
-    return {
-        "major": config.getMajorVersion(),
-        "minor": config.getMinorVersion()
-    }
-
-
-@colorspace.command(
-    name="get_config_file_rules_colorspace_from_filepath",
-    help=(
-        "return colorspace from filepath "
-        "--config_path - ocio config file path (input arg is required) "
-        "--filepath - any file path (input arg is required) "
-        "--out_path - temp json file path (input arg is required)"
+    _save_output_to_json_file(
+        get_config_version_data(config_path),
+        output_path
     )
-)
-@click.option("--config_path", required=True,
-              help="path where to read ocio config file",
-              type=click.Path(exists=True))
-@click.option("--filepath", required=True,
-              help="path to file to get colorspace from",
-              type=click.Path())
-@click.option("--out_path", required=True,
-              help="path where to write output json file",
-              type=click.Path())
-def get_config_file_rules_colorspace_from_filepath(
-    config_path, filepath, out_path
+
+
+@main.command(
+    name="get_config_file_rules_colorspace_from_filepath",
+    help="Colorspace file rules from filepath")
+@click.option(
+    "--config_path",
+    required=True,
+    help="OCIO config path to read ocio config file.",
+    type=click.Path(exists=True))
+@click.option(
+    "--filepath",
+    required=True,
+    help="Path to file to get colorspace from.",
+    type=click.Path())
+@click.option(
+    "--output_path",
+    required=True,
+    help="Path where to write output json file.",
+    type=click.Path())
+def _get_config_file_rules_colorspace_from_filepath(
+    config_path, filepath, output_path
 ):
     """Get colorspace from file path wrapper.
 
-    Python 2 wrapped console command
-
     Args:
         config_path (str): config file path string
         filepath (str): path string leading to file
-        out_path (str): temp json file path string
+        output_path (str): temp json file path string
 
     Example of use:
-    > pyton.exe ./ocio_wrapper.py \
+    > python.exe ./ocio_wrapper.py \
         colorspace get_config_file_rules_colorspace_from_filepath \
-        --config_path=<path> --filepath=<path> --out_path=<path>
+        --config_path <path> --filepath <path> --output_path <path>
     """
-    json_path = Path(out_path)
-
-    colorspace = _get_config_file_rules_colorspace_from_filepath(
-        config_path, filepath)
-
-    with open(json_path, "w") as f_:
-        json.dump(colorspace, f_)
-
-    print(f"Colorspace name is saved to '{json_path}'")
+    _save_output_to_json_file(
+        get_config_file_rules_colorspace_from_filepath(config_path, filepath),
+        output_path
+    )
 
 
-def _get_config_file_rules_colorspace_from_filepath(config_path, filepath):
-    """Return found colorspace data found in v2 file rules.
-
-    Args:
-        config_path (str): path string leading to config.ocio
-        filepath (str): path string leading to v2 file rules
-
-    Raises:
-        IOError: Input config does not exist.
-
-    Returns:
-        dict: aggregated available colorspaces
-    """
-    config_path = Path(config_path)
-
-    if not config_path.is_file():
-        raise IOError(
-            f"Input path `{config_path}` should be `config.ocio` file")
-
-    config = ocio.Config().CreateFromFile(str(config_path))
-
-    # TODO: use `parseColorSpaceFromString` instead if ocio v1
-    colorspace = config.getColorSpaceFromFilepath(str(filepath))
-
-    return colorspace
-
-
-def _get_display_view_colorspace_name(config_path, display, view):
-    """Returns the colorspace attribute of the (display, view) pair.
-
-    Args:
-        config_path (str): path string leading to config.ocio
-        display (str): display name e.g. "ACES"
-        view (str): view name e.g. "sRGB"
-
-
-    Raises:
-        IOError: Input config does not exist.
-
-    Returns:
-        view color space name (str) e.g. "Output - sRGB"
-    """
-
-    config_path = Path(config_path)
-
-    if not config_path.is_file():
-        raise IOError("Input path should be `config.ocio` file")
-
-    config = ocio.Config.CreateFromFile(str(config_path))
-    colorspace = config.getDisplayViewColorSpaceName(display, view)
-
-    return colorspace
-
-
-@config.command(
+@main.command(
     name="get_display_view_colorspace_name",
     help=(
-        "return default view colorspace name "
-        "for the given display and view "
-        "--path input arg is required"
-    )
-)
-@click.option("--in_path", required=True,
-              help="path where to read ocio config file",
-              type=click.Path(exists=True))
-@click.option("--out_path", required=True,
-              help="path where to write output json file",
-              type=click.Path())
-@click.option("--display", required=True,
-              help="display name",
-              type=click.STRING)
-@click.option("--view", required=True,
-              help="view name",
-              type=click.STRING)
-def get_display_view_colorspace_name(in_path, out_path,
-                                     display, view):
+        "Default view colorspace name for the given display and view"
+    ))
+@click.option(
+    "--config_path",
+    required=True,
+    help="path where to read ocio config file",
+    type=click.Path(exists=True))
+@click.option(
+    "--display",
+    required=True,
+    help="Display name",
+    type=click.STRING)
+@click.option(
+    "--view",
+    required=True,
+    help="view name",
+    type=click.STRING)
+@click.option(
+    "--output_path",
+    required=True,
+    help="path where to write output json file",
+    type=click.Path())
+def _get_display_view_colorspace_name(
+    config_path, display, view, output_path
+):
     """Aggregate view colorspace name to file.
 
     Wrapper command for processes without access to OpenColorIO
 
     Args:
-        in_path (str): config file path string
-        out_path (str): temp json file path string
+        config_path (str): config file path string
+        output_path (str): temp json file path string
         display (str): display name e.g. "ACES"
         view (str): view name e.g. "sRGB"
 
     Example of use:
     > pyton.exe ./ocio_wrapper.py config \
-        get_display_view_colorspace_name --in_path=<path> \
-        --out_path=<path> --display=<display> --view=<view>
+        get_display_view_colorspace_name --config_path <path> \
+        --output_path <path> --display <display> --view <view>
     """
+    _save_output_to_json_file(
+        get_display_view_colorspace_name(config_path, display, view),
+        output_path
+    )
 
-    out_data = _get_display_view_colorspace_name(in_path,
-                                                 display,
-                                                 view)
 
-    with open(out_path, "w") as f:
-        json.dump(out_data, f)
-
-    print(f"Display view colorspace saved to '{out_path}'")
-
-if __name__ == '__main__':
+if __name__ == "__main__":
+    if not has_compatible_ocio_package():
+        raise RuntimeError("OpenColorIO is not available.")
     main()

client/ayon_core/tools/adobe_webserver/app.py

@@ -104,14 +104,11 @@ class WebServerTool:
             again. In that case, use existing running webserver.
             Check here is easier than capturing exception from thread.
         """
-        sock = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
-        result = True
-        try:
-            sock.bind((host_name, port))
-            result = False
-        except:
-            print("Port is in use")
+        with socket.socket(socket.AF_INET, socket.SOCK_STREAM) as con:
+            result = con.connect_ex((host_name, port)) == 0
 
+        if result:
+            print(f"Port {port} is already in use")
         return result
 
     def call(self, func):

client/ayon_core/tools/common_models/__init__.py

@@ -14,6 +14,7 @@ from .hierarchy import (
 )
 from .thumbnails import ThumbnailsModel
 from .selection import HierarchyExpectedSelection
+from .users import UsersModel
 
 
 __all__ = (
@@ -32,4 +33,6 @@ __all__ = (
     "ThumbnailsModel",
 
     "HierarchyExpectedSelection",
+
+    "UsersModel",
 )

client/ayon_core/tools/common_models/projects.py

@@ -5,7 +5,7 @@ import ayon_api
 import six
 
 from ayon_core.style import get_default_entity_icon_color
-from ayon_core.lib import CacheItem
+from ayon_core.lib import CacheItem, NestedCacheItem
 
 PROJECTS_MODEL_SENDER = "projects.model"
 
@@ -17,6 +17,49 @@ class AbstractHierarchyController:
         pass
 
 
+class StatusItem:
+    """Item representing status of project.
+
+    Args:
+        name (str): Status name ("Not ready").
+        color (str): Status color in hex ("#434a56").
+        short (str): Short status name ("NRD").
+        icon (str): Icon name in MaterialIcons ("fiber_new").
+        state (Literal["not_started", "in_progress", "done", "blocked"]):
+            Status state.
+
+    """
+    def __init__(self, name, color, short, icon, state):
+        self.name = name
+        self.color = color
+        self.short = short
+        self.icon = icon
+        self.state = state
+
+    def to_data(self):
+        return {
+            "name": self.name,
+            "color": self.color,
+            "short": self.short,
+            "icon": self.icon,
+            "state": self.state,
+        }
+
+    @classmethod
+    def from_data(cls, data):
+        return cls(**data)
+
+    @classmethod
+    def from_project_item(cls, status_data):
+        return cls(
+            name=status_data["name"],
+            color=status_data["color"],
+            short=status_data["shortName"],
+            icon=status_data["icon"],
+            state=status_data["state"],
+        )
+
+
 class ProjectItem:
     """Item representing folder entity on a server.
 
@@ -40,6 +83,23 @@ class ProjectItem:
             }
         self.icon = icon
 
+    @classmethod
+    def from_entity(cls, project_entity):
+        """Creates folder item from entity.
+
+        Args:
+            project_entity (dict[str, Any]): Project entity.
+
+        Returns:
+            ProjectItem: Project item.
+
+        """
+        return cls(
+            project_entity["name"],
+            project_entity["active"],
+            project_entity["library"],
+        )
+
     def to_data(self):
         """Converts folder item to data.
 
@@ -79,7 +139,7 @@ def _get_project_items_from_entitiy(projects):
     """
 
     return [
-        ProjectItem(project["name"], project["active"], project["library"])
+        ProjectItem.from_entity(project)
         for project in projects
     ]
 
@@ -87,18 +147,29 @@ def _get_project_items_from_entitiy(projects):
 class ProjectsModel(object):
     def __init__(self, controller):
         self._projects_cache = CacheItem(default_factory=list)
-        self._project_items_by_name = {}
-        self._projects_by_name = {}
+        self._project_statuses_cache = NestedCacheItem(
+            levels=1, default_factory=list
+        )
+        self._projects_by_name = NestedCacheItem(
+            levels=1, default_factory=list
+        )
 
         self._is_refreshing = False
         self._controller = controller
 
     def reset(self):
         self._projects_cache.reset()
-        self._project_items_by_name = {}
-        self._projects_by_name = {}
+        self._project_statuses_cache.reset()
+        self._projects_by_name.reset()
 
     def refresh(self):
+        """Refresh project items.
+
+        This method will requery list of ProjectItem returned by
+        'get_project_items'.
+
+        To reset all cached items use 'reset' method.
+        """
         self._refresh_projects_cache()
 
     def get_project_items(self, sender):
@@ -117,12 +188,51 @@ class ProjectsModel(object):
         return self._projects_cache.get_data()
 
     def get_project_entity(self, project_name):
-        if project_name not in self._projects_by_name:
+        """Get project entity.
+
+        Args:
+            project_name (str): Project name.
+
+        Returns:
+            Union[dict[str, Any], None]: Project entity or None if project
+                was not found by name.
+
+        """
+        project_cache = self._projects_by_name[project_name]
+        if not project_cache.is_valid:
             entity = None
             if project_name:
                 entity = ayon_api.get_project(project_name)
-            self._projects_by_name[project_name] = entity
-        return self._projects_by_name[project_name]
+            project_cache.update_data(entity)
+        return project_cache.get_data()
+
+    def get_project_status_items(self, project_name, sender):
+        """Get project status items.
+
+        Args:
+            project_name (str): Project name.
+            sender (Union[str, None]): Name of sender who asked for items.
+
+        Returns:
+            list[StatusItem]: Status items for project.
+
+        """
+        statuses_cache = self._project_statuses_cache[project_name]
+        if not statuses_cache.is_valid:
+            with self._project_statuses_refresh_event_manager(
+                sender, project_name
+            ):
+                project_entity = None
+                if project_name:
+                    project_entity = self.get_project_entity(project_name)
+                statuses = []
+                if project_entity:
+                    statuses = [
+                        StatusItem.from_project_item(status)
+                        for status in project_entity["statuses"]
+                    ]
+                statuses_cache.update_data(statuses)
+        return statuses_cache.get_data()
 
     @contextlib.contextmanager
     def _project_refresh_event_manager(self, sender):
@@ -143,6 +253,23 @@ class ProjectsModel(object):
             )
             self._is_refreshing = False
 
+    @contextlib.contextmanager
+    def _project_statuses_refresh_event_manager(self, sender, project_name):
+        self._controller.emit_event(
+            "projects.statuses.refresh.started",
+            {"sender": sender, "project_name": project_name},
+            PROJECTS_MODEL_SENDER
+        )
+        try:
+            yield
+
+        finally:
+            self._controller.emit_event(
+                "projects.statuses.refresh.finished",
+                {"sender": sender, "project_name": project_name},
+                PROJECTS_MODEL_SENDER
+            )
+
     def _refresh_projects_cache(self, sender=None):
         if self._is_refreshing:
             return None

client/ayon_core/tools/common_models/thumbnails.py

@@ -1,234 +1,15 @@
-import os
-import time
 import collections
 
 import ayon_api
-import appdirs
 
 from ayon_core.lib import NestedCacheItem
-
-FileInfo = collections.namedtuple(
-    "FileInfo",
-    ("path", "size", "modification_time")
-)
-
-
-class ThumbnailsCache:
-    """Cache of thumbnails on local storage.
-
-    Thumbnails are cached to appdirs to predefined directory. Each project has
-    own subfolder with thumbnails -> that's because each project has own
-    thumbnail id validation and file names are thumbnail ids with matching
-    extension. Extensions are predefined (.png and .jpeg).
-
-    Cache has cleanup mechanism which is triggered on initialized by default.
-
-    The cleanup has 2 levels:
-    1. soft cleanup which remove all files that are older then 'days_alive'
-    2. max size cleanup which remove all files until the thumbnails folder
-        contains less then 'max_filesize'
-        - this is time consuming so it's not triggered automatically
-
-    Args:
-        cleanup (bool): Trigger soft cleanup (Cleanup expired thumbnails).
-    """
-
-    # Lifetime of thumbnails (in seconds)
-    # - default 3 days
-    days_alive = 3
-    # Max size of thumbnail directory (in bytes)
-    # - default 2 Gb
-    max_filesize = 2 * 1024 * 1024 * 1024
-
-    def __init__(self, cleanup=True):
-        self._thumbnails_dir = None
-        self._days_alive_secs = self.days_alive * 24 * 60 * 60
-        if cleanup:
-            self.cleanup()
-
-    def get_thumbnails_dir(self):
-        """Root directory where thumbnails are stored.
-
-        Returns:
-            str: Path to thumbnails root.
-        """
-
-        if self._thumbnails_dir is None:
-            # TODO use generic function
-            directory = appdirs.user_data_dir("AYON", "Ynput")
-            self._thumbnails_dir = os.path.join(directory, "thumbnails")
-        return self._thumbnails_dir
-
-    thumbnails_dir = property(get_thumbnails_dir)
-
-    def get_thumbnails_dir_file_info(self):
-        """Get information about all files in thumbnails directory.
-
-        Returns:
-            List[FileInfo]: List of file information about all files.
-        """
-
-        thumbnails_dir = self.thumbnails_dir
-        files_info = []
-        if not os.path.exists(thumbnails_dir):
-            return files_info
-
-        for root, _, filenames in os.walk(thumbnails_dir):
-            for filename in filenames:
-                path = os.path.join(root, filename)
-                files_info.append(FileInfo(
-                    path, os.path.getsize(path), os.path.getmtime(path)
-                ))
-        return files_info
-
-    def get_thumbnails_dir_size(self, files_info=None):
-        """Got full size of thumbnail directory.
-
-        Args:
-            files_info (List[FileInfo]): Prepared file information about
-                files in thumbnail directory.
-
-        Returns:
-            int: File size of all files in thumbnail directory.
-        """
-
-        if files_info is None:
-            files_info = self.get_thumbnails_dir_file_info()
-
-        if not files_info:
-            return 0
-
-        return sum(
-            file_info.size
-            for file_info in files_info
-        )
-
-    def cleanup(self, check_max_size=False):
-        """Cleanup thumbnails directory.
-
-        Args:
-            check_max_size (bool): Also cleanup files to match max size of
-                thumbnails directory.
-        """
-
-        thumbnails_dir = self.get_thumbnails_dir()
-        # Skip if thumbnails dir does not exist yet
-        if not os.path.exists(thumbnails_dir):
-            return
-
-        self._soft_cleanup(thumbnails_dir)
-        if check_max_size:
-            self._max_size_cleanup(thumbnails_dir)
-
-    def _soft_cleanup(self, thumbnails_dir):
-        current_time = time.time()
-        for root, _, filenames in os.walk(thumbnails_dir):
-            for filename in filenames:
-                path = os.path.join(root, filename)
-                modification_time = os.path.getmtime(path)
-                if current_time - modification_time > self._days_alive_secs:
-                    os.remove(path)
-
-    def _max_size_cleanup(self, thumbnails_dir):
-        files_info = self.get_thumbnails_dir_file_info()
-        size = self.get_thumbnails_dir_size(files_info)
-        if size < self.max_filesize:
-            return
-
-        sorted_file_info = collections.deque(
-            sorted(files_info, key=lambda item: item.modification_time)
-        )
-        diff = size - self.max_filesize
-        while diff > 0:
-            if not sorted_file_info:
-                break
-
-            file_info = sorted_file_info.popleft()
-            diff -= file_info.size
-            os.remove(file_info.path)
-
-    def get_thumbnail_filepath(self, project_name, thumbnail_id):
-        """Get thumbnail by thumbnail id.
-
-        Args:
-            project_name (str): Name of project.
-            thumbnail_id (str): Thumbnail id.
-
-        Returns:
-            Union[str, None]: Path to thumbnail image or None if thumbnail
-                is not cached yet.
-        """
-
-        if not thumbnail_id:
-            return None
-
-        for ext in (
-            ".png",
-            ".jpeg",
-        ):
-            filepath = os.path.join(
-                self.thumbnails_dir, project_name, thumbnail_id + ext
-            )
-            if os.path.exists(filepath):
-                return filepath
-        return None
-
-    def get_project_dir(self, project_name):
-        """Path to root directory for specific project.
-
-        Args:
-            project_name (str): Name of project for which root directory path
-                should be returned.
-
-        Returns:
-            str: Path to root of project's thumbnails.
-        """
-
-        return os.path.join(self.thumbnails_dir, project_name)
-
-    def make_sure_project_dir_exists(self, project_name):
-        project_dir = self.get_project_dir(project_name)
-        if not os.path.exists(project_dir):
-            os.makedirs(project_dir)
-        return project_dir
-
-    def store_thumbnail(self, project_name, thumbnail_id, content, mime_type):
-        """Store thumbnail to cache folder.
-
-        Args:
-            project_name (str): Project where the thumbnail belong to.
-            thumbnail_id (str): Id of thumbnail.
-            content (bytes): Byte content of thumbnail file.
-            mime_data (str): Type of content.
-
-        Returns:
-            str: Path to cached thumbnail image file.
-        """
-
-        if mime_type == "image/png":
-            ext = ".png"
-        elif mime_type == "image/jpeg":
-            ext = ".jpeg"
-        else:
-            raise ValueError(
-                "Unknown mime type for thumbnail \"{}\"".format(mime_type))
-
-        project_dir = self.make_sure_project_dir_exists(project_name)
-        thumbnail_path = os.path.join(project_dir, thumbnail_id + ext)
-        with open(thumbnail_path, "wb") as stream:
-            stream.write(content)
-
-        current_time = time.time()
-        os.utime(thumbnail_path, (current_time, current_time))
-
-        return thumbnail_path
+from ayon_core.pipeline.thumbnails import get_thumbnail_path
 
 
 class ThumbnailsModel:
     entity_cache_lifetime = 240  # In seconds
 
     def __init__(self):
-        self._thumbnail_cache = ThumbnailsCache()
         self._paths_cache = collections.defaultdict(dict)
         self._folders_cache = NestedCacheItem(
             levels=2, lifetime=self.entity_cache_lifetime)
@@ -283,28 +64,7 @@ class ThumbnailsModel:
         if thumbnail_id in project_cache:
             return project_cache[thumbnail_id]
 
-        filepath = self._thumbnail_cache.get_thumbnail_filepath(
-            project_name, thumbnail_id
-        )
-        if filepath is not None:
-            project_cache[thumbnail_id] = filepath
-            return filepath
-
-        # 'ayon_api' had a bug, public function
-        #   'get_thumbnail_by_id' did not return output of
-        #   'ServerAPI' method.
-        con = ayon_api.get_server_api_connection()
-        result = con.get_thumbnail_by_id(project_name, thumbnail_id)
-        if result is None:
-            pass
-
-        elif result.is_valid:
-            filepath = self._thumbnail_cache.store_thumbnail(
-                project_name,
-                thumbnail_id,
-                result.content,
-                result.content_type
-            )
+        filepath = get_thumbnail_path(project_name, thumbnail_id)
         project_cache[thumbnail_id] = filepath
         return filepath
 

client/ayon_core/tools/common_models/users.py

@@ -0,0 +1,84 @@
+import ayon_api
+
+from ayon_core.lib import CacheItem
+
+
+class UserItem:
+    def __init__(
+        self,
+        username,
+        full_name,
+        email,
+        avatar_url,
+        active,
+    ):
+        self.username = username
+        self.full_name = full_name
+        self.email = email
+        self.avatar_url = avatar_url
+        self.active = active
+
+    @classmethod
+    def from_entity_data(cls, user_data):
+        return cls(
+            user_data["name"],
+            user_data["attrib"]["fullName"],
+            user_data["attrib"]["email"],
+            user_data["attrib"]["avatarUrl"],
+            user_data["active"],
+        )
+
+
+class UsersModel:
+    def __init__(self, controller):
+        self._controller = controller
+        self._users_cache = CacheItem(default_factory=list)
+
+    def get_user_items(self):
+        """Get user items.
+
+        Returns:
+            List[UserItem]: List of user items.
+
+        """
+        self._invalidate_cache()
+        return self._users_cache.get_data()
+
+    def get_user_items_by_name(self):
+        """Get user items by name.
+
+        Implemented as most of cases using this model will need to find
+            user information by username.
+
+        Returns:
+            Dict[str, UserItem]: Dictionary of user items by name.
+
+        """
+        return {
+            user_item.username: user_item
+            for user_item in self.get_user_items()
+        }
+
+    def get_user_item_by_username(self, username):
+        """Get user item by username.
+
+        Args:
+            username (str): Username.
+
+        Returns:
+            Union[UserItem, None]: User item or None if not found.
+
+        """
+        self._invalidate_cache()
+        for user_item in self.get_user_items():
+            if user_item.username == username:
+                return user_item
+        return None
+
+    def _invalidate_cache(self):
+        if self._users_cache.is_valid:
+            return
+        self._users_cache.update_data([
+            UserItem.from_entity_data(user)
+            for user in ayon_api.get_users()
+        ])

client/ayon_core/tools/launcher/ui/actions_widget.py

@@ -290,6 +290,34 @@ class ActionDelegate(QtWidgets.QStyledItemDelegate):
         painter.drawPixmap(extender_x, extender_y, pix)
 
 
+class ActionsProxyModel(QtCore.QSortFilterProxyModel):
+    def __init__(self, *args, **kwargs):
+        super().__init__(*args, **kwargs)
+
+        self.setSortCaseSensitivity(QtCore.Qt.CaseInsensitive)
+
+    def lessThan(self, left, right):
+        # Sort by action order and then by label
+        left_value = left.data(ACTION_SORT_ROLE)
+        right_value = right.data(ACTION_SORT_ROLE)
+
+        # Values are same -> use super sorting
+        if left_value == right_value:
+            # Default behavior is using DisplayRole
+            return super().lessThan(left, right)
+
+        # Validate 'None' values
+        if right_value is None:
+            return True
+        if left_value is None:
+            return False
+        # Sort values and handle incompatible types
+        try:
+            return left_value < right_value
+        except TypeError:
+            return True
+
+
 class ActionsWidget(QtWidgets.QWidget):
     def __init__(self, controller, parent):
         super(ActionsWidget, self).__init__(parent)
@@ -316,10 +344,7 @@ class ActionsWidget(QtWidgets.QWidget):
 
         model = ActionsQtModel(controller)
 
-        proxy_model = QtCore.QSortFilterProxyModel()
-        proxy_model.setSortCaseSensitivity(QtCore.Qt.CaseInsensitive)
-        proxy_model.setSortRole(ACTION_SORT_ROLE)
-
+        proxy_model = ActionsProxyModel()
         proxy_model.setSourceModel(model)
         view.setModel(proxy_model)
 
@@ -359,7 +384,8 @@ class ActionsWidget(QtWidgets.QWidget):
     def _on_model_refresh(self):
         self._proxy_model.sort(0)
         # Force repaint all items
-        self._view.update()
+        viewport = self._view.viewport()
+        viewport.update()
 
     def _on_animation(self):
         time_now = time.time()

client/ayon_core/tools/loader/abstract.py

@@ -114,6 +114,7 @@ class VersionItem:
         thumbnail_id (Union[str, None]): Thumbnail id.
         published_time (Union[str, None]): Published time in format
             '%Y%m%dT%H%M%SZ'.
+        status (Union[str, None]): Status name.
         author (Union[str, None]): Author.
         frame_range (Union[str, None]): Frame range.
         duration (Union[int, None]): Duration.
@@ -132,6 +133,7 @@ class VersionItem:
         thumbnail_id,
         published_time,
         author,
+        status,
         frame_range,
         duration,
         handles,
@@ -146,6 +148,7 @@ class VersionItem:
         self.is_hero = is_hero
         self.published_time = published_time
         self.author = author
+        self.status = status
         self.frame_range = frame_range
         self.duration = duration
         self.handles = handles
@@ -185,6 +188,7 @@ class VersionItem:
             "is_hero": self.is_hero,
             "published_time": self.published_time,
             "author": self.author,
+            "status": self.status,
             "frame_range": self.frame_range,
             "duration": self.duration,
             "handles": self.handles,
@@ -488,6 +492,27 @@ class FrontendLoaderController(_BaseLoaderController):
 
         pass
 
+    @abstractmethod
+    def get_project_status_items(self, project_name, sender=None):
+        """Items for all projects available on server.
+
+        Triggers event topics "projects.statuses.refresh.started" and
+        "projects.statuses.refresh.finished" with data:
+            {
+                "sender": sender,
+                "project_name": project_name
+            }
+
+        Args:
+            project_name (Union[str, None]): Project name.
+            sender (Optional[str]): Sender who requested the items.
+
+        Returns:
+            list[StatusItem]: List of status items.
+        """
+
+        pass
+
     @abstractmethod
     def get_product_items(self, project_name, folder_ids, sender=None):
         """Product items for folder ids.

client/ayon_core/tools/loader/control.py

@@ -180,6 +180,11 @@ class LoaderController(BackendLoaderController, FrontendLoaderController):
     def get_project_items(self, sender=None):
         return self._projects_model.get_project_items(sender)
 
+    def get_project_status_items(self, project_name, sender=None):
+        return self._projects_model.get_project_status_items(
+            project_name, sender
+        )
+
     def get_folder_items(self, project_name, sender=None):
         return self._hierarchy_model.get_folder_items(project_name, sender)
 

client/ayon_core/tools/loader/models/products.py

@@ -58,6 +58,7 @@ def version_item_from_entity(version):
         thumbnail_id=version["thumbnailId"],
         published_time=published_time,
         author=author,
+        status=version["status"],
         frame_range=frame_range,
         duration=duration,
         handles=handles,
@@ -526,8 +527,11 @@ class ProductsModel:
         products = list(ayon_api.get_products(project_name, **kwargs))
         product_ids = {product["id"] for product in products}
 
+        # Add 'status' to fields -> fixed in ayon-python-api 1.0.4
+        fields = ayon_api.get_default_fields_for_type("version")
+        fields.add("status")
         versions = ayon_api.get_versions(
-            project_name, product_ids=product_ids
+            project_name, product_ids=product_ids, fields=fields
         )
 
         return self._create_product_items(

client/ayon_core/tools/loader/ui/products_delegates.py

@@ -104,7 +104,10 @@ class VersionDelegate(QtWidgets.QStyledItemDelegate):
             style = QtWidgets.QApplication.style()
 
         style.drawControl(
-            style.CE_ItemViewItem, option, painter, option.widget
+            QtWidgets.QCommonStyle.CE_ItemViewItem,
+            option,
+            painter,
+            option.widget
         )
 
         painter.save()
@@ -116,9 +119,14 @@ class VersionDelegate(QtWidgets.QStyledItemDelegate):
         pen.setColor(fg_color)
         painter.setPen(pen)
 
-        text_rect = style.subElementRect(style.SE_ItemViewItemText, option)
+        text_rect = style.subElementRect(
+            QtWidgets.QCommonStyle.SE_ItemViewItemText,
+            option
+        )
         text_margin = style.proxy().pixelMetric(
-            style.PM_FocusFrameHMargin, option, option.widget
+            QtWidgets.QCommonStyle.PM_FocusFrameHMargin,
+            option,
+            option.widget
         ) + 1
 
         painter.drawText(

client/ayon_core/tools/loader/ui/products_model.py

@@ -22,18 +22,22 @@ VERSION_HERO_ROLE = QtCore.Qt.UserRole + 11
 VERSION_NAME_ROLE = QtCore.Qt.UserRole + 12
 VERSION_NAME_EDIT_ROLE = QtCore.Qt.UserRole + 13
 VERSION_PUBLISH_TIME_ROLE = QtCore.Qt.UserRole + 14
-VERSION_AUTHOR_ROLE = QtCore.Qt.UserRole + 15
-VERSION_FRAME_RANGE_ROLE = QtCore.Qt.UserRole + 16
-VERSION_DURATION_ROLE = QtCore.Qt.UserRole + 17
-VERSION_HANDLES_ROLE = QtCore.Qt.UserRole + 18
-VERSION_STEP_ROLE = QtCore.Qt.UserRole + 19
-VERSION_AVAILABLE_ROLE = QtCore.Qt.UserRole + 20
-VERSION_THUMBNAIL_ID_ROLE = QtCore.Qt.UserRole + 21
-ACTIVE_SITE_ICON_ROLE = QtCore.Qt.UserRole + 22
-REMOTE_SITE_ICON_ROLE = QtCore.Qt.UserRole + 23
-REPRESENTATIONS_COUNT_ROLE = QtCore.Qt.UserRole + 24
-SYNC_ACTIVE_SITE_AVAILABILITY = QtCore.Qt.UserRole + 25
-SYNC_REMOTE_SITE_AVAILABILITY = QtCore.Qt.UserRole + 26
+VERSION_STATUS_NAME_ROLE = QtCore.Qt.UserRole + 15
+VERSION_STATUS_SHORT_ROLE = QtCore.Qt.UserRole + 16
+VERSION_STATUS_COLOR_ROLE = QtCore.Qt.UserRole + 17
+VERSION_STATUS_ICON_ROLE = QtCore.Qt.UserRole + 18
+VERSION_AUTHOR_ROLE = QtCore.Qt.UserRole + 19
+VERSION_FRAME_RANGE_ROLE = QtCore.Qt.UserRole + 20
+VERSION_DURATION_ROLE = QtCore.Qt.UserRole + 21
+VERSION_HANDLES_ROLE = QtCore.Qt.UserRole + 22
+VERSION_STEP_ROLE = QtCore.Qt.UserRole + 23
+VERSION_AVAILABLE_ROLE = QtCore.Qt.UserRole + 24
+VERSION_THUMBNAIL_ID_ROLE = QtCore.Qt.UserRole + 25
+ACTIVE_SITE_ICON_ROLE = QtCore.Qt.UserRole + 26
+REMOTE_SITE_ICON_ROLE = QtCore.Qt.UserRole + 27
+REPRESENTATIONS_COUNT_ROLE = QtCore.Qt.UserRole + 28
+SYNC_ACTIVE_SITE_AVAILABILITY = QtCore.Qt.UserRole + 29
+SYNC_REMOTE_SITE_AVAILABILITY = QtCore.Qt.UserRole + 30
 
 
 class ProductsModel(QtGui.QStandardItemModel):
@@ -44,6 +48,7 @@ class ProductsModel(QtGui.QStandardItemModel):
         "Product type",
         "Folder",
         "Version",
+        "Status",
         "Time",
         "Author",
         "Frames",
@@ -69,11 +74,35 @@ class ProductsModel(QtGui.QStandardItemModel):
         ]
     ]
 
-    version_col = column_labels.index("Version")
-    published_time_col = column_labels.index("Time")
+    product_name_col = column_labels.index("Product name")
+    product_type_col = column_labels.index("Product type")
     folders_label_col = column_labels.index("Folder")
+    version_col = column_labels.index("Version")
+    status_col = column_labels.index("Status")
+    published_time_col = column_labels.index("Time")
+    author_col = column_labels.index("Author")
+    frame_range_col = column_labels.index("Frames")
+    duration_col = column_labels.index("Duration")
+    handles_col = column_labels.index("Handles")
+    step_col = column_labels.index("Step")
     in_scene_col = column_labels.index("In scene")
     sitesync_avail_col = column_labels.index("Availability")
+    _display_role_mapping = {
+        product_name_col: QtCore.Qt.DisplayRole,
+        product_type_col: PRODUCT_TYPE_ROLE,
+        folders_label_col: FOLDER_LABEL_ROLE,
+        version_col: VERSION_NAME_ROLE,
+        status_col: VERSION_STATUS_NAME_ROLE,
+        published_time_col: VERSION_PUBLISH_TIME_ROLE,
+        author_col: VERSION_AUTHOR_ROLE,
+        frame_range_col: VERSION_FRAME_RANGE_ROLE,
+        duration_col: VERSION_DURATION_ROLE,
+        handles_col: VERSION_HANDLES_ROLE,
+        step_col: VERSION_STEP_ROLE,
+        in_scene_col: PRODUCT_IN_SCENE_ROLE,
+        sitesync_avail_col: VERSION_AVAILABLE_ROLE,
+
+    }
 
     def __init__(self, controller):
         super(ProductsModel, self).__init__()
@@ -96,6 +125,7 @@ class ProductsModel(QtGui.QStandardItemModel):
 
         self._last_project_name = None
         self._last_folder_ids = []
+        self._last_project_statuses = {}
 
     def get_product_item_indexes(self):
         return [
@@ -141,6 +171,15 @@ class ProductsModel(QtGui.QStandardItemModel):
         if not index.isValid():
             return None
 
+        if role in (VERSION_STATUS_SHORT_ROLE, VERSION_STATUS_COLOR_ROLE):
+            status_name = self.data(index, VERSION_STATUS_NAME_ROLE)
+            status_item = self._last_project_statuses.get(status_name)
+            if status_item is None:
+                return ""
+            if role == VERSION_STATUS_SHORT_ROLE:
+                return status_item.short
+            return status_item.color
+
         col = index.column()
         if col == 0:
             return super(ProductsModel, self).data(index, role)
@@ -168,29 +207,8 @@ class ProductsModel(QtGui.QStandardItemModel):
         if role == QtCore.Qt.DisplayRole:
             if not index.data(PRODUCT_ID_ROLE):
                 return None
-            if col == self.version_col:
-                role = VERSION_NAME_ROLE
-            elif col == 1:
-                role = PRODUCT_TYPE_ROLE
-            elif col == 2:
-                role = FOLDER_LABEL_ROLE
-            elif col == 4:
-                role = VERSION_PUBLISH_TIME_ROLE
-            elif col == 5:
-                role = VERSION_AUTHOR_ROLE
-            elif col == 6:
-                role = VERSION_FRAME_RANGE_ROLE
-            elif col == 7:
-                role = VERSION_DURATION_ROLE
-            elif col == 8:
-                role = VERSION_HANDLES_ROLE
-            elif col == 9:
-                role = VERSION_STEP_ROLE
-            elif col == 10:
-                role = PRODUCT_IN_SCENE_ROLE
-            elif col == 11:
-                role = VERSION_AVAILABLE_ROLE
-            else:
+            role = self._display_role_mapping.get(col)
+            if role is None:
                 return None
 
         index = self.index(index.row(), 0, index.parent())
@@ -312,6 +330,7 @@ class ProductsModel(QtGui.QStandardItemModel):
             version_item.published_time, VERSION_PUBLISH_TIME_ROLE
         )
         model_item.setData(version_item.author, VERSION_AUTHOR_ROLE)
+        model_item.setData(version_item.status, VERSION_STATUS_NAME_ROLE)
         model_item.setData(version_item.frame_range, VERSION_FRAME_RANGE_ROLE)
         model_item.setData(version_item.duration, VERSION_DURATION_ROLE)
         model_item.setData(version_item.handles, VERSION_HANDLES_ROLE)
@@ -393,6 +412,11 @@ class ProductsModel(QtGui.QStandardItemModel):
 
         self._last_project_name = project_name
         self._last_folder_ids = folder_ids
+        status_items = self._controller.get_project_status_items(project_name)
+        self._last_project_statuses = {
+            status_item.name: status_item
+            for status_item in status_items
+        }
 
         active_site_icon_def = self._controller.get_active_site_icon_def(
             project_name

client/ayon_core/tools/loader/ui/products_widget.py

@@ -6,7 +6,7 @@ from ayon_core.tools.utils import (
     RecursiveSortFilterProxyModel,
     DeselectableTreeView,
 )
-from ayon_core.tools.utils.delegates import PrettyTimeDelegate
+from ayon_core.tools.utils.delegates import PrettyTimeDelegate, StatusDelegate
 
 from .products_model import (
     ProductsModel,
@@ -17,12 +17,16 @@ from .products_model import (
     FOLDER_ID_ROLE,
     PRODUCT_ID_ROLE,
     VERSION_ID_ROLE,
+    VERSION_STATUS_NAME_ROLE,
+    VERSION_STATUS_SHORT_ROLE,
+    VERSION_STATUS_COLOR_ROLE,
+    VERSION_STATUS_ICON_ROLE,
     VERSION_THUMBNAIL_ID_ROLE,
 )
 from .products_delegates import (
     VersionDelegate,
     LoadedInSceneDelegate,
-    SiteSyncDelegate
+    SiteSyncDelegate,
 )
 from .actions_utils import show_actions_menu
 
@@ -89,6 +93,7 @@ class ProductsWidget(QtWidgets.QWidget):
         90,   # Product type
         130,  # Folder label
         60,   # Version
+        100,   # Status
         125,  # Time
         75,   # Author
         75,   # Frames
@@ -128,20 +133,24 @@ class ProductsWidget(QtWidgets.QWidget):
             products_view.setColumnWidth(idx, width)
 
         version_delegate = VersionDelegate()
-        products_view.setItemDelegateForColumn(
-            products_model.version_col, version_delegate)
-
         time_delegate = PrettyTimeDelegate()
-        products_view.setItemDelegateForColumn(
-            products_model.published_time_col, time_delegate)
-
+        status_delegate = StatusDelegate(
+            VERSION_STATUS_NAME_ROLE,
+            VERSION_STATUS_SHORT_ROLE,
+            VERSION_STATUS_COLOR_ROLE,
+            VERSION_STATUS_ICON_ROLE,
+        )
         in_scene_delegate = LoadedInSceneDelegate()
-        products_view.setItemDelegateForColumn(
-            products_model.in_scene_col, in_scene_delegate)
-
         sitesync_delegate = SiteSyncDelegate()
-        products_view.setItemDelegateForColumn(
-            products_model.sitesync_avail_col, sitesync_delegate)
+
+        for col, delegate in (
+            (products_model.version_col, version_delegate),
+            (products_model.published_time_col, time_delegate),
+            (products_model.status_col, status_delegate),
+            (products_model.in_scene_col, in_scene_delegate),
+            (products_model.sitesync_avail_col, sitesync_delegate),
+        ):
+            products_view.setItemDelegateForColumn(col, delegate)
 
         main_layout = QtWidgets.QHBoxLayout(self)
         main_layout.setContentsMargins(0, 0, 0, 0)
@@ -175,6 +184,7 @@ class ProductsWidget(QtWidgets.QWidget):
 
         self._version_delegate = version_delegate
         self._time_delegate = time_delegate
+        self._status_delegate = status_delegate
         self._in_scene_delegate = in_scene_delegate
         self._sitesync_delegate = sitesync_delegate
 

client/ayon_core/tools/loader/ui/window.py

@@ -335,9 +335,7 @@ class LoaderWindow(QtWidgets.QWidget):
 
     def closeEvent(self, event):
         super(LoaderWindow, self).closeEvent(event)
-        # Deselect project so current context will be selected
-        #   on next 'showEvent'
-        self._controller.set_selected_project(None)
+
         self._reset_on_show = True
 
     def keyPressEvent(self, event):

client/ayon_core/tools/publisher/widgets/card_view_widgets.py

@@ -52,6 +52,7 @@ class SelectionTypes:
 class BaseGroupWidget(QtWidgets.QWidget):
     selected = QtCore.Signal(str, str, str)
     removed_selected = QtCore.Signal()
+    double_clicked = QtCore.Signal()
 
     def __init__(self, group_name, parent):
         super(BaseGroupWidget, self).__init__(parent)
@@ -192,6 +193,7 @@ class ConvertorItemsGroupWidget(BaseGroupWidget):
                 else:
                     widget = ConvertorItemCardWidget(item, self)
                     widget.selected.connect(self._on_widget_selection)
+                    widget.double_clicked(self.double_clicked)
                     self._widgets_by_id[item.id] = widget
                     self._content_layout.insertWidget(widget_idx, widget)
                 widget_idx += 1
@@ -254,6 +256,7 @@ class InstanceGroupWidget(BaseGroupWidget):
                     )
                     widget.selected.connect(self._on_widget_selection)
                     widget.active_changed.connect(self._on_active_changed)
+                    widget.double_clicked.connect(self.double_clicked)
                     self._widgets_by_id[instance.id] = widget
                     self._content_layout.insertWidget(widget_idx, widget)
                 widget_idx += 1
@@ -271,6 +274,7 @@ class CardWidget(BaseClickableFrame):
     # Group identifier of card
     # - this must be set because if send when mouse is released with card id
     _group_identifier = None
+    double_clicked = QtCore.Signal()
 
     def __init__(self, parent):
         super(CardWidget, self).__init__(parent)
@@ -279,6 +283,11 @@ class CardWidget(BaseClickableFrame):
         self._selected = False
         self._id = None
 
+    def mouseDoubleClickEvent(self, event):
+        super(CardWidget, self).mouseDoubleClickEvent(event)
+        if self._is_valid_double_click(event):
+            self.double_clicked.emit()
+
     @property
     def id(self):
         """Id of card."""
@@ -312,6 +321,9 @@ class CardWidget(BaseClickableFrame):
 
         self.selected.emit(self._id, self._group_identifier, selection_type)
 
+    def _is_valid_double_click(self, event):
+        return True
+
 
 class ContextCardWidget(CardWidget):
     """Card for global context.
@@ -527,6 +539,15 @@ class InstanceCardWidget(CardWidget):
     def _on_expend_clicked(self):
         self._set_expanded()
 
+    def _is_valid_double_click(self, event):
+        widget = self.childAt(event.pos())
+        if (
+            widget is self._active_checkbox
+            or widget is self._expand_btn
+        ):
+            return False
+        return True
+
 
 class InstanceCardView(AbstractInstanceView):
     """Publish access to card view.
@@ -534,6 +555,8 @@ class InstanceCardView(AbstractInstanceView):
     Wrapper of all widgets in card view.
     """
 
+    double_clicked = QtCore.Signal()
+
     def __init__(self, controller, parent):
         super(InstanceCardView, self).__init__(parent)
 
@@ -715,6 +738,7 @@ class InstanceCardView(AbstractInstanceView):
                 )
                 group_widget.active_changed.connect(self._on_active_changed)
                 group_widget.selected.connect(self._on_widget_selection)
+                group_widget.double_clicked.connect(self.double_clicked)
                 self._content_layout.insertWidget(widget_idx, group_widget)
                 self._widgets_by_group[group_name] = group_widget
 
@@ -755,6 +779,7 @@ class InstanceCardView(AbstractInstanceView):
 
         widget = ContextCardWidget(self._content_widget)
         widget.selected.connect(self._on_widget_selection)
+        widget.double_clicked.connect(self.double_clicked)
 
         self._context_widget = widget
 
@@ -778,6 +803,7 @@ class InstanceCardView(AbstractInstanceView):
                 CONVERTOR_ITEM_GROUP, self._content_widget
             )
             group_widget.selected.connect(self._on_widget_selection)
+            group_widget.double_clicked.connect(self.double_clicked)
             self._content_layout.insertWidget(1, group_widget)
             self._convertor_items_group = group_widget
 

client/ayon_core/tools/publisher/widgets/list_view_widgets.py

@@ -110,6 +110,7 @@ class InstanceListItemWidget(QtWidgets.QWidget):
     This is required to be able use custom checkbox on custom place.
     """
     active_changed = QtCore.Signal(str, bool)
+    double_clicked = QtCore.Signal()
 
     def __init__(self, instance, parent):
         super(InstanceListItemWidget, self).__init__(parent)
@@ -149,6 +150,12 @@ class InstanceListItemWidget(QtWidgets.QWidget):
 
         self._set_valid_property(instance.has_valid_context)
 
+    def mouseDoubleClickEvent(self, event):
+        widget = self.childAt(event.pos())
+        super(InstanceListItemWidget, self).mouseDoubleClickEvent(event)
+        if widget is not self._active_checkbox:
+            self.double_clicked.emit()
+
     def _set_valid_property(self, valid):
         if self._has_valid_context == valid:
             return
@@ -209,6 +216,8 @@ class InstanceListItemWidget(QtWidgets.QWidget):
 
 class ListContextWidget(QtWidgets.QFrame):
     """Context (or global attributes) widget."""
+    double_clicked = QtCore.Signal()
+
     def __init__(self, parent):
         super(ListContextWidget, self).__init__(parent)
 
@@ -225,6 +234,10 @@ class ListContextWidget(QtWidgets.QFrame):
 
         self.label_widget = label_widget
 
+    def mouseDoubleClickEvent(self, event):
+        super(ListContextWidget, self).mouseDoubleClickEvent(event)
+        self.double_clicked.emit()
+
 
 class InstanceListGroupWidget(QtWidgets.QFrame):
     """Widget representing group of instances.
@@ -317,6 +330,7 @@ class InstanceListGroupWidget(QtWidgets.QFrame):
 class InstanceTreeView(QtWidgets.QTreeView):
     """View showing instances and their groups."""
     toggle_requested = QtCore.Signal(int)
+    double_clicked = QtCore.Signal()
 
     def __init__(self, *args, **kwargs):
         super(InstanceTreeView, self).__init__(*args, **kwargs)
@@ -425,6 +439,9 @@ class InstanceListView(AbstractInstanceView):
 
     This is public access to and from list view.
     """
+
+    double_clicked = QtCore.Signal()
+
     def __init__(self, controller, parent):
         super(InstanceListView, self).__init__(parent)
 
@@ -454,6 +471,7 @@ class InstanceListView(AbstractInstanceView):
         instance_view.collapsed.connect(self._on_collapse)
         instance_view.expanded.connect(self._on_expand)
         instance_view.toggle_requested.connect(self._on_toggle_request)
+        instance_view.double_clicked.connect(self.double_clicked)
 
         self._group_items = {}
         self._group_widgets = {}
@@ -687,6 +705,7 @@ class InstanceListView(AbstractInstanceView):
                         self._active_toggle_enabled
                     )
                     widget.active_changed.connect(self._on_active_changed)
+                    widget.double_clicked.connect(self.double_clicked)
                     self._instance_view.setIndexWidget(proxy_index, widget)
                     self._widgets_by_id[instance.id] = widget
 
@@ -717,6 +736,7 @@ class InstanceListView(AbstractInstanceView):
         )
         proxy_index = self._proxy_model.mapFromSource(index)
         widget = ListContextWidget(self._instance_view)
+        widget.double_clicked.connect(self.double_clicked)
         self._instance_view.setIndexWidget(proxy_index, widget)
 
         self._context_widget = widget

client/ayon_core/tools/publisher/widgets/overview_widget.py

@@ -18,6 +18,7 @@ class OverviewWidget(QtWidgets.QFrame):
     instance_context_changed = QtCore.Signal()
     create_requested = QtCore.Signal()
     convert_requested = QtCore.Signal()
+    publish_tab_requested = QtCore.Signal()
 
     anim_end_value = 200
     anim_duration = 200
@@ -113,9 +114,15 @@ class OverviewWidget(QtWidgets.QFrame):
         product_list_view.selection_changed.connect(
             self._on_product_change
         )
+        product_list_view.double_clicked.connect(
+            self.publish_tab_requested
+        )
         product_view_cards.selection_changed.connect(
             self._on_product_change
         )
+        product_view_cards.double_clicked.connect(
+            self.publish_tab_requested
+        )
         # Active instances changed
         product_list_view.active_changed.connect(
             self._on_active_changed

client/ayon_core/tools/publisher/window.py

@@ -258,6 +258,9 @@ class PublisherWindow(QtWidgets.QDialog):
         overview_widget.convert_requested.connect(
             self._on_convert_requested
         )
+        overview_widget.publish_tab_requested.connect(
+            self._go_to_publish_tab
+        )
 
         save_btn.clicked.connect(self._on_save_clicked)
         reset_btn.clicked.connect(self._on_reset_clicked)

client/ayon_core/tools/push_to_project/models/integrate.py

@@ -723,7 +723,6 @@ class ProjectPushItemProcess:
         dst_project_name = self._item.dst_project_name
         dst_folder_id = self._item.dst_folder_id
         dst_task_name = self._item.dst_task_name
-        dst_task_name_low = dst_task_name.lower()
         new_folder_name = self._item.new_folder_name
         if not dst_folder_id and not new_folder_name:
             self._status.set_failed(
@@ -765,7 +764,7 @@ class ProjectPushItemProcess:
                 dst_project_name, folder_ids=[folder_entity["id"]]
             )
         }
-        task_info = folder_tasks.get(dst_task_name_low)
+        task_info = folder_tasks.get(dst_task_name.lower())
         if not task_info:
             self._status.set_failed(
                 f"Could find task with name \"{dst_task_name}\""

client/ayon_core/tools/sceneinventory/control.py

@@ -1,14 +1,14 @@
 import ayon_api
 
 from ayon_core.lib.events import QueuedEventSystem
-from ayon_core.host import ILoadHost
+from ayon_core.host import HostBase
 from ayon_core.pipeline import (
     registered_host,
     get_current_context,
 )
-from ayon_core.tools.common_models import HierarchyModel
+from ayon_core.tools.common_models import HierarchyModel, ProjectsModel
 
-from .models import SiteSyncModel
+from .models import SiteSyncModel, ContainersModel
 
 
 class SceneInventoryController:
@@ -28,11 +28,16 @@ class SceneInventoryController:
         self._current_folder_id = None
         self._current_folder_set = False
 
+        self._containers_model = ContainersModel(self)
         self._sitesync_model = SiteSyncModel(self)
         # Switch dialog requirements
         self._hierarchy_model = HierarchyModel(self)
+        self._projects_model = ProjectsModel(self)
         self._event_system = self._create_event_system()
 
+    def get_host(self) -> HostBase:
+        return self._host
+
     def emit_event(self, topic, data=None, source=None):
         if data is None:
             data = {}
@@ -47,6 +52,7 @@ class SceneInventoryController:
         self._current_folder_id = None
         self._current_folder_set = False
 
+        self._containers_model.reset()
         self._sitesync_model.reset()
         self._hierarchy_model.reset()
 
@@ -80,13 +86,32 @@ class SceneInventoryController:
         self._current_folder_set = True
         return self._current_folder_id
 
+    def get_project_status_items(self):
+        project_name = self.get_current_project_name()
+        return self._projects_model.get_project_status_items(
+            project_name, None
+        )
+
+    # Containers methods
     def get_containers(self):
-        host = self._host
-        if isinstance(host, ILoadHost):
-            return list(host.get_containers())
-        elif hasattr(host, "ls"):
-            return list(host.ls())
-        return []
+        return self._containers_model.get_containers()
+
+    def get_containers_by_item_ids(self, item_ids):
+        return self._containers_model.get_containers_by_item_ids(item_ids)
+
+    def get_container_items(self):
+        return self._containers_model.get_container_items()
+
+    def get_container_items_by_id(self, item_ids):
+        return self._containers_model.get_container_items_by_id(item_ids)
+
+    def get_representation_info_items(self, representation_ids):
+        return self._containers_model.get_representation_info_items(
+            representation_ids
+        )
+
+    def get_version_items(self, product_ids):
+        return self._containers_model.get_version_items(product_ids)
 
     # Site Sync methods
     def is_sitesync_enabled(self):

client/ayon_core/tools/sceneinventory/delegates.py

@@ -1,38 +1,10 @@
-import numbers
-
-import ayon_api
-
-from ayon_core.pipeline import HeroVersionType
-from ayon_core.tools.utils.models import TreeModel
-from ayon_core.tools.utils.lib import format_version
-
 from qtpy import QtWidgets, QtCore, QtGui
 
+from .model import VERSION_LABEL_ROLE
+
 
 class VersionDelegate(QtWidgets.QStyledItemDelegate):
     """A delegate that display version integer formatted as version string."""
-
-    version_changed = QtCore.Signal()
-    first_run = False
-    lock = False
-
-    def __init__(self, controller, *args, **kwargs):
-        self._controller = controller
-        super(VersionDelegate, self).__init__(*args, **kwargs)
-
-    def get_project_name(self):
-        return self._controller.get_current_project_name()
-
-    def displayText(self, value, locale):
-        if isinstance(value, HeroVersionType):
-            return format_version(value)
-        if not isinstance(value, numbers.Integral):
-            # For cases where no version is resolved like NOT FOUND cases
-            # where a representation might not exist in current database
-            return
-
-        return format_version(value)
-
     def paint(self, painter, option, index):
         fg_color = index.data(QtCore.Qt.ForegroundRole)
         if fg_color:
@@ -44,7 +16,7 @@ class VersionDelegate(QtWidgets.QStyledItemDelegate):
                 fg_color = None
 
         if not fg_color:
-            return super(VersionDelegate, self).paint(painter, option, index)
+            return super().paint(painter, option, index)
 
         if option.widget:
             style = option.widget.style()
@@ -60,9 +32,7 @@ class VersionDelegate(QtWidgets.QStyledItemDelegate):
 
         painter.save()
 
-        text = self.displayText(
-            index.data(QtCore.Qt.DisplayRole), option.locale
-        )
+        text = index.data(VERSION_LABEL_ROLE)
         pen = painter.pen()
         pen.setColor(fg_color)
         painter.setPen(pen)
@@ -82,77 +52,3 @@ class VersionDelegate(QtWidgets.QStyledItemDelegate):
         )
 
         painter.restore()
-
-    def createEditor(self, parent, option, index):
-        item = index.data(TreeModel.ItemRole)
-        if item.get("isGroup") or item.get("isMerged"):
-            return
-
-        editor = QtWidgets.QComboBox(parent)
-
-        def commit_data():
-            if not self.first_run:
-                self.commitData.emit(editor)  # Update model data
-                self.version_changed.emit()   # Display model data
-        editor.currentIndexChanged.connect(commit_data)
-
-        self.first_run = True
-        self.lock = False
-
-        return editor
-
-    def setEditorData(self, editor, index):
-        if self.lock:
-            # Only set editor data once per delegation
-            return
-
-        editor.clear()
-
-        # Current value of the index
-        item = index.data(TreeModel.ItemRole)
-        value = index.data(QtCore.Qt.DisplayRole)
-
-        project_name = self.get_project_name()
-        # Add all available versions to the editor
-        product_id = item["version_entity"]["productId"]
-        version_entities = list(sorted(
-            ayon_api.get_versions(
-                project_name, product_ids={product_id}, active=True
-            ),
-            key=lambda item: abs(item["version"])
-        ))
-
-        selected = None
-        items = []
-        is_hero_version = value < 0
-        for version_entity in version_entities:
-            version = version_entity["version"]
-            label = format_version(version)
-            item = QtGui.QStandardItem(label)
-            item.setData(version_entity, QtCore.Qt.UserRole)
-            items.append(item)
-
-            if (
-                version == value
-                or is_hero_version and version < 0
-            ):
-                selected = item
-
-        # Reverse items so latest versions be upper
-        items.reverse()
-        for item in items:
-            editor.model().appendRow(item)
-
-        index = 0
-        if selected:
-            index = selected.row()
-
-        # Will trigger index-change signal
-        editor.setCurrentIndex(index)
-        self.first_run = False
-        self.lock = True
-
-    def setModelData(self, editor, model, index):
-        """Apply the integer version back in the model"""
-        version = editor.itemData(editor.currentIndex())
-        model.setData(index, version["name"])

client/ayon_core/tools/sceneinventory/model.py

@@ -1,57 +1,113 @@
 import re
 import logging
-import uuid
 
-from collections import defaultdict
+import collections
 
-import ayon_api
 from qtpy import QtCore, QtGui
 import qtawesome
 
-from ayon_core.pipeline import (
-    get_current_project_name,
-    HeroVersionType,
-)
 from ayon_core.style import get_default_entity_icon_color
 from ayon_core.tools.utils import get_qt_icon
-from ayon_core.tools.utils.models import TreeModel, Item
+from ayon_core.tools.utils.lib import format_version
+
+ITEM_ID_ROLE = QtCore.Qt.UserRole + 1
+NAME_COLOR_ROLE = QtCore.Qt.UserRole + 2
+COUNT_ROLE = QtCore.Qt.UserRole + 3
+IS_CONTAINER_ITEM_ROLE = QtCore.Qt.UserRole + 4
+VERSION_IS_LATEST_ROLE = QtCore.Qt.UserRole + 5
+VERSION_IS_HERO_ROLE = QtCore.Qt.UserRole + 6
+VERSION_LABEL_ROLE = QtCore.Qt.UserRole + 7
+VERSION_COLOR_ROLE = QtCore.Qt.UserRole + 8
+STATUS_NAME_ROLE = QtCore.Qt.UserRole + 9
+STATUS_COLOR_ROLE = QtCore.Qt.UserRole + 10
+STATUS_SHORT_ROLE = QtCore.Qt.UserRole + 11
+STATUS_ICON_ROLE = QtCore.Qt.UserRole + 12
+PRODUCT_ID_ROLE = QtCore.Qt.UserRole + 13
+PRODUCT_TYPE_ROLE = QtCore.Qt.UserRole + 14
+PRODUCT_TYPE_ICON_ROLE = QtCore.Qt.UserRole + 15
+PRODUCT_GROUP_NAME_ROLE = QtCore.Qt.UserRole + 16
+PRODUCT_GROUP_ICON_ROLE = QtCore.Qt.UserRole + 17
+LOADER_NAME_ROLE = QtCore.Qt.UserRole + 18
+OBJECT_NAME_ROLE = QtCore.Qt.UserRole + 19
+ACTIVE_SITE_PROGRESS_ROLE = QtCore.Qt.UserRole + 20
+REMOTE_SITE_PROGRESS_ROLE = QtCore.Qt.UserRole + 21
+ACTIVE_SITE_ICON_ROLE = QtCore.Qt.UserRole + 22
+REMOTE_SITE_ICON_ROLE = QtCore.Qt.UserRole + 23
+# This value hold unique value of container that should be used to identify
+#     containers inbetween refresh.
+ITEM_UNIQUE_NAME_ROLE = QtCore.Qt.UserRole + 24
 
 
-def walk_hierarchy(node):
-    """Recursively yield group node."""
-    for child in node.children():
-        if child.get("isGroupNode"):
-            yield child
-
-        for _child in walk_hierarchy(child):
-            yield _child
-
-
-class InventoryModel(TreeModel):
+class InventoryModel(QtGui.QStandardItemModel):
     """The model for the inventory"""
 
-    Columns = [
+    column_labels = [
         "Name",
-        "version",
-        "count",
-        "productType",
-        "group",
-        "loader",
-        "objectName",
-        "active_site",
-        "remote_site",
+        "Version",
+        "Status",
+        "Count",
+        "Product type",
+        "Group",
+        "Loader",
+        "Object name",
+        "Active site",
+        "Remote site",
     ]
-    active_site_col = Columns.index("active_site")
-    remote_site_col = Columns.index("remote_site")
+    name_col = column_labels.index("Name")
+    version_col = column_labels.index("Version")
+    status_col = column_labels.index("Status")
+    count_col = column_labels.index("Count")
+    product_type_col = column_labels.index("Product type")
+    product_group_col = column_labels.index("Group")
+    loader_col = column_labels.index("Loader")
+    object_name_col = column_labels.index("Object name")
+    active_site_col = column_labels.index("Active site")
+    remote_site_col = column_labels.index("Remote site")
+    display_role_by_column = {
+        name_col: QtCore.Qt.DisplayRole,
+        version_col: VERSION_LABEL_ROLE,
+        status_col: STATUS_NAME_ROLE,
+        count_col: COUNT_ROLE,
+        product_type_col: PRODUCT_TYPE_ROLE,
+        product_group_col: PRODUCT_GROUP_NAME_ROLE,
+        loader_col: LOADER_NAME_ROLE,
+        object_name_col: OBJECT_NAME_ROLE,
+        active_site_col: ACTIVE_SITE_PROGRESS_ROLE,
+        remote_site_col: REMOTE_SITE_PROGRESS_ROLE,
+    }
+    decoration_role_by_column = {
+        name_col: QtCore.Qt.DecorationRole,
+        product_type_col: PRODUCT_TYPE_ICON_ROLE,
+        product_group_col: PRODUCT_GROUP_ICON_ROLE,
+        active_site_col: ACTIVE_SITE_ICON_ROLE,
+        remote_site_col: REMOTE_SITE_ICON_ROLE,
+    }
+    foreground_role_by_column = {
+        name_col: NAME_COLOR_ROLE,
+        version_col: VERSION_COLOR_ROLE,
+        status_col: STATUS_COLOR_ROLE
+    }
+    width_by_column = {
+        name_col: 250,
+        version_col: 55,
+        status_col: 100,
+        count_col: 55,
+        product_type_col: 150,
+        product_group_col: 120,
+        loader_col: 150,
+    }
 
     OUTDATED_COLOR = QtGui.QColor(235, 30, 30)
     CHILD_OUTDATED_COLOR = QtGui.QColor(200, 160, 30)
     GRAYOUT_COLOR = QtGui.QColor(160, 160, 160)
 
-    UniqueRole = QtCore.Qt.UserRole + 2     # unique label role
-
     def __init__(self, controller, parent=None):
-        super(InventoryModel, self).__init__(parent)
+        super().__init__(parent)
+
+        self.setColumnCount(len(self.column_labels))
+        for idx, label in enumerate(self.column_labels):
+            self.setHeaderData(idx, QtCore.Qt.Horizontal, label)
+
         self.log = logging.getLogger(self.__class__.__name__)
 
         self._controller = controller
@@ -60,103 +116,217 @@ class InventoryModel(TreeModel):
 
         self._default_icon_color = get_default_entity_icon_color()
 
-        site_icons = self._controller.get_site_provider_icons()
-
-        self._site_icons = {
-            provider: get_qt_icon(icon_def)
-            for provider, icon_def in site_icons.items()
-        }
-
     def outdated(self, item):
         return item.get("isOutdated", True)
 
+    def refresh(self, selected=None):
+        """Refresh the model"""
+        # for debugging or testing, injecting items from outside
+        container_items = self._controller.get_container_items()
+
+        self._clear_items()
+
+        items_by_repre_id = {}
+        for container_item in container_items:
+            # if (
+            #     selected is not None
+            #     and container_item.item_id not in selected
+            # ):
+            #     continue
+            repre_id = container_item.representation_id
+            items = items_by_repre_id.setdefault(repre_id, [])
+            items.append(container_item)
+
+        repre_id = set(items_by_repre_id.keys())
+        repre_info_by_id = self._controller.get_representation_info_items(
+            repre_id
+        )
+        product_ids = {
+            repre_info.product_id
+            for repre_info in repre_info_by_id.values()
+        }
+        version_items_by_product_id = self._controller.get_version_items(
+            product_ids
+        )
+        # SiteSync addon information
+        progress_by_id = self._controller.get_representations_site_progress(
+            repre_id
+        )
+        sites_info = self._controller.get_sites_information()
+        site_icons = {
+            provider: get_qt_icon(icon_def)
+            for provider, icon_def in (
+                self._controller.get_site_provider_icons().items()
+            )
+        }
+        status_items_by_name = {
+            status_item.name: status_item
+            for status_item in self._controller.get_project_status_items()
+        }
+
+        group_item_icon = qtawesome.icon(
+            "fa.folder", color=self._default_icon_color
+        )
+        valid_item_icon = qtawesome.icon(
+            "fa.file-o", color=self._default_icon_color
+        )
+        invalid_item_icon = qtawesome.icon(
+            "fa.exclamation-circle", color=self._default_icon_color
+        )
+        group_icon = qtawesome.icon(
+            "fa.object-group", color=self._default_icon_color
+        )
+        product_type_icon = qtawesome.icon(
+            "fa.folder", color="#0091B2"
+        )
+        group_item_font = QtGui.QFont()
+        group_item_font.setBold(True)
+
+        active_site_icon = site_icons.get(sites_info["active_site_provider"])
+        remote_site_icon = site_icons.get(sites_info["remote_site_provider"])
+
+        root_item = self.invisibleRootItem()
+
+        group_items = []
+        for repre_id, container_items in items_by_repre_id.items():
+            repre_info = repre_info_by_id[repre_id]
+            version_label = "N/A"
+            version_color = None
+            is_latest = False
+            is_hero = False
+            status_name = None
+            status_color = None
+            status_short = None
+            if not repre_info.is_valid:
+                group_name = "< Entity N/A >"
+                item_icon = invalid_item_icon
+
+            else:
+                group_name = "{}_{}: ({})".format(
+                    repre_info.folder_path.rsplit("/")[-1],
+                    repre_info.product_name,
+                    repre_info.representation_name
+                )
+                item_icon = valid_item_icon
+
+                version_items = (
+                    version_items_by_product_id[repre_info.product_id]
+                )
+                version_item = version_items[repre_info.version_id]
+                version_label = format_version(version_item.version)
+                is_hero = version_item.version < 0
+                is_latest = version_item.is_latest
+                if not is_latest:
+                    version_color = self.OUTDATED_COLOR
+                status_name = version_item.status
+                status_item = status_items_by_name.get(status_name)
+                if status_item:
+                    status_short = status_item.short
+                    status_color = status_item.color
+
+            container_model_items = []
+            for container_item in container_items:
+                unique_name = (
+                    repre_info.representation_name
+                    + container_item.object_name or "<none>"
+                )
+
+                item = QtGui.QStandardItem()
+                item.setColumnCount(root_item.columnCount())
+                item.setData(container_item.namespace, QtCore.Qt.DisplayRole)
+                item.setData(self.GRAYOUT_COLOR, NAME_COLOR_ROLE)
+                item.setData(self.GRAYOUT_COLOR, VERSION_COLOR_ROLE)
+                item.setData(item_icon, QtCore.Qt.DecorationRole)
+                item.setData(repre_info.product_id, PRODUCT_ID_ROLE)
+                item.setData(container_item.item_id, ITEM_ID_ROLE)
+                item.setData(version_label, VERSION_LABEL_ROLE)
+                item.setData(container_item.loader_name, LOADER_NAME_ROLE)
+                item.setData(container_item.object_name, OBJECT_NAME_ROLE)
+                item.setData(True, IS_CONTAINER_ITEM_ROLE)
+                item.setData(unique_name, ITEM_UNIQUE_NAME_ROLE)
+                container_model_items.append(item)
+
+            if not container_model_items:
+                continue
+
+            progress = progress_by_id[repre_id]
+            active_site_progress = "{}%".format(
+                max(progress["active_site"], 0) * 100
+            )
+            remote_site_progress = "{}%".format(
+                max(progress["remote_site"], 0) * 100
+            )
+
+            group_item = QtGui.QStandardItem()
+            group_item.setColumnCount(root_item.columnCount())
+            group_item.setData(group_name, QtCore.Qt.DisplayRole)
+            group_item.setData(group_name, ITEM_UNIQUE_NAME_ROLE)
+            group_item.setData(group_item_icon, QtCore.Qt.DecorationRole)
+            group_item.setData(group_item_font, QtCore.Qt.FontRole)
+            group_item.setData(repre_info.product_id, PRODUCT_ID_ROLE)
+            group_item.setData(repre_info.product_type, PRODUCT_TYPE_ROLE)
+            group_item.setData(product_type_icon, PRODUCT_TYPE_ICON_ROLE)
+            group_item.setData(is_latest, VERSION_IS_LATEST_ROLE)
+            group_item.setData(is_hero, VERSION_IS_HERO_ROLE)
+            group_item.setData(version_label, VERSION_LABEL_ROLE)
+            group_item.setData(len(container_items), COUNT_ROLE)
+            group_item.setData(status_name, STATUS_NAME_ROLE)
+            group_item.setData(status_short, STATUS_SHORT_ROLE)
+            group_item.setData(status_color, STATUS_COLOR_ROLE)
+
+            group_item.setData(
+                active_site_progress, ACTIVE_SITE_PROGRESS_ROLE
+            )
+            group_item.setData(
+                remote_site_progress, REMOTE_SITE_PROGRESS_ROLE
+            )
+            group_item.setData(active_site_icon, ACTIVE_SITE_ICON_ROLE)
+            group_item.setData(remote_site_icon, REMOTE_SITE_ICON_ROLE)
+            group_item.setData(False, IS_CONTAINER_ITEM_ROLE)
+
+            if version_color is not None:
+                group_item.setData(version_color, VERSION_COLOR_ROLE)
+
+            if repre_info.product_group:
+                group_item.setData(
+                    repre_info.product_group, PRODUCT_GROUP_NAME_ROLE
+                )
+                group_item.setData(group_icon, PRODUCT_GROUP_ICON_ROLE)
+
+            group_item.appendRows(container_model_items)
+            group_items.append(group_item)
+
+        if group_items:
+            root_item.appendRows(group_items)
+
+    def flags(self, index):
+        return QtCore.Qt.ItemIsEnabled | QtCore.Qt.ItemIsSelectable
+
     def data(self, index, role):
         if not index.isValid():
             return
 
-        item = index.internalPointer()
+        col = index.column()
+        if role == QtCore.Qt.DisplayRole:
+            role = self.display_role_by_column.get(col)
+            if role is None:
+                print(col, role)
+                return None
 
-        if role == QtCore.Qt.FontRole:
-            # Make top-level entries bold
-            if item.get("isGroupNode") or item.get("isNotSet"):  # group-item
-                font = QtGui.QFont()
-                font.setBold(True)
-                return font
+        elif role == QtCore.Qt.DecorationRole:
+            role = self.decoration_role_by_column.get(col)
+            if role is None:
+                return None
 
-        if role == QtCore.Qt.ForegroundRole:
-            # Set the text color to the OUTDATED_COLOR when the
-            # collected version is not the same as the highest version
-            key = self.Columns[index.column()]
-            if key == "version":  # version
-                if item.get("isGroupNode"):  # group-item
-                    if self.outdated(item):
-                        return self.OUTDATED_COLOR
+        elif role == QtCore.Qt.ForegroundRole:
+            role = self.foreground_role_by_column.get(col)
+            if role is None:
+                return None
 
-                    if self._hierarchy_view:
-                        # If current group is not outdated, check if any
-                        # outdated children.
-                        for _node in walk_hierarchy(item):
-                            if self.outdated(_node):
-                                return self.CHILD_OUTDATED_COLOR
-                else:
+        if col != 0:
+            index = self.index(index.row(), 0, index.parent())
 
-                    if self._hierarchy_view:
-                        # Although this is not a group item, we still need
-                        # to distinguish which one contain outdated child.
-                        for _node in walk_hierarchy(item):
-                            if self.outdated(_node):
-                                return self.CHILD_OUTDATED_COLOR.darker(150)
-
-                    return self.GRAYOUT_COLOR
-
-            if key == "Name" and not item.get("isGroupNode"):
-                return self.GRAYOUT_COLOR
-
-        # Add icons
-        if role == QtCore.Qt.DecorationRole:
-            if index.column() == 0:
-                # Override color
-                color = item.get("color", self._default_icon_color)
-                if item.get("isGroupNode"):  # group-item
-                    return qtawesome.icon("fa.folder", color=color)
-                if item.get("isNotSet"):
-                    return qtawesome.icon("fa.exclamation-circle", color=color)
-
-                return qtawesome.icon("fa.file-o", color=color)
-
-            if index.column() == 3:
-                # Product type icon
-                return item.get("productTypeIcon", None)
-
-            column_name = self.Columns[index.column()]
-
-            if column_name == "group" and item.get("group"):
-                return qtawesome.icon("fa.object-group",
-                                      color=get_default_entity_icon_color())
-
-            if item.get("isGroupNode"):
-                if column_name == "active_site":
-                    provider = item.get("active_site_provider")
-                    return self._site_icons.get(provider)
-
-                if column_name == "remote_site":
-                    provider = item.get("remote_site_provider")
-                    return self._site_icons.get(provider)
-
-        if role == QtCore.Qt.DisplayRole and item.get("isGroupNode"):
-            column_name = self.Columns[index.column()]
-            progress = None
-            if column_name == "active_site":
-                progress = item.get("active_site_progress", 0)
-            elif column_name == "remote_site":
-                progress = item.get("remote_site_progress", 0)
-            if progress is not None:
-                return "{}%".format(max(progress, 0) * 100)
-
-        if role == self.UniqueRole:
-            return item["representation"] + item.get("objectName", "<none>")
-
-        return super(InventoryModel, self).data(index, role)
+        return super().data(index, role)
 
     def set_hierarchy_view(self, state):
         """Set whether to display products in hierarchy view."""
@@ -165,299 +335,34 @@ class InventoryModel(TreeModel):
         if state != self._hierarchy_view:
             self._hierarchy_view = state
 
-    def refresh(self, selected=None, containers=None):
-        """Refresh the model"""
-
-        # for debugging or testing, injecting items from outside
-        if containers is None:
-            containers = self._controller.get_containers()
-
-        self.clear()
-        if not selected or not self._hierarchy_view:
-            self._add_containers(containers)
-            return
-
-        # Filter by cherry-picked items
-        self._add_containers((
-            container
-            for container in containers
-            if container["objectName"] in selected
-        ))
-
-    def _add_containers(self, containers, parent=None):
-        """Add the items to the model.
-
-        The items should be formatted similar to `api.ls()` returns, an item
-        is then represented as:
-            {"filename_v001.ma": [full/filename/of/loaded/filename_v001.ma,
-                                  full/filename/of/loaded/filename_v001.ma],
-             "nodetype" : "reference",
-             "node": "referenceNode1"}
-
-        Note: When performing an additional call to `add_items` it will *not*
-            group the new items with previously existing item groups of the
-            same type.
-
-        Args:
-            containers (generator): Container items.
-            parent (Item, optional): Set this item as parent for the added
-              items when provided. Defaults to the root of the model.
-
-        Returns:
-            node.Item: root node which has children added based on the data
-        """
-
-        project_name = get_current_project_name()
-
-        self.beginResetModel()
-
-        # Group by representation
-        grouped = defaultdict(lambda: {"containers": list()})
-        for container in containers:
-            repre_id = container["representation"]
-            grouped[repre_id]["containers"].append(container)
-
-        (
-            repres_by_id,
-            versions_by_id,
-            products_by_id,
-            folders_by_id,
-        ) = self._query_entities(project_name, set(grouped.keys()))
-        # Add to model
-        not_found = defaultdict(list)
-        not_found_ids = []
-        for repre_id, group_dict in sorted(grouped.items()):
-            group_containers = group_dict["containers"]
-            representation = repres_by_id.get(repre_id)
-            if not representation:
-                not_found["representation"].extend(group_containers)
-                not_found_ids.append(repre_id)
+    def get_outdated_item_ids(self, ignore_hero=True):
+        outdated_item_ids = []
+        root_item = self.invisibleRootItem()
+        for row in range(root_item.rowCount()):
+            group_item = root_item.child(row)
+            if group_item.data(VERSION_IS_LATEST_ROLE):
                 continue
 
-            version_entity = versions_by_id.get(representation["versionId"])
-            if not version_entity:
-                not_found["version"].extend(group_containers)
-                not_found_ids.append(repre_id)
+            if ignore_hero and group_item.data(VERSION_IS_HERO_ROLE):
                 continue
 
-            product_entity = products_by_id.get(version_entity["productId"])
-            if not product_entity:
-                not_found["product"].extend(group_containers)
-                not_found_ids.append(repre_id)
-                continue
+            for idx in range(group_item.rowCount()):
+                item = group_item.child(idx)
+                outdated_item_ids.append(item.data(ITEM_ID_ROLE))
+        return outdated_item_ids
 
-            folder_entity = folders_by_id.get(product_entity["folderId"])
-            if not folder_entity:
-                not_found["folder"].extend(group_containers)
-                not_found_ids.append(repre_id)
-                continue
-
-            group_dict.update({
-                "representation": representation,
-                "version": version_entity,
-                "product": product_entity,
-                "folder": folder_entity
-            })
-
-        for _repre_id in not_found_ids:
-            grouped.pop(_repre_id)
-
-        for where, group_containers in not_found.items():
-            # create the group header
-            group_node = Item()
-            name = "< NOT FOUND - {} >".format(where)
-            group_node["Name"] = name
-            group_node["representation"] = name
-            group_node["count"] = len(group_containers)
-            group_node["isGroupNode"] = False
-            group_node["isNotSet"] = True
-
-            self.add_child(group_node, parent=parent)
-
-            for container in group_containers:
-                item_node = Item()
-                item_node.update(container)
-                item_node["Name"] = container.get("objectName", "NO NAME")
-                item_node["isNotFound"] = True
-                self.add_child(item_node, parent=group_node)
-
-        # TODO Use product icons
-        product_type_icon = qtawesome.icon(
-            "fa.folder", color="#0091B2"
-        )
-        # Prepare site sync specific data
-        progress_by_id = self._controller.get_representations_site_progress(
-            set(grouped.keys())
-        )
-        sites_info = self._controller.get_sites_information()
-
-        # Query the highest available version so the model can know
-        # whether current version is currently up-to-date.
-        highest_version_by_product_id = ayon_api.get_last_versions(
-            project_name,
-            product_ids={
-                group["version"]["productId"] for group in grouped.values()
-            },
-            fields={"productId", "version"}
-        )
-        # Map value to `version` key
-        highest_version_by_product_id = {
-            product_id: version["version"]
-            for product_id, version in highest_version_by_product_id.items()
-        }
-
-        for repre_id, group_dict in sorted(grouped.items()):
-            group_containers = group_dict["containers"]
-            repre_entity = group_dict["representation"]
-            version_entity = group_dict["version"]
-            folder_entity = group_dict["folder"]
-            product_entity = group_dict["product"]
-
-            product_type = product_entity["productType"]
-
-            # create the group header
-            group_node = Item()
-            group_node["Name"] = "{}_{}: ({})".format(
-                folder_entity["name"],
-                product_entity["name"],
-                repre_entity["name"]
-            )
-            group_node["representation"] = repre_id
-
-            # Detect hero version type
-            version = version_entity["version"]
-            if version < 0:
-                version = HeroVersionType(version)
-            group_node["version"] = version
-
-            # Check if the version is outdated.
-            # Hero versions are never considered to be outdated.
-            is_outdated = False
-            if not isinstance(version, HeroVersionType):
-                last_version = highest_version_by_product_id.get(
-                    version_entity["productId"])
-                if last_version is not None:
-                    is_outdated = version_entity["version"] != last_version
-            group_node["isOutdated"] = is_outdated
-
-            group_node["productType"] = product_type or ""
-            group_node["productTypeIcon"] = product_type_icon
-            group_node["count"] = len(group_containers)
-            group_node["isGroupNode"] = True
-            group_node["group"] = product_entity["attrib"].get("productGroup")
-
-            # Site sync specific data
-            progress = progress_by_id[repre_id]
-            group_node.update(sites_info)
-            group_node["active_site_progress"] = progress["active_site"]
-            group_node["remote_site_progress"] = progress["remote_site"]
-
-            self.add_child(group_node, parent=parent)
-
-            for container in group_containers:
-                item_node = Item()
-                item_node.update(container)
-
-                # store the current version on the item
-                item_node["version"] = version_entity["version"]
-                item_node["version_entity"] = version_entity
-
-                # Remapping namespace to item name.
-                # Noted that the name key is capital "N", by doing this, we
-                # can view namespace in GUI without changing container data.
-                item_node["Name"] = container["namespace"]
-
-                self.add_child(item_node, parent=group_node)
-
-        self.endResetModel()
-
-        return self._root_item
-
-    def _query_entities(self, project_name, repre_ids):
-        """Query entities for representations from containers.
-
-        Returns:
-            tuple[dict, dict, dict, dict]: Representation, version, product
-                and folder documents by id.
-        """
-
-        repres_by_id = {}
-        versions_by_id = {}
-        products_by_id = {}
-        folders_by_id = {}
-        output = (
-            repres_by_id,
-            versions_by_id,
-            products_by_id,
-            folders_by_id,
-        )
-
-        filtered_repre_ids = set()
-        for repre_id in repre_ids:
-            # Filter out invalid representation ids
-            # NOTE: This is added because scenes from OpenPype did contain
-            #   ObjectId from mongo.
-            try:
-                uuid.UUID(repre_id)
-                filtered_repre_ids.add(repre_id)
-            except ValueError:
-                continue
-        if not filtered_repre_ids:
-            return output
-
-        repre_entities = ayon_api.get_representations(project_name, repre_ids)
-        repres_by_id.update({
-            repre_entity["id"]: repre_entity
-            for repre_entity in repre_entities
-        })
-        version_ids = {
-            repre_entity["versionId"]
-            for repre_entity in repres_by_id.values()
-        }
-        if not version_ids:
-            return output
-
-        versions_by_id.update({
-            version_entity["id"]: version_entity
-            for version_entity in ayon_api.get_versions(
-                project_name, version_ids=version_ids
-            )
-        })
-
-        product_ids = {
-            version_entity["productId"]
-            for version_entity in versions_by_id.values()
-        }
-        if not product_ids:
-            return output
-
-        products_by_id.update({
-            product_entity["id"]: product_entity
-            for product_entity in ayon_api.get_products(
-                project_name, product_ids=product_ids
-            )
-        })
-        folder_ids = {
-            product_entity["folderId"]
-            for product_entity in products_by_id.values()
-        }
-        if not folder_ids:
-            return output
-
-        folders_by_id.update({
-            folder_entity["id"]: folder_entity
-            for folder_entity in ayon_api.get_folders(
-                project_name, folder_ids=folder_ids
-            )
-        })
-        return output
+    def _clear_items(self):
+        root_item = self.invisibleRootItem()
+        root_item.removeRows(0, root_item.rowCount())
 
 
 class FilterProxyModel(QtCore.QSortFilterProxyModel):
     """Filter model to where key column's value is in the filtered tags"""
 
     def __init__(self, *args, **kwargs):
-        super(FilterProxyModel, self).__init__(*args, **kwargs)
+        super().__init__(*args, **kwargs)
+        self.setDynamicSortFilter(True)
+        self.setFilterCaseSensitivity(QtCore.Qt.CaseInsensitive)
         self._filter_outdated = False
         self._hierarchy_view = False
 
@@ -467,28 +372,23 @@ class FilterProxyModel(QtCore.QSortFilterProxyModel):
 
         # Always allow bottom entries (individual containers), since their
         # parent group hidden if it wouldn't have been validated.
-        rows = model.rowCount(source_index)
-        if not rows:
+        if source_index.data(IS_CONTAINER_ITEM_ROLE):
             return True
 
-        # Filter by regex
-        if hasattr(self, "filterRegExp"):
-            regex = self.filterRegExp()
-        else:
-            regex = self.filterRegularExpression()
-        pattern = regex.pattern()
-        if pattern:
-            pattern = re.escape(pattern)
-
-            if not self._matches(row, parent, pattern):
-                return False
-
         if self._filter_outdated:
             # When filtering to outdated we filter the up to date entries
             # thus we "allow" them when they are outdated
-            if not self._is_outdated(row, parent):
+            if source_index.data(VERSION_IS_LATEST_ROLE):
                 return False
 
+        # Filter by regex
+        if hasattr(self, "filterRegularExpression"):
+            regex = self.filterRegularExpression()
+        else:
+            regex = self.filterRegExp()
+
+        if not self._matches(row, parent, regex.pattern()):
+            return False
         return True
 
     def set_filter_outdated(self, state):
@@ -505,37 +405,6 @@ class FilterProxyModel(QtCore.QSortFilterProxyModel):
         if state != self._hierarchy_view:
             self._hierarchy_view = state
 
-    def _is_outdated(self, row, parent):
-        """Return whether row is outdated.
-
-        A row is considered outdated if `isOutdated` data is true or not set.
-
-        """
-        def outdated(node):
-            return node.get("isOutdated", True)
-
-        index = self.sourceModel().index(row, self.filterKeyColumn(), parent)
-
-        # The scene contents are grouped by "representation", e.g. the same
-        # "representation" loaded twice is grouped under the same header.
-        # Since the version check filters these parent groups we skip that
-        # check for the individual children.
-        has_parent = index.parent().isValid()
-        if has_parent and not self._hierarchy_view:
-            return True
-
-        # Filter to those that have the different version numbers
-        node = index.internalPointer()
-        if outdated(node):
-            return True
-
-        if self._hierarchy_view:
-            for _node in walk_hierarchy(node):
-                if outdated(_node):
-                    return True
-
-        return False
-
     def _matches(self, row, parent, pattern):
         """Return whether row matches regex pattern.
 
@@ -548,38 +417,31 @@ class FilterProxyModel(QtCore.QSortFilterProxyModel):
             bool
 
         """
+        if not pattern:
+            return True
+
+        flags = 0
+        if self.sortCaseSensitivity() == QtCore.Qt.CaseInsensitive:
+            flags = re.IGNORECASE
+
+        regex = re.compile(re.escape(pattern), flags=flags)
+
         model = self.sourceModel()
         column = self.filterKeyColumn()
         role = self.filterRole()
 
-        def matches(row, parent, pattern):
+        matches_queue = collections.deque()
+        matches_queue.append((row, parent))
+        while matches_queue:
+            queue_item = matches_queue.popleft()
+            row, parent = queue_item
+
             index = model.index(row, column, parent)
-            key = model.data(index, role)
-            if re.search(pattern, key, re.IGNORECASE):
+            value = model.data(index, role)
+            if regex.search(value):
                 return True
 
-        if matches(row, parent, pattern):
-            return True
+            for idx in range(model.rowCount(index)):
+                matches_queue.append((idx, index))
 
-        # Also allow if any of the children matches
-        source_index = model.index(row, column, parent)
-        rows = model.rowCount(source_index)
-
-        if any(
-            matches(idx, source_index, pattern)
-            for idx in range(rows)
-        ):
-            return True
-
-        if not self._hierarchy_view:
-            return False
-
-        for idx in range(rows):
-            child_index = model.index(idx, column, source_index)
-            child_rows = model.rowCount(child_index)
-            return any(
-                self._matches(child_idx, child_index, pattern)
-                for child_idx in range(child_rows)
-            )
-
-        return True
+        return False

client/ayon_core/tools/sceneinventory/models/__init__.py

@@ -1,6 +1,8 @@
+from .containers import ContainersModel
 from .sitesync import SiteSyncModel
 
 
 __all__ = (
+    "ContainersModel",
     "SiteSyncModel",
 )

client/ayon_core/tools/sceneinventory/models/containers.py

@@ -0,0 +1,343 @@
+import uuid
+import collections
+
+import ayon_api
+from ayon_api.graphql import GraphQlQuery
+from ayon_core.host import ILoadHost
+
+
+# --- Implementation that should be in ayon-python-api ---
+# The implementation is not available in all versions of ayon-python-api.
+RepresentationHierarchy = collections.namedtuple(
+    "RepresentationHierarchy",
+    ("folder", "product", "version", "representation")
+)
+
+
+def representations_parent_ids_qraphql_query():
+    query = GraphQlQuery("RepresentationsHierarchyQuery")
+
+    project_name_var = query.add_variable("projectName", "String!")
+    repre_ids_var = query.add_variable("representationIds", "[String!]")
+
+    project_field = query.add_field("project")
+    project_field.set_filter("name", project_name_var)
+
+    repres_field = project_field.add_field_with_edges("representations")
+    repres_field.add_field("id")
+    repres_field.add_field("name")
+    repres_field.set_filter("ids", repre_ids_var)
+    version_field = repres_field.add_field("version")
+    version_field.add_field("id")
+    product_field = version_field.add_field("product")
+    product_field.add_field("id")
+    product_field.add_field("name")
+    product_field.add_field("productType")
+    product_attrib_field = product_field.add_field("attrib")
+    product_attrib_field.add_field("productGroup")
+    folder_field = product_field.add_field("folder")
+    folder_field.add_field("id")
+    folder_field.add_field("path")
+    return query
+
+
+def get_representations_hierarchy(project_name, representation_ids):
+    """Find representations parents by representation id.
+
+    Representation parent entities up to project.
+
+    Args:
+         project_name (str): Project where to look for entities.
+         representation_ids (Iterable[str]): Representation ids.
+
+    Returns:
+        dict[str, RepresentationParents]: Parent entities by
+            representation id.
+
+    """
+    if not representation_ids:
+        return {}
+
+    repre_ids = set(representation_ids)
+    output = {
+        repre_id: RepresentationHierarchy(None, None, None, None)
+        for repre_id in representation_ids
+    }
+
+    query = representations_parent_ids_qraphql_query()
+    query.set_variable_value("projectName", project_name)
+    query.set_variable_value("representationIds", list(repre_ids))
+
+    con = ayon_api.get_server_api_connection()
+    parsed_data = query.query(con)
+    for repre in parsed_data["project"]["representations"]:
+        repre_id = repre["id"]
+        version = repre.pop("version")
+        product = version.pop("product")
+        folder = product.pop("folder")
+
+        output[repre_id] = RepresentationHierarchy(
+            folder, product, version, repre
+        )
+
+    return output
+# --- END of ayon-python-api implementation ---
+
+
+class ContainerItem:
+    def __init__(
+        self,
+        representation_id,
+        loader_name,
+        namespace,
+        name,
+        object_name,
+        item_id
+    ):
+        self.representation_id = representation_id
+        self.loader_name = loader_name
+        self.object_name = object_name
+        self.namespace = namespace
+        self.name = name
+        self.item_id = item_id
+
+    @classmethod
+    def from_container_data(cls, container):
+        return cls(
+            representation_id=container["representation"],
+            loader_name=container["loader"],
+            namespace=container["namespace"],
+            name=container["name"],
+            object_name=container["objectName"],
+            item_id=uuid.uuid4().hex,
+        )
+
+
+class RepresentationInfo:
+    def __init__(
+        self,
+        folder_id,
+        folder_path,
+        product_id,
+        product_name,
+        product_type,
+        product_group,
+        version_id,
+        representation_name,
+    ):
+        self.folder_id = folder_id
+        self.folder_path = folder_path
+        self.product_id = product_id
+        self.product_name = product_name
+        self.product_type = product_type
+        self.product_group = product_group
+        self.version_id = version_id
+        self.representation_name = representation_name
+        self._is_valid = None
+
+    @property
+    def is_valid(self):
+        if self._is_valid is None:
+            self._is_valid = (
+                self.folder_id is not None
+                and self.product_id is not None
+                and self.version_id is not None
+                and self.representation_name is not None
+            )
+        return self._is_valid
+
+    @classmethod
+    def new_invalid(cls):
+        return cls(None, None, None, None, None, None, None, None)
+
+
+class VersionItem:
+    def __init__(self, version_id, product_id, version, status, is_latest):
+        self.version = version
+        self.version_id = version_id
+        self.product_id = product_id
+        self.version = version
+        self.status = status
+        self.is_latest = is_latest
+
+    @property
+    def is_hero(self):
+        return self.version < 0
+
+    @classmethod
+    def from_entity(cls, version_entity, is_latest):
+        return cls(
+            version_id=version_entity["id"],
+            product_id=version_entity["productId"],
+            version=version_entity["version"],
+            status=version_entity["status"],
+            is_latest=is_latest,
+        )
+
+
+class ContainersModel:
+    def __init__(self, controller):
+        self._controller = controller
+        self._items_cache = None
+        self._containers_by_id = {}
+        self._container_items_by_id = {}
+        self._version_items_by_product_id = {}
+        self._repre_info_by_id = {}
+
+    def reset(self):
+        self._items_cache = None
+        self._containers_by_id = {}
+        self._container_items_by_id = {}
+        self._version_items_by_product_id = {}
+        self._repre_info_by_id = {}
+
+    def get_containers(self):
+        self._update_cache()
+        return list(self._containers_by_id.values())
+
+    def get_containers_by_item_ids(self, item_ids):
+        return {
+            item_id: self._containers_by_id.get(item_id)
+            for item_id in item_ids
+        }
+
+    def get_container_items(self):
+        self._update_cache()
+        return list(self._items_cache)
+    
+    def get_container_items_by_id(self, item_ids):
+        return {
+            item_id: self._container_items_by_id.get(item_id)
+            for item_id in item_ids
+        }
+
+    def get_representation_info_items(self, representation_ids):
+        output = {}
+        missing_repre_ids = set()
+        for repre_id in representation_ids:
+            try:
+                uuid.UUID(repre_id)
+            except ValueError:
+                output[repre_id] = RepresentationInfo.new_invalid()
+                continue
+
+            repre_info = self._repre_info_by_id.get(repre_id)
+            if repre_info is None:
+                missing_repre_ids.add(repre_id)
+            else:
+                output[repre_id] = repre_info
+
+        if not missing_repre_ids:
+            return output
+
+        project_name = self._controller.get_current_project_name()
+        repre_hierarchy_by_id = get_representations_hierarchy(
+            project_name, missing_repre_ids
+        )
+        for repre_id, repre_hierarchy in repre_hierarchy_by_id.items():
+            kwargs = {
+                "folder_id": None,
+                "folder_path": None,
+                "product_id": None,
+                "product_name": None,
+                "product_type": None,
+                "product_group": None,
+                "version_id": None,
+                "representation_name": None,
+            }
+            folder = repre_hierarchy.folder
+            product = repre_hierarchy.product
+            version = repre_hierarchy.version
+            repre = repre_hierarchy.representation
+            if folder:
+                kwargs["folder_id"] = folder["id"]
+                kwargs["folder_path"] = folder["path"]
+            if product:
+                group = product["attrib"]["productGroup"]
+                kwargs["product_id"] = product["id"]
+                kwargs["product_name"] = product["name"]
+                kwargs["product_type"] = product["productType"]
+                kwargs["product_group"] = group
+            if version:
+                kwargs["version_id"] = version["id"]
+            if repre:
+                kwargs["representation_name"] = repre["name"]
+
+            repre_info = RepresentationInfo(**kwargs)
+            self._repre_info_by_id[repre_id] = repre_info
+            output[repre_id] = repre_info
+        return output
+
+    def get_version_items(self, product_ids):
+        if not product_ids:
+            return {}
+
+        missing_ids = {
+            product_id
+            for product_id in product_ids
+            if product_id not in self._version_items_by_product_id
+        }
+        if missing_ids:
+            def version_sorted(entity):
+                return entity["version"]
+
+            project_name = self._controller.get_current_project_name()
+            version_entities_by_product_id = {
+                product_id: []
+                for product_id in missing_ids
+            }
+
+            version_entities = list(ayon_api.get_versions(
+                project_name,
+                product_ids=missing_ids,
+                fields={"id", "version", "productId", "status"}
+            ))
+            version_entities.sort(key=version_sorted)
+            for version_entity in version_entities:
+                product_id = version_entity["productId"]
+                version_entities_by_product_id[product_id].append(
+                    version_entity
+                )
+
+            for product_id, version_entities in (
+                version_entities_by_product_id.items()
+            ):
+                last_version = abs(version_entities[-1]["version"])
+                version_items_by_id = {
+                    entity["id"]: VersionItem.from_entity(
+                        entity, abs(entity["version"]) == last_version
+                    )
+                    for entity in version_entities
+                }
+                self._version_items_by_product_id[product_id] = (
+                    version_items_by_id
+                )
+
+        return {
+            product_id: dict(self._version_items_by_product_id[product_id])
+            for product_id in product_ids
+        }
+
+    def _update_cache(self):
+        if self._items_cache is not None:
+            return
+
+        host = self._controller.get_host()
+        if isinstance(host, ILoadHost):
+            containers = list(host.get_containers())
+        elif hasattr(host, "ls"):
+            containers = list(host.ls())
+        else:
+            containers = []
+        container_items = []
+        containers_by_id = {}
+        container_items_by_id = {}
+        for container in containers:
+            item = ContainerItem.from_container_data(container)
+            containers_by_id[item.item_id] = container
+            container_items_by_id[item.item_id] = item
+            container_items.append(item)
+
+        self._containers_by_id = containers_by_id
+        self._container_items_by_id = container_items_by_id
+        self._items_cache = container_items

client/ayon_core/tools/sceneinventory/select_version_dialog.py

@@ -0,0 +1,216 @@
+import uuid
+
+from qtpy import QtWidgets, QtCore, QtGui
+
+from ayon_core.tools.utils.delegates import StatusDelegate
+
+from .model import (
+    ITEM_ID_ROLE,
+    STATUS_NAME_ROLE,
+    STATUS_SHORT_ROLE,
+    STATUS_COLOR_ROLE,
+    STATUS_ICON_ROLE,
+)
+
+
+class VersionOption:
+    def __init__(
+        self,
+        version,
+        label,
+        status_name,
+        status_short,
+        status_color
+    ):
+        self.version = version
+        self.label = label
+        self.status_name = status_name
+        self.status_short = status_short
+        self.status_color = status_color
+
+
+class SelectVersionModel(QtGui.QStandardItemModel):
+    def data(self, index, role=None):
+        if role is None:
+            role = QtCore.Qt.DisplayRole
+
+        index = self.index(index.row(), 0, index.parent())
+        return super().data(index, role)
+
+
+class SelectVersionComboBox(QtWidgets.QComboBox):
+    def __init__(self, *args, **kwargs):
+        super().__init__(*args, **kwargs)
+        combo_model = SelectVersionModel(0, 2)
+
+        self.setModel(combo_model)
+
+        combo_view = QtWidgets.QTreeView(self)
+        combo_view.setHeaderHidden(True)
+        combo_view.setIndentation(0)
+
+        self.setView(combo_view)
+
+        header = combo_view.header()
+        header.setSectionResizeMode(0, QtWidgets.QHeaderView.ResizeToContents)
+        header.setSectionResizeMode(1, QtWidgets.QHeaderView.Stretch)
+
+        status_delegate = StatusDelegate(
+            STATUS_NAME_ROLE,
+            STATUS_SHORT_ROLE,
+            STATUS_COLOR_ROLE,
+            STATUS_ICON_ROLE,
+        )
+        combo_view.setItemDelegateForColumn(1, status_delegate)
+
+        self._combo_model = combo_model
+        self._combo_view = combo_view
+        self._status_delegate = status_delegate
+        self._items_by_id = {}
+
+    def paintEvent(self, event):
+        painter = QtWidgets.QStylePainter(self)
+        option = QtWidgets.QStyleOptionComboBox()
+        self.initStyleOption(option)
+        painter.drawComplexControl(QtWidgets.QStyle.CC_ComboBox, option)
+        idx = self.currentIndex()
+        status_name = self.itemData(idx, STATUS_NAME_ROLE)
+        if status_name is None:
+            painter.drawControl(QtWidgets.QStyle.CE_ComboBoxLabel, option)
+            return
+
+        painter.save()
+        text_field_rect = self.style().subControlRect(
+            QtWidgets.QStyle.CC_ComboBox,
+            option,
+            QtWidgets.QStyle.SC_ComboBoxEditField
+        )
+        adj_rect = text_field_rect.adjusted(1, 0, -1, 0)
+        painter.drawText(
+            adj_rect,
+            QtCore.Qt.AlignLeft | QtCore.Qt.AlignVCenter,
+            option.currentText
+        )
+        metrics = QtGui.QFontMetrics(self.font())
+        text_width = metrics.width(option.currentText)
+        x_offset = text_width + 2
+        diff_width = adj_rect.width() - x_offset
+        if diff_width <= 0:
+            return
+
+        status_rect = adj_rect.adjusted(x_offset + 2, 0, 0, 0)
+        if diff_width < metrics.width(status_name):
+            status_name = self.itemData(idx, STATUS_SHORT_ROLE)
+
+        color = QtGui.QColor(self.itemData(idx, STATUS_COLOR_ROLE))
+
+        pen = painter.pen()
+        pen.setColor(color)
+        painter.setPen(pen)
+        painter.drawText(
+            status_rect,
+            QtCore.Qt.AlignLeft | QtCore.Qt.AlignVCenter,
+            status_name
+        )
+
+    def set_current_index(self, index):
+        model = self._combo_view.model()
+        if index > model.rowCount():
+            return
+
+        self.setCurrentIndex(index)
+
+    def get_item_by_id(self, item_id):
+        return self._items_by_id[item_id]
+
+    def set_versions(self, version_options):
+        self._items_by_id = {}
+        model = self._combo_model
+        root_item = model.invisibleRootItem()
+        root_item.removeRows(0, root_item.rowCount())
+
+        new_items = []
+        for version_option in version_options:
+            item_id = uuid.uuid4().hex
+            item = QtGui.QStandardItem(version_option.label)
+            item.setColumnCount(root_item.columnCount())
+            item.setData(
+                version_option.status_name, STATUS_NAME_ROLE
+            )
+            item.setData(
+                version_option.status_short, STATUS_SHORT_ROLE
+            )
+            item.setData(
+                version_option.status_color, STATUS_COLOR_ROLE
+            )
+            item.setData(item_id, ITEM_ID_ROLE)
+
+            new_items.append(item)
+            self._items_by_id[item_id] = version_option
+
+        if new_items:
+            root_item.appendRows(new_items)
+
+
+class SelectVersionDialog(QtWidgets.QDialog):
+    def __init__(self, parent=None):
+        super().__init__(parent=parent)
+
+        self.setWindowTitle("Select version")
+
+        label_widget = QtWidgets.QLabel("Set version number to", self)
+        versions_combobox = SelectVersionComboBox(self)
+
+        btns_widget = QtWidgets.QWidget(self)
+
+        confirm_btn = QtWidgets.QPushButton("OK", btns_widget)
+        cancel_btn = QtWidgets.QPushButton("Cancel", btns_widget)
+
+        btns_layout = QtWidgets.QHBoxLayout(btns_widget)
+        btns_layout.setContentsMargins(0, 0, 0, 0)
+        btns_layout.addStretch(1)
+        btns_layout.addWidget(confirm_btn, 0)
+        btns_layout.addWidget(cancel_btn, 0)
+
+        main_layout = QtWidgets.QVBoxLayout(self)
+        main_layout.addWidget(label_widget, 0)
+        main_layout.addWidget(versions_combobox, 0)
+        main_layout.addWidget(btns_widget, 0)
+
+        confirm_btn.clicked.connect(self._on_confirm)
+        cancel_btn.clicked.connect(self._on_cancel)
+
+        self._selected_item = None
+        self._cancelled = False
+        self._versions_combobox = versions_combobox
+
+    def get_selected_item(self):
+        if self._cancelled:
+            return None
+        return self._selected_item
+
+    def set_versions(self, version_options):
+        self._versions_combobox.set_versions(version_options)
+
+    def select_index(self, index):
+        self._versions_combobox.set_current_index(index)
+
+    @classmethod
+    def ask_for_version(cls, version_options, index=None, parent=None):
+        dialog = cls(parent)
+        dialog.set_versions(version_options)
+        if index is not None:
+            dialog.select_index(index)
+        dialog.exec_()
+        return dialog.get_selected_item()
+
+    def _on_confirm(self):
+        self._cancelled = False
+        index = self._versions_combobox.currentIndex()
+        item_id = self._versions_combobox.itemData(index, ITEM_ID_ROLE)
+        self._selected_item = self._versions_combobox.get_item_by_id(item_id)
+        self.accept()
+
+    def _on_cancel(self):
+        self._cancelled = True
+        self.reject()

client/ayon_core/tools/sceneinventory/window.py

@@ -2,17 +2,10 @@ from qtpy import QtWidgets, QtCore, QtGui
 import qtawesome
 
 from ayon_core import style, resources
-from ayon_core.tools.utils.lib import (
-    preserve_expanded_rows,
-    preserve_selection,
-)
+from ayon_core.tools.utils import PlaceholderLineEdit
+
 from ayon_core.tools.sceneinventory import SceneInventoryController
 
-from .delegates import VersionDelegate
-from .model import (
-    InventoryModel,
-    FilterProxyModel
-)
 from .view import SceneInventoryView
 
 
@@ -20,7 +13,7 @@ class SceneInventoryWindow(QtWidgets.QDialog):
     """Scene Inventory window"""
 
     def __init__(self, controller=None, parent=None):
-        super(SceneInventoryWindow, self).__init__(parent)
+        super().__init__(parent)
 
         if controller is None:
             controller = SceneInventoryController()
@@ -33,10 +26,9 @@ class SceneInventoryWindow(QtWidgets.QDialog):
 
         self.resize(1100, 480)
 
-        # region control
-
         filter_label = QtWidgets.QLabel("Search", self)
-        text_filter = QtWidgets.QLineEdit(self)
+        text_filter = PlaceholderLineEdit(self)
+        text_filter.setPlaceholderText("Filter by name...")
 
         outdated_only_checkbox = QtWidgets.QCheckBox(
             "Filter to outdated", self
@@ -44,52 +36,30 @@ class SceneInventoryWindow(QtWidgets.QDialog):
         outdated_only_checkbox.setToolTip("Show outdated files only")
         outdated_only_checkbox.setChecked(False)
 
-        icon = qtawesome.icon("fa.arrow-up", color="white")
+        update_all_icon = qtawesome.icon("fa.arrow-up", color="white")
         update_all_button = QtWidgets.QPushButton(self)
         update_all_button.setToolTip("Update all outdated to latest version")
-        update_all_button.setIcon(icon)
+        update_all_button.setIcon(update_all_icon)
 
-        icon = qtawesome.icon("fa.refresh", color="white")
+        refresh_icon = qtawesome.icon("fa.refresh", color="white")
         refresh_button = QtWidgets.QPushButton(self)
         refresh_button.setToolTip("Refresh")
-        refresh_button.setIcon(icon)
+        refresh_button.setIcon(refresh_icon)
 
-        control_layout = QtWidgets.QHBoxLayout()
-        control_layout.addWidget(filter_label)
-        control_layout.addWidget(text_filter)
-        control_layout.addWidget(outdated_only_checkbox)
-        control_layout.addWidget(update_all_button)
-        control_layout.addWidget(refresh_button)
-
-        model = InventoryModel(controller)
-        proxy = FilterProxyModel()
-        proxy.setSourceModel(model)
-        proxy.setDynamicSortFilter(True)
-        proxy.setFilterCaseSensitivity(QtCore.Qt.CaseInsensitive)
+        headers_widget = QtWidgets.QWidget(self)
+        headers_layout = QtWidgets.QHBoxLayout(headers_widget)
+        headers_layout.setContentsMargins(0, 0, 0, 0)
+        headers_layout.addWidget(filter_label, 0)
+        headers_layout.addWidget(text_filter, 1)
+        headers_layout.addWidget(outdated_only_checkbox, 0)
+        headers_layout.addWidget(update_all_button, 0)
+        headers_layout.addWidget(refresh_button, 0)
 
         view = SceneInventoryView(controller, self)
-        view.setModel(proxy)
 
-        sync_enabled = controller.is_sitesync_enabled()
-        view.setColumnHidden(model.active_site_col, not sync_enabled)
-        view.setColumnHidden(model.remote_site_col, not sync_enabled)
-
-        # set some nice default widths for the view
-        view.setColumnWidth(0, 250)  # name
-        view.setColumnWidth(1, 55)   # version
-        view.setColumnWidth(2, 55)   # count
-        view.setColumnWidth(3, 150)  # product type
-        view.setColumnWidth(4, 120)  # group
-        view.setColumnWidth(5, 150)  # loader
-
-        # apply delegates
-        version_delegate = VersionDelegate(controller, self)
-        column = model.Columns.index("version")
-        view.setItemDelegateForColumn(column, version_delegate)
-
-        layout = QtWidgets.QVBoxLayout(self)
-        layout.addLayout(control_layout)
-        layout.addWidget(view)
+        main_layout = QtWidgets.QVBoxLayout(self)
+        main_layout.addWidget(headers_widget, 0)
+        main_layout.addWidget(view, 1)
 
         show_timer = QtCore.QTimer()
         show_timer.setInterval(0)
@@ -114,12 +84,8 @@ class SceneInventoryWindow(QtWidgets.QDialog):
         self._update_all_button = update_all_button
         self._outdated_only_checkbox = outdated_only_checkbox
         self._view = view
-        self._model = model
-        self._proxy = proxy
-        self._version_delegate = version_delegate
 
         self._first_show = True
-        self._first_refresh = True
 
     def showEvent(self, event):
         super(SceneInventoryWindow, self).showEvent(event)
@@ -139,29 +105,16 @@ class SceneInventoryWindow(QtWidgets.QDialog):
         whilst trying to name an instance.
 
         """
+        pass
 
     def _on_refresh_request(self):
         """Signal callback to trigger 'refresh' without any arguments."""
 
         self.refresh()
 
-    def refresh(self, containers=None):
-        self._first_refresh = False
+    def refresh(self):
         self._controller.reset()
-        with preserve_expanded_rows(
-            tree_view=self._view,
-            role=self._model.UniqueRole
-        ):
-            with preserve_selection(
-                tree_view=self._view,
-                role=self._model.UniqueRole,
-                current_index=False
-            ):
-                kwargs = {"containers": containers}
-                # TODO do not touch view's inner attribute
-                if self._view._hierarchy_view:
-                    kwargs["selected"] = self._view._selected
-                self._model.refresh(**kwargs)
+        self._view.refresh()
 
     def _on_show_timer(self):
         if self._show_counter < 3:
@@ -171,17 +124,13 @@ class SceneInventoryWindow(QtWidgets.QDialog):
         self.refresh()
 
     def _on_hierarchy_view_change(self, enabled):
-        self._proxy.set_hierarchy_view(enabled)
-        self._model.set_hierarchy_view(enabled)
+        self._view.set_hierarchy_view(enabled)
 
     def _on_text_filter_change(self, text_filter):
-        if hasattr(self._proxy, "setFilterRegExp"):
-            self._proxy.setFilterRegExp(text_filter)
-        else:
-            self._proxy.setFilterRegularExpression(text_filter)
+        self._view.set_text_filter(text_filter)
 
     def _on_outdated_state_change(self):
-        self._proxy.set_filter_outdated(
+        self._view.set_filter_outdated(
             self._outdated_only_checkbox.isChecked()
         )
 

client/ayon_core/tools/tray/tray.py

@@ -447,8 +447,10 @@ class SystemTrayIcon(QtWidgets.QSystemTrayIcon):
 
     def initialize_addons(self):
         self._initializing_addons = True
-        self.tray_man.initialize_addons()
-        self._initializing_addons = False
+        try:
+            self.tray_man.initialize_addons()
+        finally:
+            self._initializing_addons = False
 
     def _click_timer_timeout(self):
         self._click_timer.stop()

client/ayon_core/tools/utils/delegates.py

@@ -2,7 +2,7 @@ import time
 from datetime import datetime
 import logging
 
-from qtpy import QtWidgets
+from qtpy import QtWidgets, QtGui
 
 log = logging.getLogger(__name__)
 
@@ -106,3 +106,80 @@ class PrettyTimeDelegate(QtWidgets.QStyledItemDelegate):
     def displayText(self, value, locale):
         if value is not None:
             return pretty_timestamp(value)
+
+
+class StatusDelegate(QtWidgets.QStyledItemDelegate):
+    """Delegate showing status name and short name."""
+    def __init__(
+        self,
+        status_name_role,
+        status_short_name_role,
+        status_color_role,
+        status_icon_role,
+        *args, **kwargs
+    ):
+        super().__init__(*args, **kwargs)
+        self.status_name_role = status_name_role
+        self.status_short_name_role = status_short_name_role
+        self.status_color_role = status_color_role
+        self.status_icon_role = status_icon_role
+
+    def paint(self, painter, option, index):
+        if option.widget:
+            style = option.widget.style()
+        else:
+            style = QtWidgets.QApplication.style()
+
+        style.drawControl(
+            QtWidgets.QCommonStyle.CE_ItemViewItem,
+            option,
+            painter,
+            option.widget
+        )
+
+        painter.save()
+
+        text_rect = style.subElementRect(
+            QtWidgets.QCommonStyle.SE_ItemViewItemText,
+            option
+        )
+        text_margin = style.proxy().pixelMetric(
+            QtWidgets.QCommonStyle.PM_FocusFrameHMargin,
+            option,
+            option.widget
+        ) + 1
+        padded_text_rect = text_rect.adjusted(
+            text_margin, 0, - text_margin, 0
+        )
+
+        fm = QtGui.QFontMetrics(option.font)
+        text = self._get_status_name(index)
+        if padded_text_rect.width() < fm.width(text):
+            text = self._get_status_short_name(index)
+
+        fg_color = self._get_status_color(index)
+        pen = painter.pen()
+        pen.setColor(fg_color)
+        painter.setPen(pen)
+
+        painter.drawText(
+            padded_text_rect,
+            option.displayAlignment,
+            text
+        )
+
+        painter.restore()
+
+    def _get_status_name(self, index):
+        return index.data(self.status_name_role)
+
+    def _get_status_short_name(self, index):
+        return index.data(self.status_short_name_role)
+
+    def _get_status_color(self, index):
+        return QtGui.QColor(index.data(self.status_color_role))
+
+    def _get_status_icon(self, index):
+        if self.status_icon_role is not None:
+            return index.data(self.status_icon_role)
+        return None