Fix: Harden History replay and recomputation consistency

Post-merge auditing exposed cases where plugin provenance could be lost during
History operations, partial recomputation failures could leave outputs in an
inconsistent state, and multi-action edits could replay dependent work more than
once. History execution now preserves feature identity, reports failures
explicitly, and applies dependent updates in a deterministic, transactional way.

* [FIX] : Preserve plugin origins when replaying actions, remapping metadata,
  recomputing transformations, and refreshing analyses
* [FIX] : Stop dependent cascades after failed actions and keep affected
  actions stale while allowing independent branches to continue
* [FIX] : Validate multi-output recomputation before updating objects and
  roll back all outputs when an update cannot be completed
* [FIX] : Isolate multi-object analysis persistence failures, continue with
  remaining objects, and distinguish empty results from failed execution
* [CHG] : Deduplicate and globally order multi-action edits, restore action
  state on cancellation, and cascade analyses after upstream changes
* [NEW] : Add regression coverage for plugin provenance, transactional
  recomputation, cascade failures, and multi-action History edits
* [CHG] : Synchronize French translations for recomputation failure messages

Author: dappham-CODRA

datalab/adapters_metadata/common.py

@@ -55,6 +55,7 @@ class ResultData:
     results: list[BaseResultAdapter] | None = None
     ylabels: list[str] | None = None
     short_ids: list[str] | None = None
+    execution_success: bool = True
 
     def __bool__(self) -> bool:
         """Return True if there are results stored"""

datalab/gui/panel/base.py

@@ -895,7 +895,7 @@ def apply_analysis_parameters(
         obj: SignalObj | ImageObj | None = None,
         interactive: bool = True,
         param: gds.DataSet | None = None,
-    ) -> None:
+    ) -> bool:
         """Apply analysis parameters: re-run the 1-to-0 analysis in place.
 
         Args:
@@ -911,7 +911,7 @@ def apply_analysis_parameters(
         editor = self.analysis_param_editor
         obj = obj or self.current_analysis_obj
         if obj is None:
-            return
+            return False
 
         # Extract analysis parameters
         proc_params = extract_analysis_parameters(obj)
@@ -920,7 +920,7 @@ def apply_analysis_parameters(
                 QW.QMessageBox.warning(
                     self, _("Error"), _("Analysis metadata is incomplete.")
                 )
-            return
+            return False
 
         func_name = proc_params.func_name
 
@@ -929,21 +929,22 @@ def apply_analysis_parameters(
         # the stored analysis parameters.
         if param is None:
             param = editor.dataset if editor is not None else proc_params.param
+        recompute_param = copy.deepcopy(param)
 
         # Disable ROI creation during re-analysis: detection functions store
         # create_rois=True in their parameters, but re-running should only
         # update analysis results, not recreate ROIs (which would make them
         # impossible to delete or modify).
-        if hasattr(param, "create_rois"):
-            param.create_rois = False
+        if hasattr(recompute_param, "create_rois"):
+            recompute_param.create_rois = False
 
         # Re-run the analysis in place (no history entry: runs under replaying)
         processor = self.__get_processor_associated_to(obj)
         try:
-            processor.recompute_1_to_0(
+            success = processor.recompute_1_to_0(
                 func_name,
                 obj,
-                param,
+                recompute_param,
                 plugin_origin=proc_params.plugin_origin,
             )
         except Exception as exc:  # pylint: disable=broad-exception-caught
@@ -954,7 +955,13 @@ def apply_analysis_parameters(
                 _("Error"),
                 _("Failed to recompute analysis:\n%s") % str(exc),
             )
-            return
+            return False
+        if not success:
+            if interactive:
+                QW.QMessageBox.warning(
+                    self, _("Error"), _("Failed to recompute analysis.")
+                )
+            return False
 
         # Propagate the edited param to the History panel: mutate the matching
         # analysis action (snapshot originals first) and refresh its tree
@@ -965,7 +972,7 @@ def apply_analysis_parameters(
             action = hpanel.find_analysis_action(get_uuid(obj), func_name)
             if action is not None:
                 action.snapshot_kwargs()
-                action.kwargs["param"] = copy.deepcopy(param)
+                action.kwargs["param"] = copy.deepcopy(recompute_param)
                 hpanel.refresh_action(action)
 
         # Refresh the object display after re-analysis
@@ -983,6 +990,7 @@ def apply_analysis_parameters(
                 self.current_analysis_obj, set_current=True
             ),
         )
+        return True
 
     def __get_processor_associated_to(
         self, obj: SignalObj | ImageObj
@@ -3111,23 +3119,54 @@ def recompute_1_to_1_objects(
                         return recomputed_uuids, True
         return recomputed_uuids, False
 
-    def recompute_1_to_0_objects(self, objects: list[SignalObj | ImageObj]) -> None:
+    def recompute_1_to_0_objects(
+        self, objects: list[SignalObj | ImageObj]
+    ) -> tuple[set[str], bool]:
         """Recompute 1-to-0 analysis operations for the given objects.
 
         Args:
             objects: Objects with stored 1-to-0 analysis parameters
         """
         if not objects:
-            return
+            return set(), False
+        recomputed_uuids: set[str] = set()
         with create_progress_bar(
             self, _("Recomputing analyses"), max_=len(objects)
         ) as progress:
             for index, obj in enumerate(objects):
                 progress.setValue(index + 1)
                 QW.QApplication.processEvents()
                 if progress.wasCanceled():
-                    break
-                self.processor.recompute_analysis(obj)
+                    return recomputed_uuids, True
+                try:
+                    success = self.processor.recompute_analysis(obj)
+                    message = _("Analysis computation failed.")
+                except Exception as exc:  # pylint: disable=broad-exception-caught
+                    success = False
+                    message = str(exc)
+                if success:
+                    recomputed_uuids.add(get_uuid(obj))
+                    continue
+                if execenv.unattended:
+                    continue
+                failtxt = _("Failed to recompute analysis")
+                if index == len(objects) - 1:
+                    QW.QMessageBox.warning(
+                        self,
+                        _("Recompute"),
+                        f"{failtxt} '{obj.title}':\n{message}",
+                    )
+                else:
+                    conttxt = _("Do you want to continue with the next object?")
+                    answer = QW.QMessageBox.warning(
+                        self,
+                        _("Recompute"),
+                        f"{failtxt} '{obj.title}':\n{message}\n\n{conttxt}",
+                        QW.QMessageBox.Yes | QW.QMessageBox.No,
+                    )
+                    if answer == QW.QMessageBox.No:
+                        return recomputed_uuids, True
+        return recomputed_uuids, False
 
     def select_source_objects(self) -> None:
         """Select source objects associated with the selected object's processing.

datalab/gui/panel/history/chainmodel.py

@@ -150,6 +150,7 @@ def remap_processing_parameters(
         param=parameters.param,
         source_uuid=source_uuid,
         source_uuids=source_uuids,
+        plugin_origin=parameters.plugin_origin,
     )
 
 

datalab/gui/panel/history/interactive_replay.py

@@ -14,8 +14,10 @@
 
 from datalab.config import _
 from datalab.env import execenv
+from datalab.gui.panel.history import chain as hchain
 from datalab.gui.panel.history import recompute as hrec
 from datalab.history import HistoryAction, HistorySession
+from datalab.history.core import copy_history_value
 
 if TYPE_CHECKING:
     from datalab.gui.panel.history.panel import HistoryPanel
@@ -124,11 +126,13 @@ def prompt_edit_action_params(
 
 
 def edit_mode_replay_actions(panel: HistoryPanel, actions: list[HistoryAction]) -> None:
-    """Edit and recompute only the selected actions, in session order.
+    """Edit selected actions and recompute their affected branches once.
 
-    Each selected action gets exactly one parameter dialog; non-selected
-    downstream actions are left untouched (no automatic cascade). A
-    re-entrance guard prevents nested prompt loops.
+    Each selected action gets exactly one parameter dialog. Recomputable
+    selected actions are always included, while accepted parameter edits also
+    include all downstream dependent actions. The resulting global plan is
+    deduplicated and executed in session order. A re-entrance guard prevents
+    nested prompt loops.
     """
     # Deduplicate and sort the selected actions in their session order
     ordered = order_selected_actions(panel, actions)
@@ -137,8 +141,16 @@ def edit_mode_replay_actions(panel: HistoryPanel, actions: list[HistoryAction])
     with panel.runtime.execution.replaying_edits() as started:
         if not started:
             return
+        entry_states = {
+            action.uuid: (
+                copy_history_value(action.kwargs),
+                copy_history_value(action.saved_kwargs),
+            )
+            for action in ordered
+        }
         edited_actions: list[HistoryAction] = []
         recomputable: list[HistoryAction] = []
+        deferred_actions: list[HistoryAction] = []
         for action in ordered:
             is_creation = (
                 action.kind == HistoryAction.KIND_UI
@@ -148,26 +160,54 @@ def edit_mode_replay_actions(panel: HistoryPanel, actions: list[HistoryAction])
                 action.kind == HistoryAction.KIND_COMPUTE and action.pattern is not None
             )
             if not is_creation and not is_compute:
-                with panel.replaying(), panel.output_suppressed():
-                    action.replay(panel.mainwindow, restore_selection=True, edit=True)
+                deferred_actions.append(action)
                 continue
             result = prompt_edit_action_params(panel, action)
             if result is False:
-                for done in edited_actions:
-                    done.restore_kwargs()
-                    panel.tree.refresh_action_item(done)
+                for selected_action in ordered:
+                    kwargs, saved_kwargs = entry_states[selected_action.uuid]
+                    selected_action.kwargs = kwargs
+                    selected_action.saved_kwargs = saved_kwargs
+                    panel.tree.refresh_action_item(selected_action)
                 return
             if result is True:
                 edited_actions.append(action)
             recomputable.append(action)
 
         for action in edited_actions:
             panel.tree.refresh_action_item(action)
-        for action in recomputable:
-            hrec.recompute_action_in_place(panel, action)
+        planned = list(recomputable)
+        for action in edited_actions:
+            planned.extend(hchain.get_downstream_actions(panel, action))
+        planned = order_selected_actions(panel, planned)
+        execution_plan = order_selected_actions(panel, deferred_actions + planned)
+        for action in planned:
+            action.is_stale = True
             panel.tree.refresh_action_item(action)
-        if edited_actions:
-            hrec.recompute_cascade(panel, edited_actions[0])
+        QW.QApplication.processEvents()
+        blocked_outputs: set[str] = set()
+        try:
+            for action in execution_plan:
+                if action in deferred_actions:
+                    with panel.replaying(), panel.output_suppressed():
+                        action.replay(
+                            panel.mainwindow, restore_selection=True, edit=True
+                        )
+                    continue
+                if hchain.action_consumes_any(action, blocked_outputs):
+                    blocked_outputs.update(
+                        panel.runtime.objects.action_output_uuids.get(action.uuid, [])
+                    )
+                    continue
+                success = hrec.recompute_action_in_place(panel, action)
+                action.is_stale = not success
+                panel.tree.refresh_action_item(action)
+                if not success:
+                    blocked_outputs.update(
+                        panel.runtime.objects.action_output_uuids.get(action.uuid, [])
+                    )
+        finally:
+            hrec.flush_cascade_warnings(panel)
         QW.QApplication.processEvents()
 
 
@@ -214,6 +254,11 @@ def restore_action_params(
             continue
         action.restore_kwargs()
         panel.tree.refresh_action_item(action)
-        hrec.recompute_action_in_place(panel, action)
-        hrec.recompute_cascade(panel, action)
+        success = hrec.recompute_action_in_place(panel, action)
+        action.is_stale = not success
+        panel.tree.refresh_action_item(action)
+        if not success:
+            break
+        if not isinstance(item, HistorySession):
+            hrec.recompute_cascade(panel, action)
     panel.ui.update_actions_state()