refactor(viewer): event and command use IntEnum and not str

Author: Ludofr3

bot/control/mouse.py

@@ -2,6 +2,7 @@
 from panda3d.core import MouseButton, Point2, Point3
 
 from bot.control.picker import RayPicker
+from bot.viewer.contracts import ViewEventType
 from bot.math.constraints import ConstraintManager
 
 
@@ -80,7 +81,7 @@ def _finalize_drag(self, world_pos):
                     curve.rebuild_cp_collision()
 
             self.base._on_event_cb(
-                "cp_pick_end",
+                ViewEventType.CP_PICK_END,
                 {
                     "curve_tag": self.drag_curve_tag,
                     "cp_index": self.drag_cp_index,
@@ -98,7 +99,7 @@ def _handle_hover(self, m_pos: Point2):
 
         if hovered_tag != self.last_hovered_tag:
             self.last_hovered_tag = hovered_tag
-            self.base._on_event_cb("hover", hovered_tag)
+            self.base._on_event_cb(ViewEventType.HOVER, hovered_tag)
 
     def _handle_cp_interaction(self, m_pos: Point2, left_down: bool):
         if not self.edit_mode_enabled and not self.dragging_cp:
@@ -162,7 +163,7 @@ def _start_cp_drag(self, metadata: dict, m_pos: Point2):
             )
 
         self.base._on_event_cb(
-            "cp_pick_start",
+            ViewEventType.CP_PICK_START,
             {
                 "curve_tag": self.drag_curve_tag,
                 "cp_index": self.drag_cp_index,
@@ -189,7 +190,7 @@ def _update_cp_drag(self, m_pos: Point2):
             )
 
         self.base._on_event_cb(
-            "cp_drag",
+            ViewEventType.CP_DRAG,
             {
                 "curve_tag": self.drag_curve_tag,
                 "cp_index": self.drag_cp_index,
@@ -225,7 +226,7 @@ def _handle_curve_click(self, m_pos: Point2, left_down: bool):
             metadata.get("pick_kind") == "curve"
             and metadata.get("curve_tag") is not None
         ):
-            self.base._on_event_cb("curve_selected", metadata["curve_tag"])
+            self.base._on_event_cb(ViewEventType.CURVE_SELECTED, metadata["curve_tag"])
 
     def _handle_drag(self, curr_pos: Point2):
         if self.dragging_cp:

bot/viewer/app.py

@@ -12,7 +12,7 @@
 from bot.control.camera import CameraController
 from bot.control.mouse import MouseHandler
 from bot.control.keyboard import KeyboardHandler
-from bot.viewer.contracts import ScenePayload
+from bot.viewer.contracts import ScenePayload, SceneUpdateOp, ViewerCommandType
 
 _DEFAULT_SCENE = {
     "background_color": [0.1, 0.1, 0.12],
@@ -100,39 +100,39 @@ def __process_commands(self, task):
         while not self._cmd_queue.empty():
             try:
                 cmd, data = self._cmd_queue.get_nowait()
-                if cmd == "add":
+                if cmd == SceneUpdateOp.ADD:
                     self.__load_scene(data)
-                elif cmd == "update":
+                elif cmd == SceneUpdateOp.UPDATE:
                     self.__update_scene(data)
-                elif cmd == "delete":
+                elif cmd == SceneUpdateOp.DELETE:
                     self.__delete_in_scene(data)
-                elif cmd == "reload_config":
+                elif cmd == ViewerCommandType.RELOAD_CONFIG:
                     self._config = data
                     if self._scene:
                         self._scene.apply_settings(self.__scene_cfg())
                     if self._camera_controller:
                         self._camera_controller.apply_settings(self.__camera_cfg())
-                elif cmd == "highlight_curve":
+                elif cmd == ViewerCommandType.HIGHLIGHT_CURVE:
                     if self._scene:
                         self._scene.set_curve_color(data["tag"], data["color"])
-                elif cmd == "update_hud":
+                elif cmd == ViewerCommandType.UPDATE_HUD:
                     self.hud.setText(data["text"])
-                elif cmd == "set_edit_mode":
+                elif cmd == ViewerCommandType.SET_EDIT_MODE:
                     enabled = bool(data.get("enabled", False))
                     curve_tag = data.get("curve_tag")
                     self.mouse_handler.set_edit_mode(enabled, curve_tag)
                     if self._scene:
                         self._scene.set_edit_mode(enabled)
                         if curve_tag is not None:
                             self._scene.set_active_curve(curve_tag)
-                elif cmd == "set_active_curve":
+                elif cmd == ViewerCommandType.SET_ACTIVE_CURVE:
                     curve_tag = data.get("curve_tag")
                     self.mouse_handler.set_edit_mode(
                         self.mouse_handler.edit_mode_enabled, curve_tag
                     )
                     if self._scene:
                         self._scene.set_active_curve(curve_tag)
-                elif cmd == "set_axis_constraint":
+                elif cmd == ViewerCommandType.SET_AXIS_CONSTRAINT:
                     self.__set_axis_constraint(data.get("mask", 7))
             except queue.Empty:
                 break
@@ -160,7 +160,7 @@ def __load_scene(self, payload: dict):
         if self._scene is not None:
             self._scene.clear()
 
-        if isinstance(payload, dict) and payload.get("op") == "add":
+        if isinstance(payload, dict) and payload.get("op") == SceneUpdateOp.ADD:
             geom_data = payload_to_geom_data(payload)
         else:
             geom_data = payload
@@ -183,7 +183,7 @@ def __update_scene(self, payload: dict):
             self.__load_scene(payload)
             return
 
-        if isinstance(payload, dict) and payload.get("op") == "update":
+        if isinstance(payload, dict) and payload.get("op") == SceneUpdateOp.UPDATE:
             self._scene.apply_patch(payload)
             return
 

bot/viewer/contracts.py

@@ -2,69 +2,79 @@
 
 from __future__ import annotations
 
-from typing import Any, Literal, TypedDict, Union, NotRequired
-from enum import Enum
+from enum import IntEnum
+from typing import Any, Literal, NotRequired, TypedDict, Union
 
 from bot.core.spline import BEZIER_TYP, NURBS_TYP
 
 
-class SceneUpdateOp(str, Enum):
+class SceneUpdateOp(IntEnum):
     """
     Category 1: Geometric Update Flow (Parent -> Child)
     Heavy payloads used to synchronize 3D topology and geometry.
     """
-    ADD = "add"          # Initializes or fully rebuilds the scene.
-    UPDATE = "update"    # Applies a partial patch to existing geometries.
-    DELETE = "delete"    # Removes one or multiple geometries from the scene.
 
+    ADD = 1  # Initializes or fully rebuilds the scene.
+    UPDATE = 2  # Applies a partial patch to existing geometries.
+    DELETE = 3  # Removes one or multiple geometries from the scene.
 
-class ViewerCommandType(str, Enum):
+
+class ViewerCommandType(IntEnum):
     """
     Category 2: Display State Commands (Parent -> Child)
     Orders given to the GUI by the parent process.
     """
+
     # FIXME Color changes on hover should be detected and applied locally by the child.
-    HIGHLIGHT_CURVE = "highlight_curve"
+    HIGHLIGHT_CURVE = 10
 
     # Legitimate: The parent sends domain-specific data (calculated by the kernel) that the child lacks.
-    UPDATE_HUD = "update_hud"
+    UPDATE_HUD = 11
 
     # Legitimate: The parent (script/kernel) forces the UI into edit mode programmatically.
-    SET_EDIT_MODE = "set_edit_mode"
+    SET_EDIT_MODE = 12
 
     # Legitimate: The parent targets a specific curve programmatically.
-    SET_ACTIVE_CURVE = "set_active_curve"
+    SET_ACTIVE_CURVE = 13
 
     # FIXME The child already has the math logic (ConstraintManager) to calculate axes locally.
-    SET_AXIS_CONSTRAINT = "set_axis_constraint"
+    SET_AXIS_CONSTRAINT = 14
 
     # Legitimate: The parent commands the child process to terminate gracefully.
-    EXIT = "exit"
+    EXIT = 15
 
+    RELOAD_CONFIG = 16
 
-class ViewEventType(str, Enum):
+
+class ViewEventType(IntEnum):
     """
     Category 3: User Interaction Events (Child -> Parent)
     Notifications of physical user actions occurring in the 3D window.
     """
+
     # FIXME If no custom user callback is set, sending this just to trigger a HIGHLIGHT_CURVE is wasteful.
-    HOVER = "hover"
+    HOVER = 100
 
     # Legitimate: The parent needs to know which curve was clicked to update its internal state.
-    CURVE_SELECTED = "curve_selected"
+    CURVE_SELECTED = 101
 
     # Legitimate: Notifies the parent that a control point drag operation has started.
-    CP_PICK_START = "cp_pick_start"
+    CP_PICK_START = 102
 
     # FIXME Sending mouse position at 60 FPS clogs the IPC pipe.
     # The child should handle real-time visual updates locally via `preview_evaluate`.
-    CP_DRAG = "cp_drag"
+    CP_DRAG = 103
 
     # Legitimate (Crucial): The parent receives the final position to permanently update the math kernel.
-    CP_PICK_END = "cp_pick_end"
+    CP_PICK_END = 104
 
     # Legitimate: The parent receives an absolute 3D coordinate to instantiate a new free point.
-    PICK = "pick"
+    PICK = 105
+
+
+ParentCommand = SceneUpdateOp | ViewerCommandType
+ParentMessage = tuple[ParentCommand, Any]
+ChildMessage = tuple[ViewEventType, Any]
 
 
 class CurveGeometry(TypedDict):
@@ -89,7 +99,7 @@ class CurveDelta(TypedDict):
 class ScenePayload(TypedDict):
     """Universal exchange format for incremental scene updates."""
 
-    op: Literal["add", "update", "delete"]
+    op: SceneUpdateOp
     changed_curves: dict[str, CurveDelta]
     deleted_curves: NotRequired[list[str]]
     bounds: NotRequired[dict[str, Any]]
@@ -98,45 +108,82 @@ class ScenePayload(TypedDict):
 
 
 class EventHover(TypedDict):
-    event_type: Literal["hover"]
+    event_type: Literal[ViewEventType.HOVER]
     tag: str | None
 
+
 class EventCurveSelected(TypedDict):
-    event_type: Literal["curve_selected"]
+    event_type: Literal[ViewEventType.CURVE_SELECTED]
     curve_tag: str
 
-class EventCPInteraction(TypedDict):
-    event_type: Literal["cp_pick_start", "cp_drag", "cp_pick_end"]
+
+class EventCPPickStart(TypedDict):
+    event_type: Literal[ViewEventType.CP_PICK_START]
+    curve_tag: str
+    cp_index: int
+    world_pos: list[float]
+
+
+class EventCPDrag(TypedDict):
+    event_type: Literal[ViewEventType.CP_DRAG]
     curve_tag: str
     cp_index: int
     world_pos: list[float]
 
+
+class EventCPPickEnd(TypedDict):
+    event_type: Literal[ViewEventType.CP_PICK_END]
+    curve_tag: str
+    cp_index: int
+    world_pos: list[float]
+
+
 class EventPick(TypedDict):
-    event_type: Literal["pick"]
+    event_type: Literal[ViewEventType.PICK]
     world_pos: list[float]
 
-ViewEvent = Union[EventHover, EventCurveSelected, EventCPInteraction, EventPick]
 
+ViewEvent = Union[
+    EventHover,
+    EventCurveSelected,
+    EventCPPickStart,
+    EventCPDrag,
+    EventCPPickEnd,
+    EventPick,
+]
 
 
 class CmdHighlightCurve(TypedDict):
-    cmd: Literal["highlight_curve"]
+    cmd: Literal[ViewerCommandType.HIGHLIGHT_CURVE]
     tag: str
     color: list[float]
 
+
 class CmdUpdateHud(TypedDict):
-    cmd: Literal["update_hud"]
+    cmd: Literal[ViewerCommandType.UPDATE_HUD]
     text: str
 
+
 class CmdSetEditMode(TypedDict):
-    cmd: Literal["set_edit_mode"]
+    cmd: Literal[ViewerCommandType.SET_EDIT_MODE]
     enabled: bool
     curve_tag: str | None
 
+
 class CmdSetActiveCurve(TypedDict):
-    cmd: Literal["set_active_curve"]
+    cmd: Literal[ViewerCommandType.SET_ACTIVE_CURVE]
     curve_tag: str | None
 
+
+class CmdSetAxisConstraint(TypedDict):
+    cmd: Literal[ViewerCommandType.SET_AXIS_CONSTRAINT]
+    mask: int
+
+
 ViewerCommand = Union[
-    CmdHighlightCurve, CmdUpdateHud, CmdSetEditMode, CmdSetActiveCurve
-]
+    CmdHighlightCurve,
+    CmdUpdateHud,
+    CmdSetEditMode,
+    CmdSetActiveCurve,
+    CmdSetAxisConstraint,
+]

bot/viewer/serialize.py

@@ -7,7 +7,7 @@
 
 import numpy as np
 
-from bot.viewer.contracts import CurveDelta, CurveGeometry, ScenePayload
+from bot.viewer.contracts import CurveDelta, CurveGeometry, ScenePayload, SceneUpdateOp
 
 
 def floats_to_bytes(points: Sequence[Sequence[float]] | np.ndarray) -> bytes:
@@ -74,7 +74,7 @@ def merge_deltas(*payloads: ScenePayload) -> ScenePayload:
     bounds: dict[str, Any] | None = None
     points: bytes | None = None
     edges: list[tuple[int, int, str]] | None = None
-    op: str = "add"
+    op: SceneUpdateOp = SceneUpdateOp.ADD
 
     for payload in payloads:
         op = payload.get("op", op)