Move nodes and templates to AliceVision's repository

meshroom/core/__init__.py

@@ -347,13 +347,11 @@
 
 def initPipelines():
     meshroomFolder = os.path.dirname(os.path.dirname(__file__))
-    # Load pipeline templates: check in the default folder and any folder the user might have
-    # added to the environment variable
-    additionalPipelinesPath = os.environ.get("MESHROOM_PIPELINE_TEMPLATES_PATH", "").split(os.pathsep)
-    additionalPipelinesPath = [i for i in additionalPipelinesPath if i]
-    pipelineTemplatesFolders = [os.path.join(meshroomFolder, 'pipelines')] + additionalPipelinesPath
+    # Load pipeline templates: check in any folder the user might have added to the environment variable
+    pipelinesPath = os.environ.get("MESHROOM_PIPELINE_TEMPLATES_PATH", "").split(os.pathsep)
+    pipelineTemplatesFolders = [i for i in pipelinesPath if i]
     for f in pipelineTemplatesFolders:
         if os.path.isdir(f):
             loadPipelineTemplates(f)
         else:
-            logging.error("Pipeline templates folder '{}' does not exist.".format(f))
+            logging.warning("Pipeline templates folder '{}' does not exist.".format(f))

tests/test_templatesVersion.py → meshroom/core/test.py

@@ -1,61 +1,77 @@
 #!/usr/bin/env python
 # coding:utf-8
 
-from meshroom.core.graph import Graph
-from meshroom.core import pipelineTemplates, Version
+from meshroom.core import unregisterNodeType, pipelineTemplates, Version
 from meshroom.core.node import CompatibilityIssue, CompatibilityNode
 from meshroom.core.graphIO import GraphIO
 
-import json
 import meshroom
 
+import json
 
-def test_templateVersions():
-    """
-    This test checks that there is no compatibility issue with the nodes saved in the template files.
-    It fails when an upgrade of a templates is needed. Any template can still be opened even if its
-    nodes are not up-to-date, as they will be automatically upgraded.
-    """
-    meshroom.core.initNodes()
-    meshroom.core.initPipelines()
-
-    assert len(pipelineTemplates) >= 1
+def checkTemplateVersions(path: str, nodesAlreadyLoaded: bool = False) -> bool:
+    """ Check whether there is a compatibility issue with the nodes saved in the template provided with "path". """
+    if not nodesAlreadyLoaded:
+        meshroom.core.initNodes()
 
-    for _, path in pipelineTemplates.items():
-        with open(path) as jsonFile:
-            fileData = json.load(jsonFile)
+    with open(path) as jsonFile:
+        fileData = json.load(jsonFile)
 
+    try:
         graphData = fileData.get(GraphIO.Keys.Graph, fileData)
-
-        assert isinstance(graphData, dict)
+        if not isinstance(graphData, dict):
+            return False
 
         header = fileData.get(GraphIO.Keys.Header, {})
-        assert header.get("template", False)
+        if not header.get("template", False):
+            return False
         nodesVersions = header.get(GraphIO.Keys.NodesVersions, {})
 
         for _, nodeData in graphData.items():
             nodeType = nodeData["nodeType"]
-            assert nodeType in meshroom.core.nodesDesc
+            if not nodeType in meshroom.core.nodesDesc:
+                return False
 
             nodeDesc = meshroom.core.nodesDesc[nodeType]
             currentNodeVersion = meshroom.core.nodeVersion(nodeDesc)
 
             inputs = nodeData.get("inputs", {})
             internalInputs = nodeData.get("internalInputs", {})
             version = nodesVersions.get(nodeType, None)
 
             compatibilityIssue = None
 
             if version and currentNodeVersion and Version(version).major != Version(currentNodeVersion).major:
                 compatibilityIssue = CompatibilityIssue.VersionConflict
             else:
                 for attrName, value in inputs.items():
                     if not CompatibilityNode.attributeDescFromName(nodeDesc.inputs, attrName, value):
                         compatibilityIssue = CompatibilityIssue.DescriptionConflict
                         break
                 for attrName, value in internalInputs.items():
                     if not CompatibilityNode.attributeDescFromName(nodeDesc.internalInputs, attrName, value):
                         compatibilityIssue = CompatibilityIssue.DescriptionConflict
                         break
 
-            assert compatibilityIssue is None, "{} in {} for node {}".format(compatibilityIssue, path, nodeType)
+            if compatibilityIssue is not None:
+                print("{} in {} for node {}".format(compatibilityIssue, path, nodeType))
+                return False
+
+        return True
+
+    finally:
+        if not nodesAlreadyLoaded:
+            nodeTypes = [nodeType for _, nodeType in meshroom.core.nodesDesc.items()]
+            for nodeType in nodeTypes:
+                unregisterNodeType(nodeType)
+
+
+def checkAllTemplatesVersions() -> bool:
+    meshroom.core.initNodes()
+    meshroom.core.initPipelines()
+
+    validVersions = []
+    for _, path in pipelineTemplates.items():
+        validVersions.append(checkTemplateVersions(path, nodesAlreadyLoaded=True))
+
+    return all(validVersions)