Remove request ID and use ViewParams comparison instead

Author: paulromano

openmc_plotter/main_window.py

@@ -1226,7 +1226,7 @@ def requestInitialPlot(self):
 
     def requestPlotUpdate(self, view=None):
         if self.model is None:
-            return None
+            return
         if self.plot_manager is None:
             self.plot_manager = self.model.plot_manager
             self.plot_manager.plot_started.connect(self._on_plot_started)
@@ -1238,44 +1238,42 @@ def requestPlotUpdate(self, view=None):
             view = self.model.activeView
         view_snapshot = copy.deepcopy(view)
         if self.model.can_reuse_maps(view_snapshot):
-            request_id = self.plot_manager.new_request_id()
+            view_params = self.model.view_params_payload(view_snapshot)
+            self.plot_manager.set_latest_view_params(view_params)
             self.plot_manager.clear_pending()
             self.model.makePlot(view_snapshot, self.model.ids_map, self.model.properties)
             self.resetModels()
             self.showCurrentView()
             if not self.plot_manager.is_busy:
                 self._on_plot_idle()
-            return request_id
+            return
         view_params = self.model.view_params_payload(view_snapshot)
-        request_id, started = self.plot_manager.enqueue(view_snapshot, view_params)
+        started = self.plot_manager.enqueue(view_snapshot, view_params)
         if started:
             self.statusBar().showMessage('Generating Plot...')
         else:
             self.statusBar().showMessage('Generating Plot... (update queued)')
-        return request_id
 
     def waitForPlotIdle(self, timeout_ms=None):
         if self.plot_manager is not None:
             return self.plot_manager.wait_for_idle(timeout_ms)
         return True
 
-    def _on_plot_started(self, request_id):
+    def _on_plot_started(self):
         self.busyIndicator.show()
         self.statusBar().showMessage('Generating Plot...')
 
-    def _on_plot_queued(self, request_id):
+    def _on_plot_queued(self):
         self.statusBar().showMessage('Generating Plot... (update queued)')
 
-    def _on_plot_finished(self, request_id, view_snapshot, ids_map, properties):
-        if request_id != self.plot_manager.latest_request_id:
+    def _on_plot_finished(self, view_snapshot, view_params, ids_map, properties):
+        if view_params != self.plot_manager.latest_view_params:
             return
         self.model.makePlot(view_snapshot, ids_map, properties)
         self.resetModels()
         self.showCurrentView()
 
-    def _on_plot_error(self, request_id, error_msg):
-        if request_id != self.plot_manager.latest_request_id:
-            return
+    def _on_plot_error(self, error_msg):
         msg_box = QMessageBox()
         msg_box.setText(f"Failed to generate plot:\n\n{error_msg}")
         msg_box.setIcon(QMessageBox.Warning)

openmc_plotter/plotmodel.py

@@ -105,20 +105,18 @@ def hash_model(model_path):
 
 @dataclass(frozen=True)
 class PlotRequest:
-    request_id: int
     view_snapshot: "PlotView"
     view_params: Dict[str, object]
 
 
 @dataclass(frozen=True)
 class PlotWorkItem:
-    request_id: int
     view_params: Dict[str, object]
 
 
 class PlotWorker(QObject):
-    finished = Signal(int, object, object)
-    error = Signal(int, str)
+    finished = Signal(object, object, object)
+    error = Signal(str)
 
     @Slot(object)
     def generate_maps(self, work_item: PlotWorkItem):
@@ -133,16 +131,16 @@ def generate_maps(self, work_item: PlotWorkItem):
             view_param.color_overlaps = params["color_overlaps"]
             ids_map = openmc.lib.id_map(view_param)
             properties = openmc.lib.property_map(view_param)
-            self.finished.emit(work_item.request_id, ids_map, properties)
+            self.finished.emit(work_item.view_params, ids_map, properties)
         except Exception as exc:
-            self.error.emit(work_item.request_id, str(exc))
+            self.error.emit(str(exc))
 
 
 class PlotManager(QObject):
-    plot_started = Signal(int)
-    plot_queued = Signal(int)
-    plot_finished = Signal(int, object, object, object)
-    plot_error = Signal(int, str)
+    plot_started = Signal()
+    plot_queued = Signal()
+    plot_finished = Signal(object, object, object, object)
+    plot_error = Signal(str)
     plot_idle = Signal()
     work_requested = Signal(object)
 
@@ -159,12 +157,11 @@ def __init__(self):
 
         self._pending_request = None
         self._in_flight_request = None
-        self._latest_request_id = 0
-        self._next_request_id = 1
+        self._latest_view_params = None
 
     @property
-    def latest_request_id(self):
-        return self._latest_request_id
+    def latest_view_params(self):
+        return self._latest_view_params
 
     @property
     def is_busy(self):
@@ -175,22 +172,18 @@ def has_pending(self):
         return self._pending_request is not None
 
     def enqueue(self, view_snapshot, view_params):
-        request = PlotRequest(self._next_request_id, view_snapshot, view_params)
-        self._next_request_id += 1
-        self._latest_request_id = request.request_id
+        request = PlotRequest(view_snapshot, view_params)
+        self._latest_view_params = view_params
         if self._in_flight_request is None:
             self._pending_request = request
             self._start_next()
-            return request.request_id, True
+            return True
         self._pending_request = request
-        self.plot_queued.emit(request.request_id)
-        return request.request_id, False
+        self.plot_queued.emit()
+        return False
 
-    def new_request_id(self):
-        request_id = self._next_request_id
-        self._next_request_id += 1
-        self._latest_request_id = request_id
-        return request_id
+    def set_latest_view_params(self, view_params):
+        self._latest_view_params = view_params
 
     def clear_pending(self):
         self._pending_request = None
@@ -227,27 +220,26 @@ def _start_next(self):
             return
         self._in_flight_request = self._pending_request
         self._pending_request = None
-        self.plot_started.emit(self._in_flight_request.request_id)
-        work_item = PlotWorkItem(self._in_flight_request.request_id,
-                                 self._in_flight_request.view_params)
+        self.plot_started.emit()
+        work_item = PlotWorkItem(self._in_flight_request.view_params)
         self.work_requested.emit(work_item)
 
-    @Slot(int, object, object)
-    def _on_worker_finished(self, request_id, ids_map, properties):
+    @Slot(object, object, object)
+    def _on_worker_finished(self, view_params, ids_map, properties):
         request = self._in_flight_request
         self._in_flight_request = None
         if request is not None:
-            self.plot_finished.emit(request_id, request.view_snapshot,
-                                    ids_map, properties)
+            self.plot_finished.emit(request.view_snapshot,
+                                    view_params, ids_map, properties)
         if self._pending_request is not None:
             self._start_next()
         else:
             self.plot_idle.emit()
 
-    @Slot(int, str)
-    def _on_worker_error(self, request_id, message):
+    @Slot(str)
+    def _on_worker_error(self, message):
         self._in_flight_request = None
-        self.plot_error.emit(request_id, message)
+        self.plot_error.emit(message)
         if self._pending_request is not None:
             self._start_next()
         else: