flashforge-python-api 1.0.0__py3-none-any.whl

flashforge/tcp/parsers/location_info.py

@@ -0,0 +1,68 @@
+"""
+Location information parser for FlashForge 3D printers.
+
+This module parses the response from M114 command to extract current
+X, Y, Z coordinates of the printer's print head.
+"""
+
+import logging
+from typing import Optional
+
+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.
+    """
+
+    def __init__(self) -> None:
+        """Initialize empty location info."""
+        self.x: str = ""
+        """The current X-axis coordinate as a string (e.g., "10.00")."""
+
+        self.y: str = ""
+        """The current Y-axis coordinate as a string (e.g., "20.50")."""
+
+        self.z: str = ""
+        """The current Z-axis coordinate as a string (e.g., "5.25")."""
+
+    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()
+            return self
+        except Exception:
+            logger.error("LocationInfo replay has bad/null data")
+            return None
+
+    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]"
+        """
+        return f"X: {self.x} Y: {self.y} Z: {self.z}"

flashforge/tcp/parsers/print_status.py

@@ -0,0 +1,182 @@
+"""
+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):
+        """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']:
+        """
+        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
+        """
+        if not replay:
+            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('/')
+                    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
+
+            return self
+
+        except Exception as e:
+            print(f"Error parsing print status: {e}")
+            return None
+
+    def get_print_percent(self) -> float:
+        """
+        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.
+        """
+        try:
+            current_layer = int(self.layer_current)
+            total_layers = int(self.layer_total)
+
+            if total_layers == 0:
+                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')
+
+    def get_layer_progress(self) -> str:
+        """
+        Gets the layer progress as a string.
+        
+        Returns:
+            A string in the format "currentLayer/totalLayers"
+        """
+        return f"{self.layer_current}/{self.layer_total}"
+
+    def get_sd_progress(self) -> str:
+        """
+        Gets the SD card byte progress as a string.
+        
+        Returns:
+            A string in the format "currentBytes/totalBytes"
+        """
+        return f"{self.sd_current}/{self.sd_total}"
+
+    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
+        """
+        try:
+            current_bytes = int(self.sd_current)
+            total_bytes = int(self.sd_total)
+
+            if total_bytes == 0:
+                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')
+
+    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
+        """
+        try:
+            current = int(self.layer_current)
+            total = int(self.layer_total)
+            return current >= total and total > 0
+        except (ValueError, TypeError):
+            return False
+
+    def __str__(self) -> str:
+        """String representation of the print status."""
+        layer_perc = self.get_print_percent()
+        sd_perc = self.get_sd_percent()
+
+        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}])")
+
+    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}')")

flashforge/tcp/parsers/printer_info.py

@@ -0,0 +1,154 @@
+"""
+Printer information parser for FlashForge 3D printers.
+
+This module parses the response from M115 command to extract printer details
+like model, firmware version, serial number, and capabilities.
+"""
+
+import logging
+from typing import Optional
+
+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.
+    """
+
+    def __init__(self) -> None:
+        """Initialize empty printer info."""
+        self.type_name: str = ""
+        """The machine type or model name (e.g., "FlashForge Adventurer 5M Pro")."""
+
+        self.name: str = ""
+        """The user-assigned name of the printer."""
+
+        self.firmware_version: str = ""
+        """The firmware version currently installed on the printer."""
+
+        self.serial_number: str = ""
+        """The unique serial number of the printer."""
+
+        self.dimensions: str = ""
+        """The build dimensions of the printer (e.g., "X:220 Y:220 Z:220")."""
+
+        self.mac_address: str = ""
+        """The MAC address of the printer's network interface."""
+
+        self.tool_count: str = ""
+        """The number of tools (extruders) the printer has."""
+
+    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]"
+        - Line 3: "Machine Name: [Name]"
+        - Line 4: "Firmware: [FirmwareVersion]"
+        - Line 5: "SN: [SerialNumber]"
+        - 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
+        """
+        if not replay:
+            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:
+                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:
+                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:
+                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:
+                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
+
+        except Exception as e:
+            logger.error(f"Error creating PrinterInfo instance from replay: {e}")
+            return None
+
+    def _get_right(self, rp_data: str) -> Optional[str]:
+        """
+        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()
+        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
+        """
+        return (
+            f"Printer Type: {self.type_name}\n"
+            f"Name: {self.name}\n"
+            f"Firmware: {self.firmware_version}\n"
+            f"Serial Number: {self.serial_number}\n"
+            f"Print Dimensions: {self.dimensions}\n"
+            f"Tool Count: {self.tool_count}\n"
+            f"MAC Address: {self.mac_address}"
+        )

flashforge/tcp/parsers/temp_info.py

@@ -0,0 +1,217 @@
+"""
+Temperature information parser for FlashForge 3D printers.
+
+This module parses the response from M105 command to extract temperature data
+for the extruder and print bed.
+"""
+
+import logging
+from typing import Optional
+
+logger = logging.getLogger(__name__)
+
+
+class TempData:
+    """
+    Represents temperature data for a single component (e.g., extruder or bed).
+    
+    Includes current temperature and target (set) temperature.
+    Temperatures are stored as strings but can be retrieved as numbers.
+    """
+
+    def __init__(self, data: str) -> None:
+        """
+        Create a TempData instance by parsing a temperature string.
+        
+        The input string can be in the format "current/set" (e.g., "210/210")
+        or just "current" (e.g., "25") if the target temperature is not specified.
+        It also handles and removes a trailing "/0.0" if present from some printer firmwares.
+        All temperatures are rounded to the nearest integer.
+        
+        Args:
+            data: The temperature data string (e.g., "210/210", "25", "60/60/0.0")
+        """
+        # Handle potential formatting issues by removing any non-relevant part
+        data = data.replace('/0.0', '')  # Remove trailing '/0.0' if exists
+
+        if "/" in data:
+            # Replay has current/set temps
+            split_temps = data.split('/')
+            self._current = self._parse_temp_data(split_temps[0].strip())
+            self._set = self._parse_temp_data(split_temps[1].strip()) if len(split_temps) > 1 else None
+        else:
+            # Replay only has current temp (when printer is idle)
+            self._current = self._parse_temp_data(data)
+            self._set = None
+
+    def _parse_temp_data(self, data: str) -> str:
+        """
+        Parse a raw temperature string value, round it, and return as string.
+        
+        Args:
+            data: The raw temperature string (e.g., "210.5", "60")
+            
+        Returns:
+            The rounded temperature as a string
+        """
+        if "." in data:
+            data = data.split('.')[0].strip()  # Truncate decimal part before rounding
+        temp = round(float(data))
+        return str(temp)
+
+    def get_full(self) -> str:
+        """
+        Get the full temperature string, including current and set temperatures.
+        
+        Returns:
+            A string in the format "current/set" or just "current" if set temperature is not available
+        """
+        if self._set is None:
+            return self._current
+        return f"{self._current}/{self._set}"
+
+    def get_current(self) -> int:
+        """
+        Get the current temperature as a number.
+        
+        Returns:
+            The current temperature in Celsius
+        """
+        return int(self._current)
+
+    def get_set(self) -> int:
+        """
+        Get the target (set) temperature as a number.
+        
+        Returns:
+            The set temperature in Celsius, or 0 if not set
+        """
+        return int(self._set) if self._set else 0
+
+
+class TempInfo:
+    """
+    Represents the temperature information for the printer's extruder and bed.
+    
+    This data is typically parsed from the response of an M105 G-code command,
+    which reports the current and target temperatures.
+    """
+
+    def __init__(self) -> None:
+        """Initialize empty temperature info."""
+        self._extruder_temp: Optional[TempData] = None
+        """Temperature data for the extruder."""
+
+        self._bed_temp: Optional[TempData] = None
+        """Temperature data for the print bed."""
+
+    def from_replay(self, replay: str) -> Optional['TempInfo']:
+        """
+        Parse a raw string replay from M105 command to populate temperature info.
+        
+        The M105 response format is usually a single line (after the "ok" or command echo)
+        containing temperature segments like "T0:25/0" or "T:210/210 B:60/60".
+        This method splits the relevant line by spaces and then parses each segment.
+        It looks for segments starting with "T0:", "T):", or "T:" for extruder temperature,
+        and "B:" for bed temperature.
+        
+        Args:
+            replay: The raw multi-line string response from the printer
+            
+        Returns:
+            The populated TempInfo instance, or None if parsing fails
+        """
+        if not replay:
+            return None
+
+        try:
+            data = replay.split('\n')
+            if len(data) <= 1:
+                logger.error(f"TempInfo replay has invalid data: {data}")
+                return None
+
+            # Relevant temperature data is usually on the second line (data[1])
+            # e.g., "T0:25/0 B:28/0 @:0 B@:0" or "T:210/210 B:60/60"
+            temp_data = data[1].split(' ')
+            extruder_data_str = None
+            bed_data_str = None
+
+            # Parse each temperature segment
+            for segment in temp_data:
+                # Check for extruder temperature (T0, T, or T) for some printers)
+                if segment.startswith('T0:'):
+                    extruder_data_str = segment.replace('T0:', '')
+                elif segment.startswith('T):'):  # Some printers might use T):
+                    extruder_data_str = segment.replace('T):', '')
+                elif segment.startswith('T:'):  # General case for T:
+                    extruder_data_str = segment.replace('T:', '')
+                # Check for bed temperature
+                elif segment.startswith('B:'):
+                    bed_data_str = segment.replace('B:', '')
+
+            # If we found extruder data, create TempData object
+            if extruder_data_str:
+                self._extruder_temp = TempData(extruder_data_str)
+            else:
+                logger.error(f"No extruder temperature found in replay data: {replay}")
+                return None  # Extruder temp is critical
+
+            # If we found bed data, create TempData object; otherwise, default to 0/0
+            if bed_data_str:
+                self._bed_temp = TempData(bed_data_str)
+            else:
+                logger.warning(f"No bed temperature found in replay data, defaulting to 0/0: {replay}")
+                self._bed_temp = TempData('0/0')  # Default if not present
+
+            return self
+
+        except Exception as e:
+            logger.error(f"Unable to create TempInfo instance from replay: {e}")
+            logger.error(f"Raw replay data: {replay}")
+            return None
+
+    def get_extruder_temp(self) -> Optional[TempData]:
+        """
+        Get the extruder temperature data.
+        
+        Returns:
+            A TempData object for the extruder, or None if not available
+        """
+        return self._extruder_temp
+
+    def get_bed_temp(self) -> Optional[TempData]:
+        """
+        Get the print bed temperature data.
+        
+        Returns:
+            A TempData object for the bed, or None if not available
+        """
+        return self._bed_temp
+
+    def is_cooled(self) -> bool:
+        """
+        Check if both the bed and extruder are cooled down to relatively low temperatures.
+        
+        Bed temperature <= 40°C and extruder temperature <= 200°C (though 200 is still hot).
+        Use with caution, as "cooled" here is relative and 200C is still very hot for an extruder.
+        
+        Returns:
+            True if temperatures are at or below the defined thresholds, False otherwise
+        """
+        bed_temp = self._bed_temp.get_current() if self._bed_temp else 0
+        extruder_temp = self._extruder_temp.get_current() if self._extruder_temp else 0
+        return bed_temp <= 40 and extruder_temp <= 200
+
+    def are_temps_safe(self) -> bool:
+        """
+        Check if the current temperatures are within a generally safe operating range.
+        
+        Prevents overheating (extruder < 250°C, bed < 100°C).
+        These are arbitrary "safe" limits and might need adjustment based on specific printer/material.
+        
+        Returns:
+            True if temperatures are below the defined "safe" thresholds, False otherwise
+        """
+        bed_temp = self._bed_temp.get_current() if self._bed_temp else 0
+        extruder_temp = self._extruder_temp.get_current() if self._extruder_temp else 0
+        return extruder_temp < 250 and bed_temp < 100