Created STUB for frontend development

gmmcosta15 · gmmcosta15 · commit 0edfc1f1246b · 2026-03-25T12:11:05.000Z
diff --git a/BlocksScreen/devices/AMU/manager.py b/BlocksScreen/devices/AMU/manager.py
@@ -1,9 +1,12 @@
 import logging
 import re
+import typing
 from pathlib import Path
 
 from PyQt6 import QtCore
 
+from .models import MMUState
+
 logger: logging.Logger = logging.getLogger(__name__)
 
 CONFIG_PATH: Path = Path("~/printer_data/config/printer.cfg").expanduser()
@@ -21,9 +24,22 @@
 class AMUManager(QtCore.QObject):
     """Main manager of the AMU system"""
 
+    run_gcode_signal: typing.ClassVar[QtCore.pyqtSignal] = QtCore.pyqtSignal(
+        str, name="run-gcode"
+    )
+
+    mmu_state_changed: typing.ClassVar[QtCore.pyqtSignal] = QtCore.pyqtSignal(
+        object, name="mmu-state-changed"
+    )
+
+    amu_toggled: typing.ClassVar[QtCore.pyqtSignal] = QtCore.pyqtSignal(
+        bool, name="amu-toggled"
+    )
+
     def __init__(self, parent: QtCore.QObject | None = None) -> None:
         super().__init__(parent)
         self._amu_state = False
+        self._mmu_state: MMUState | None = None
         self.__setup_configfile()
 
     def __setup_configfile(self) -> None:
@@ -44,11 +60,10 @@ def _apply_patterns(self, state: bool) -> bool:
             state (bool): True: Uncomment, False: Comment
 
         Returns:
-            bool: True: Sucess, False: Failed
+            bool: True: Success, False: Failed
         """
-        # signal to say that it was changed AMU para mainwindow
         if self._amu_state == state:
-            return
+            return False
 
         replacement = r"\2"
         if not state:
@@ -62,23 +77,114 @@ def _apply_patterns(self, state: bool) -> bool:
             return True
         except OSError as e:
             logger.error(
-                "Failed to apply(state=%s) AMU System: could not read/write %s\n%e",
+                "Failed to apply(state=%s) AMU System: could not read/write %s\n%s",
                 state,
                 self._config_filename,
                 e,
             )
             return False
 
-    def toggle_amu_system(self, activate: bool) -> bool:
-        """Method that comments/uncomments the AMU_FILES from the printer.cfg according with state value
+    def toggle_amu_system(self, activate: bool) -> None:
+        """Enable or disable the AMU system by commenting/uncommenting config includes.
+
+        Emits:
+            amu_toggled (bool): True if the operation succeeded, False otherwise.
 
         Args:
-            state (bool): True: Uncomment, False: Comment
+            activate (bool): True to enable the AMU, False to disable it.
+
+        """
+        result: bool = self._apply_patterns(activate)
+        self.amu_toggled.emit(result)
+
+    def get_state(self) -> MMUState | None:
+        """Returns current MMU state, None if not yet received.
 
         Returns:
-            bool: True: Sucess, False: Failed
+            MMUState: Latest state received from Moonraker
+            None: If no state has been received yet.
+
+        """
+        return self._mmu_state
+
+    def is_amu_active(self) -> bool:
+        """Returns whether AMU includes are currently uncommented in printer.cfg"""
+        return self._amu_state
+
+    def set_gate_info(
+        self, gate: int, material: str, color: str, spool_id: int
+    ) -> None:
+        """Sets all gate attributes for a single MMU_GATE
+
+        Args:
+            gate (int): Gate index (0-based).
+            material (str): Filament material name, e.g. ``"PLA"``.
+            color (str): Filament color as hex string, e.g. ``"ff56e0"``.
+            spool_id (int): Spoolman spool ID, or -1 if not tracked.
+        """
+        ...
+
+    def set_gate_material(self, gate: int, material: str) -> None:
+        """Set the `material` at the gate `gate`
+
+        Args:
+            gate (int): Gate index (0-based).
+            material (str): Filament material name, e.g. ``"PLA"``.
+        """
+
+    def set_gate_color(self, gate: int, color: str) -> None:
+        """Set the `color` at the gate `gate`
+
+        Args:
+            gate (int): Gate index (0-based).
+            color (str): Filament color, e.g. ``"ff56e0"``.
+        """
+
+    def set_gate_spool(self, gate: int, spool_id: int) -> None:
+        """Set the `spool_id` at the gate `gate`
+
+        Args:
+            gate (int): Gate index (0-based).
+            spool_id (int): Spoolman spool ID, or -1 to clear.
+        """
+
+    def home_mmu(self) -> None:
+        """Home the MMU selector by sending MMU_HOME."""
+
+    def reset_mmu(self) -> None:
+        """Reset the MMU and clear any pause or error state by sending MMU_RESET."""
+
+    def load_gate(self, gate: int) -> None:
+        """Load filament from the specified gate by sending MMU_LOAD
+
+        Args:
+            gate (int): Gate index to select (0-based)
+        """
+
+    def unload(self) -> None:
+        """Unload the currently loaded filament by sending MMU_UNLOAD."""
+        ...
+
+    def select_tool(self, tool: int) -> None:
+        """Select a tool, triggering a filament change if needed.
+
+        Args:
+            tool (int): Tool index to select (0-based).
+        """
+        ...
+
+    @QtCore.pyqtSlot(dict, name="update_mmu_state")
+    def update_mmu_state(self, data: dict) -> None:
+        """Receive an MMU status dict from Moonraker and update internal state.
+
+        Called with either a full status response (on connect) or a diff
+        (from notify_status_update). Builds or updates the MMUState and
+        emits mmu_state_changed
+
+        Args:
+            data (dict): Raw MMU status or diff dict from Moonraker
         """
-        return self._apply_patterns(activate)
+        ...
 
 
 if __name__ == "__main__":
diff --git a/BlocksScreen/devices/AMU/models.py b/BlocksScreen/devices/AMU/models.py
@@ -19,6 +19,11 @@ class GateInfo:
     color_rgb: tuple[float, float, float]
     spool_id: int
 
+    @property
+    def is_available(self) -> bool:
+        """Return True if the gate has filament available to load."""
+        return self.status in (GateStatus.AVAILABLE, GateStatus.AVAILABLE_FROM_BUFFER)
+
 
 @dataclass(frozen=True, slots=True)
 class MMUState:
@@ -34,8 +39,28 @@ class MMUState:
     gates: tuple[GateInfo, ...]
     ttg_map: tuple[int, ...]
 
+    @property
+    def is_paused(self) -> bool:
+        """Return True if the MMU is in a paused/error state."""
+        return self.print_state == "pause"
+
+    @property
+    def current_gate_info(self) -> GateInfo | None:
+        """Return the GateInfo for the currently selected gate, or None if no gate is selected."""
+        if 0 <= self.gate < len(self.gates):
+            return self.gates[self.gate]
+        return None
+
     @classmethod
     def from_status(cls, data: dict) -> "MMUState":
+        """Build an MMUState from a full Moonraker mmu status dict.
+
+        Args:
+            data (dict): Full status dict from printer.objects.query or the initial notify_status_update payload.
+
+        Returns:
+            MMUState: New instance populated from *data*
+        """
         num_gates = data.get("num_gates", 0)
 
         statuses = data.get("gate_status", [GateStatus.UNKNOWN] * num_gates)
@@ -69,7 +94,21 @@ def from_status(cls, data: dict) -> "MMUState":
             ttg_map=tuple(data.get("ttg_map", [])),
         )
 
+    def gate_for_tool(self, tool: int) -> int:
+        """Returns the gate mapped to *tool*, or -1 if unmapped."""
+        if 0 <= tool < len(self.ttg_map):
+            return self.ttg_map[tool]
+        return -1
+
     def apply_diff(self, diff: dict) -> "MMUState":
+        """Apply a Moonraker status diff and return an updated MMUState.
+
+        Args:
+            diff (dict): Partial status dict from notify_status_update.
+
+        Returns:
+            MMUState: New instance with updated fields
+        """
         gate_keys: set[str] = {
             "gate_status",
             "gate_material",
