🎉 🎨 Add persistent colors

pyflow/blocks/block.py

@@ -72,8 +72,11 @@ def __init__(
         self.sockets_in: List[Socket] = []
         self.sockets_out: List[Socket] = []
 
-        self._pen_outline = QPen(QColor("#7F000000"))
-        self._pen_outline_selected = QPen(QColor("#FFFFA637"))
+        self.pen_width = 3
+        self._pen_outline = QPen(QColor("#00000000"))
+        self._pen_outline.setWidth(self.pen_width)
+        self._pen_outline_selected = QPen(QColor("#800030FF"))
+        self._pen_outline_selected.setWidth(self.pen_width)
         self._brush_background = QBrush(BACKGROUND_COLOR)
 
         self.setFlag(QGraphicsItem.GraphicsItemFlag.ItemIsSelectable)
@@ -138,12 +141,26 @@ def paint(
         path_outline.addRoundedRect(
             0, 0, self.width, self.height, self.edge_size, self.edge_size
         )
-        painter.setPen(
-            self._pen_outline_selected if self.isSelected() else self.pen_outline
-        )
+        painter.setPen(self.pen_outline)
         painter.setBrush(Qt.BrushStyle.NoBrush)
         painter.drawPath(path_outline.simplified())
 
+        # selection inner outline
+        if self.isSelected():
+            path_in_outline = QPainterPath()
+            outline_width = self.pen_outline.widthF()
+            path_in_outline.addRoundedRect(
+                -2 * outline_width,
+                -2 * outline_width,
+                self.width + 4 * outline_width,
+                self.height + 4 * outline_width,
+                self.edge_size + 2 * outline_width,
+                self.edge_size + 2 * outline_width,
+            )
+            painter.setPen(self._pen_outline_selected)
+            painter.setBrush(Qt.BrushStyle.NoBrush)
+            painter.drawPath(path_in_outline.simplified())
+
     def add_socket(self, socket: Socket):
         """Add a socket to the block."""
         if socket.socket_type == "input":

pyflow/blocks/codeblock.py

@@ -11,7 +11,7 @@
 
 from pyflow.blocks.block import Block
 from pyflow.core.edge import Edge
-from pyflow.blocks.executableblock import ExecutableBlock
+from pyflow.blocks.executableblock import ExecutableBlock, ExecutableState
 from pyflow.blocks.pyeditor import PythonEditor
 from pyflow.core.add_button import AddEdgeButton, AddNewBlockButton
 
@@ -62,14 +62,17 @@ def __init__(self, source: str = "", **kwargs):
         self.output_closed = True
         self._splitter_size = [1, 1]
         self._cached_stdout = ""
-        self.has_been_run = False
         self.blocks_to_run = []
 
-        self._pen_outlines = [
-            QPen(QColor("#7F000000")),  # Idle
-            QPen(QColor("#FF0000")),  # Running
-            QPen(QColor("#00ff00")),  # Transmitting
-        ]
+        self._pen_outlines = {
+            ExecutableState.IDLE: QPen(QColor("#00000000")),  # No outline
+            ExecutableState.RUNNING: QPen(QColor("#ff6107ff")),  # Purple
+            ExecutableState.PENDING: QPen(QColor("#80fc6107")),  # Dark orange
+            ExecutableState.DONE: QPen(QColor("#158000")),  # Dark green
+            ExecutableState.CRASHED: QPen(QColor("#ff0000")),  # Red: Crashed
+        }
+        for pen in self._pen_outlines.values():
+            pen.setWidth(self.pen_width)
 
         self.output_panel_background_color = "#1E1E1E"
 
@@ -133,14 +136,14 @@ def init_add_newblock_button(self):
 
     def handle_run_right(self):
         """Called when the button for "Run All" was pressed."""
-        if self.run_state != 0:
+        if self.run_state in (ExecutableState.PENDING, ExecutableState.RUNNING):
             self._interrupt_execution()
         else:
             self.run_right()
 
     def handle_run_left(self):
         """Called when the button for "Run Left" was pressed."""
-        if self.run_state != 0:
+        if self.run_state in (ExecutableState.PENDING, ExecutableState.RUNNING):
             self._interrupt_execution()
         else:
             self.run_left()
@@ -170,10 +173,17 @@ def run_code(self):
         super().run_code()  # actually run the code
 
     def execution_finished(self):
+        """Reset the text of the run buttons after it was executed."""
         super().execution_finished()
         self.run_button.setText(">")
         self.run_all_button.setText(">>")
 
+    def execution_canceled(self):
+        """Reset the text of the run buttons after it was canceled."""
+        super().execution_canceled()
+        self.run_button.setText(">")
+        self.run_all_button.setText(">>")
+
     def link(self, block: "ExecutableBlock"):
         """Link a block to the current one."""
         # Add sockets to the new block and the current one
@@ -259,9 +269,8 @@ def source(self, value: str):
         if value != self._source:
             # If text has changed, set self and all output blocks to not run
             output_blocks, _ = self.custom_bfs(self, reverse=True)
-            for block in output_blocks:
-                block.has_been_run = False
-            self.has_been_run = False
+            for block in output_blocks + [self]:
+                block.run_state = ExecutableState.IDLE
             self.source_editor.setText(value)
             self._source = value
 

pyflow/blocks/executableblock.py

@@ -15,9 +15,10 @@
 from pyflow.blocks.block import Block
 from pyflow.core.socket import Socket
 from pyflow.core.edge import Edge
+from pyflow.core.executable import Executable, ExecutableState
 
 
-class ExecutableBlock(Block):
+class ExecutableBlock(Block, Executable):
 
     """
     Executable Block
@@ -35,10 +36,8 @@ def __init__(self, **kwargs):
         Create a new executable block.
         Do not call this method except when inheriting from this class.
         """
-        super().__init__(**kwargs)
-
-        self.has_been_run = False
-        self._run_state = 0
+        Block.__init__(self, **kwargs)
+        Executable.__init__(self)
 
         # Each element is a list of blocks/edges to be animated
         # Running will paint each element one after the other
@@ -85,19 +84,25 @@ def run_code(self):
 
             if kernel.busy is False:
                 kernel.run_queue()
-            self.has_been_run = True
+            self.run_state = ExecutableState.PENDING
 
     def execution_finished(self):
-        """Reset the text of the run buttons."""
-        self.run_state = 0
+        """Reset the state of the block after it was executed."""
+        if self.run_state != ExecutableState.CRASHED:
+            self.run_state = ExecutableState.DONE
+        self.blocks_to_run = []
+
+    def execution_canceled(self):
+        """Reset the state of the block after its execution was canceled."""
+        if self.run_state != ExecutableState.CRASHED:
+            self.run_state = ExecutableState.IDLE
         self.blocks_to_run = []
 
     def _interrupt_execution(self):
         """Interrupt an execution, reset the blocks in the queue."""
         for block, _ in self.scene().kernel.execution_queue:
             # Reset the blocks that have not been run
-            block.reset_has_been_run()
-            block.execution_finished()
+            block.execution_canceled()
         # Clear kernel execution queue
         self.scene().kernel.execution_queue = []
         # Interrupt the kernel
@@ -110,9 +115,6 @@ def transmitting_animation_in(self):
         Animate the visual flow
         Set color to transmitting and set a timer before switching to normal
         """
-        for elem in self.transmitting_queue[0]:
-            # Set color to transmitting
-            elem.run_state = 2
         QApplication.processEvents()
         QTimer.singleShot(self.transmitting_delay, self.transmitting_animation_out)
 
@@ -121,14 +123,6 @@ def transmitting_animation_out(self):
         Animate the visual flow
         After the timer, set color to normal and move on with the queue
         """
-        for elem in self.transmitting_queue[0]:
-            # Reset color only if the block will not be run
-            if hasattr(elem, "has_been_run"):
-                if elem.has_been_run is True:
-                    elem.run_state = 0
-            else:
-                elem.run_state = 0
-
         QApplication.processEvents()
         self.transmitting_queue.pop(0)
         if self.transmitting_queue:
@@ -270,17 +264,19 @@ def right_traversal(self):
 
     def run_blocks(self):
         """Run a list of blocks."""
-        for block in self.blocks_to_run[::-1]:
-            if not block.has_been_run:
+        for block in self.blocks_to_run[::-1] + [self]:
+            if block.run_state not in {
+                ExecutableState.PENDING,
+                ExecutableState.RUNNING,
+                ExecutableState.DONE,
+            }:
                 block.run_code()
-        if not self.has_been_run:
-            self.run_code()
 
     def run_left(self):
         """Run all of the block's dependencies and then run the block."""
 
-        # Reset has_been_run to make sure that the self is run again
-        self.has_been_run = False
+        # Reset state to make sure that the self is run again
+        self.run_state = ExecutableState.IDLE
 
         # To avoid crashing when spamming the button
         if self.transmitting_queue:
@@ -326,12 +322,9 @@ def run_right(self):
         # Start transmitting animation
         self.transmitting_animation_in()
 
-    def reset_has_been_run(self):
-        """Called when the output is an error."""
-        self.has_been_run = False
-
     def error_occured(self):
         """Interrupt the kernel if an error occured"""
+        self.run_state = ExecutableState.CRASHED
         self._interrupt_execution()
 
     @property
@@ -345,24 +338,6 @@ def source(self) -> str:
     def source(self, value: str):
         raise NotImplementedError("source(self) should be overriden")
 
-    @property
-    def run_state(self) -> int:
-        """Run state.
-
-        Describe the current state of the ExecutableBlock:
-            - 0: idle.
-            - 1: running.
-            - 2: transmitting.
-
-        """
-        return self._run_state
-
-    @run_state.setter
-    def run_state(self, value: int):
-        self._run_state = value
-        # Update to force repaint
-        self.update()
-
     def handle_stdout(self, value: str):
         """Handle the stdout signal."""
 

pyflow/core/edge.py

@@ -17,9 +17,10 @@
 
 from pyflow.core.serializable import Serializable
 from pyflow.core.socket import Socket
+from pyflow.core.executable import Executable, ExecutableState
 
 
-class Edge(QGraphicsPathItem, Serializable):
+class Edge(QGraphicsPathItem, Serializable, Executable):
 
     """Base class for directed edges in Pyflow."""
 
@@ -28,12 +29,12 @@ class Edge(QGraphicsPathItem, Serializable):
 
     def __init__(
         self,
-        edge_width: float = 4.0,
+        edge_width: float = 6.0,
         path_type=DEFAULT_DATA["path_type"],
         edge_color="#001000",
-        edge_selected_color="#00ff00",
+        edge_selected_color="#0030FF",
         edge_running_color="#FF0000",
-        edge_transmitting_color="#00ff00",
+        edge_pending_color="#00ff00",
         source: QPointF = QPointF(0, 0),
         destination: QPointF = QPointF(0, 0),
         source_socket: Socket = None,
@@ -55,6 +56,8 @@ def __init__(
 
         Serializable.__init__(self)
         QGraphicsPathItem.__init__(self, parent=None)
+        Executable.__init__(self)
+
         self._pen = QPen(QColor(edge_color))
         self._pen.setWidthF(edge_width)
 
@@ -68,13 +71,14 @@ def __init__(
         self._pen_running = QPen(QColor(edge_running_color))
         self._pen_running.setWidthF(edge_width)
 
-        self._pen_transmitting = QPen(QColor(edge_transmitting_color))
-        self._pen_transmitting.setWidthF(edge_width)
-
-        self.pens = [self._pen, self._pen_running, self._pen_transmitting]
+        self._pen_pending = QPen(QColor(edge_pending_color))
+        self._pen_pending.setWidthF(edge_width)
 
-        # 0 for normal, 1 for running, 2 for transmitting
-        self.run_state = 0
+        self.state_pens = {
+            ExecutableState.IDLE: self._pen,
+            ExecutableState.RUNNING: self._pen_running,
+            ExecutableState.PENDING: self._pen_pending,
+        }
 
         self.setFlag(QGraphicsPathItem.GraphicsItemFlag.ItemIsSelectable)
         self.setZValue(-1)
@@ -117,16 +121,16 @@ def paint(
         self,
         painter: QPainter,
         option: QStyleOptionGraphicsItem,  # pylint:disable=unused-argument
-        widget: Optional[QWidget] = None,
-    ):  # pylint:disable=unused-argument
+        widget: Optional[QWidget] = None,  # pylint:disable=unused-argument
+    ):
         """Paint the edge."""
         self.update_path()
         if self.isSelected():
             pen = self._pen_selected
         elif self.destination_socket is None:
             pen = self._pen_dragging
         else:
-            pen = self.pens[self.run_state]
+            pen = self.state_pens[self.run_state]
         painter.setPen(pen)
         painter.setBrush(Qt.BrushStyle.NoBrush)
         painter.drawPath(self.path())
@@ -257,21 +261,3 @@ def deserialize(self, data: OrderedDict, hashmap: dict = None, restore_id=True):
             self.update_path()
         except KeyError:
             self.remove()
-
-    @property
-    def run_state(self) -> int:
-        """Run state.
-
-        Describe the current state of the Edge:
-            - 0: idle.
-            - 1: running.
-            - 2: transmitting.
-
-        """
-        return self._run_state
-
-    @run_state.setter
-    def run_state(self, value: int):
-        self._run_state = value
-        # Update to force repaint
-        self.update()

pyflow/core/executable.py

@@ -0,0 +1,27 @@
+from enum import Enum
+
+
+class ExecutableState(Enum):
+    IDLE = 0
+    RUNNING = 1
+    PENDING = 2
+    DONE = 3
+    CRASHED = 4
+
+
+class Executable:
+    def __init__(self) -> None:
+        self._run_state = ExecutableState.IDLE
+
+    @property
+    def run_state(self) -> ExecutableState:
+        """The current state of the Executable."""
+        return self._run_state
+
+    @run_state.setter
+    def run_state(self, value: ExecutableState):
+        assert isinstance(value, ExecutableState)
+        self._run_state = value
+        # Update to force repaint if available
+        if hasattr(self, "update"):
+            self.update()