Merge pull request #49 from quadproduction/release/1.9.0

release/1.9.0

quad_pyblish_module/plugins/photoshop/publish/help/validate_nomenclature.xml

@@ -13,11 +13,11 @@ Layer name doesn't has the correct name, based on the following recommendations
     - 'XX_UTIL' for groups
     - 'XX_UTIL_[layer name]' for layers
 - Blue layers corresponds to 'BG' and should be named :
-    - '[layer number]_BG' for groups
-    - '[layer number]_BG _[layer name]' for layers
+    - '[group number]_BG' for groups
+    - '[group number]_[layer number]_BG _[layer name]' for layers
 - Red layers corresponds to 'CH' and should be named :
-    - '[layer number]_CH' for groups
-    - '[layer number]_CH _[layer name]' for layers
+    - '[group number]_CH' for groups
+    - '[group number]_[layer number]_CH _[layer name]' for layers
 
 
 {msg}

quad_pyblish_module/plugins/photoshop/publish/validate_layers_organization.py

@@ -1,13 +1,16 @@
+import os
+import logging
 import pyblish.api
 
 from openpype.hosts.photoshop import api as photoshop
 from openpype.pipeline import OptionalPyblishPluginMixin
+from openpype.settings import get_project_settings
 from openpype.pipeline.publish import (
     ValidateContentsOrder,
     PublishXmlValidationError  
 )
 
-from .common import ColorMatches
+from enum import Enum
 
 
 class ValidateLayersOrganizationRepair(pyblish.api.Action):
@@ -28,8 +31,8 @@ def _is_group(layer):
     return layer.group
 
 
-def _check_color_error(color):
-    return False if color in [data.value for data in ColorMatches] else True
+def _check_color_error(color, layers_types_colors):
+    return False if color in layers_types_colors.keys() else True
 
 
 def _generate_layer_with_error(layer, group_error, color_error):
@@ -40,9 +43,9 @@ def _generate_layer_with_error(layer, group_error, color_error):
     }
 
 
-def _check_layer_is_clean(layer, layers_errors):
+def _check_layer_is_clean(layer, layers_errors, layers_types_colors):
     have_parents = bool(layer.parents)
-    have_bad_color = _check_color_error(layer.color_code)
+    have_bad_color = _check_color_error(layer.color_code, layers_types_colors)
 
     # return if layer is group, have no parent, and color is correct
     if not have_parents and not have_bad_color and _is_group(layer):
@@ -79,17 +82,26 @@ class ValidateLayersOrganization(
     active = False
 
     def process(self, context):
-
         if not self.is_active(context.data):
             return
+
+        project_name = os.environ['AVALON_PROJECT']
+        project_settings = get_project_settings(project_name)
+        try:
+            layers_types_colors = project_settings['fix_custom_settings']['photoshop']['types_colors']
+        except KeyError as err:
+            msg = "Layers types colors has not been found in settings. ValidateNomenclature plugin can't be executed."
+            logging.error(msg)
+            logging.error(err)
+            raise Exception
 
         stub = photoshop.stub()
         layers = stub.get_layers()
 
         layers_errors = list()
 
         for layer in layers:
-            _check_layer_is_clean(layer, layers_errors)
+            _check_layer_is_clean(layer, layers_errors, layers_types_colors)
 
         if layers_errors:
             msg = (

quad_pyblish_module/plugins/photoshop/publish/validate_nomenclature.py

@@ -1,16 +1,18 @@
 from enum import Enum
+import os
+import logging
+import re
 
 import pyblish.api
 
 from openpype.hosts.photoshop import api as photoshop
 from openpype.pipeline import OptionalPyblishPluginMixin
+from openpype.settings import get_project_settings
 from openpype.pipeline.publish import (
     ValidateContentsOrder,
     PublishXmlValidationError  
 )
 
-from .common import ColorMatches
-
 
 class ValidateNomenclatureRepair(pyblish.api.Action):
     """Repair the instance asset."""
@@ -26,10 +28,6 @@ def process(self, context, plugin):
         return True
 
 
-def _guess_group_prefix_from_color_code(layer, numbering):
-    return 'XX' if layer.color_code in [ColorMatches.REF.value, ColorMatches.UTIL.value] else f'{numbering*10:03d}'
-
-
 def _convert_index_to_letter(index):
     return chr(ord('`')+index)
 
@@ -49,15 +47,6 @@ def _extract_layers_from_group(layers, group_layer):
     ]
 
 
-def _extract_list_of_id_names(layers):
-    return [
-        { 
-            'id': layer.id,
-            'name': layer.name
-        } for layer in layers
-    ]
-
-
 def _generate_layer_with_id_name(layer_id, old_layer_name, new_layer_name):
     return {
         'id': layer_id,
@@ -66,41 +55,6 @@ def _generate_layer_with_id_name(layer_id, old_layer_name, new_layer_name):
     }
 
 
-def rename_group(layer, numbering, renamed_layers):
-    prefix = _guess_group_prefix_from_color_code(layer, numbering)
-    group_name = ColorMatches(layer.color_code).name
-    new_layer_name = f'{prefix}_{group_name}'
-
-    if new_layer_name == layer.name:
-        return
-
-    renamed_layers.append(
-        _generate_layer_with_id_name(
-            layer_id=layer.id,
-            old_layer_name= layer.name,
-            new_layer_name=new_layer_name
-        )
-    )
-
-
-def rename_layer(layer, numbering, layer_index, renamed_layers):
-    prefix = _guess_group_prefix_from_color_code(layer, numbering)
-    letter_index = _convert_index_to_letter(layer_index)
-    group_name = ColorMatches(layer.color_code).name
-    new_layer_name = f'{prefix}_{letter_index}_{group_name}_{layer.name}'
-
-    if new_layer_name == layer.name:
-        return
-
-    renamed_layers.append(
-        _generate_layer_with_id_name(
-            layer_id=layer.id,
-            old_layer_name= layer.name,
-            new_layer_name=new_layer_name
-        )
-    )
-
-
 class ValidateNomenclature(
         OptionalPyblishPluginMixin,
         pyblish.api.ContextPlugin
@@ -115,23 +69,43 @@ class ValidateNomenclature(
     order = ValidateContentsOrder
     families = ["image"]
     actions = [ValidateNomenclatureRepair]
-    optional = True    
+    optional = True
     active = False
 
     def process(self, context):
         if not self.is_active(context.data):
             return
+
+        project_name = os.environ['AVALON_PROJECT']
+        project_settings = get_project_settings(project_name)
+
+        try:
+            self.types_colors = project_settings['fix_custom_settings']['photoshop']['types_colors']
+            self.groups_templates = project_settings['fix_custom_settings']['photoshop']['groups']['templates']
+            self.layers_templates = project_settings['fix_custom_settings']['photoshop']['layers']['templates']
+            self.groups_expressions = project_settings['fix_custom_settings']['photoshop']['groups']['expressions']
+            self.layers_expressions = project_settings['fix_custom_settings']['photoshop']['layers']['expressions']
+
+        except KeyError as err:
+            msg = "Types colors, templates or expressions are missing from settings. ValidateNomenclature plugin can't be executed."
+            logging.error(msg)
+            logging.error(err)
+            raise Exception
 
         stub = photoshop.stub()
         layers = stub.get_layers()
         layers.reverse()
         renamed_layers = list()
 
-        for numbering, group_layer in enumerate(_extract_groups(layers), 1):
-            rename_group(group_layer, numbering, renamed_layers)
+        for group_index, group_layer in enumerate(_extract_groups(layers), 1):
+
+            renamed_group = self.rename_group_if_needed(group_layer, group_index)
+            if renamed_group: renamed_layers.append(renamed_group)
 
             for layer_index, layer in enumerate(_extract_layers_from_group(layers, group_layer), 1):
-                rename_layer(layer, numbering, layer_index, renamed_layers)
+
+                renamed_layer = self.rename_layer_if_needed(layer, group_index, layer_index)
+                if renamed_layer: renamed_layers.append(renamed_layer)
 
         if renamed_layers:
             number_of_layers = len(renamed_layers)
@@ -153,3 +127,130 @@ def process(self, context):
 
             raise PublishXmlValidationError(self, msg,
                                             formatting_data=formatting_data)
+
+    def rename_group_if_needed(self, group_layer, group_index):
+        renamed_group = None
+        group_template = self.get_groups_template(group_layer)
+
+        if not self.validate_group_name(group_template, group_layer.name):
+            renamed_group = self.rename(group_template, group_layer, group_index)
+
+        return renamed_group
+
+    def rename_layer_if_needed(self, layer, group_index, layer_index):
+        renamed_layer = None
+        layer_template = self.get_layers_template(layer)
+
+        if not self.validate_layer_name(layer_template, layer.name):
+            renamed_layer = self.rename(layer_template, layer, group_index, layer_index)
+
+        return renamed_layer
+
+    def get_groups_template(self, group):
+        return self._get_template(
+            templates=self.groups_templates,
+            layer=group
+        )
+
+    def get_layers_template(self, layer):
+        return self._get_template(
+            templates=self.layers_templates,
+            layer=layer
+        )
+
+    def _get_template(self, templates, layer):
+        template = None
+        overriden_templates = templates.get(f'overriden')
+
+        if overriden_templates:
+            template = self._search_for_overriden_template(
+                filters_set=overriden_templates,
+                layer_type=self.types_colors.get(layer.color_code, '??')
+            )
+
+        if not template:
+            template = templates.get(f"default", None)
+
+            if not template:
+                logging.warning(f"Can't find template correct template for layer {layer.name}. Can't rename it.")
+                return layer.name
+
+        return template
+
+    def validate_group_name(self, template, group_name):
+        return self._validate_name(
+            template=template,
+            layer_name=group_name,
+            expressions=self.groups_expressions
+        )
+
+    def validate_layer_name(self, template, layer_name):
+        return self._validate_name(
+            template=template,
+            layer_name=layer_name,
+            expressions=self.layers_expressions
+        )
+
+    def _validate_name(self, template, layer_name, expressions):
+        template = self._remove_format_specifications(template)
+        template_regex = template.format(**expressions)
+        return re.compile(template_regex).match(layer_name)
+
+    def _remove_format_specifications(self, template):
+        return re.sub(
+            pattern=r'(:)(.*?)(?=})',
+            repl='',
+            string=template
+        )
+
+    def rename(self, template, layer, group_index, layer_index=None):
+        layer_type = self.types_colors.get(layer.color_code, '??')
+        new_layer_name = template.format(
+            **self._pack_layer_data(layer, layer_type, group_index, layer_index)
+        )
+        if new_layer_name == layer.name:
+            return
+
+        return _generate_layer_with_id_name(
+            layer_id=layer.id,
+            old_layer_name= layer.name,
+            new_layer_name=new_layer_name
+        )
+
+    def _search_for_overriden_template(self, filters_set, **filter_data):
+        "Browse filtering sets and check for each template if given filtering data met a filter set."
+        "Return the first template which met all conditions, None if no ones does."
+        for filter_set in filters_set:
+            if not filter_set:
+                continue
+
+            only_valid_properties = False
+
+            for filter_property_name, filter_value in filter_data.items():
+                property_template_value = filter_set.get(filter_property_name)
+                if not property_template_value:
+                    continue
+
+                if property_template_value == filter_value:
+                    only_valid_properties = True
+
+                else :
+                    only_valid_properties = False
+                    break
+
+            if only_valid_properties:
+                return filter_set.get('template', None)
+
+        return None
+
+
+    def _pack_layer_data(self, layer, layer_type, group_index, layer_index=None):
+        packed_data = {
+            'group_number': group_index,
+            'type': layer_type,
+            'layer_name': layer.name
+        }
+        if layer_index: 
+            packed_data['layer_number'] = _convert_index_to_letter(layer_index)
+
+        return packed_data

quad_pyblish_module/plugins/tvpaint/publish/extract_psd.py

@@ -6,6 +6,7 @@
 from pathlib import Path
 
 import pyblish.api
+import logging
 from openpype.settings import get_project_settings
 from openpype.hosts.tvpaint.api import lib