[ui] Attribute: Attribute check validators when user edit, and show orange icon if an error exists. Mandatory atribute have a '*'

Author: nicolas-lambert-tc

meshroom/core/attribute.py

@@ -9,6 +9,7 @@
 from collections.abc import Iterable, Sequence
 from string import Template
 from meshroom.common import BaseObject, Property, Variant, Signal, ListModel, DictModel, Slot
+from meshroom.core.desc.validators import NotEmptyValidator
 from meshroom.core import desc, hashValue
 
 from typing import TYPE_CHECKING
@@ -470,6 +471,31 @@ def _is2D(self) -> bool:
 
         return next((imageSemantic for imageSemantic in Attribute.VALID_IMAGE_SEMANTICS if self.desc.semantic == imageSemantic), None) is not None
 
+    def getErrorMessages(self) -> list[str]:
+        """ Execute the validators and aggregate the eventual error messages"""
+
+        result = []
+
+        for validator in self.desc._validators:
+            isValid, errorMessages = validator(self.node, self)
+
+            if isValid:
+                continue
+
+            for errorMessage in errorMessages:
+                result.append(errorMessage)
+        
+        return result
+
+    def _isMandatory(self) -> bool:
+        """ An attribute is considered as mandatory it contain a NotEmptyValidator """
+
+        for validator in self.desc.validators:
+            if isinstance(validator, NotEmptyValidator):
+                return True
+            
+        return False
+
     name = Property(str, getName, constant=True)
     fullName = Property(str, getFullName, constant=True)
     fullNameToNode = Property(str, getFullNameToNode, constant=True)
@@ -516,6 +542,10 @@ def _is2D(self) -> bool:
     validValue = Property(bool, getValidValue, setValidValue, notify=validValueChanged)
     root = Property(BaseObject, root.fget, constant=True)
 
+    errorMessageChanged = Signal()
+    errorMessages = Property(Variant, lambda self: self.getErrorMessages(), notify=errorMessageChanged)
+    isMandatory = Property(bool, _isMandatory, constant=True )
+
 
 def raiseIfLink(func):
     """ If Attribute instance is a link, raise a RuntimeError."""

meshroom/core/desc/attribute.py

@@ -6,13 +6,26 @@
 
 from meshroom.common import BaseObject, JSValue, Property, Variant, VariantList
 
+from typing import TYPE_CHECKING
+
+if TYPE_CHECKING:
+    from meshroom.core.desc.validators import AttributeValidator
+
 
 class Attribute(BaseObject):
     """
     """
 
-    def __init__(self, name, label, description, value, advanced, semantic, group, enabled, invalidate=True,
-                 uidIgnoreValue=None, validValue=True, errorMessage="", visible=True, exposed=False):
+    def __init__(self, name, label, description, value, advanced, semantic, group, enabled, 
+                 invalidate=True,
+                 uidIgnoreValue=None, 
+                 validValue=True, 
+                 errorMessage="", 
+                 visible=True, 
+                 exposed=False, 
+                 validators:list["AttributeValidator"]=None
+                 ):
+        
         super(Attribute, self).__init__()
         self._name = name
         self._label = label
@@ -33,6 +46,8 @@ def __init__(self, name, label, description, value, advanced, semantic, group, e
         self._isDynamicValue = (self._value is None)
         self._valueType = None
 
+        self._validators = validators if isinstance(validators, (list, tuple)) else []
+        
     def getInstanceType(self):
         """ Return the correct Attribute instance corresponding to the description. """
         # Import within the method to prevent cyclic dependencies
@@ -70,7 +85,11 @@ def matchDescription(self, value, strict=True):
         except ValueError:
             return False
         return True
-
+    
+    @property
+    def validators(self):
+        return self._validators
+    
     name = Property(str, lambda self: self._name, constant=True)
     label = Property(str, lambda self: self._label, constant=True)
     description = Property(str, lambda self: self._description, constant=True)
@@ -108,15 +127,15 @@ def matchDescription(self, value, strict=True):
 class ListAttribute(Attribute):
     """ A list of Attributes """
     def __init__(self, elementDesc, name, label, description, group="allParams", advanced=False, semantic="",
-                 enabled=True, joinChar=" ", visible=True, exposed=False):
+                 enabled=True, joinChar=" ", visible=True, exposed=False, validators=None):
         """
         :param elementDesc: the Attribute description of elements to store in that list
         """
         self._elementDesc = elementDesc
         self._joinChar = joinChar
         super(ListAttribute, self).__init__(name=name, label=label, description=description, value=[],
                                             invalidate=False, group=group, advanced=advanced, semantic=semantic,
-                                            enabled=enabled, visible=visible, exposed=exposed)
+                                            enabled=enabled, visible=visible, exposed=exposed, validators=validators)
 
     def getInstanceType(self):
         # Import within the method to prevent cyclic dependencies
@@ -160,7 +179,7 @@ def matchDescription(self, value, strict=True):
 class GroupAttribute(Attribute):
     """ A macro Attribute composed of several Attributes """
     def __init__(self, groupDesc, name, label, description, group="allParams", advanced=False, semantic="",
-                 enabled=True, joinChar=" ", brackets=None, visible=True, exposed=False):
+                 enabled=True, joinChar=" ", brackets=None, visible=True, exposed=False, validators=None):
         """
         :param groupDesc: the description of the Attributes composing this group
         """
@@ -169,7 +188,7 @@ def __init__(self, groupDesc, name, label, description, group="allParams", advan
         self._brackets = brackets
         super(GroupAttribute, self).__init__(name=name, label=label, description=description, value={},
                                              group=group, advanced=advanced, invalidate=False, semantic=semantic,
-                                             enabled=enabled, visible=visible, exposed=exposed)
+                                             enabled=enabled, visible=visible, exposed=exposed, validators=validators)
 
     def getInstanceType(self):
         # Import within the method to prevent cyclic dependencies
@@ -267,21 +286,21 @@ class Param(Attribute):
     """
     """
     def __init__(self, name, label, description, value, group, advanced, semantic, enabled, invalidate=True,
-                 uidIgnoreValue=None, validValue=True, errorMessage="", visible=True, exposed=False):
+                 uidIgnoreValue=None, validValue=True, errorMessage="", visible=True, exposed=False, validators=None):
         super(Param, self).__init__(name=name, label=label, description=description, value=value,
                                     group=group, advanced=advanced, enabled=enabled, invalidate=invalidate,
                                     semantic=semantic, uidIgnoreValue=uidIgnoreValue, validValue=validValue,
-                                    errorMessage=errorMessage, visible=visible, exposed=exposed)
+                                    errorMessage=errorMessage, visible=visible, exposed=exposed, validators=validators)
 
 
 class File(Attribute):
     """
     """
     def __init__(self, name, label, description, value, group="allParams", advanced=False, invalidate=True,
-                 semantic="", enabled=True, visible=True, exposed=True):
+                 semantic="", enabled=True, visible=True, exposed=True, validators=None):
         super(File, self).__init__(name=name, label=label, description=description, value=value, group=group,
                                    advanced=advanced, enabled=enabled, invalidate=invalidate, semantic=semantic,
-                                   visible=visible, exposed=exposed)
+                                   visible=visible, exposed=exposed, validators=validators)
         self._valueType = str
 
     def validateValue(self, value):
@@ -304,10 +323,10 @@ class BoolParam(Param):
     """
     """
     def __init__(self, name, label, description, value, group="allParams", advanced=False, enabled=True,
-                 invalidate=True, semantic="", visible=True, exposed=False):
+                 invalidate=True, semantic="", visible=True, exposed=False, validators=None):
         super(BoolParam, self).__init__(name=name, label=label, description=description, value=value,
                                         group=group, advanced=advanced, enabled=enabled, invalidate=invalidate,
-                                        semantic=semantic, visible=visible, exposed=exposed)
+                                        semantic=semantic, visible=visible, exposed=exposed, validators=validators)
         self._valueType = bool
 
     def validateValue(self, value):
@@ -332,12 +351,12 @@ class IntParam(Param):
     """
     """
     def __init__(self, name, label, description, value, range=None, group="allParams", advanced=False, enabled=True,
-                 invalidate=True, semantic="", validValue=True, errorMessage="", visible=True, exposed=False):
+                 invalidate=True, semantic="", validValue=True, errorMessage="", visible=True, exposed=False, validators=None):
         self._range = range
         super(IntParam, self).__init__(name=name, label=label, description=description, value=value,
                                        group=group, advanced=advanced, enabled=enabled, invalidate=invalidate,
                                        semantic=semantic, validValue=validValue, errorMessage=errorMessage,
-                                       visible=visible, exposed=exposed)
+                                       visible=visible, exposed=exposed, validators=validators)
         self._valueType = int
 
     def validateValue(self, value):
@@ -362,12 +381,12 @@ class FloatParam(Param):
     """
     """
     def __init__(self, name, label, description, value, range=None, group="allParams", advanced=False, enabled=True,
-                 invalidate=True, semantic="", validValue=True, errorMessage="", visible=True, exposed=False):
+                 invalidate=True, semantic="", validValue=True, errorMessage="", visible=True, exposed=False, validators=None):
         self._range = range
         super(FloatParam, self).__init__(name=name, label=label, description=description, value=value,
                                          group=group, advanced=advanced, enabled=enabled, invalidate=invalidate,
                                          semantic=semantic, validValue=validValue, errorMessage=errorMessage,
-                                         visible=visible, exposed=exposed)
+                                         visible=visible, exposed=exposed, validators=validators)
         self._valueType = float
 
     def validateValue(self, value):
@@ -391,10 +410,10 @@ class PushButtonParam(Param):
     """
     """
     def __init__(self, name, label, description, group="allParams", advanced=False, enabled=True,
-                 invalidate=True, semantic="", visible=True, exposed=False):
+                 invalidate=True, semantic="", visible=True, exposed=False, validators=None):
         super(PushButtonParam, self).__init__(name=name, label=label, description=description, value=None,
                                               group=group, advanced=advanced, enabled=enabled, invalidate=invalidate,
-                                              semantic=semantic, visible=visible, exposed=exposed)
+                                              semantic=semantic, visible=visible, exposed=exposed, validators=validators)
         self._valueType = None
 
     def getInstanceType(self):
@@ -430,12 +449,12 @@ class ChoiceParam(Param):
     def __init__(self, name: str, label: str, description: str, value, values, exclusive=True, saveValuesOverride=False, 
                  group="allParams", joinChar=" ", advanced=False, enabled=True, invalidate=True, semantic="", 
                  validValue=True, errorMessage="",
-                 visible=True, exposed=False):
+                 visible=True, exposed=False, validators=None):
 
         super(ChoiceParam, self).__init__(name=name, label=label, description=description, value=value,
                                           group=group, advanced=advanced, enabled=enabled, invalidate=invalidate,
                                           semantic=semantic, validValue=validValue, errorMessage=errorMessage,
-                                          visible=visible, exposed=exposed)
+                                          visible=visible, exposed=exposed, validators=validators)
         self._values = values
         self._saveValuesOverride = saveValuesOverride
         self._exclusive = exclusive
@@ -509,11 +528,11 @@ class StringParam(Param):
     """
     def __init__(self, name, label, description, value, group="allParams", advanced=False, enabled=True,
                  invalidate=True, semantic="", uidIgnoreValue=None, validValue=True, errorMessage="", visible=True,
-                 exposed=False):
+                 exposed=False, validators=None):
         super(StringParam, self).__init__(name=name, label=label, description=description, value=value,
                                           group=group, advanced=advanced, enabled=enabled, invalidate=invalidate,
                                           semantic=semantic, uidIgnoreValue=uidIgnoreValue, validValue=validValue,
-                                          errorMessage=errorMessage, visible=visible, exposed=exposed)
+                                          errorMessage=errorMessage, visible=visible, exposed=exposed, validators=validators)
         self._valueType = str
 
     def validateValue(self, value):
@@ -534,10 +553,10 @@ class ColorParam(Param):
     """
     """
     def __init__(self, name, label, description, value, group="allParams", advanced=False, enabled=True,
-                 invalidate=True, semantic="", visible=True, exposed=False):
+                 invalidate=True, semantic="", visible=True, exposed=False, validators=None):
         super(ColorParam, self).__init__(name=name, label=label, description=description, value=value,
                                          group=group, advanced=advanced, enabled=enabled, invalidate=invalidate,
-                                         semantic=semantic, visible=visible, exposed=exposed)
+                                         semantic=semantic, visible=visible, exposed=exposed, validators=validators)
         self._valueType = str
 
     def validateValue(self, value):

meshroom/core/desc/validators.py

@@ -0,0 +1,43 @@
+from typing import TYPE_CHECKING, TypeVar
+
+if TYPE_CHECKING:
+    from meshroom.core.attribute import Attribute
+    from meshroom.core.node import Node
+
+
+SuccessResponse = (True, [])
+Number = TypeVar("Number", int, float)
+
+
+class AttributeValidator(object):
+
+    def __call__(self, node: "Node", attribute: "Attribute") -> tuple[bool, list[str]]: raise NotImplementedError()
+
+
+class NotEmptyValidator(AttributeValidator):
+
+    def __call__(self, node: "Node", attribute: "Attribute") -> tuple[bool, list[str]]:
+
+        if attribute.value is None or attribute.value == "":
+            return (False, ["Empty value are not allowed"])
+        
+        return SuccessResponse
+
+
+class RangeValidator(AttributeValidator):
+
+    def __init__(self, min:Number, max:Number):
+        self._min = min
+        self._max = max
+
+    def __call__(self, node:"Node", attribute: "Attribute") -> tuple[bool, list[str]]:
+        
+        if not isinstance(attribute, Number):
+            return (False, ["Attribute value should be a number"])
+        
+
+        if attribute.value < self._min or attribute.value > self._max:
+            return (False, [f"Value should be greater than {self._min} and less than {self._max}", 
+                            f"({self._min} < {attribute.value} < {self._max})"])
+
+        return SuccessResponse