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

flashforge/tcp/parsers/location_info.py

@@ -6,6 +6,7 @@ X, Y, Z coordinates of the printer's print head.
 """
 
 import logging
+import re
 from typing import Optional
 
 logger = logging.getLogger(__name__)
@@ -14,7 +15,7 @@ logger = logging.getLogger(__name__)
 class LocationInfo:
     """
     Represents the current X, Y, and Z coordinates of the printer's print head.
-    
+
     This information is typically parsed from the response of an M114 G-code command,
     which reports the current position.
     """
@@ -30,29 +31,41 @@ class LocationInfo:
         self.z: str = ""
         """The current Z-axis coordinate as a string (e.g., "5.25")."""
 
-    def from_replay(self, replay: str) -> Optional['LocationInfo']:
+    def from_replay(self, replay: str) -> Optional["LocationInfo"]:
         """
         Parse a raw string replay from M114 command to populate coordinate info.
-        
+
         The parsing logic assumes the replay is a multi-line string where the second line
         (data[1]) contains the coordinate data in a format like "X:10.00 Y:20.50 Z:5.25 ...".
         It splits this line by spaces and then extracts the values for X, Y, and Z by
         removing the prefixes "X:", "Y:", and "Z:".
-        
+
         Args:
             replay: The raw multi-line string response from the printer
-            
+
         Returns:
             The populated LocationInfo instance, or None if parsing fails
         """
         try:
-            data = replay.split('\n')
-            # The first line (data[0]) is often the command echo (e.g., "ok M114") or similar,
-            # actual coordinate data is expected on the second line.
-            loc_data = data[1].split(' ')
-            self.x = loc_data[0].replace("X:", "").strip()
-            self.y = loc_data[1].replace("Y:", "").strip()
-            self.z = loc_data[2].replace("Z:", "").strip()
+            lines = [line.strip() for line in replay.replace("\r", "\n").split("\n") if line.strip()]
+            coordinate_line = next(
+                (line for line in lines if "X:" in line and "Y:" in line and "Z:" in line),
+                "",
+            )
+            if not coordinate_line:
+                logger.error("LocationInfo replay has bad/null data")
+                return None
+
+            x_match = re.search(r"X:\s*([^\s]+)", coordinate_line)
+            y_match = re.search(r"Y:\s*([^\s]+)", coordinate_line)
+            z_match = re.search(r"Z:\s*([^\s]+)", coordinate_line)
+            if not x_match or not y_match or not z_match:
+                logger.error("LocationInfo replay has bad/null data")
+                return None
+
+            self.x = x_match.group(1)
+            self.y = y_match.group(1)
+            self.z = z_match.group(1)
             return self
         except Exception:
             logger.error("LocationInfo replay has bad/null data")
@@ -61,7 +74,7 @@ class LocationInfo:
     def __str__(self) -> str:
         """
         Return a string representation of the location information.
-        
+
         Returns:
             A string in the format "X: [X_value] Y: [Y_value] Z: [Z_value]"
         """

flashforge/tcp/parsers/print_status.py

@@ -3,39 +3,40 @@ FlashForge Python API - Print Status Parser
 
 Parses print progress information from M27 command responses.
 """
+
 from typing import Optional
 
 
 class PrintStatus:
     """
     Represents the status of an ongoing print job, including SD card byte progress and layer progress.
-    
+
     This information is typically parsed from the response of an M27 G-code command,
     which reports the print progress from the SD card.
     """
 
-    def __init__(self):
+    def __init__(self) -> None:
         """Initialize a new PrintStatus instance."""
         self.sd_current: str = ""
         self.sd_total: str = ""
         self.layer_current: str = ""
         self.layer_total: str = ""
 
-    def from_replay(self, replay: str) -> Optional['PrintStatus']:
+    def from_replay(self, replay: str) -> Optional["PrintStatus"]:
         """
         Parses a raw string replay (typically from an M27 command) to populate
         the print status properties of this instance.
-        
+
         The parsing logic expects a multi-line string:
         - Line 1 (data[0]): Usually a command echo, ignored
         - Line 2 (data[1]): Contains SD card progress, e.g., "SD printing byte 12345/67890"
                             It extracts the current and total bytes
         - Line 3 (data[2]): Contains layer progress, e.g., "Layer: 10/250"
                             It extracts the current and total layers
-        
+
         Args:
             replay: The raw multi-line string response from the printer
-            
+
         Returns:
             The populated PrintStatus instance, or None if parsing fails
         """
@@ -43,44 +44,31 @@ class PrintStatus:
             return None
 
         try:
-            data = replay.split('\n')
-
-            # Parse SD progress (line 1)
-            if len(data) > 1:
-                # Example: "SD printing byte 12345/67890"
-                sd_progress = data[1].replace("SD printing byte ", "").strip()
-                sd_progress_data = sd_progress.split('/')
-
-                if len(sd_progress_data) >= 2:
-                    self.sd_current = sd_progress_data[0].strip()
-                    self.sd_total = sd_progress_data[1].strip()
-                else:
-                    print("PrintStatus: Invalid SD progress format")
-                    return None
-
-            # Parse layer progress (line 2)
-            if len(data) > 2:
-                try:
-                    # Example: "Layer: 10/250"
-                    layer_progress = data[2].replace("Layer: ", "").strip()
-                except Exception:
-                    print("PrintStatus: Bad layer progress")
-                    print(f"Raw printer replay: {replay}")
-                    return None
-
-                try:
-                    lp_data = layer_progress.split('/')
+            self.sd_current = ""
+            self.sd_total = ""
+            self.layer_current = ""
+            self.layer_total = ""
+            lines = [line.strip() for line in replay.replace("\r", "\n").split("\n") if line.strip()]
+
+            for line in lines:
+                if "SD printing byte " in line:
+                    sd_progress = line.split("SD printing byte ", 1)[1].strip().strip('"')
+                    sd_progress_data = sd_progress.split("/")
+                    if len(sd_progress_data) >= 2:
+                        self.sd_current = sd_progress_data[0].strip()
+                        self.sd_total = sd_progress_data[1].strip()
+                elif line.startswith("Layer:"):
+                    layer_progress = line.replace("Layer:", "", 1).strip()
+                    lp_data = layer_progress.split("/")
                     if len(lp_data) >= 2:
                         self.layer_current = lp_data[0].strip()
                         self.layer_total = lp_data[1].strip()
                     else:
-                        print("PrintStatus: Invalid layer progress format")
-                        print(f"layerProgress: {layer_progress}")
                         return None
-                except Exception:
-                    print("PrintStatus: Bad layer progress parsing")
-                    print(f"layerProgress: {layer_progress}")
-                    return None
+
+            if not self.sd_current or not self.sd_total:
+                print("PrintStatus: Invalid SD progress format")
+                return None
 
             return self
 
@@ -92,7 +80,7 @@ class PrintStatus:
         """
         Calculates the print progress percentage based on the current and total layers.
         The result is clamped between 0 and 100.
-        
+
         Returns:
             The print progress percentage (0-100), rounded to the nearest integer.
             Returns NaN if layer information is not available or invalid.
@@ -102,18 +90,18 @@ class PrintStatus:
             total_layers = int(self.layer_total)
 
             if total_layers == 0:
-                return float('nan')
+                return float("nan")
 
             perc = (current_layer / total_layers) * 100
             return round(min(100, max(0, perc)))  # Clamp between 0 and 100
 
         except (ValueError, TypeError):
-            return float('nan')
+            return self.get_sd_percent()
 
     def get_layer_progress(self) -> str:
         """
         Gets the layer progress as a string.
-        
+
         Returns:
             A string in the format "currentLayer/totalLayers"
         """
@@ -122,7 +110,7 @@ class PrintStatus:
     def get_sd_progress(self) -> str:
         """
         Gets the SD card byte progress as a string.
-        
+
         Returns:
             A string in the format "currentBytes/totalBytes"
         """
@@ -131,7 +119,7 @@ class PrintStatus:
     def get_sd_percent(self) -> float:
         """
         Calculates the SD card progress percentage based on current and total bytes.
-        
+
         Returns:
             The SD progress percentage (0-100), or NaN if data is invalid
         """
@@ -140,18 +128,18 @@ class PrintStatus:
             total_bytes = int(self.sd_total)
 
             if total_bytes == 0:
-                return float('nan')
+                return float("nan")
 
             perc = (current_bytes / total_bytes) * 100
             return round(min(100, max(0, perc)))  # Clamp between 0 and 100
 
         except (ValueError, TypeError):
-            return float('nan')
+            return float("nan")
 
     def is_complete(self) -> bool:
         """
         Checks if the print is complete based on layer progress.
-        
+
         Returns:
             True if current layer equals total layers, False otherwise
         """
@@ -160,7 +148,8 @@ class PrintStatus:
             total = int(self.layer_total)
             return current >= total and total > 0
         except (ValueError, TypeError):
-            return False
+            sd_percent = self.get_sd_percent()
+            return sd_percent == 100 if sd_percent == sd_percent else False
 
     def __str__(self) -> str:
         """String representation of the print status."""
@@ -170,13 +159,17 @@ class PrintStatus:
         layer_str = "nan%" if layer_perc != layer_perc else f"{layer_perc}%"  # Check for NaN
         sd_str = "nan%" if sd_perc != sd_perc else f"{sd_perc}%"  # Check for NaN
 
-        return (f"PrintStatus(layer={self.get_layer_progress()} [{layer_str}], "
-                f"sd={self.get_sd_progress()} [{sd_str}])")
+        return (
+            f"PrintStatus(layer={self.get_layer_progress()} [{layer_str}], "
+            f"sd={self.get_sd_progress()} [{sd_str}])"
+        )
 
     def __repr__(self) -> str:
         """Detailed string representation for debugging."""
-        return (f"PrintStatus("
-                f"sd_current='{self.sd_current}', "
-                f"sd_total='{self.sd_total}', "
-                f"layer_current='{self.layer_current}', "
-                f"layer_total='{self.layer_total}')")
+        return (
+            f"PrintStatus("
+            f"sd_current='{self.sd_current}', "
+            f"sd_total='{self.sd_total}', "
+            f"layer_current='{self.layer_current}', "
+            f"layer_total='{self.layer_total}')"
+        )

flashforge/tcp/parsers/printer_info.py

@@ -6,6 +6,7 @@ like model, firmware version, serial number, and capabilities.
 """
 
 import logging
+import re
 from typing import Optional
 
 logger = logging.getLogger(__name__)
@@ -14,7 +15,7 @@ logger = logging.getLogger(__name__)
 class PrinterInfo:
     """
     Represents general information about the FlashForge 3D printer.
-    
+
     This information is typically parsed from the response of an M115 G-code command,
     which provides details about the printer's firmware and capabilities.
     """
@@ -42,13 +43,13 @@ class PrinterInfo:
         self.tool_count: str = ""
         """The number of tools (extruders) the printer has."""
 
-    def from_replay(self, replay: str) -> Optional['PrinterInfo']:
+    def from_replay(self, replay: str) -> Optional["PrinterInfo"]:
         """
         Parse a raw string replay from M115 command to populate printer info.
-        
+
         The M115 response is expected to be a multi-line string where each line
         provides a piece of information in a "Key: Value" format.
-        
+
         Expected format:
         - Line 1: Command echo/header (ignored)
         - Line 2: "Machine Type: [TypeName]"
@@ -58,10 +59,10 @@ class PrinterInfo:
         - Line 6: Dimensions string (e.g., "X:220 Y:220 Z:220")
         - Line 7: "Tool count: [ToolCount]"
         - Line 8: "Mac Address:[MacAddress]"
-        
+
         Args:
             replay: The raw multi-line string response from the M115 command
-            
+
         Returns:
             The populated PrinterInfo instance, or None if parsing fails
         """
@@ -69,51 +70,40 @@ class PrinterInfo:
             return None
 
         try:
-            data = replay.split('\n')
-
-            # Parse machine type (line 2)
-            name = self._get_right(data[1])  # Expected: "Machine Type: Adventurer 5M Pro"
-            if name is None:
+            lines = [line.strip() for line in replay.replace("\r", "\n").split("\n") if line.strip()]
+
+            for line in lines:
+                if line.startswith("Machine Type:"):
+                    self.type_name = line.replace("Machine Type:", "", 1).strip()
+                elif line.startswith("Machine Name:"):
+                    self.name = line.replace("Machine Name:", "", 1).strip()
+                elif line.startswith("Firmware:"):
+                    self.firmware_version = line.replace("Firmware:", "", 1).strip()
+                elif line.startswith("SN:"):
+                    self.serial_number = line.replace("SN:", "", 1).strip()
+                elif line.startswith("Serial Number:"):
+                    self.serial_number = line.replace("Serial Number:", "", 1).strip()
+                elif line.startswith("Tool count:") or line.startswith("Tool Count:"):
+                    tool_count = self._get_right(line)
+                    if tool_count is not None:
+                        self.tool_count = tool_count
+                elif line.startswith("Mac Address:"):
+                    self.mac_address = line.replace("Mac Address:", "", 1).strip()
+                elif re.search(r"X:\s*\d+.*Y:\s*\d+.*Z:\s*\d+", line, re.IGNORECASE):
+                    self.dimensions = line
+
+            if not self.type_name:
                 logger.error("PrinterInfo replay has null Machine Type")
                 return None
-            self.type_name = name
-
-            # Parse machine name (line 3)
-            nick = self._get_right(data[2])  # Expected: "Machine Name: MyPrinter"
-            if nick is None:
+            if not self.name:
                 logger.error("PrinterInfo replay has null Machine Name")
                 return None
-            self.name = nick
-
-            # Parse firmware version (line 4)
-            fw = self._get_right(data[3])  # Expected: "Firmware: V1.2.3"
-            if fw is None:
+            if not self.firmware_version:
                 logger.error("PrinterInfo replay has null firmware version")
                 return None
-            self.firmware_version = fw
-
-            # Parse serial number (line 5)
-            sn = self._get_right(data[4])  # Expected: "SN: SN12345"
-            if sn is None:
+            if not self.serial_number:
                 logger.error("PrinterInfo replay has null serial number")
                 return None
-            self.serial_number = sn
-
-            # Parse dimensions (line 6) - direct string
-            if len(data) > 5:
-                self.dimensions = data[5].strip()  # Expected: "X:220 Y:220 Z:220"
-
-            # Parse tool count (line 7)
-            if len(data) > 6:
-                tcs = self._get_right(data[6])  # Expected: "Tool count: 1"
-                if tcs is None:
-                    logger.error("PrinterInfo replay has null tool count")
-                    return None
-                self.tool_count = tcs
-
-            # Parse MAC address (line 8)
-            if len(data) > 7:
-                self.mac_address = data[7].replace("Mac Address:", "").strip()
 
             return self
 
@@ -121,25 +111,25 @@ class PrinterInfo:
             logger.error(f"Error creating PrinterInfo instance from replay: {e}")
             return None
 
-    def _get_right(self, rp_data: str) -> Optional[str]:
+    def _get_right(self, rp_data: str) -> str | None:
         """
         Helper function to extract the value part of a "Key: Value" string.
-        
+
         Args:
             rp_data: The input string (e.g., "Machine Type: Adventurer 5M Pro")
-            
+
         Returns:
             The extracted value string (e.g., "Adventurer 5M Pro"), or None if parsing fails
         """
         try:
-            return rp_data.split(':', 1)[1].strip()
+            return rp_data.split(":", 1)[1].strip()
         except (IndexError, AttributeError):
             return None
 
     def __str__(self) -> str:
         """
         Return a string representation of the printer information.
-        
+
         Returns:
             A multi-line string detailing the printer's properties
         """