Fix Ayon Load Media PR logic and refactor to latest develop

client/ayon_core/addon/README.md

@@ -35,14 +35,14 @@ AYON addons should contain separated logic of specific kind of implementation, s
 - addon has more logic when used in a tray
  - it is possible that addon can be used only in the tray
 - abstract methods
- - `tray_init` - initialization triggered after `initialize` when used in `TrayModulesManager` and before `connect_with_addons`
+ - `tray_init` - initialization triggered after `initialize` when used in `TrayAddonsManager` and before `connect_with_addons`
  - `tray_menu` - add actions to tray widget's menu that represent the addon
  - `tray_start` - start of addon's login in tray
  - addon is initialized and connected with other addons
  - `tray_exit` - addon's cleanup like stop and join threads etc.
- - order of calling is based on implementation this order is how it works with `TrayModulesManager`
+ - order of calling is based on implementation this order is how it works with `TrayAddonsManager`
  - it is recommended to import and use GUI implementation only in these methods
-- has attribute `tray_initialized` (bool) which is set to False by default and is set by `TrayModulesManager` to True after `tray_init`
+- has attribute `tray_initialized` (bool) which is set to False by default and is set by `TrayAddonsManager` to True after `tray_init`
  - if addon has logic only in tray or for both then should be checking for `tray_initialized` attribute to decide how should handle situations
 
 ### ITrayService

client/ayon_core/addon/base.py

@@ -8,7 +8,6 @@
 import logging
 import threading
 import collections
-
 from uuid import uuid4
 from abc import ABCMeta, abstractmethod
 
@@ -38,27 +37,33 @@
     "base.py",
     "interfaces.py",
     "click_wrap.py",
-    "example_addons",
-    "default_modules",
 )
-IGNORED_HOSTS_IN_AYON = {
-    "flame",
-    "harmony",
-}
-IGNORED_MODULES_IN_AYON = set()
 
 # When addon was moved from ayon-core codebase
 # - this is used to log the missing addon
 MOVED_ADDON_MILESTONE_VERSIONS = {
+    "aftereffects": VersionInfo(0, 2, 0),
     "applications": VersionInfo(0, 2, 0),
+    "blender": VersionInfo(0, 2, 0),
     "celaction": VersionInfo(0, 2, 0),
     "clockify": VersionInfo(0, 2, 0),
+    "deadline": VersionInfo(0, 2, 0),
     "flame": VersionInfo(0, 2, 0),
+    "fusion": VersionInfo(0, 2, 0),
+    "harmony": VersionInfo(0, 2, 0),
+    "hiero": VersionInfo(0, 2, 0),
     "max": VersionInfo(0, 2, 0),
+    "photoshop": VersionInfo(0, 2, 0),
+    "timers_manager": 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),
+    "royalrender": VersionInfo(0, 2, 0),
     "substancepainter": VersionInfo(0, 2, 0),
+    "houdini": VersionInfo(0, 3, 0),
+    "unreal": VersionInfo(0, 2, 0),
 }
 
 
@@ -409,12 +414,6 @@ def _load_addons_in_core(
     hosts_dir = os.path.join(AYON_CORE_ROOT, "hosts")
     modules_dir = os.path.join(AYON_CORE_ROOT, "modules")
 
-    ignored_host_names = set(IGNORED_HOSTS_IN_AYON)
-    ignored_module_dir_filenames = (
-        set(IGNORED_DEFAULT_FILENAMES)
-        | IGNORED_MODULES_IN_AYON
-    )
-
     for dirpath in {hosts_dir, modules_dir}:
         if not os.path.exists(dirpath):
             log.warning((
@@ -423,10 +422,9 @@ def _load_addons_in_core(
             continue
 
         is_in_modules_dir = dirpath == modules_dir
+        ignored_filenames = set()
         if is_in_modules_dir:
-            ignored_filenames = ignored_module_dir_filenames
-        else:
-            ignored_filenames = ignored_host_names
+            ignored_filenames = set(IGNORED_DEFAULT_FILENAMES)
 
         for filename in os.listdir(dirpath):
             # Ignore filenames
@@ -492,9 +490,6 @@ def _load_addons_in_core(
 
 
 def _load_addons():
-    # Support to use 'openpype' imports
-    sys.modules["openpype"] = sys.modules["ayon_core"]
-
     # Key under which will be modules imported in `sys.modules`
     modules_key = "openpype_modules"
 
@@ -547,6 +542,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
 
@@ -577,6 +575,26 @@ def name(self):
 
         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.
 
@@ -692,6 +710,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.
 
@@ -868,10 +910,6 @@ def initialize_addons(self):
                 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
@@ -883,6 +921,13 @@ def initialize_addons(self):
                     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:
@@ -1171,39 +1216,55 @@ class name and value is time delta of it's processing.
             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
@@ -1330,7 +1391,7 @@ def __init__(self, settings=None):
         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/cli.py

@@ -268,7 +268,7 @@ def main(*args, **kwargs):
         os.path.join(AYON_CORE_ROOT, "tools"),
         # add common AYON vendor
         # (common for multiple Python interpreter versions)
-        os.path.join(AYON_CORE_ROOT, "vendor", "python", "common")
+        os.path.join(AYON_CORE_ROOT, "vendor", "python")
     ]
     for path in additional_paths:
         if path not in split_paths:

client/ayon_core/cli_commands.py

@@ -36,7 +36,7 @@ def add_addons(click_func):
                 log.warning(
                     "Failed to add cli command for module \"{}\"".format(
                         addon.name
-                    )
+                    ), exc_info=True
                 )
         return click_func