flashforge-python-api 1.0.2__py3-none-any.whl → 1.2.0__py3-none-any.whl

flashforge/tcp/gcode/gcode_controller.py

@@ -7,28 +7,36 @@ the basic TCP communication provided by FlashForgeTcpClient.
 
 import asyncio
 import logging
-from typing import TYPE_CHECKING
+from typing import TYPE_CHECKING, Protocol
 
 from .gcodes import GCodes
 
 if TYPE_CHECKING:
-    from ..ff_client import FlashForgeClient
+    from ..parsers.temp_info import TempInfo
 
 logger = logging.getLogger(__name__)
 
 
+class SupportsGCodeClient(Protocol):
+    """Client protocol implemented by both the legacy and Adventurer 3 TCP clients."""
+
+    async def send_cmd_ok(self, cmd: str) -> bool: ...
+
+    async def get_temp_info(self) -> "TempInfo | None": ...
+
+
 class GCodeController:
     """
     Controller for sending specific G-code commands to FlashForge printers.
-    
+
     This class provides convenient methods for common printer operations
     like LED control, job management, movement, and temperature control.
     """
 
-    def __init__(self, client: 'FlashForgeClient') -> None:
+    def __init__(self, client: SupportsGCodeClient) -> None:
         """
         Initialize the G-code controller.
-        
+
         Args:
             client: The FlashForgeClient instance for sending commands
         """
@@ -37,7 +45,7 @@ class GCodeController:
     async def led_on(self) -> bool:
         """
         Turn the printer's LED lights on.
-        
+
         Returns:
             True if the command was successful, False otherwise
         """
@@ -46,7 +54,7 @@ class GCodeController:
     async def led_off(self) -> bool:
         """
         Turn the printer's LED lights off.
-        
+
         Returns:
             True if the command was successful, False otherwise
         """
@@ -55,7 +63,7 @@ class GCodeController:
     async def pause_job(self) -> bool:
         """
         Pause the current print job.
-        
+
         Returns:
             True if the command was successful, False otherwise
         """
@@ -64,7 +72,7 @@ class GCodeController:
     async def resume_job(self) -> bool:
         """
         Resume a paused print job.
-        
+
         Returns:
             True if the command was successful, False otherwise
         """
@@ -73,7 +81,7 @@ class GCodeController:
     async def stop_job(self) -> bool:
         """
         Stop the current print job.
-        
+
         Returns:
             True if the command was successful, False otherwise
         """
@@ -82,10 +90,10 @@ class GCodeController:
     async def start_job(self, filename: str) -> bool:
         """
         Start a print job from a file stored on the printer.
-        
+
         Args:
             filename: The name of the file to print (typically without path)
-            
+
         Returns:
             True if the command was successful, False otherwise
         """
@@ -95,7 +103,7 @@ class GCodeController:
     async def home(self) -> bool:
         """
         Home all axes (X, Y, Z) of the printer.
-        
+
         Returns:
             True if the command was successful, False otherwise
         """
@@ -104,9 +112,9 @@ class GCodeController:
     async def rapid_home(self) -> bool:
         """
         Perform a rapid homing of all axes.
-        
+
         Note: This uses the same command as regular homing in the current implementation.
-        
+
         Returns:
             True if the command was successful, False otherwise
         """
@@ -116,13 +124,13 @@ class GCodeController:
     async def move(self, x: float, y: float, z: float, feedrate: int) -> bool:
         """
         Move the extruder to a specified X, Y, Z position.
-        
+
         Args:
             x: The target X coordinate
-            y: The target Y coordinate  
+            y: The target Y coordinate
             z: The target Z coordinate
             feedrate: The feedrate for the movement in mm/min
-            
+
         Returns:
             True if the command was successful, False otherwise
         """
@@ -132,12 +140,12 @@ class GCodeController:
     async def move_extruder(self, x: float, y: float, feedrate: int) -> bool:
         """
         Move the extruder to a specified X, Y position.
-        
+
         Args:
             x: The target X coordinate
             y: The target Y coordinate
             feedrate: The feedrate for the movement in mm/min
-            
+
         Returns:
             True if the command was successful, False otherwise
         """
@@ -147,11 +155,11 @@ class GCodeController:
     async def extrude(self, length: float, feedrate: int = 450) -> bool:
         """
         Command the extruder to extrude a specific length of filament.
-        
+
         Args:
             length: The length of filament to extrude in millimeters
             feedrate: The feedrate for extrusion in mm/min (default: 450)
-            
+
         Returns:
             True if the command was successful, False otherwise
         """
@@ -161,11 +169,11 @@ class GCodeController:
     async def set_extruder_temp(self, temp: int, wait_for: bool = False) -> bool:
         """
         Set the target temperature for the extruder.
-        
+
         Args:
             temp: The target temperature in Celsius
             wait_for: If True, wait until the target temperature is reached
-            
+
         Returns:
             True if the command was successful, False otherwise
         """
@@ -183,11 +191,11 @@ class GCodeController:
     async def set_bed_temp(self, temp: int, wait_for: bool = False) -> bool:
         """
         Set the target temperature for the print bed.
-        
+
         Args:
-            temp: The target temperature in Celsius  
+            temp: The target temperature in Celsius
             wait_for: If True, wait until the target temperature is reached
-            
+
         Returns:
             True if the command was successful, False otherwise
         """
@@ -205,7 +213,7 @@ class GCodeController:
     async def cancel_extruder_temp(self) -> bool:
         """
         Cancel extruder heating and set its target temperature to 0.
-        
+
         Returns:
             True if the command was successful, False otherwise
         """
@@ -216,10 +224,10 @@ class GCodeController:
     async def cancel_bed_temp(self, wait_for_cool: bool = False) -> bool:
         """
         Cancel print bed heating and set its target temperature to 0.
-        
+
         Args:
             wait_for_cool: If True, wait for the bed to cool down after canceling
-            
+
         Returns:
             True if the command was successful, False otherwise
         """
@@ -234,15 +242,17 @@ class GCodeController:
 
         return True
 
-    async def wait_for_bed_temp(self, target_temp: int, cooling: bool = False, timeout: int = 600) -> bool:
+    async def wait_for_bed_temp(
+        self, target_temp: int, cooling: bool = False, timeout: int = 600
+    ) -> bool:
         """
         Wait for the bed temperature to reach the target.
-        
+
         Args:
             target_temp: The target temperature to wait for
             cooling: If True, wait for temperature to drop below target; otherwise wait to reach target
             timeout: Maximum time to wait in seconds (default: 600)
-            
+
         Returns:
             True if target temperature was reached, False on timeout or error
         """
@@ -264,17 +274,19 @@ class GCodeController:
 
             await asyncio.sleep(5)  # Check every 5 seconds
 
-        logger.warning(f"Timeout waiting for bed temperature {'cooling to' if cooling else 'heating to'} {target_temp}°C")
+        logger.warning(
+            f"Timeout waiting for bed temperature {'cooling to' if cooling else 'heating to'} {target_temp}°C"
+        )
         return False
 
     async def wait_for_extruder_temp(self, target_temp: int, timeout: int = 600) -> bool:
         """
         Wait for the extruder temperature to reach the target.
-        
+
         Args:
             target_temp: The target temperature to wait for
             timeout: Maximum time to wait in seconds (default: 600)
-            
+
         Returns:
             True if target temperature was reached, False on timeout or error
         """

flashforge/tcp/gcode/gcodes.py

@@ -12,7 +12,7 @@ from typing import Final
 class GCodes:
     """
     Collection of G-code and M-code command strings for FlashForge 3D printers.
-    
+
     All commands use the FlashForge TCP protocol with '~' prefix.
     """
 
@@ -64,6 +64,12 @@ class GCodes:
     CMD_GET_THUMBNAIL: Final[str] = "~M662"
     """Command to retrieve a thumbnail image for a specified G-code file."""
 
+    CMD_PREP_FILE_UPLOAD: Final[str] = "~M28 %%size%% 0:/user/%%filename%%"
+    """Command to begin a legacy raw-binary file upload to printer storage."""
+
+    CMD_COMPLETE_FILE_UPLOAD: Final[str] = "~M29"
+    """Command to finalize a legacy raw-binary file upload."""
+
     # Camera control
     TAKE_PICTURE: Final[str] = "~M240"
     """Command to instruct the printer to take a picture with its camera, if equipped."""

flashforge/tcp/parsers/__init__.py

@@ -13,15 +13,15 @@ from .temp_info import TempData, TempInfo
 from .thumbnail_info import ThumbnailInfo
 
 __all__ = [
-    'PrinterInfo',
-    'TempInfo',
-    'TempData',
-    'LocationInfo',
-    'EndstopStatus',
-    'MachineStatus',
-    'MoveMode',
-    'Status',
-    'Endstop',
-    'PrintStatus',
-    'ThumbnailInfo',
+    "PrinterInfo",
+    "TempInfo",
+    "TempData",
+    "LocationInfo",
+    "EndstopStatus",
+    "MachineStatus",
+    "MoveMode",
+    "Status",
+    "Endstop",
+    "PrintStatus",
+    "ThumbnailInfo",
 ]

flashforge/tcp/parsers/endstop_status.py

@@ -3,13 +3,18 @@ FlashForge Python API - Endstop Status Parser
 
 Parses endstop and machine status information from M119 command responses.
 """
+
 import re
 from enum import Enum
 from typing import Optional
 
+# Pre-compiled regex to match key:value pairs where value is an integer
+KV_PATTERN = re.compile(r"([A-Za-z0-9-]+):\s*(\d+)")
+
 
 class MachineStatus(Enum):
     """Enumerates the possible operational statuses of the machine."""
+
     BUILDING_FROM_SD = "BUILDING_FROM_SD"
     BUILDING_COMPLETED = "BUILDING_COMPLETED"
     PAUSED = "PAUSED"
@@ -20,6 +25,7 @@ class MachineStatus(Enum):
 
 class MoveMode(Enum):
     """Enumerates the possible movement modes of the printer."""
+
     MOVING = "MOVING"
     PAUSED = "PAUSED"
     READY = "READY"
@@ -38,31 +44,15 @@ class Status:
         """
         Creates an instance of Status by parsing a string line.
         It uses regular expressions to find key-value pairs like "S:0".
-        
-        Args:
-            data: The string line containing status flags (e.g., "Status S:0 L:0 J:0 F:0")
-        """
-        self.s: int = self._get_value(data, "S")
-        self.l: int = self._get_value(data, "L")
-        self.j: int = self._get_value(data, "J")
-        self.f: int = self._get_value(data, "F")
 
-    def _get_value(self, input_str: str, key: str) -> int:
-        """
-        Helper function to extract a numeric value associated with a key from a string.
-        
         Args:
-            input_str: The string to search within
-            key: The key whose numeric value is to be extracted
-            
-        Returns:
-            The parsed integer value, or -1 if the key is not found or parsing fails
+            data: The string line containing status flags (e.g., "Status S:0 L:0 J:0 F:0")
         """
-        pattern = rf"{key}:(\d+)"
-        match = re.search(pattern, input_str)
-        if match and match.group(1):
-            return int(match.group(1))
-        return -1
+        matches: dict[str, str] = dict(KV_PATTERN.findall(data))
+        self.s: int = int(matches.get("S", -1))
+        self.l: int = int(matches.get("L", -1))
+        self.j: int = int(matches.get("J", -1))
+        self.f: int = int(matches.get("F", -1))
 
 
 class Endstop:
@@ -75,55 +65,40 @@ class Endstop:
         """
         Creates an instance of Endstop by parsing a string line.
         It uses regular expressions to find key-value pairs like "X-max:0".
-        
-        Args:
-            data: The string line containing endstop states (e.g., "Endstop X-max:0 Y-max:0 Z-min:1")
-        """
-        self.x_max: int = self._get_value(data, "X-max")
-        self.y_max: int = self._get_value(data, "Y-max")
-        self.z_min: int = self._get_value(data, "Z-min")
 
-    def _get_value(self, input_str: str, key: str) -> int:
-        """
-        Helper function to extract a numeric value associated with a key from a string.
-        
         Args:
-            input_str: The string to search within
-            key: The key whose numeric value is to be extracted
-            
-        Returns:
-            The parsed integer value, or -1 if the key is not found or parsing fails
+            data: The string line containing endstop states (e.g., "Endstop X-max:0 Y-max:0 Z-min:1")
         """
-        pattern = rf"{key}:(\d+)"
-        match = re.search(pattern, input_str)
-        if match and match.group(1):
-            return int(match.group(1))
-        return -1
+        matches: dict[str, str] = dict(KV_PATTERN.findall(data))
+        self.x_max: int = int(matches.get("X-max", -1))
+        self.y_max: int = int(matches.get("Y-max", -1))
+        self.z_min: int = int(matches.get("Z-min", -1))
 
 
 class EndstopStatus:
     """
     Represents the status of the printer's endstops and various other machine states.
-    
+
     This information is typically parsed from the response of an M119 command or a similar
     consolidated status report from the printer. It includes endstop states, machine operational status,
     movement mode, LED status, and the currently loaded file.
     """
 
-    def __init__(self):
+    def __init__(self) -> None:
         """Initialize a new EndstopStatus instance."""
-        self.endstop: Optional[Endstop] = None
+        self.endstop: Endstop | None = None
         self.machine_status: MachineStatus = MachineStatus.DEFAULT
         self.move_mode: MoveMode = MoveMode.DEFAULT
-        self.status: Optional[Status] = None
+        self.status: Status | None = None
+        self.filament_status: str = ""
         self.led_enabled: bool = False
-        self.current_file: Optional[str] = None
+        self.current_file: str | None = None
 
-    def from_replay(self, replay: str) -> Optional['EndstopStatus']:
+    def from_replay(self, replay: str) -> Optional["EndstopStatus"]:
         """
         Parses a raw string replay (typically from an M119 or similar status command)
         to populate the properties of this EndstopStatus instance.
-        
+
         The replay is expected to be a multi-line string where each line provides specific information:
         - Line 1 (data[0]): Usually a command echo or header, ignored
         - Line 2 (data[1]): Parsed into the endstop object
@@ -132,10 +107,10 @@ class EndstopStatus:
         - Line 5 (data[4]): Parsed into the status object
         - Line 6 (data[5]): Parsed to determine led_enabled (1 for true, 0 for false)
         - Line 7 (data[6]): Parsed to get current_file, or None if empty
-        
+
         Args:
             replay: The raw multi-line string response from the printer
-            
+
         Returns:
             The populated EndstopStatus instance, or None if parsing fails
         """
@@ -143,72 +118,66 @@ class EndstopStatus:
             return None
 
         try:
-            data = replay.split('\n')
-
-            # Validate that we have enough lines for a valid response
-            # A valid M119 response should have at least 2 lines (command echo + endstop data)
-            if len(data) < 2:
+            lines = [line.strip() for line in replay.replace("\r", "\n").split("\n") if line.strip()]
+            if not lines:
                 return None
 
-            # Check if the data looks like a valid M119 response
-            # Should contain "Endstop" in the second line
-            if len(data) > 1 and "Endstop" not in data[1]:
+            endstop_line = next((line for line in lines if "Endstop" in line), None)
+            if endstop_line is None:
                 return None
 
-            # Parse endstop data (line 1)
-            if len(data) > 1:
-                self.endstop = Endstop(data[1])
-
-            # Parse machine status (line 2)
-            if len(data) > 2:
-                machine_status = data[2].replace("MachineStatus: ", "").strip()
-                if "BUILDING_FROM_SD" in machine_status:
-                    self.machine_status = MachineStatus.BUILDING_FROM_SD
-                elif "BUILDING_COMPLETED" in machine_status:
-                    self.machine_status = MachineStatus.BUILDING_COMPLETED
-                elif "PAUSED" in machine_status:
-                    self.machine_status = MachineStatus.PAUSED
-                elif "READY" in machine_status:
-                    self.machine_status = MachineStatus.READY
-                elif "BUSY" in machine_status:
-                    self.machine_status = MachineStatus.BUSY
-                else:
-                    print(f"EndstopStatus: Encountered unknown MachineStatus: {machine_status}")
-                    self.machine_status = MachineStatus.DEFAULT
-
-            # Parse move mode (line 3)
-            if len(data) > 3:
-                move_mode = data[3].replace("MoveMode: ", "").strip()
-                if "MOVING" in move_mode:
-                    self.move_mode = MoveMode.MOVING
-                elif "PAUSED" in move_mode:
-                    self.move_mode = MoveMode.PAUSED
-                elif "READY" in move_mode:
-                    self.move_mode = MoveMode.READY
-                elif "WAIT_ON_TOOL" in move_mode:
-                    self.move_mode = MoveMode.WAIT_ON_TOOL
-                elif "HOMING" in move_mode:
-                    self.move_mode = MoveMode.HOMING
-                else:
-                    print(f"EndstopStatus: Encountered unknown MoveMode: {move_mode}")
-                    self.move_mode = MoveMode.DEFAULT
-
-            # Parse status flags (line 4)
-            if len(data) > 4:
-                self.status = Status(data[4])
-
-            # Parse LED status (line 5)
-            if len(data) > 5:
-                led_str = data[5].replace("LED: ", "").strip()
-                try:
-                    self.led_enabled = int(led_str) == 1
-                except ValueError:
-                    self.led_enabled = False
-
-            # Parse current file (line 6)
-            if len(data) > 6:
-                current_file = data[6].replace("CurrentFile: ", "").strip()
-                self.current_file = current_file if current_file else None
+            self.endstop = Endstop(endstop_line)
+
+            for line in lines:
+                if line.startswith("MachineStatus:"):
+                    machine_status = line.replace("MachineStatus:", "", 1).strip().upper()
+                    if "BUILDING_FROM_SD" in machine_status:
+                        self.machine_status = MachineStatus.BUILDING_FROM_SD
+                    elif "BUILDING_COMPLETED" in machine_status:
+                        self.machine_status = MachineStatus.BUILDING_COMPLETED
+                    elif "PAUSED" in machine_status:
+                        self.machine_status = MachineStatus.PAUSED
+                    elif "READY" in machine_status or "IDLE" in machine_status:
+                        self.machine_status = MachineStatus.READY
+                    elif "BUSY" in machine_status:
+                        self.machine_status = MachineStatus.BUSY
+                    else:
+                        print(f"EndstopStatus: Encountered unknown MachineStatus: {machine_status}")
+                        self.machine_status = MachineStatus.DEFAULT
+                elif line.startswith("MoveMode:"):
+                    move_mode = line.replace("MoveMode:", "", 1).strip().upper()
+                    if "MOVING" in move_mode:
+                        self.move_mode = MoveMode.MOVING
+                    elif "PAUSED" in move_mode:
+                        self.move_mode = MoveMode.PAUSED
+                    elif "READY" in move_mode or move_mode in {"0", "0.0"}:
+                        self.move_mode = MoveMode.READY
+                    elif "WAIT_ON_TOOL" in move_mode:
+                        self.move_mode = MoveMode.WAIT_ON_TOOL
+                    elif "HOMING" in move_mode:
+                        self.move_mode = MoveMode.HOMING
+                    else:
+                        print(f"EndstopStatus: Encountered unknown MoveMode: {move_mode}")
+                        self.move_mode = MoveMode.DEFAULT
+                elif line.startswith("Status "):
+                    self.status = Status(line)
+                elif line.startswith("FilamentStatus:"):
+                    self.filament_status = line.replace("FilamentStatus:", "", 1).strip()
+                elif line.startswith("LEDStatus:"):
+                    led_status = line.replace("LEDStatus:", "", 1).strip().lower()
+                    self.led_enabled = led_status == "on"
+                elif line.startswith("LED:"):
+                    led_str = line.replace("LED:", "", 1).strip()
+                    try:
+                        self.led_enabled = int(led_str) == 1
+                    except ValueError:
+                        self.led_enabled = False
+                elif line.startswith("CurrentFile:"):
+                    current_file = line.replace("CurrentFile:", "", 1).strip()
+                    self.current_file = current_file if current_file else None
+                elif line.startswith("PrintFileName:"):
+                    current_file = line.replace("PrintFileName:", "", 1).strip()
+                    self.current_file = current_file if current_file else None
 
             return self
 
@@ -221,7 +190,7 @@ class EndstopStatus:
     def is_print_complete(self) -> bool:
         """
         Checks if the machine status indicates that a print has been completed.
-        
+
         Returns:
             True if machine_status is BUILDING_COMPLETED, False otherwise
         """
@@ -230,7 +199,7 @@ class EndstopStatus:
     def is_printing(self) -> bool:
         """
         Checks if the machine status indicates that a print is currently in progress from SD.
-        
+
         Returns:
             True if machine_status is BUILDING_FROM_SD, False otherwise
         """
@@ -239,35 +208,37 @@ class EndstopStatus:
     def is_ready(self) -> bool:
         """
         Checks if the printer is in a ready state (both move mode and machine status are READY).
-        
+
         Returns:
             True if the printer is ready, False otherwise
         """
-        return (self.move_mode == MoveMode.READY and
-                self.machine_status == MachineStatus.READY)
+        return self.move_mode == MoveMode.READY and self.machine_status == MachineStatus.READY
 
     def is_paused(self) -> bool:
         """
         Checks if the printer is currently paused (either machine status or move mode is PAUSED).
-        
+
         Returns:
             True if the printer is paused, False otherwise
         """
-        return (self.machine_status == MachineStatus.PAUSED or
-                self.move_mode == MoveMode.PAUSED)
+        return self.machine_status == MachineStatus.PAUSED or self.move_mode == MoveMode.PAUSED
 
     def __str__(self) -> str:
         """String representation of the endstop status."""
-        return (f"EndstopStatus(machine={self.machine_status.value}, "
-                f"move={self.move_mode.value}, led={self.led_enabled}, "
-                f"file='{self.current_file}')")
+        return (
+            f"EndstopStatus(machine={self.machine_status.value}, "
+            f"move={self.move_mode.value}, led={self.led_enabled}, "
+            f"file='{self.current_file}')"
+        )
 
     def __repr__(self) -> str:
         """Detailed string representation for debugging."""
-        return (f"EndstopStatus("
-                f"endstop={self.endstop}, "
-                f"machine_status={self.machine_status}, "
-                f"move_mode={self.move_mode}, "
-                f"status={self.status}, "
-                f"led_enabled={self.led_enabled}, "
-                f"current_file='{self.current_file}')")
+        return (
+            f"EndstopStatus("
+            f"endstop={self.endstop}, "
+            f"machine_status={self.machine_status}, "
+            f"move_mode={self.move_mode}, "
+            f"status={self.status}, "
+            f"led_enabled={self.led_enabled}, "
+            f"current_file='{self.current_file}')"
+        )