[ui/core] Add Validators paradigm

meshroom/common/PySignal.py

@@ -158,6 +158,10 @@ class ClassSignal:
     """
     _map = {}
 
+    def __init__(self, *args, **kwargs):
+        self._args = args
+        self._kwargs = kwargs
+
     def __get__(self, instance, owner):
         if instance is None:
             # When we access ClassSignal element on the class object without any instance,

meshroom/core/attribute.py

@@ -12,6 +12,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 meshroom.core.keyValues import KeyValues
 from meshroom.core.exception import InvalidEdgeError
@@ -401,21 +402,6 @@ def _isDefault(self):
         else:
             return self._getValue() == self.getDefaultValue()
 
-    def _isValid(self):
-        """
-        Check attribute description validValue:
-            - If it is a function, execute it and return the result
-            - Otherwise, simply return true
-        """
-        if callable(self._desc.validValue):
-            try:
-                return self._desc.validValue(self.node)
-            except Exception as exc:
-                if not self.node.isCompatibilityNode:
-                    logging.warning(f"Failed to evaluate 'isValid' (node lambda) for attribute '{self.fullName}': {exc}")
-                return True
-        return True
-
     def _is2dDisplayable(self) -> bool:
         """
         Return True if the current attribute is considered as a displayable 2D file.
@@ -487,6 +473,39 @@ def updateInternals(self):
         # Emit if the enable status has changed
         self._setEnabled(self._getEnabled())
 
+    def getErrorMessages(self) -> list[str]:
+        """ Execute the validators and aggregate the error messages if there are any. """
+        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 _isValid(self) -> bool:
+        """ Check the validation and return False if any validator returns (False, errors). """
+        for validator in self.desc.validators:
+            isValid, _ = validator(self.node, self)
+
+            if not isValid:
+                return False
+
+        return True
+
+    def _isMandatory(self) -> bool:
+        """ An attribute is considered as mandatory if it contains a NotEmptyValidator. """
+        for validator in self.desc.validators:
+            if isinstance(validator, NotEmptyValidator):
+                return True
+
+        return False
+
     def _getEnabled(self) -> bool:
         if callable(self._desc.enabled):
             try:
@@ -742,6 +761,9 @@ def validateIncomingConnection(self, connectingAttribute: Attribute) -> bool:
 
     expressionApplied = Signal()
 
+    errorMessageChanged = Signal()
+    errorMessages = Property(Variant, lambda self: self.getErrorMessages(), notify=errorMessageChanged)
+    isMandatory = Property(bool, _isMandatory, constant=True )    
 
 def raiseIfLink(func):
     """

meshroom/core/desc/validators.py

@@ -0,0 +1,64 @@
+from typing import TYPE_CHECKING, Protocol, runtime_checkable
+
+if TYPE_CHECKING:
+    from meshroom.core.attribute import Attribute
+    from meshroom.core.node import Node
+
+
+def success() -> tuple[bool, list[str]]:
+    return (True, [])
+
+def error(*messages: str) -> tuple[bool, list[str]]:
+    return (False, list(messages))
+
+@runtime_checkable
+class AttributeValidator(Protocol):
+    """
+    Interface for an attribute validation.
+    This class can be inherited, and the __call__ methods overridden to implement any custom attribute validation logic.
+
+    Because it is a callable class, validators can also be created on the fly.
+
+    .. code-block: python
+        lambda node, attribute: success() if attribute.value and attribute.value != "" else error("attribute have no value")
+    """
+
+    def __call__(self, node: "Node", attribute: "Attribute") -> tuple[bool, list[str]]:
+        """
+        This method can be overridden to implement any custom attribute validation logic.
+        The `success()` and `error()` helpers can be used to encapsulate the returning responses.
+
+        :param node: The node that holds the attribute to validate
+        :param attribute: The attribute to validate
+
+        :returns: The validation response: (True, []) if it is valid, (False, [errorMessage1, errorMessage2, ...]) otherwise.
+        """
+        raise NotImplementedError()
+
+
+class NotEmptyValidator(AttributeValidator):
+    """
+    Ensure that the attribute value is not empty.
+    This class is used to determine if an attribute value should be considered as mandatory/required.
+    """
+
+    def __call__(self, node: "Node", attribute: "Attribute") -> tuple[bool, list[str]]:
+        if attribute.value is None or attribute.value == "":
+            return error("An empty value is not allowed.")
+
+        return success()
+
+
+class RangeValidator(AttributeValidator):
+    """ Check if the attribute value is in a given range. """
+
+    def __init__(self, min, max):
+        self._min = min
+        self._max = max
+
+    def __call__(self, node: "Node", attribute: "Attribute") -> tuple[bool, list[str]]:
+        if attribute.value < self._min or attribute.value > self._max:
+            return error(f"Value should be greater than {self._min} and less than {self._max} ",
+                         f"({self._min} < {attribute.value} < {self._max}).")
+
+        return success()

meshroom/core/node.py

@@ -1522,6 +1522,8 @@ def _onAttributeChanged(self, attr: Attribute):
         if callback:
             callback(self)
 
+        self.hasInvalidAttributeChanged.emit()
+
         if self.graph:
             # If we are in a graph, propagate the notification to the connected output attributes
             for edge in self.graph.outEdges(attr):
@@ -1792,7 +1794,7 @@ def loadOutputAttr(self):
         # This does not apply to non dynamic output
         if not self.nodeDesc.hasDynamicOutputAttribute:
             return
-        
+
         # Check existence of values.json file
         valuesFile = self.valuesFile
         if not os.path.exists(valuesFile):
@@ -2160,6 +2162,12 @@ def hasTextOutputAttribute(self) -> bool:
         """
         return next((attr for attr in self._attributes if attr.enabled and attr.isOutput and attr.isTextDisplayable), None) is not None
 
+    def _hasInvalidAttribute(self):
+        for attribute in self._attributes:
+            if len(attribute.errorMessages) > 0:
+                return True
+        return False
+
     def _hasDisplayableShape(self):
         """
         Return True if at least one attribute is a ShapeAttribute, a ShapeListAttribute or a shape File.
@@ -2240,6 +2248,9 @@ def _hasDisplayableShape(self):
     # Whether the node contains a ShapeAttribute, a ShapeListAttribute or a shape File.
     hasDisplayableShape = Property(bool, _hasDisplayableShape, constant=True)
 
+    hasInvalidAttributeChanged = Signal()
+    hasInvalidAttribute = Property(bool, _hasInvalidAttribute, notify=hasInvalidAttributeChanged)
+
 
 class Node(BaseNode):
     """

meshroom/ui/commands.py

@@ -314,16 +314,21 @@ def redoImpl(self):
         if self.value == self.oldValue:
             return False
         if self.graph.attribute(self.attrName) is not None:
-            self.graph.attribute(self.attrName).value = self.value
+            attribute = self.graph.attribute(self.attrName)
         else:
-            self.graph.internalAttribute(self.attrName).value = self.value
+            attribute = self.graph.internalAttribute(self.attrName)
+
+        attribute.value = self.value        
+
         return True
 
     def undoImpl(self):
         if self.graph.attribute(self.attrName) is not None:
-            self.graph.attribute(self.attrName).value = self.oldValue
+            attribute = self.graph.attribute(self.attrName)
         else:
-            self.graph.internalAttribute(self.attrName).value = self.oldValue
+            attribute = self.graph.internalAttribute(self.attrName)
+
+        attribute.value = self.oldValue
 
 class AddAttributeKeyValueCommand(GraphCommand):
     def __init__(self, graph, attribute, key, value, parent=None):

meshroom/ui/qml/Application.qml

@@ -39,7 +39,7 @@ Page {
         property alias showImageGallery: imageGalleryVisibilityCB.checked
         property alias showTextViewer: textViewerVisibilityCB.checked
     }
-    
+
     Settings {
         id: nodeActionsSettings
         category: "NodeActions"
@@ -135,6 +135,14 @@ Page {
         return true;
     }
 
+    function getAllNodes() {
+        const nodes = []
+        for (let i = 0; i < graphEditor.graph.nodes.count; i++) {
+            nodes.push(graphEditor.graph.nodes.at(i))
+        }
+        return nodes
+    }
+
     // File dialogs
     Platform.FileDialog {
         id: saveFileDialog
@@ -267,14 +275,24 @@ Page {
         function submit(nodes) {
             if (!canSubmit) {
                 unsavedSubmitDialog.open()
-            } else {
+            }
+            else {
                 try {
-                    _currentScene.submit(nodes)
+                    if (nodes == null) {
+                        nodes = getAllNodes()
+                    }
+                    if (nodes && nodes.find(node => node.hasInvalidAttribute)) {
+                        submitWithWarningDialog.nodes = nodes
+                        submitWithWarningDialog.open()
+                    } else {
+                        _currentScene.submit(nodes)
+                    }
                 }
                 catch (error) {
                     const data = ErrorHandler.analyseError(error)
-                    if (data.context === "SUBMITTING")
+                    if (data.context === "SUBMITTING") {
                         computeSubmitErrorDialog.openError(data.type, data.msg, nodes)
+                    }
                 }
             }
         }
@@ -400,6 +418,26 @@ Page {
             onAccepted: saveAsAction.trigger()
         }
 
+        MessageDialog {
+            id: submitWithWarningDialog
+
+            canCopy: false
+            icon.text: MaterialIcons.warning
+            parent: Overlay.overlay
+            preset: "Warning"
+            title: "Nodes With Warnings"
+            text: "Some nodes have warnings. Are you sure you want to submit them?"
+            helperText: "Submit nodes even if some of them have warnings."
+            standardButtons: Dialog.Cancel | Dialog.Yes
+
+            property var nodes: []
+
+            onDiscarded: close()
+            onAccepted: {
+                _currentScene.submit(nodes)
+            }
+        }
+
         MessageDialog {
             id: fileModifiedDialog
 
@@ -733,7 +771,7 @@ Page {
                         model: MeshroomApp.recentProjectFiles
                         MenuItem {
                             enabled: modelData["status"] != 0
-                            
+
                             onTriggered: ensureSaved(function() {
                                 openRecentMenu.dismiss()
                                 if (_currentScene.load(modelData["path"])) {
@@ -887,7 +925,7 @@ Page {
                         id: nodeActionsSettingsMenu
                         title: "NodeActions Settings"
                         implicitWidth: 250
-                        
+
                         MenuItem {
                             id: nodeActionsConfirmDelete
                             checkable: true
@@ -1504,7 +1542,7 @@ Page {
                     SplitView.minimumWidth: 350
 
                     node: _currentScene ? _currentScene.selectedNode : null
-                    property bool computing: _currentScene ? _currentScene.computing : false       
+                    property bool computing: _currentScene ? _currentScene.computing : false
                     property var currentAttributes: []
 
                     // Make NodeEditor readOnly when computing