Attribute Converter : handle deserialization of converters

Author: Alxiice

meshroom/core/attribute.py

@@ -324,7 +324,7 @@ def _handleLinkValue(self, value) -> bool:
             self._linkExpression = value
         return True
 
-    def _applyExpr(self):
+    def _applyExpr(self, converterMap: dict = None):
         """
         For string parameters with an expression (when loaded from file),
         this function convert the expression into a real edge in the graph
@@ -353,7 +353,13 @@ def _applyExpr(self):
             attr = node.attribute(linkAttrName) if node.hasAttribute(linkAttrName) else node.internalAttribute(linkAttrName)
             if attr is None:
                 raise InvalidEdgeError(self.fullName, link, "Source attribute does not exist.")
-            attr.connectTo(self)
+            connectedEdge, _ = attr.connectTo(self)
+            if connectedEdge:
+                src, dst = connectedEdge[0]
+                if converterMap and (converterName:=converterMap.get((src.fullName, dst.fullName))): 
+                    logging.info(f"Edge: {src.fullName}->{dst.fullName} set converter to {converterName}")
+                    edge = self.node.graph.edge(dst)
+                    edge.setConverter(converterName)
         except InvalidEdgeError as err:
             logging.warning(err)
         except Exception as err:
@@ -1039,9 +1045,9 @@ def _setValue(self, value):
             self.requestGraphUpdate()
 
     # Override
-    def _applyExpr(self):
+    def _applyExpr(self, converterMap: dict = None):
         if self._linkExpression:
-            super()._applyExpr()
+            super()._applyExpr(converterMap)
         else:
             for value in self._value:
                 value._applyExpr()
@@ -1288,12 +1294,12 @@ def _setValue(self, exportedValue):
             raise AttributeError(f"Failed to set on GroupAttribute: {str(value)}")
 
     # Override
-    def _applyExpr(self):
+    def _applyExpr(self, converterMap: dict = None):
         if self._linkExpression:
-            super()._applyExpr()
+            super()._applyExpr(converterMap)
         else:
             for value in self._value:
-                value._applyExpr()
+                value._applyExpr(converterMap)
 
     # Override
     def resetToDefaultValue(self):

meshroom/core/graph.py

@@ -401,6 +401,8 @@ def _deserialize(self, graphData: dict):
         self.header = graphData.get(GraphIO.Keys.Header, {})
         fileVersion = Version(self.header.get(GraphIO.Keys.FileVersion, "0.0"))
         graphContent = self._normalizeGraphContent(graphData, fileVersion)
+        graphConverters = graphData.get(GraphIO.Keys.Converters, {})
+        converterMap = {tuple(v): k for k, v in graphConverters.items()}
         isTemplate = self.header.get(GraphIO.Keys.Template, False)
         explicitCachePaths = self.header.get(GraphIO.Keys.CacheDir)
         if explicitCachePaths:
@@ -414,7 +416,7 @@ def _deserialize(self, graphData: dict):
                 self._deserializeNode(nodeData, nodeName, self)
 
             # Create graph edges by resolving attributes expressions
-            self._applyExpr()
+            self._applyExpr(converterMap)
 
         # Templates are specific: they contain only the minimal amount of
         # serialized data to describe the graph structure.
@@ -571,15 +573,30 @@ def importGraphContent(self, graph: "Graph") -> list[Node]:
         Returns:
             The list of newly created Nodes.
         """
+        
+        edgesWithConverters = [e for e in graph.edges if e._converter]
+        converterMap = {
+            (e.src.fullName, e.dst.fullName): e._converter.getName()
+            for e in edgesWithConverters
+        }
 
-        def _renameClashingNodes():
+        def replaceKey(src, dst, oldName, newName):
+            return (src.replace(oldName, newName, 1), dst.replace(oldName, newName, 1))
+
+        def _renameClashingNodes(converterMap):
             if not self.nodes:
                 return
             unavailableNames = set(self.nodes.keys())
             for node in graph.nodes:
-                if node._name in unavailableNames:
+                oldName = node._name
+                if oldName in unavailableNames:
                     node._name = self._createUniqueNodeName(node.nodeType, unavailableNames)
+                    converterMap = {
+                        replaceKey(src, dst, oldName, node._name): value
+                        for (src, dst), value in converterMap.items()
+                    }
                 unavailableNames.add(node._name)
+            return converterMap
 
         def _importNodesAndEdges() -> list[Node]:
             importedNodes = []
@@ -590,10 +607,10 @@ def _importNodesAndEdges() -> list[Node]:
                 for srcNode in nodes:
                     node = self._deserializeNode(srcNode.toDict(), srcNode.name, graph)
                     importedNodes.append(node)
-                self._applyExpr()
+                self._applyExpr(converterMap)
             return importedNodes
 
-        _renameClashingNodes()
+        converterMap = _renameClashingNodes(converterMap)
         importedNodes = _importNodesAndEdges()
         return importedNodes
 
@@ -1489,10 +1506,10 @@ def discoverVertex(self, vertex, graph):
         self.dfs(visitor=visitor, startNodes=[startNode])
         return visitor.canCompute + (2 * visitor.canSubmit)
 
-    def _applyExpr(self):
+    def _applyExpr(self, converterMap: dict = None):
         with GraphModification(self):
             for node in self._nodes:
-                node._applyExpr()
+                node._applyExpr(converterMap)
 
     def toDict(self):
         nodes = {k: node.toDict() for k, node in self._nodes.objects.items()}

meshroom/core/node.py

@@ -1106,9 +1106,9 @@ def hasInternalAttribute(self, name):
             return p[0][0] in self._internalAttributes.keys() or p[0][1] in self._internalAttributes.keys()
         return name in self._internalAttributes.keys()
 
-    def _applyExpr(self):
+    def _applyExpr(self, converterMap: dict = None):
         for attr in self._attributes:
-            attr._applyExpr()
+            attr._applyExpr(converterMap)
         for attr in self._internalAttributes:
             attr._applyExpr()