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

flashforge/api/controls/files.py

@@ -1,16 +1,17 @@
 """
 FlashForge Python API - Files Module
 """
+
 import base64
-from typing import TYPE_CHECKING, List, Optional
+from typing import TYPE_CHECKING
 
 import aiohttp
+from pydantic import ValidationError
 
 from ...models.machine_info import FFGcodeFileEntry
-from ...models.responses import GenericResponse, GCodeListResponse, ThumbnailResponse
+from ...models.responses import GCodeListResponse, ThumbnailResponse
 from ..constants.endpoints import Endpoints
 from ..network.utils import NetworkUtils
-from pydantic import ValidationError
 
 if TYPE_CHECKING:
     from ...client import FlashForgeClient
@@ -25,34 +26,34 @@ class Files:
     def __init__(self, client: "FlashForgeClient"):
         """
         Creates an instance of the Files class.
-        
+
         Args:
             client: The FlashForgeClient instance used for communication with the printer.
         """
         self.client = client
 
-    async def get_file_list(self) -> List[str]:
+    async def get_file_list(self) -> list[str]:
         """
         Retrieves a list of files stored locally on the printer.
-        
+
         Returns:
             A list of file names, or empty list if retrieval fails.
         """
         # This method uses the TCP client to get file list
-        if hasattr(self.client, 'tcp_client') and self.client.tcp_client:
+        if hasattr(self.client, "tcp_client") and self.client.tcp_client:
             return await self.client.tcp_client.get_file_list_async()
         return []
 
-    async def get_local_file_list(self) -> List[str]:
+    async def get_local_file_list(self) -> list[str]:
         """
         Retrieves a list of files stored locally on the printer.
-        
+
         Returns:
             A list of file names, or empty list if retrieval fails.
         """
         return await self.get_file_list()
 
-    async def get_recent_file_list(self) -> List[FFGcodeFileEntry]:
+    async def get_recent_file_list(self) -> list[FFGcodeFileEntry]:
         """
         Retrieves a list of the 10 most recently printed files from the printer's API.
         For AD5X and newer printers, returns detailed file entries with material info.
@@ -61,17 +62,14 @@ class Files:
         Returns:
             A list of FFGcodeFileEntry objects. Returns an empty list if the request fails or an error occurs.
         """
-        payload = {
-            "serialNumber": self.client.serial_number,
-            "checkCode": self.client.check_code
-        }
+        payload = {"serialNumber": self.client.serial_number, "checkCode": self.client.check_code}
 
         try:
             async with aiohttp.ClientSession() as session:
                 async with session.post(
                     self.client.get_endpoint(Endpoints.GCODE_LIST),
                     json=payload,
-                    headers={"Content-Type": "application/json"}
+                    headers={"Content-Type": "application/json"},
                 ) as response:
                     if response.status != 200:
                         return []
@@ -84,6 +82,7 @@ class Files:
                         # Fallback: manually parse as JSON if Content-Type is malformed
                         text = await response.text()
                         import json
+
                         data = json.loads(text)
 
                     if not NetworkUtils.is_ok(data):
@@ -96,7 +95,7 @@ class Files:
                     except ValidationError:
                         raw_list = data.get("gcodeList", [])
                         if isinstance(raw_list, list):
-                            entries: List[FFGcodeFileEntry] = []
+                            entries: list[FFGcodeFileEntry] = []
                             for file_name in raw_list:
                                 if isinstance(file_name, str):
                                     entries.append(
@@ -120,15 +119,17 @@ class Files:
                         if isinstance(first_item, str):
                             # Convert string array to FFGcodeFileEntry objects
                             return [
-                                FFGcodeFileEntry(
-                                    gcodeFileName=file_name,
-                                    printingTime=0
-                                )
+                                FFGcodeFileEntry(gcodeFileName=file_name, printingTime=0)
                                 for file_name in result.gcode_list
+                                if isinstance(file_name, str)
+                            ]
+                        elif isinstance(first_item, FFGcodeFileEntry):
+                            # Already FFGcodeFileEntry objects - need explicit type narrowing
+                            return [
+                                item
+                                for item in result.gcode_list
+                                if isinstance(item, FFGcodeFileEntry)
                             ]
-                        else:
-                            # Already FFGcodeFileEntry objects
-                            return result.gcode_list
 
                     return []
 
@@ -136,7 +137,7 @@ class Files:
             print(f"GetRecentFileList error: {err}")
             return []
 
-    async def get_gcode_thumbnail(self, file_name: str) -> Optional[bytes]:
+    async def get_gcode_thumbnail(self, file_name: str) -> bytes | None:
         """
         Retrieves the thumbnail image for a specified G-code file.
         The image data is returned as bytes.
@@ -151,7 +152,7 @@ class Files:
         payload = {
             "serialNumber": self.client.serial_number,
             "checkCode": self.client.check_code,
-            "fileName": file_name
+            "fileName": file_name,
         }
 
         try:
@@ -159,7 +160,7 @@ class Files:
                 async with session.post(
                     self.client.get_endpoint(Endpoints.GCODE_THUMB),
                     json=payload,
-                    headers={"Content-Type": "application/json"}
+                    headers={"Content-Type": "application/json"},
                 ) as response:
                     if response.status != 200:
                         return None
@@ -172,6 +173,7 @@ class Files:
                         # Fallback: manually parse as JSON if Content-Type is malformed
                         text = await response.text()
                         import json
+
                         data = json.loads(text)
 
                     if NetworkUtils.is_ok(data):

flashforge/api/controls/info.py

@@ -1,12 +1,14 @@
 """
 FlashForge Python API - Info Module
 """
-from typing import TYPE_CHECKING, Optional
+
+from datetime import datetime, timedelta
+from typing import TYPE_CHECKING
 
 import aiohttp
 
-from ...models.machine_info import FFMachineInfo, MachineState
-from ...models.responses import DetailResponse
+from ...models.machine_info import FFMachineInfo, MachineState, Temperature
+from ...models.responses import DetailResponse, FFPrinterDetail
 from ..constants.endpoints import Endpoints
 
 if TYPE_CHECKING:
@@ -21,13 +23,13 @@ class MachineInfoParser:
     """
 
     @staticmethod
-    def from_detail(detail) -> Optional[FFMachineInfo]:
+    def from_detail(detail: FFPrinterDetail | None) -> FFMachineInfo | None:
         """
         Converts printer details from the API response format to our internal FFMachineInfo model.
-        
+
         Args:
             detail: The FFPrinterDetail object received from the printer's API.
-            
+
         Returns:
             An FFMachineInfo object containing structured and formatted printer information,
             or None if the input detail is None or an error occurs during processing.
@@ -36,42 +38,13 @@ class MachineInfoParser:
             return None
 
         try:
-            # Helper function to format time from seconds
-            def format_time_from_seconds(seconds: float) -> str:
-                try:
-                    valid_seconds = int(seconds) if isinstance(seconds, (int, float)) else 0
-                    hours = valid_seconds // 3600
-                    minutes = (valid_seconds % 3600) // 60
-                    return f"{hours:02d}:{minutes:02d}"
-                except Exception:
-                    return "00:00"
-
-            # Helper function to get machine state
-            def get_machine_state(status: str) -> MachineState:
-                valid_status = status.lower() if isinstance(status, str) else ""
-                state_mapping = {
-                    "ready": MachineState.READY,
-                    "busy": MachineState.BUSY,
-                    "calibrate_doing": MachineState.CALIBRATING,
-                    "error": MachineState.ERROR,
-                    "heating": MachineState.HEATING,
-                    "printing": MachineState.PRINTING,
-                    "pausing": MachineState.PAUSING,
-                    "paused": MachineState.PAUSED,
-                    "cancel": MachineState.CANCELLED,
-                    "completed": MachineState.COMPLETED,
-                }
-
-                if valid_status in state_mapping:
-                    return state_mapping[valid_status]
-
-                if valid_status:
-                    print(f"Unknown machine status received: '{status}'")
-                return MachineState.UNKNOWN
-
             # Calculate derived values
-            print_eta = format_time_from_seconds(getattr(detail, "estimated_time", 0) or 0)
-            formatted_run_time = format_time_from_seconds(getattr(detail, "print_duration", 0) or 0)
+            estimated_time = getattr(detail, "estimated_time", 0) or 0
+            print_eta = MachineInfoParser._format_time_from_seconds(estimated_time)
+            formatted_run_time = MachineInfoParser._format_time_from_seconds(
+                getattr(detail, "print_duration", 0) or 0
+            )
+            completion_time = datetime.now() + timedelta(seconds=estimated_time)
 
             total_minutes = getattr(detail, "cumulative_print_time", 0) or 0
             hours = total_minutes // 60
@@ -90,67 +63,63 @@ class MachineInfoParser:
             print_progress = getattr(detail, "print_progress", 0) or 0
             est_length = total_job_filament_meters * print_progress
             est_weight = (getattr(detail, "estimated_right_weight", 0) or 0) * print_progress
+            has_material_station = (
+                getattr(detail, "has_matl_station", None) is True
+                or (getattr(getattr(detail, "matl_station_info", None), "slot_cnt", 0) or 0) > 0
+                or len(getattr(getattr(detail, "matl_station_info", None), "slot_infos", []) or []) > 0
+            )
+            printer_name = getattr(detail, "name", "") or ""
+            is_ad5x = printer_name.upper() == "AD5X" or has_material_station
+            is_pro = "Pro" in printer_name and not is_ad5x
 
             # Build the FFMachineInfo object
             machine_info = FFMachineInfo(
                 # Auto-shutdown settings
                 auto_shutdown=auto_shutdown,
                 auto_shutdown_time=getattr(detail, "auto_shutdown_time", 0) or 0,
-
                 # Camera
                 camera_stream_url=getattr(detail, "camera_stream_url", "") or "",
-
                 # Fan speeds
                 chamber_fan_speed=getattr(detail, "chamber_fan_speed", 0) or 0,
                 cooling_fan_speed=getattr(detail, "cooling_fan_speed", 0) or 0,
                 cooling_fan_left_speed=getattr(detail, "cooling_fan_left_speed", None),
-
                 # Cumulative stats
                 cumulative_filament=getattr(detail, "cumulative_filament", 0) or 0,
                 cumulative_print_time=getattr(detail, "cumulative_print_time", 0) or 0,
-
                 # Current print speed
                 current_print_speed=getattr(detail, "current_print_speed", 0) or 0,
-
                 # Disk space
                 free_disk_space=f"{(getattr(detail, 'remaining_disk_space', 0) or 0):.2f}",
-
                 # Door and error status
                 door_open=door_open,
                 error_code=getattr(detail, "error_code", "") or "",
-
                 # Current print estimates
                 est_length=est_length,
                 est_weight=est_weight,
                 estimated_time=getattr(detail, "estimated_time", 0) or 0,
-
                 # Fans & LED status
                 external_fan_on=external_fan_on,
                 internal_fan_on=internal_fan_on,
                 lights_on=lights_on,
-
                 # Network
                 ip_address=getattr(detail, "ip_addr", "") or "",
                 mac_address=getattr(detail, "mac_addr", "") or "",
-
                 # Print settings
                 fill_amount=getattr(detail, "fill_amount", 0) or 0,
                 firmware_version=getattr(detail, "firmware_version", "") or "",
-                name=getattr(detail, "name", "") or "",
-                is_pro="Pro" in (getattr(detail, "name", "") or ""),
-                is_ad5x="AD5X" in (getattr(detail, "name", "") or "").upper(),
+                name=printer_name,
+                is_pro=is_pro,
+                is_ad5x=is_ad5x,
                 nozzle_size=getattr(detail, "nozzle_model", "") or "",
-
                 # Temperatures
-                print_bed={
-                    "current": getattr(detail, "plat_temp", 0) or 0,
-                    "set": getattr(detail, "plat_target_temp", 0) or 0
-                },
-                extruder={
-                    "current": getattr(detail, "right_temp", 0) or 0,
-                    "set": getattr(detail, "right_target_temp", 0) or 0
-                },
-
+                print_bed=Temperature(
+                    current=getattr(detail, "plat_temp", 0) or 0,
+                    set=getattr(detail, "plat_target_temp", 0) or 0,
+                ),
+                extruder=Temperature(
+                    current=getattr(detail, "right_temp", 0) or 0,
+                    set=getattr(detail, "right_target_temp", 0) or 0,
+                ),
                 # Current print stats
                 print_duration=getattr(detail, "print_duration", 0) or 0,
                 print_file_name=getattr(detail, "print_file_name", "") or "",
@@ -160,23 +129,20 @@ class MachineInfoParser:
                 print_progress_int=int(print_progress * 100),
                 print_speed_adjust=getattr(detail, "print_speed_adjust", 0) or 0,
                 filament_type=getattr(detail, "right_filament_type", "") or "",
-
                 # Machine state
-                machine_state=get_machine_state(getattr(detail, "status", "") or ""),
+                machine_state=MachineInfoParser._get_machine_state(getattr(detail, "status", "") or ""),
                 status=getattr(detail, "status", "") or "",
                 total_print_layers=getattr(detail, "target_print_layer", 0) or 0,
                 tvoc=getattr(detail, "tvoc", 0) or 0,
                 z_axis_compensation=getattr(detail, "z_axis_compensation", 0) or 0,
-
                 # Cloud codes
                 flash_cloud_register_code=getattr(detail, "flash_register_code", "") or "",
                 polar_cloud_register_code=getattr(detail, "polar_register_code", "") or "",
-
                 # Extras
                 print_eta=print_eta,
+                completion_time=completion_time,
                 formatted_run_time=formatted_run_time,
                 formatted_total_run_time=formatted_total_run_time,
-
                 # AD5X Material Station
                 has_matl_station=getattr(detail, "has_matl_station", None),
                 matl_station_info=getattr(detail, "matl_station_info", None),
@@ -190,6 +156,41 @@ class MachineInfoParser:
             print(f"Detail object causing error: {detail}")
             return None
 
+    @staticmethod
+    def _format_time_from_seconds(seconds: float) -> str:
+        """Format a duration in seconds as HH:MM."""
+        try:
+            valid_seconds = int(seconds) if isinstance(seconds, (int, float)) else 0
+            hours = valid_seconds // 3600
+            minutes = (valid_seconds % 3600) // 60
+            return f"{hours:02d}:{minutes:02d}"
+        except Exception:
+            return "00:00"
+
+    @staticmethod
+    def _get_machine_state(status: str) -> MachineState:
+        """Map raw status strings into the public machine state enum."""
+        valid_status = status.lower() if isinstance(status, str) else ""
+        state_mapping = {
+            "ready": MachineState.READY,
+            "busy": MachineState.BUSY,
+            "calibrate_doing": MachineState.CALIBRATING,
+            "error": MachineState.ERROR,
+            "heating": MachineState.HEATING,
+            "printing": MachineState.PRINTING,
+            "pausing": MachineState.PAUSING,
+            "paused": MachineState.PAUSED,
+            "cancel": MachineState.CANCELLED,
+            "completed": MachineState.COMPLETED,
+        }
+
+        if valid_status in state_mapping:
+            return state_mapping[valid_status]
+
+        if valid_status:
+            print(f"Unknown machine status received: '{status}'")
+        return MachineState.UNKNOWN
+
 
 class Info:
     """
@@ -200,17 +201,17 @@ class Info:
     def __init__(self, client: "FlashForgeClient"):
         """
         Creates an instance of the Info class.
-        
+
         Args:
             client: The FlashForgeClient instance used for communication with the printer.
         """
         self.client = client
 
-    async def get(self) -> Optional[FFMachineInfo]:
+    async def get(self) -> FFMachineInfo | None:
         """
         Retrieves comprehensive machine information, processed into the FFMachineInfo model.
         This method fetches detailed data from the printer and transforms it.
-        
+
         Returns:
             An FFMachineInfo object, or None if an error occurs or no data is returned.
         """
@@ -222,53 +223,50 @@ class Info:
     async def is_printing(self) -> bool:
         """
         Checks if the printer is currently in the "printing" state.
-        
+
         Returns:
             True if the printer is printing, False otherwise or if status cannot be determined.
         """
         info = await self.get()
         return info.status == "printing" if info else False
 
-    async def get_status(self) -> Optional[str]:
+    async def get_status(self) -> str | None:
         """
         Retrieves the raw status string of the printer (e.g., "ready", "printing", "error").
-        
+
         Returns:
             The status string, or None if it cannot be determined.
         """
         info = await self.get()
         return info.status if info else None
 
-    async def get_machine_state(self) -> Optional[MachineState]:
+    async def get_machine_state(self) -> MachineState | None:
         """
         Retrieves the machine state as a MachineState enum value.
-        
+
         Returns:
             A MachineState enum value, or None if it cannot be determined.
         """
         info = await self.get()
         return info.machine_state if info else None
 
-    async def get_detail_response(self) -> Optional[DetailResponse]:
+    async def get_detail_response(self) -> DetailResponse | None:
         """
         Retrieves the raw detailed response from the printer's detail endpoint.
         This contains a wealth of information about the printer's current state.
-        
+
         Returns:
             A DetailResponse object containing the raw printer details,
             or None if the request fails or an error occurs.
         """
-        payload = {
-            "serialNumber": self.client.serial_number,
-            "checkCode": self.client.check_code
-        }
+        payload = {"serialNumber": self.client.serial_number, "checkCode": self.client.check_code}
 
         try:
             async with aiohttp.ClientSession() as session:
                 async with session.post(
                     self.client.get_endpoint(Endpoints.DETAIL),
                     json=payload,
-                    headers={"Content-Type": "application/json"}
+                    headers={"Content-Type": "application/json"},
                 ) as response:
                     if response.status != 200:
                         print(f"Non-200 status from detail endpoint: {response.status}")
@@ -283,8 +281,9 @@ class Info:
                         # Fallback: manually parse as JSON if Content-Type is malformed
                         text = await response.text()
                         import json
+
                         data = json.loads(text)
-                    
+
                     return DetailResponse(**data)
 
         except Exception as error: