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

flashforge/tcp/parsers/temp_info.py

@@ -14,7 +14,7 @@ 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.
     """
@@ -22,23 +22,25 @@ class TempData:
     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
+        data = data.replace("/0.0", "")  # Remove trailing '/0.0' if exists
 
         if "/" in data:
             # Replay has current/set temps
-            split_temps = data.split('/')
+            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
+            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)
@@ -47,22 +49,22 @@ class TempData:
     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
+            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
         """
@@ -73,7 +75,7 @@ class TempData:
     def get_current(self) -> int:
         """
         Get the current temperature as a number.
-        
+
         Returns:
             The current temperature in Celsius
         """
@@ -82,7 +84,7 @@ class TempData:
     def get_set(self) -> int:
         """
         Get the target (set) temperature as a number.
-        
+
         Returns:
             The set temperature in Celsius, or 0 if not set
         """
@@ -92,32 +94,32 @@ class TempData:
 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
+        self._extruder_temp: TempData | None = None
         """Temperature data for the extruder."""
 
-        self._bed_temp: Optional[TempData] = None
+        self._bed_temp: TempData | None = None
         """Temperature data for the print bed."""
 
-    def from_replay(self, replay: str) -> Optional['TempInfo']:
+    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
         """
@@ -125,29 +127,24 @@ class TempInfo:
             return None
 
         try:
-            data = replay.split('\n')
-            if len(data) <= 1:
-                logger.error(f"TempInfo replay has invalid data: {data}")
+            lines = [line.strip() for line in replay.replace("\r", "\n").split("\n") if line.strip()]
+            if not lines:
+                logger.error("TempInfo replay has invalid data: %s", replay)
                 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:', '')
+            for line in lines:
+                for segment in line.split(" "):
+                    if segment.startswith("T0:"):
+                        extruder_data_str = segment.replace("T0:", "")
+                    elif segment.startswith("T):"):
+                        extruder_data_str = segment.replace("T):", "")
+                    elif segment.startswith("T:"):
+                        extruder_data_str = segment.replace("T:", "")
+                    elif segment.startswith("B:"):
+                        bed_data_str = segment.replace("B:", "")
 
             # If we found extruder data, create TempData object
             if extruder_data_str:
@@ -160,8 +157,10 @@ class TempInfo:
             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
+                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
 
@@ -170,19 +169,19 @@ class TempInfo:
             logger.error(f"Raw replay data: {replay}")
             return None
 
-    def get_extruder_temp(self) -> Optional[TempData]:
+    def get_extruder_temp(self) -> TempData | None:
         """
         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]:
+    def get_bed_temp(self) -> TempData | None:
         """
         Get the print bed temperature data.
-        
+
         Returns:
             A TempData object for the bed, or None if not available
         """
@@ -191,10 +190,10 @@ class TempInfo:
     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
         """
@@ -205,10 +204,10 @@ class TempInfo:
     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
         """

flashforge/tcp/parsers/thumbnail_info.py

@@ -3,6 +3,8 @@ FlashForge Python API - Thumbnail Info Parser
 
 Handles the parsing, storage, and manipulation of 3D print file thumbnail images.
 """
+
+import asyncio
 import base64
 from pathlib import Path
 from typing import Optional
@@ -11,29 +13,29 @@ from typing import Optional
 class ThumbnailInfo:
     """
     Handles the parsing, storage, and manipulation of 3D print file thumbnail images.
-    
+
     Thumbnails are typically retrieved from the printer using a command like M662,
     which returns a mixed response containing text (e.g., "ok") followed by raw binary PNG data.
     This class provides methods to extract the PNG data, convert it to various formats, and save it to a file.
     """
 
-    def __init__(self):
+    def __init__(self) -> None:
         """Initialize a new ThumbnailInfo instance."""
-        self._image_data: Optional[bytes] = None
-        self._file_name: Optional[str] = None
+        self._image_data: bytes | None = None
+        self._file_name: str | None = None
 
-    def from_replay(self, replay: str, file_name: str) -> Optional['ThumbnailInfo']:
+    def from_replay(self, replay: str, file_name: str) -> Optional["ThumbnailInfo"]:
         """
         Parses thumbnail data from a raw printer response string.
-        
+
         The method expects the response to contain an "ok" text delimiter, after which
         the binary PNG data begins. It searches for the PNG signature (0x89 PNG)
         within the binary portion to correctly extract the image.
-        
+
         Args:
             replay: The raw string response from the printer, which may include text and binary data
             file_name: The name of the file for which the thumbnail was retrieved
-            
+
         Returns:
             A ThumbnailInfo instance populated with the image data if parsing is successful,
             or None if the replay is invalid, "ok" is not found, or the PNG signature is missing
@@ -44,9 +46,24 @@ class ThumbnailInfo:
         try:
             # Store the file name
             self._file_name = file_name
+            if "Error: File not exists" in replay:
+                return None
+
+            binary_buffer = replay.encode("latin1")
+            magic_marker = b"\xA2\xA2\x2A\x2A"
+            magic_offset = binary_buffer.find(magic_marker)
+            if magic_offset >= 0 and len(binary_buffer) >= magic_offset + 8:
+                payload_length = int.from_bytes(
+                    binary_buffer[magic_offset + 4 : magic_offset + 8],
+                    byteorder="big",
+                )
+                payload_end = magic_offset + 8 + payload_length
+                if len(binary_buffer) >= payload_end:
+                    self._image_data = binary_buffer[magic_offset + 8 : payload_end]
+                    return self
 
             # Find where the PNG data starts (after the "ok" text delimiter)
-            ok_index = replay.find('ok')
+            ok_index = replay.find("ok")
             if ok_index == -1:
                 print("ThumbnailInfo: No 'ok' found in response")
                 return None
@@ -58,11 +75,11 @@ class ThumbnailInfo:
 
             # Convert the extracted string part (assumed to be binary) into bytes
             # The printer sends binary data as part of a string reply
-            binary_buffer = raw_binary_data.encode('latin1')  # Use latin1 to preserve byte values
+            binary_buffer = raw_binary_data.encode("latin1")  # Use latin1 to preserve byte values
 
             # Look for the PNG file signature (89 50 4E 47 0D 0A 1A 0A) in the buffer
             # to correctly identify the start of the actual image data
-            png_signature = b'\x89\x50\x4E\x47\x0D\x0A\x1A\x0A'
+            png_signature = b"\x89\x50\x4e\x47\x0d\x0a\x1a\x0a"
             png_start = binary_buffer.find(png_signature)
 
             if png_start >= 0:
@@ -77,59 +94,65 @@ class ThumbnailInfo:
             print(f"ThumbnailInfo: Error parsing response: {e}")
             return None
 
-    def get_image_data(self) -> Optional[str]:
+    def get_image_data(self) -> str | None:
         """
         Gets the raw thumbnail image data as a Base64 encoded string.
-        
+
         Returns:
             A Base64 encoded string of the PNG image data, or None if no image data is available
         """
         if not self._image_data:
             return None
-        return base64.b64encode(self._image_data).decode('ascii')
+        return base64.b64encode(self._image_data).decode("ascii")
 
-    def get_image_bytes(self) -> Optional[bytes]:
+    def get_image_bytes(self) -> bytes | None:
         """
         Gets the raw thumbnail image data as bytes.
-        
+
         Returns:
             The PNG image data as bytes, or None if no image data is available
         """
         return self._image_data
 
-    def get_file_name(self) -> Optional[str]:
+    def get_file_name(self) -> str | None:
         """
         Gets the file name associated with this thumbnail.
-        
+
         Returns:
             The file name string, or None if it was not set during parsing
         """
         return self._file_name
 
-    def to_base64_data_url(self) -> Optional[str]:
+    def to_base64_data_url(self) -> str | None:
         """
         Converts the thumbnail image data to a Base64 data URL, suitable for embedding in web pages.
-        
+
         Returns:
             A Base64 data URL string (e.g., "data:image/png;base64,..."), or None if no image data is available
         """
         if not self._image_data:
             return None
 
-        base64_data = base64.b64encode(self._image_data).decode('ascii')
+        base64_data = base64.b64encode(self._image_data).decode("ascii")
         return f"data:image/png;base64,{base64_data}"
 
-    async def save_to_file(self, file_path: Optional[str] = None) -> bool:
+    @staticmethod
+    def _write_file_sync(file_path: str, data: bytes) -> None:
+        """Helper to write bytes to a file synchronously."""
+        with open(file_path, "wb") as f:
+            f.write(data)
+
+    async def save_to_file(self, file_path: str | None = None) -> bool:
         """
         Saves the thumbnail image data to a file.
-        
+
         If no file_path is provided, it attempts to generate a filename using the
         original filename (stored during from_replay) with a ".png" extension.
-        
+
         Args:
             file_path: Optional. The full path (including filename and extension) where the thumbnail should be saved.
                       If not provided, a filename is generated from self._file_name
-                      
+
         Returns:
             True if the file was saved successfully, False otherwise
         """
@@ -149,9 +172,9 @@ class ThumbnailInfo:
                 print("ThumbnailInfo: No file path provided and no filename to generate one from")
                 return False
 
-            # Write the bytes to file
-            with open(file_path, 'wb') as f:
-                f.write(self._image_data)
+            # Write the bytes to file in a separate thread to avoid blocking the event loop
+            loop = asyncio.get_running_loop()
+            await loop.run_in_executor(None, self._write_file_sync, file_path, self._image_data)
 
             print(f"ThumbnailInfo: Saved thumbnail to {file_path}")
             return True
@@ -160,13 +183,13 @@ class ThumbnailInfo:
             print(f"ThumbnailInfo: Error saving thumbnail to file: {e}")
             return False
 
-    def save_to_file_sync(self, file_path: Optional[str] = None) -> bool:
+    def save_to_file_sync(self, file_path: str | None = None) -> bool:
         """
         Synchronous version of save_to_file for compatibility.
-        
+
         Args:
             file_path: Optional. The full path where the thumbnail should be saved
-            
+
         Returns:
             True if the file was saved successfully, False otherwise
         """
@@ -187,7 +210,7 @@ class ThumbnailInfo:
                 return False
 
             # Write the bytes to file
-            with open(file_path, 'wb') as f:
+            with open(file_path, "wb") as f:
                 f.write(self._image_data)
 
             print(f"ThumbnailInfo: Saved thumbnail to {file_path}")
@@ -200,7 +223,7 @@ class ThumbnailInfo:
     def get_image_size(self) -> tuple[int, int]:
         """
         Gets the image dimensions by parsing the PNG header.
-        
+
         Returns:
             A tuple of (width, height) in pixels, or (0, 0) if parsing fails
         """
@@ -209,8 +232,8 @@ class ThumbnailInfo:
 
         try:
             # PNG width and height are stored at bytes 16-23 in big-endian format
-            width = int.from_bytes(self._image_data[16:20], byteorder='big')
-            height = int.from_bytes(self._image_data[20:24], byteorder='big')
+            width = int.from_bytes(self._image_data[16:20], byteorder="big")
+            height = int.from_bytes(self._image_data[20:24], byteorder="big")
             return (width, height)
         except Exception:
             return (0, 0)
@@ -218,7 +241,7 @@ class ThumbnailInfo:
     def has_image_data(self) -> bool:
         """
         Checks if this instance contains valid image data.
-        
+
         Returns:
             True if image data is available, False otherwise
         """
@@ -236,7 +259,9 @@ class ThumbnailInfo:
 
     def __repr__(self) -> str:
         """Detailed string representation for debugging."""
-        return (f"ThumbnailInfo("
-                f"file_name='{self._file_name}', "
-                f"has_data={self.has_image_data()}, "
-                f"size={len(self._image_data) if self._image_data else 0} bytes)")
+        return (
+            f"ThumbnailInfo("
+            f"file_name='{self._file_name}', "
+            f"has_data={self.has_image_data()}, "
+            f"size={len(self._image_data) if self._image_data else 0} bytes)"
+        )