[core] node: rename cmdVars into expVars

Make a clear difference between the variables needed for expressions and
the ones needed for the command line nodes.

Author: fabiencastan

meshroom/core/attribute.py

@@ -131,11 +131,11 @@ def _getEvalValue(self):
             env = self.node.nodePlugin.configFullEnv if self.node.nodePlugin else os.environ
             substituted = Template(self.value).safe_substitute(env)
             try:
-                varResolved = substituted.format(**self.node._cmdVars, **self.node._staticCmdVars)
+                varResolved = substituted.format(**self.node._expVars, **self.node._staticExpVars)
                 return varResolved
             except (KeyError, IndexError):
                 # Catch KeyErrors and IndexErros to be able to open files created prior to the
-                # support of relative variables (when self.node._cmdVars was not used to evaluate
+                # support of relative variables (when self.node._expVars was not used to evaluate
                 # expressions in the attribute)
                 return substituted
         return self.value

meshroom/core/desc/node.py

@@ -306,7 +306,7 @@ def buildCommandLine(self, chunk) -> str:
         if chunk.node.isParallelized and chunk.node.size > 1:
             cmdSuffix = " " + self.commandLineRange.format(**chunk.range.toDict()) + " " + cmdSuffix
 
-        return cmdPrefix + chunk.node.nodeDesc.commandLine.format(**chunk.node._cmdVars, **chunk.node._staticCmdVars, **cmdLineVars) + cmdSuffix
+        return cmdPrefix + chunk.node.nodeDesc.commandLine.format(**chunk.node._expVars, **chunk.node._staticExpVars, **cmdLineVars) + cmdSuffix
 
     def processChunk(self, chunk):
         cmd = self.buildCommandLine(chunk)

meshroom/core/node.py

@@ -681,7 +681,7 @@ def __init__(self, nodeType: str, position: Position = None, parent: BaseObject
         self.dirty: bool = True  # whether this node's outputs must be re-evaluated on next Graph update
         self._chunks = ListModel(parent=self)
         self._uid: str = uid
-        self._cmdVars: dict = {}
+        self._expVars: dict = {}
         self._size: int = 0
         self._logManager: Optional[LogManager] = None
         self._position: Position = position or Position()
@@ -695,7 +695,7 @@ def __init__(self, nodeType: str, position: Position = None, parent: BaseObject
 
         self.globalStatusChanged.connect(self.updateDuplicatesStatusAndLocked)
 
-        self._staticCmdVars = {
+        self._staticExpVars = {
             "nodeType": self.nodeType,
             "nodeSourceCodeFolder": self.sourceCodeFolder
         }
@@ -965,24 +965,24 @@ def _computeInternalFolder(self, cacheDir):
             nodeType=self.nodeType,
             uid=self._uid)
 
-    def _buildCmdVars(self):
+    def _buildExpVars(self):
         """
         Generate command variables using input attributes and resolved output attributes
         names and values.
         """
-        def _buildAttributeCmdVars(cmdVars, name, attr):
+        def _buildAttributeExpVars(expVars, name, attr):
             if attr.enabled:
                 # xxValue is exposed without quotes to allow to compose expressions
-                cmdVars[name + "Value"] = attr.getValueStr(withQuotes=False)
+                expVars[name + "Value"] = attr.getValueStr(withQuotes=False)
 
                 if isinstance(attr, GroupAttribute):
                     assert isinstance(attr.value, DictModel)
                     # If the GroupAttribute is not set in a single command line argument,
                     # the sub-attributes may need to be exposed individually
                     for v in attr._value:
-                        _buildAttributeCmdVars(cmdVars, v.name, v)
+                        _buildAttributeExpVars(expVars, v.name, v)
 
-        self._cmdVars = {
+        self._expVars = {
             "uid": self._uid,
             "nodeCacheFolder": self._internalFolder,
         }
@@ -991,16 +991,16 @@ def _buildAttributeCmdVars(cmdVars, name, attr):
         for name, attr in self._attributes.objects.items():
             if attr.isOutput:
                 continue  # skip outputs
-            _buildAttributeCmdVars(self._cmdVars, name, attr)
+            _buildAttributeExpVars(self._expVars, name, attr)
 
         # For updating output attributes invalidation values
-        cmdVarsNoCache = self._cmdVars.copy()
-        cmdVarsNoCache["cache"] = ""
+        expVarsNoCache = self._expVars.copy()
+        expVarsNoCache["cache"] = ""
 
         # Use "self._internalFolder" instead of "self.internalFolder" because we do not want it to
         # be resolved with the {cache} information ("self.internalFolder" resolves
         # "self._internalFolder")
-        cmdVarsNoCache["nodeCacheFolder"] = self._internalFolderExp.format(**cmdVarsNoCache, **self._staticCmdVars)
+        expVarsNoCache["nodeCacheFolder"] = self._internalFolderExp.format(**expVarsNoCache, **self._staticExpVars)
 
         # Evaluate output params
         for name, attr in self._attributes.objects.items():
@@ -1022,8 +1022,8 @@ def _buildAttributeCmdVars(cmdVars, name, attr):
                                         format(nodeName=self.name, attrName=attr.name))
                     if defaultValue is not None:
                         try:
-                            attr.value = defaultValue.format(**self._cmdVars)
-                            attr._invalidationValue = defaultValue.format(**cmdVarsNoCache)
+                            attr.value = defaultValue.format(**self._expVars)
+                            attr._invalidationValue = defaultValue.format(**expVarsNoCache)
                         except KeyError as e:
                             logging.warning('Invalid expression with missing key on "{nodeName}.{attrName}" with '
                                             'value "{defaultValue}".\nError: {err}'.
@@ -1036,7 +1036,7 @@ def _buildAttributeCmdVars(cmdVars, name, attr):
                                             err=str(e)))
 
             # xxValue is exposed without quotes to allow to compose expressions
-            self._cmdVars[name + 'Value'] = attr.getValueStr(withQuotes=False)
+            self._expVars[name + 'Value'] = attr.getValueStr(withQuotes=False)
 
 
     def createCmdLineVars(self):
@@ -1332,7 +1332,7 @@ def updateInternals(self, cacheDir=None):
         # Update command variables / output attributes
         self._computeUid()
         self._computeInternalFolder(cacheDir)
-        self._buildCmdVars()
+        self._buildExpVars()
         if self.nodeDesc:
             self.nodeDesc.postUpdate(self)
         # Notify internal folder change if needed

tests/test_nodeCommandLineFormatting.py

@@ -138,52 +138,52 @@ def test_formatting_listOfFiles(self):
 
         # Values are not retrieved as strings in the command line, so quotes around them are
         # not expected
-        assert node._cmdVars["imagesValue"] == \
+        assert node._expVars["imagesValue"] == \
             'single value with space {} {}'.format(inputImages[0],
                                                    inputImages[1])
 
     def test_formatting_strings(self):
         graph = Graph("")
         node = graph.addNewNode("NodeWithAttributesNeedingFormatting")
-        node._buildCmdVars()
+        node._buildExpVars()
 
         # Assert an empty File attribute generates empty quotes when requesting its value as
         # a string
         assert node.input.getValueStr() == '""'
-        assert node._cmdVars["inputValue"] == ""
+        assert node._expVars["inputValue"] == ""
 
         # Assert a Choice attribute with a non-empty default value is surrounded with quotes
         # when requested as a string
         assert node.method.getValueStr() == '"MethodC"'
-        assert node._cmdVars["methodValue"] == "MethodC"
+        assert node._expVars["methodValue"] == "MethodC"
 
         # Assert that the empty list is really empty (no quotes)
         assert node.images.getValueStr() == ""
-        assert node._cmdVars["imagesValue"] == "", "Empty list should become fully empty"
+        assert node._expVars["imagesValue"] == "", "Empty list should become fully empty"
 
         # Assert that the list with one empty value generates empty quotes
         node.images.extend("")
         assert node.images.getValueStr() == '""', \
             "A list with one empty string should generate empty quotes"
-        assert node._cmdVars["imagesValue"] == "", \
+        assert node._expVars["imagesValue"] == "", \
             "The value is always only the value, so empty here"
 
         # Assert that a list with 2 empty strings generates quotes
         node.images.extend("")
         assert node.images.getValueStr() == '"" ""', \
             "A list with 2 empty strings should generate quotes"
-        assert node._cmdVars["imagesValue"] == ' ', \
+        assert node._expVars["imagesValue"] == ' ', \
             "The value is always only the value, so 2 empty strings with the " \
             "space separator in the middle"
 
     def test_formatting_groups(self):
         graph = Graph("")
         node = graph.addNewNode("NodeWithAttributesNeedingFormatting")
-        node._buildCmdVars()
+        node._buildExpVars()
 
         assert node.firstGroup.getValueStr() == '"False:3"'
-        assert node._cmdVars["firstGroupValue"] == 'False:3', \
+        assert node._expVars["firstGroupValue"] == 'False:3', \
             "There should be no quotes here as the value is not formatted as a string"
 
         assert node.secondGroup.getValueStr() == '"False,second_value,3.0"'
-        assert node._cmdVars["secondGroupValue"] == 'False,second_value,3.0'
+        assert node._expVars["secondGroupValue"] == 'False,second_value,3.0'