[core] Graph: cleanup unused methods

meshroom/core/graph.py

@@ -371,139 +371,6 @@ def _evaluateUidConflicts(self, graphContent: dict):
                 n = nodeFactory(nodeData, nodeName)
                 self._addNode(n, nodeName)
 
-    def updateImportedProject(self, data):
-        """
-        Update the names and links of the project to import so that it can fit
-        correctly in the existing graph.
-
-        Parse all the nodes from the project that is going to be imported.
-        If their name already exists in the graph, replace them with new names,
-        then parse all the nodes' inputs/outputs to replace the old names with
-        the new ones in the links.
-
-        Args:
-            data (dict): the dictionary containing all the nodes to import and their data
-
-        Returns:
-            updatedData (dict): the dictionary containing all the nodes to import with their updated names and data
-        """
-        nameCorrespondences = {}  # maps the old node name to its updated one
-        updatedData = {}  # input data with updated node names and links
-
-        def createUniqueNodeName(nodeNames, inputName):
-            """
-            Create a unique name that does not already exist in the current graph or in the list
-            of nodes that will be imported.
-            """
-            i = 1
-            while i:
-                newName = "{name}_{index}".format(name=inputName, index=i)
-                if newName not in nodeNames and newName not in updatedData.keys():
-                    return newName
-                i += 1
-
-        # First pass to get all the names that already exist in the graph, update them, and keep track of the changes
-        for nodeName, nodeData in sorted(data.items(), key=lambda x: self.getNodeIndexFromName(x[0])):
-            if not isinstance(nodeData, dict):
-                raise RuntimeError('updateImportedProject error: Node is not a dict.')
-
-            if nodeName in self._nodes.keys() or nodeName in updatedData.keys():
-                newName = createUniqueNodeName(self._nodes.keys(), nodeData["nodeType"])
-                updatedData[newName] = nodeData
-                nameCorrespondences[nodeName] = newName
-
-            else:
-                updatedData[nodeName] = nodeData
-
-        newNames = [nodeName for nodeName in updatedData]  # names of all the nodes that will be added
-
-        # Second pass to update all the links in the input/output attributes for every node with the new names
-        for nodeName, nodeData in updatedData.items():
-            nodeType = nodeData.get("nodeType", None)
-            nodeDesc = meshroom.core.nodesDesc[nodeType]
-
-            inputs = nodeData.get("inputs", {})
-            outputs = nodeData.get("outputs", {})
-
-            if inputs:
-                inputs = self.updateLinks(inputs, nameCorrespondences)
-                inputs = self.resetExternalLinks(inputs, nodeDesc.inputs, newNames)
-                updatedData[nodeName]["inputs"] = inputs
-            if outputs:
-                outputs = self.updateLinks(outputs, nameCorrespondences)
-                outputs = self.resetExternalLinks(outputs, nodeDesc.outputs, newNames)
-                updatedData[nodeName]["outputs"] = outputs
-
-        return updatedData
-
-    @staticmethod
-    def updateLinks(attributes, nameCorrespondences):
-        """
-        Update all the links that refer to nodes that are going to be imported and whose
-        names have to be updated.
-
-        Args:
-            attributes (dict): attributes whose links need to be updated
-            nameCorrespondences (dict): node names to replace in the links with the name to replace them with
-
-        Returns:
-            attributes (dict): the attributes with all the updated links
-        """
-        for key, val in attributes.items():
-            for corr in nameCorrespondences.keys():
-                if isinstance(val, str) and corr in val:
-                    attributes[key] = val.replace(corr, nameCorrespondences[corr])
-                elif isinstance(val, list):
-                    for v in val:
-                        if isinstance(v, str):
-                            if corr in v:
-                                val[val.index(v)] = v.replace(corr, nameCorrespondences[corr])
-                        else:  # the list does not contain strings, so there cannot be links to update
-                            break
-                    attributes[key] = val
-
-        return attributes
-
-    @staticmethod
-    def resetExternalLinks(attributes, nodeDesc, newNames):
-        """
-        Reset all links to nodes that are not part of the nodes which are going to be imported:
-        if there are links to nodes that are not in the list, then it means that the references
-        are made to external nodes, and we want to get rid of those.
-
-        Args:
-            attributes (dict): attributes whose links might need to be reset
-            nodeDesc (list): list with all the attributes' description (including their default value)
-            newNames (list): names of the nodes that are going to be imported; no node name should be referenced
-                             in the links except those contained in this list
-
-        Returns:
-            attributes (dict): the attributes with all the links referencing nodes outside those which will be imported
-                               reset to their default values
-        """
-        for key, val in attributes.items():
-            defaultValue = None
-            for desc in nodeDesc:
-                if desc.name == key:
-                    defaultValue = desc.value
-                    break
-
-            if isinstance(val, str):
-                if Attribute.isLinkExpression(val) and not any(name in val for name in newNames):
-                    if defaultValue is not None:  # prevents from not entering condition if defaultValue = ''
-                        attributes[key] = defaultValue
-
-            elif isinstance(val, list):
-                removedCnt = len(val)  # counter to know whether all the list entries will be deemed invalid
-                tmpVal = list(val)  # deep copy to ensure we iterate over the entire list (even if elements are removed)
-                for v in tmpVal:
-                    if isinstance(v, str) and Attribute.isLinkExpression(v) and not any(name in v for name in newNames):
-                        val.remove(v)
-                        removedCnt -= 1
-                if removedCnt == 0 and defaultValue is not None:  # if all links were wrong, reset the attribute
-                    attributes[key] = defaultValue
-
-        return attributes
 
     def importGraphContentFromFile(self, filepath: PathLike) -> list[Node]:
         """Import the content (nodes and edges) of another Graph file into this Graph instance.