Rework radar system

python_app/gui/controllers/history_controller.py

@@ -0,0 +1,71 @@
+"""Retained acquisitions and pending processor-history deletions."""
+
+from __future__ import annotations
+
+from collections import deque
+from itertools import chain
+import time
+from typing import TypeVar
+
+from python_app.gui.settings_defaults import GUI_SAVE_HISTORY_LIMIT
+from python_app.gui.runtime.history import record_result_history
+from python_app.models.collection_identity import CollectionIdentity, collection_key, history_collection_removed
+from python_app.models.dataset_model import ResultCollection, SweepCollection
+
+_Collection = TypeVar("_Collection", SweepCollection, ResultCollection)
+
+
+def _remove_acquisition(history: deque[_Collection], key: tuple[int, int]) -> None:
+    retained = [item for item in history if collection_key(item) != key]
+    history.clear()
+    history.extend(retained)
+
+
+class HistoryController:
+    """Own GUI history without opening rings, starting workers, or drawing plots."""
+
+    def __init__(self, limit: int = GUI_SAVE_HISTORY_LIMIT) -> None:
+        self.raw: deque[SweepCollection] = deque(maxlen=limit)
+        self.preprocessed: deque[SweepCollection] = deque(maxlen=limit)
+        self.results: deque[ResultCollection] = deque(maxlen=limit)
+        self.replay_results: list[ResultCollection] = []
+        self.run_signature: tuple[object, ...] | None = None
+        self.clear_before_ns = 0
+        self.removed: list[dict[str, int]] = []
+
+    def is_removed(self, collection: CollectionIdentity) -> bool:
+        return history_collection_removed(collection, self.clear_before_ns, self.removed)
+
+    def record_result(self, collection: ResultCollection) -> bool:
+        """Replace a recomputed sweep or insert a new one in acquisition order."""
+        return not self.is_removed(collection) and record_result_history(self.results, collection)
+
+    def apply_deletion(self, command: str, target: dict[str, int] | None = None) -> None:
+        """Stage deletions before publishing settings; a failed write must retain them."""
+        if command == "clear_all":
+            self.clear_before_ns = time.monotonic_ns()
+            self.removed.clear()
+        elif command == "remove_last" and target is not None:
+            self.removed.append(dict(target))
+
+    def delete(self, *, remove_last: bool) -> None:
+        """Mutate retained stages and stage their deletion before any external action."""
+        self.replay_results.clear()
+        if not remove_last:
+            self.apply_deletion("clear_all")
+            self.raw.clear()
+            self.preprocessed.clear()
+            self.results.clear()
+            return
+        newest = max(chain(self.raw, self.preprocessed, self.results), key=lambda item: item.capture_start_ns, default=None)
+        if newest is None:
+            return
+        key = collection_key(newest)
+        self.apply_deletion("remove_last", {"collection_id": key[0], "capture_start_ns": key[1]})
+        _remove_acquisition(self.raw, key)
+        _remove_acquisition(self.preprocessed, key)
+        _remove_acquisition(self.results, key)
+
+    def bscan_source(self) -> list[ResultCollection]:
+        """A completed replay contains only the re-fed sweeps with current settings."""
+        return list(self.replay_results or self.results)