Create & Publish: Attribute definitions per instance

client/ayon_core/pipeline/create/context.py

@@ -171,7 +171,6 @@ def __init__(
         self.publish_plugins_mismatch_targets = []
         self.publish_plugins = []
         self.plugins_with_defs = []
-        self._attr_plugins_by_product_type = {}
 
         # Helpers for validating context of collected instances
         #   - they can be validation for multiple instances at one time
@@ -564,9 +563,6 @@ def _reset_publish_plugins(self, discover_publish_plugins):
             publish_plugins_discover
         )
 
-        # Reset publish plugins
-        self._attr_plugins_by_product_type = {}
-
         discover_result = DiscoverResult(pyblish.api.Plugin)
         plugins_with_defs = []
         plugins_by_targets = []
@@ -694,11 +690,29 @@ def reset_context_data(self):
 
         publish_attributes = original_data.get("publish_attributes") or {}
 
-        attr_plugins = self._get_publish_plugins_with_attr_for_context()
         self._publish_attributes = PublishAttributes(
-            self, publish_attributes, attr_plugins
+            self, publish_attributes
         )
 
+        for plugin in self.plugins_with_defs:
+            if is_func_signature_supported(
+                plugin.convert_attribute_values, self, None
+            ):
+                plugin.convert_attribute_values(self, None)
+
+            elif not plugin.__instanceEnabled__:
+                output = plugin.convert_attribute_values(publish_attributes)
+                if output:
+                    publish_attributes.update(output)
+
+        for plugin in self.plugins_with_defs:
+            attr_defs = plugin.get_attribute_defs_for_context(self)
+            if not attr_defs:
+                continue
+            self._publish_attributes.set_publish_plugin_attr_defs(
+                plugin.__name__, attr_defs
+            )
+
     def context_data_to_store(self):
         """Data that should be stored by host function.
 
@@ -734,11 +748,25 @@ def creator_adds_instance(self, instance):
             return
 
         self._instances_by_id[instance.id] = instance
+
+        publish_attributes = instance.publish_attributes
         # Prepare publish plugin attributes and set it on instance
-        attr_plugins = self._get_publish_plugins_with_attr_for_product_type(
-            instance.product_type
-        )
-        instance.set_publish_plugins(attr_plugins)
+        for plugin in self.plugins_with_defs:
+            if is_func_signature_supported(
+                plugin.convert_attribute_values, self, instance
+            ):
+                plugin.convert_attribute_values(self, instance)
+
+            elif plugin.__instanceEnabled__:
+                output = plugin.convert_attribute_values(publish_attributes)
+                if output:
+                    publish_attributes.update(output)
+
+        for plugin in self.plugins_with_defs:
+            attr_defs = plugin.get_attribute_defs_for_instance(self, instance)
+            if not attr_defs:
+                continue
+            instance.set_publish_plugin_attr_defs(plugin.__name__, attr_defs)
 
         # Add instance to be validated inside 'bulk_instances_collection'
         #   context manager if is inside bulk
@@ -1309,44 +1337,6 @@ def remove_instances(self, instances):
         if failed_info:
             raise CreatorsRemoveFailed(failed_info)
 
-    def _get_publish_plugins_with_attr_for_product_type(self, product_type):
-        """Publish plugin attributes for passed product type.
-
-        Attribute definitions for specific product type are cached.
-
-        Args:
-            product_type(str): Instance product type for which should be
-                attribute definitions returned.
-        """
-
-        if product_type not in self._attr_plugins_by_product_type:
-            import pyblish.logic
-
-            filtered_plugins = pyblish.logic.plugins_by_families(
-                self.plugins_with_defs, [product_type]
-            )
-            plugins = []
-            for plugin in filtered_plugins:
-                if plugin.__instanceEnabled__:
-                    plugins.append(plugin)
-            self._attr_plugins_by_product_type[product_type] = plugins
-
-        return self._attr_plugins_by_product_type[product_type]
-
-    def _get_publish_plugins_with_attr_for_context(self):
-        """Publish plugins attributes for Context plugins.
-
-        Returns:
-            List[pyblish.api.Plugin]: Publish plugins that have attribute
-                definitions for context.
-        """
-
-        plugins = []
-        for plugin in self.plugins_with_defs:
-            if not plugin.__instanceEnabled__:
-                plugins.append(plugin)
-        return plugins
-
     @property
     def collection_shared_data(self):
         """Access to shared data that can be used during creator's collection.

client/ayon_core/pipeline/create/creator_plugins.py

@@ -1,7 +1,7 @@
 # -*- coding: utf-8 -*-
 import copy
 import collections
-from typing import TYPE_CHECKING, Optional
+from typing import TYPE_CHECKING, Optional, Dict, Any
 
 from abc import ABC, abstractmethod
 
@@ -19,11 +19,12 @@
 from .product_name import get_product_name
 from .utils import get_next_versions_for_instances
 from .legacy_create import LegacyCreator
+from .structures import CreatedInstance
 
 if TYPE_CHECKING:
     from ayon_core.lib import AbstractAttrDef
     # Avoid cyclic imports
-    from .context import CreateContext, CreatedInstance, UpdateData  # noqa: F401
+    from .context import CreateContext, UpdateData  # noqa: F401
 
 
 class ProductConvertorPlugin(ABC):
@@ -362,6 +363,18 @@ def log(self):
             self._log = Logger.get_logger(self.__class__.__name__)
         return self._log
 
+    def _create_instance(
+        self, product_type: str, product_name: str, data: Dict[str, Any]
+    ) -> CreatedInstance:
+        instance = CreatedInstance(
+            product_type,
+            product_name,
+            data,
+            creator=self,
+        )
+        self._add_instance_to_context(instance)
+        return instance
+
     def _add_instance_to_context(self, instance):
         """Helper method to add instance to create context.
 
@@ -551,6 +564,16 @@ def get_instance_attr_defs(self):
 
         return self.instance_attr_defs
 
+    def get_attr_defs_for_instance(self, instance):
+        """Get attribute definitions for an instance.
+
+        Args:
+            instance (CreatedInstance): Instance for which to get
+                attribute definitions.
+
+        """
+        return self.get_instance_attr_defs()
+
     @property
     def collection_shared_data(self):
         """Access to shared data that can be used during creator's collection.

client/ayon_core/pipeline/create/structures.py

@@ -4,6 +4,7 @@
 
 from ayon_core.lib.attribute_definitions import (
     UnknownDef,
+    UIDef,
     serialize_attr_defs,
     deserialize_attr_defs,
 )
@@ -248,18 +249,11 @@ class PublishAttributes:
             plugins that may have defined attribute definitions.
     """
 
-    def __init__(self, parent, origin_data, attr_plugins=None):
+    def __init__(self, parent, origin_data):
         self.parent = parent
         self._origin_data = copy.deepcopy(origin_data)
 
-        attr_plugins = attr_plugins or []
-        self.attr_plugins = attr_plugins
-
         self._data = copy.deepcopy(origin_data)
-        self._plugin_names_order = []
-        self._missing_plugins = []
-
-        self.set_publish_plugins(attr_plugins)
 
     def __getitem__(self, key):
         return self._data[key]
@@ -290,10 +284,9 @@ def pop(self, key, default=None):
         if key not in self._data:
             return default
 
-        if key in self._missing_plugins:
-            self._missing_plugins.remove(key)
-            removed_item = self._data.pop(key)
-            return removed_item.data_to_store()
+        value = self._data[key]
+        if not isinstance(value, AttributeValues):
+            return self._data.pop(key)
 
         value_item = self._data[key]
         # Prepare value to return
@@ -302,12 +295,6 @@ def pop(self, key, default=None):
         value_item.reset_values()
         return output
 
-    def plugin_names_order(self):
-        """Plugin names order by their 'order' attribute."""
-
-        for name in self._plugin_names_order:
-            yield name
-
     def mark_as_stored(self):
         self._origin_data = copy.deepcopy(self.data_to_store())
 
@@ -323,56 +310,39 @@ def data_to_store(self):
     def origin_data(self):
         return copy.deepcopy(self._origin_data)
 
-    def set_publish_plugins(self, attr_plugins):
-        """Set publish plugins attribute definitions."""
+    def set_publish_plugin_attr_defs(self, plugin_name, attr_defs):
+        """Set attribute definitions for plugin.
 
-        self._plugin_names_order = []
-        self._missing_plugins = []
-        self.attr_plugins = attr_plugins or []
-
-        origin_data = self._origin_data
-        data = self._data
-        self._data = {}
-        added_keys = set()
-        for plugin in attr_plugins:
-            output = plugin.convert_attribute_values(data)
-            if output is not None:
-                data = output
-            attr_defs = plugin.get_attribute_defs()
-            if not attr_defs:
-                continue
+        Args:
+            plugin_name(str): Name of plugin.
+            attr_defs(Optional[List[AbstractAttrDef]]): Attribute definitions.
 
-            key = plugin.__name__
-            added_keys.add(key)
-            self._plugin_names_order.append(key)
+        """
+        # TODO what if 'attr_defs' is 'None'?
+        value = self._data.get(plugin_name)
+        if value is None:
+            value = {}
 
-            value = data.get(key) or {}
-            orig_value = copy.deepcopy(origin_data.get(key) or {})
-            self._data[key] = PublishAttributeValues(
-                self, attr_defs, value, orig_value
-            )
+        for attr_def in attr_defs:
+            if isinstance(attr_def, (UIDef, UnknownDef)):
+                continue
+            key = attr_def.key
+            if key in value:
+                value[key] = attr_def.convert_value(value[key])
 
-        for key, value in data.items():
-            if key not in added_keys:
-                self._missing_plugins.append(key)
-                self._data[key] = PublishAttributeValues(
-                    self, [], value, value
-                )
+        self._data[plugin_name] = PublishAttributeValues(
+            self, attr_defs, value, value
+        )
 
     def serialize_attributes(self):
         return {
             "attr_defs": {
                 plugin_name: attrs_value.get_serialized_attr_defs()
                 for plugin_name, attrs_value in self._data.items()
             },
-            "plugin_names_order": self._plugin_names_order,
-            "missing_plugins": self._missing_plugins
         }
 
     def deserialize_attributes(self, data):
-        self._plugin_names_order = data["plugin_names_order"]
-        self._missing_plugins = data["missing_plugins"]
-
         attr_defs = deserialize_attr_defs(data["attr_defs"])
 
         origin_data = self._origin_data
@@ -390,10 +360,7 @@ def deserialize_attributes(self, data):
 
         for key, value in data.items():
             if key not in added_keys:
-                self._missing_plugins.append(key)
-                self._data[key] = PublishAttributeValues(
-                    self, [], value, value
-                )
+                self._data[key] = value
 
 
 class CreatedInstance:
@@ -449,7 +416,6 @@ def __init__(
             creator_identifier = creator.identifier
             group_label = creator.get_group_label()
             creator_label = creator.label
-            creator_attr_defs = creator.get_instance_attr_defs()
 
         self._creator_label = creator_label
         self._group_label = group_label or creator_identifier
@@ -509,6 +475,9 @@ def __init__(
         # {key: value}
         creator_values = copy.deepcopy(orig_creator_attributes)
 
+        if creator is not None:
+            creator_attr_defs = creator.get_attr_defs_for_instance(self)
+
         self._data["creator_attributes"] = CreatorAttributeValues(
             self,
             list(creator_attr_defs),
@@ -518,9 +487,8 @@ def __init__(
 
         # Stored publish specific attribute values
         # {<plugin name>: {key: value}}
-        # - must be set using 'set_publish_plugins'
         self._data["publish_attributes"] = PublishAttributes(
-            self, orig_publish_attributes, None
+            self, orig_publish_attributes
         )
         if data:
             self._data.update(data)
@@ -749,18 +717,17 @@ def from_existing(cls, instance_data, creator):
             product_type, product_name, instance_data, creator
         )
 
-    def set_publish_plugins(self, attr_plugins):
-        """Set publish plugins with attribute definitions.
-
-        This method should be called only from 'CreateContext'.
+    def set_publish_plugin_attr_defs(self, plugin_name, attr_defs):
+        """Set attribute definitions for publish plugin.
 
         Args:
-            attr_plugins (List[pyblish.api.Plugin]): Pyblish plugins which
-                inherit from 'AYONPyblishPluginMixin' and may contain
-                attribute definitions.
-        """
+            plugin_name(str): Name of publish plugin.
+            attr_defs(List[AbstractAttrDef]): Attribute definitions.
 
-        self.publish_attributes.set_publish_plugins(attr_plugins)
+        """
+        self.publish_attributes.set_publish_plugin_attr_defs(
+            plugin_name, attr_defs
+        )
 
     def add_members(self, members):
         """Currently unused method."""