graphics items refactor: cleaning up methods

src/lifeblood_viewer/graphics_items/__init__.py

@@ -1,4 +1,4 @@
 # export inner classes
-from .graphics_items import Node, Task, NodeConnection, SceneNetworkItemWithUI
+from .graphics_items import Node, Task, NodeConnection
 from .network_item import NetworkItem, NetworkItemWithUI
 from .network_item_watchers import NetworkItemWatcher, WatchableNetworkItem, WatchableNetworkItemProxy

src/lifeblood_viewer/graphics_items/graphics_items.py

@@ -74,7 +74,7 @@ def set_name(self, new_name: str):
         if new_name == self.__name:
             return
         self.__name = new_name
-        self.item_updated(redraw=True, ui=True)
+        self.item_updated()
 
     def set_selected(self, selected: bool, *, unselect_others=False):
         scene: QGraphicsScene = self.graphics_scene()
@@ -90,7 +90,7 @@ def update_nodeui(self, nodeui: NodeUi):
     def reanalyze_nodeui(self):
         Node._node_inputs_outputs_cached[self.__node_type] = (list(self.__nodeui.inputs_names()), list(self.__nodeui.outputs_names()))
         self.__inputs, self.__outputs = Node._node_inputs_outputs_cached[self.__node_type]
-        self.item_updated(redraw=True, ui=True)  # cuz input count affects visualization in the graph
+        self.item_updated()
 
     def get_nodeui(self) -> Optional[NodeUi]:
         return self.__nodeui
@@ -162,15 +162,13 @@ def add_task(self, task: "Task"):
         if task in self.__tasks:
             return
         logger.debug(f"adding task {task.get_id()} to node {self.get_id()}")
-        need_ui_update = self != task.node()
+
         if task.node() and task.node() != self:
             task.node().remove_task(task)
         task._set_parent_node(self)
         self.__tasks.add(task)
-        if need_ui_update:
-            task.item_updated(redraw=False, ui=True)
 
-        self.item_updated(redraw=True, ui=False)  # cuz node displays task number - we should redraw
+        self.item_updated()
 
         if len(self.item_watchers()) > 0:
             task.add_item_watcher(self)
@@ -192,7 +190,7 @@ def remove_tasks(self, tasks_to_remove: Iterable["Task"]):
         # invalidate sorted cache
         self.__tasks_sorted_cached = None
 
-        self.item_updated(redraw=True, ui=False)  # cuz node displays task number - we should redraw
+        self.item_updated()
 
     def remove_task(self, task_to_remove: "Task"):
         logger.debug(f"removing task {task_to_remove.get_id()} from node {self.get_id()}")
@@ -204,7 +202,7 @@ def remove_task(self, task_to_remove: "Task"):
         self.__tasks_sorted_cached = None
 
         self.__tasks.remove(task_to_remove)
-        self.item_updated(redraw=True, ui=False)  # cuz node displays task number - we should redraw
+        self.item_updated()
 
     def _sorted_tasks(self, order: TaskSortOrder) -> List["Task"]:
         if self.__tasks_sorted_cached is None:
@@ -216,7 +214,7 @@ def _sorted_tasks(self, order: TaskSortOrder) -> List["Task"]:
                 raise NotImplementedError(f'sort order {order} is not implemented')
         return self.__tasks_sorted_cached[order]
 
-    def tasks_iter(self, *, order: Optional[TaskSortOrder] = None):
+    def tasks_iter(self, *, order: Optional[TaskSortOrder] = None) -> Iterable["Task"]:
         if order is None:
             return (x for x in self.__tasks)
         return self._sorted_tasks(order)
@@ -369,7 +367,7 @@ def set_name(self, name: str):
         if name == self.__raw_data.name:
             return
         self.__raw_data.name = name
-        self.item_updated(redraw=False, ui=True)
+        self.item_updated()
 
     def state(self) -> TaskState:
         return self.__raw_data.state
@@ -389,7 +387,7 @@ def set_groups(self, groups: Set[str]):
         if self.__raw_data.groups == groups:
             return
         self.__raw_data.groups = groups
-        self.item_updated(redraw=False, ui=True)
+        self.item_updated()
 
     def attributes(self):
         return MappingProxyType(self.__ui_attributes)
@@ -405,7 +403,7 @@ def set_state_details(self, state_details: Optional[str] = None):
             return
         self.__raw_data.state_details = state_details
         self.__state_details_cached = None
-        self.item_updated(redraw=False, ui=True)
+        self.item_updated()
 
     def set_state(self, state: Optional[TaskState], paused: Optional[bool]):
         if (state is None or state == self.__raw_data.state) and (paused is None or self.__raw_data.paused == paused):
@@ -419,15 +417,15 @@ def set_state(self, state: Optional[TaskState], paused: Optional[bool]):
             self.__raw_data.paused = paused
         if self.__node:
             self.__node.task_state_changed(self)
-        self.item_updated(redraw=True, ui=True)
+        self.item_updated()
 
     def set_task_data(self, raw_data: TaskData):
         self.__state_details_cached = None
         state_changed = self.__raw_data.state != raw_data.state
         self.__raw_data = raw_data
         if state_changed and self.__node:
             self.__node.task_state_changed(self)
-            self.item_updated(redraw=True, ui=True)
+            self.item_updated()
 
     def apply_task_delta(self, task_delta: TaskDelta, get_node: Callable[[int], Node]):
         if task_delta.paused is not DataNotSet:
@@ -466,18 +464,18 @@ def apply_task_delta(self, task_delta: TaskDelta, get_node: Callable[[int], Node
             self.__raw_data.parent_id = task_delta.parent_id
         if task_delta.state_details is not DataNotSet:
             self.set_state_details(task_delta.state_details)
-        self.item_updated(redraw=True, ui=True)
+        self.item_updated()
 
     def set_progress(self, progress: float):
         self.__raw_data.progress = progress
         # logger.debug('progress %d', progress)
-        self.item_updated(redraw=True, ui=True)
+        self.item_updated()
 
     def get_progress(self) -> Optional[float]:
         return self.__raw_data.progress if self.__raw_data else None
 
-    def item_updated(self, *, redraw: bool = False, ui: bool = False):
-        super().item_updated(redraw=redraw, ui=ui)
+    def item_updated(self):
+        super().item_updated()
         for watcher in self.item_watchers():
             watcher.item_was_updated(self)
 
@@ -519,7 +517,7 @@ def update_log(self, alllog: Dict[int, Dict[int, Union[IncompleteInvocationLogDa
         # clear cached inverted dict, it will be rebuilt on next access
         self.__reset_cached_invocation_data()
 
-        self.item_updated(redraw=False, ui=True)
+        self.item_updated()
 
     def remove_invocations_log(self, invocation_ids: List[int]):
         logger.debug('removing invocations for %s', invocation_ids)
@@ -531,7 +529,7 @@ def remove_invocations_log(self, invocation_ids: List[int]):
         # clear cached inverted dict, it will be rebuilt on next access
         self.__reset_cached_invocation_data()
 
-        self.item_updated(redraw=False, ui=True)
+        self.item_updated()
 
     def invocations_total_time(self, only_last_per_node: bool = True) -> float:
         """
@@ -575,11 +573,11 @@ def invocation_logs(self) -> List[Tuple[int, int, Union[IncompleteInvocationLogD
     def update_attributes(self, attributes: dict):
         logger.debug('attrs updated with %s', attributes)
         self.__ui_attributes = attributes
-        self.item_updated(redraw=False, ui=True)
+        self.item_updated()
 
     def set_environment_attributes(self, env_attrs: Optional[EnvironmentResolverArguments]):
         self.__ui_env_res_attributes = env_attrs
-        self.item_updated(redraw=False, ui=True)
+        self.item_updated()
 
     def environment_attributes(self) -> Optional[EnvironmentResolverArguments]:
         return self.__ui_env_res_attributes

src/lifeblood_viewer/graphics_items/network_item.py

@@ -9,18 +9,6 @@ def get_id(self):
 
 
 class NetworkItemWithUI(NetworkItem):
-    def item_updated(self, *, redraw: bool = False, ui: bool = False):
-        """
-        should be called when item's state is changed
-        :param redraw: True if item itself redraw is needed
-        :param ui: True if item's parameter ui redraw is needed
-        """
-        if redraw:
-            self.update()
-        if ui:
-            self.update()  # currently contents and UI are drawn always together, so this will do
-            # but in future TODO: invalidate only UI layer
-
     def draw_imgui_elements(self, drawing_widget):
         """
         this should only be called from active opengl context!

src/lifeblood_viewer/graphics_items/pretty_items/decorated_node.py

@@ -15,7 +15,7 @@ def __init__(self, scene: GraphicsSceneBase, id: int, type: str, name: str, node
         for decorator in self.__decorators:
             decorator.setParentItem(self)
 
-    def item_updated(self, *, redraw: bool = False, ui: bool = False):
-        super().item_updated(redraw=redraw, ui=ui)
+    def item_updated(self):
+        super().item_updated()
         for decorator in self.__decorators:
             decorator.node_updated()

src/lifeblood_viewer/graphics_items/pretty_items/drawable_node.py

@@ -100,7 +100,7 @@ def set_expanded(self, expanded: bool):
 
         for i, task in enumerate(self.tasks()):
             self.__make_task_child_with_position(task, *self.get_task_pos(task, i), animate=True)
-        self.item_updated(redraw=True)
+        self.item_updated()
 
     def get_input_position(self, name: str = 'main', *, local: bool = False) -> QPointF:
         if not self.input_names():
@@ -236,7 +236,7 @@ def remove_task(self, task_to_remove: "Task"):
             self.__make_task_child_with_position(self.__visual_tasks[i], *self.get_task_pos(self.__visual_tasks[i], i), animate=True)
         self.__visual_tasks = self.__visual_tasks[:-1]
         assert task_to_remove not in self.__visual_tasks
-        self.item_updated(redraw=True, ui=False)  # cuz node displays task number - we should redraw
+        self.item_updated()
 
     def _find_insert_index_for_task(self, task, prefer_back=False):
         if task.state() == TaskState.IN_PROGRESS and not prefer_back:
@@ -349,7 +349,7 @@ def reanalyze_nodeui(self):
             self.__header_brush = QBrush(gradient)
         else:
             self.__header_brush = QBrush(QColor(*(x * 255 for x in css.main_color()), 192))
-        self.item_updated(redraw=True, ui=True)  # cuz input count affects visualization in the graph
+        self.item_updated()
 
     def prepareGeometryChange(self):
         super().prepareGeometryChange()

src/lifeblood_viewer/graphics_items/scene_network_item.py

@@ -12,6 +12,12 @@ def itemChange(self, change: QGraphicsItem.GraphicsItemChange, value):
                 raise RuntimeError('changing scenes is not supported')
         return super().itemChange(change, value)
 
+    def item_updated(self):
+        """
+        should be called when item's state is changed
+        """
+        self.update()
+
 
 class SceneNetworkItem(NetworkItem, SceneItemCommon):
     def __init__(self, scene: GraphicsSceneBase, id: int):

src/lifeblood_viewer/nodeeditor.py

@@ -662,7 +662,7 @@ def show_task_menu(self, task: Task, *, pos: Optional[QPoint] = None):
             for state in TaskState:
                 if state in (TaskState.GENERATING, TaskState.INVOKING, TaskState.IN_PROGRESS, TaskState.POST_GENERATING):
                     continue
-                state_submenu.addAction(state.name).triggered.connect(lambda checked=False, x=task.get_id(), state=state: self.__scene.set_task_state([x], state))
+                state_submenu.addAction(state.name).triggered.connect(lambda checked=False, x=task.get_id(), state_=state: self.__scene.set_task_state([x], state_))
 
         if pos is None:
             pos = self.mapToGlobal(self.mapFromScene(task.scenePos()))

src/lifeblood_viewer/scene_ops.py

@@ -344,9 +344,6 @@ def _my_do_longop(self, longop: LongOperation):
             return
         # TODO: currently possible errors on scheduler side are ignored, not good
         self.__scene.request_node_parameters_change(node_id, [param], LongOperationData(longop))
-        node = self.__scene.get_node(node_id)
-        if node:
-            node.item_updated(ui=True)
         yield
 
     def _my_undo_longop(self, longop: LongOperation):
@@ -359,10 +356,6 @@ def _my_undo_longop(self, longop: LongOperation):
             param.set_expression(self.__old_expression)
         self.__scene.request_node_parameters_change(node_id, [param], LongOperationData(longop))
         yield
-        # update node ui, just in case
-        node = self.__scene.get_node(node_id)
-        if node:
-            node.item_updated(ui=True)
 
     def __str__(self):
         return f'Param Changed {self.__param_name} @ {self.__node_sid}'