[core] node: Add chunkPlaceholder property

`chunkPlaceholder` is a list model that is meant to contain a placeholder
chunk for nodes that have dynamic chunks: prior to the chunks' creation,
it is used to reflect the state of the node as a single chunk.

In particular, this allows to reflect accurately the node's status while
it is submitted but the chunks have not been created yet.

The property is a list model as it allows it to be used as a model later
on on the QML side.

Author: cbentejac

meshroom/core/node.py

@@ -567,9 +567,9 @@ def upgradeStatusFile(self):
         Upgrade node status file based on the current status.
         """
         self.saveStatusFile()
-        self.statusChanged.emit()
         # We want to make sure the nodeStatus is up to date too
         self.node.upgradeStatusFile()
+        self.statusChanged.emit()
 
     def upgradeStatusTo(self, newStatus, execMode=None):
         if newStatus.value < self._status.status.value:
@@ -798,6 +798,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: list[NodeChunk] = ListModel(parent=self)
         self._chunksCreated = False  # Only initialize chunks on compute
+        self._chunkPlaceholder: list[NodeChunk] = ListModel(parent=self)  # Placeholder chunk for nodes with dynamic ones
         self._uid: str = uid
         self._expVars: dict = {}
         self._size: int = 0
@@ -1363,6 +1364,11 @@ def upgradeStatusTo(self, newStatus, execMode=None):
                 self._nodeStatus.execMode = execMode
             self._nodeStatus.status = newStatus
             self.upgradeStatusFile()
+            chunkPlaceholder = NodeChunk(self, desc.computation.Range())
+            chunkPlaceholder._status.execMode = self._nodeStatus.execMode
+            chunkPlaceholder._status.status = self._nodeStatus.status
+            self.chunkPlaceholder.setObjectList([chunkPlaceholder])
+            self.chunksChanged.emit()
         self.globalStatusChanged.emit()
 
     def updateStatisticsFromCache(self):
@@ -1530,9 +1536,7 @@ def updateNodeStatusFromCache(self):
         return chunksRangeHasChanged
 
     def updateStatusFromCache(self):
-        """
-        Update node status based on status file content/existence.
-        """
+        """ Update node status based on status file content/existence. """
         # Update nodeStatus from cache
         chunkChanged = self.updateNodeStatusFromCache()
         # Create chunks if we found info on them on the node cache
@@ -1541,12 +1545,18 @@ def updateStatusFromCache(self):
             try:
                 self.createChunksFromCache()
             except Exception as e:
-                logging.warning(f"Could not create chunks from cache :{e}")
+                logging.warning(f"Could not create chunks from cache: {e}")
                 return
         s = self.globalStatus
         if self._chunksCreated:
             for chunk in self._chunks:
                 chunk.updateStatusFromCache()
+        else:
+            # Restore placeholder chunk if needed
+            chunkPlaceholder = NodeChunk(self, desc.computation.Range())
+            chunkPlaceholder._status.execMode = self._nodeStatus.execMode
+            chunkPlaceholder._status.status = self._nodeStatus.status
+            self._chunkPlaceholder.setObjectList([chunkPlaceholder])
         # logging.debug(f"updateStatusFromCache: {self.name}, status: {s} => {self.globalStatus}")
         self.updateOutputAttr()
 
@@ -1583,6 +1593,12 @@ def initStatusOnSubmit(self, forceCompute=False):
             self._nodeStatus.initExternSubmit()
             self.upgradeStatusFile()
             self.globalStatusChanged.emit()
+            if self._nodeStatus.execMode == ExecMode.EXTERN and self._nodeStatus.status in (Status.RUNNING, Status.SUBMITTED):
+                chunkPlaceholder = NodeChunk(self, desc.computation.Range())
+                chunkPlaceholder._status.execMode = self._nodeStatus.execMode
+                chunkPlaceholder._status.status = self._nodeStatus.status
+                self._chunkPlaceholder.setObjectList([chunkPlaceholder])
+            self.chunksChanged.emit()
 
     def initStatusOnCompute(self, forceCompute=False):
         hasChunkToLaunch = False
@@ -1599,6 +1615,12 @@ def initStatusOnCompute(self, forceCompute=False):
             self._nodeStatus.initLocalSubmit()
             self.upgradeStatusFile()
             self.globalStatusChanged.emit()
+            if self._nodeStatus.execMode == ExecMode.LOCAL and self._nodeStatus.status in (Status.RUNNING, Status.SUBMITTED):
+                chunkPlaceholder = NodeChunk(self, desc.computation.Range())
+                chunkPlaceholder._status.execMode = self._nodeStatus.execMode
+                chunkPlaceholder._status.status = self._nodeStatus.status
+                self._chunkPlaceholder.setObjectList([chunkPlaceholder])
+            self.chunksChanged.emit()
 
     def processIteration(self, iteration):
         self._chunks[iteration].process()
@@ -2059,6 +2081,7 @@ def _hasDisplayableShape(self):
     chunksCreated = Property(bool, lambda self: self._chunksCreated, notify=chunksCreatedChanged)
     chunksChanged = Signal()
     chunks = Property(Variant, getChunks, notify=chunksChanged)
+    chunkPlaceholder = Property(Variant, lambda self: self._chunkPlaceholder, notify=chunksChanged)
     nbParallelizationBlocks = Property(int, lambda self: len(self._chunks) if self._chunksCreated else 0, notify=chunksChanged)
     sizeChanged = Signal()
     size = Property(int, getSize, notify=sizeChanged)
@@ -2197,7 +2220,7 @@ def toDict(self):
         }
 
     def _resetChunks(self):
-        """ Set chunks on the node
+        """ Set chunks on the node.
         # TODO : Maybe don't delete chunks if we will recreate them as before ?
         """
         if isinstance(self.nodeDesc, desc.InputNode):
@@ -2208,6 +2231,7 @@ def _resetChunks(self):
             chunk.statusChanged.disconnect(self.globalStatusChanged)
         # Empty list
         self._chunks.setObjectList([])
+        self._chunkPlaceholder.setObjectList([])
         # Recreate list with reset values (1 chunk or the static size)
         if not self.isParallelized:
             if not self.nodeDesc.size:
@@ -2235,7 +2259,8 @@ def _resetChunks(self):
         else:
             self._chunksCreated = False
             self.setSize(0)
-            self._chunks.setObjectList([])
+            self._chunkPlaceholder.setObjectList([NodeChunk(self, desc.computation.Range())])
+
         # Create chunks when possible
         self.chunksCreatedChanged.emit()
         self.chunksChanged.emit()
@@ -2271,7 +2296,7 @@ def __createChunks(self, ranges):
         self.chunksCreatedChanged.emit()
 
     def createChunksFromCache(self):
-        """Create chunks when a node cache exists"""
+        """ Create chunks when a node cache exists. """
         try:
             # Get size from cache
             size = self._nodeStatus.nbChunks
@@ -2285,7 +2310,7 @@ def createChunksFromCache(self):
             raise e
 
     def createChunks(self):
-        """Create chunks when computation is about to start"""
+        """ Create chunks when computation is about to start. """
         if self._chunksCreated:
             return
         if isinstance(self.nodeDesc, desc.InputNode):