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

flashforge/client.py

@@ -4,33 +4,50 @@ FlashForge Python API - Main Unified Client
 This module provides the main FlashForgeClient class that orchestrates both HTTP and TCP
 communication layers for controlling FlashForge 3D printers.
 """
+
 import asyncio
-from typing import Optional
+from dataclasses import dataclass
 
 import aiohttp
 
-from .api.constants.endpoints import Endpoints
+from .api.constants.endpoints import CAMERA_STREAM_PORT, Endpoints
 from .api.controls import Control, Files, Info, JobControl, TempControl
 from .api.controls.info import MachineInfoParser
 from .api.network.utils import NetworkUtils
-from .models import FFMachineInfo, ProductResponse
+from .models import FFMachineInfo, Product, ProductResponse
 from .tcp import FlashForgeClient as TcpClient
-from .tcp import PrinterInfo
+from .tcp import FlashForgeTcpClientOptions, PrinterInfo
+from .tcp.parsers.temp_info import TempInfo
+
+
+@dataclass(slots=True)
+class FiveMClientConnectionOptions:
+    """Optional connection and feature overrides for FiveMClient-compatible clients."""
+
+    http_port: int | None = None
+    tcp_port: int | None = None
+    led_control_override: bool | None = None
 
 
 class FlashForgeClient:
     """
     Main client for interacting with a FlashForge 3D printer.
-    
+
     This class provides methods for controlling the printer, managing print jobs,
     retrieving information, and handling file operations. It orchestrates both
     HTTP and TCP communication layers to provide a unified interface.
     """
 
-    def __init__(self, ip_address: str, serial_number: str, check_code: str):
+    def __init__(
+        self,
+        ip_address: str,
+        serial_number: str,
+        check_code: str,
+        options: FiveMClientConnectionOptions | None = None,
+    ):
         """
         Creates an instance of FlashForgeClient.
-        
+
         Args:
             ip_address: The IP address of the printer
             serial_number: The serial number of the printer
@@ -42,15 +59,19 @@ class FlashForgeClient:
         self.check_code = check_code
 
         # Constants
-        self._PORT = 8898
+        self._PORT = options.http_port if options and options.http_port is not None else 8898
         self._HTTP_TIMEOUT = 5.0
 
         # HTTP client state
-        self._http_session: Optional[aiohttp.ClientSession] = None
-        self._http_client_busy = False
+        self._http_session: aiohttp.ClientSession | None = None
+        self._http_client_event = asyncio.Event()
+        self._http_client_event.set()  # Not busy initially
 
         # TCP client setup
-        self.tcp_client = TcpClient(ip_address)
+        tcp_options = None
+        if options and options.tcp_port is not None:
+            tcp_options = FlashForgeTcpClientOptions(port=options.tcp_port)
+        self.tcp_client = TcpClient(ip_address, tcp_options)
 
         # Control instances
         self.control = Control(self)
@@ -68,12 +89,22 @@ class FlashForgeClient:
         self.mac_address: str = ""
         self.flash_cloud_code: str = ""
         self.polar_cloud_code: str = ""
+        self.camera_stream_url: str = ""
         self.lifetime_print_time: str = ""
         self.lifetime_filament_meters: str = ""
+        self.product_info: Product | None = None
 
         # Control states
         self.led_control: bool = False
         self.filtration_control: bool = False
+        self._detected_led_control: bool = False
+        self._detected_filtration_control: bool = False
+        self._led_control_override = (
+            options.led_control_override
+            if options and options.led_control_override is not None
+            else None
+        )
+        self._apply_feature_overrides()
 
     @property
     def is_ad5x(self) -> bool:
@@ -85,35 +116,37 @@ class FlashForgeClient:
         """
         return self._is_ad5x
 
-    async def __aenter__(self):
+    async def __aenter__(self) -> "FlashForgeClient":
         """Async context manager entry."""
         await self._ensure_http_session()
         await self.initialize()
         return self
 
-    async def __aexit__(self, exc_type, exc_val, exc_tb):
+    async def __aexit__(
+        self,
+        exc_type: type[BaseException] | None,
+        exc_val: BaseException | None,
+        exc_tb: object,
+    ) -> None:
         """Async context manager exit."""
         await self.dispose()
 
     async def _ensure_http_session(self) -> aiohttp.ClientSession:
         """
         Ensures that an HTTP session is available.
-        
+
         Returns:
             The HTTP session instance
         """
         if self._http_session is None or self._http_session.closed:
             timeout = aiohttp.ClientTimeout(total=self._HTTP_TIMEOUT)
-            self._http_session = aiohttp.ClientSession(
-                timeout=timeout,
-                headers={"Accept": "*/*"}
-            )
+            self._http_session = aiohttp.ClientSession(timeout=timeout, headers={"Accept": "*/*"})
         return self._http_session
 
     async def initialize(self) -> bool:
         """
         Initializes the FlashForgeClient and verifies the connection to the printer.
-        
+
         Returns:
             True if initialization is successful, False otherwise
         """
@@ -123,17 +156,35 @@ class FlashForgeClient:
         print("Failed to connect to printer")
         return False
 
+    @property
+    def _http_client_busy(self) -> bool:
+        """
+        Legacy property to maintain internal API compatibility.
+        Returns True if the client is busy (event is not set), False otherwise.
+        """
+        return not self._http_client_event.is_set()
+
+    @_http_client_busy.setter
+    def _http_client_busy(self, value: bool) -> None:
+        """
+        Sets the busy state using the event.
+        True means busy (clear event), False means not busy (set event).
+        """
+        if value:
+            self._http_client_event.clear()
+        else:
+            self._http_client_event.set()
+
     async def is_http_client_busy(self) -> bool:
         """
         Checks if the HTTP client is currently busy.
-        
+        Waits until the client is not busy before returning.
+
         Returns:
-            True if the HTTP client is busy, False otherwise
+            False (always returns False after waiting, for compatibility)
         """
-        # Wait a bit if busy to prevent tight loops
-        while self._http_client_busy:
-            await asyncio.sleep(0.01)
-        return self._http_client_busy
+        await self._http_client_event.wait()
+        return False
 
     def release_http_client(self) -> None:
         """Releases the HTTP client, allowing it to be used for new requests."""
@@ -142,9 +193,9 @@ class FlashForgeClient:
     async def init_control(self) -> bool:
         """
         Initializes the control interface with the printer.
-        
+
         This involves sending a product command and initializing TCP control.
-        
+
         Returns:
             True if control initialization is successful, False otherwise
         """
@@ -155,20 +206,75 @@ class FlashForgeClient:
 
     async def dispose(self) -> None:
         """
-        Disposes of the FlashForgeClient instance, stopping keep-alive messages 
+        Disposes of the FlashForgeClient instance, stopping keep-alive messages
         and cleaning up resources.
         """
         # Stop TCP keep-alive and dispose
-        if hasattr(self.tcp_client, 'stop_keep_alive'):
+        if hasattr(self.tcp_client, "stop_keep_alive"):
             await self.tcp_client.stop_keep_alive(True)
-        if hasattr(self.tcp_client, 'dispose'):
+        if hasattr(self.tcp_client, "dispose"):
             await self.tcp_client.dispose()
 
         # Close HTTP session
         if self._http_session and not self._http_session.closed:
             await self._http_session.close()
 
-    def cache_details(self, info: Optional[FFMachineInfo]) -> bool:
+        self.camera_stream_url = ""
+
+    async def detect_camera_stream(self, timeout_ms: int = 3000) -> str:
+        """
+        Probes the printer's known OEM camera endpoint.
+
+        Falls back to a short GET when HEAD is unsupported so MJPEG servers
+        that reject HEAD requests are still detected.
+
+        Args:
+            timeout_ms: Timeout for each probe attempt in milliseconds.
+
+        Returns:
+            The working camera stream URL, or an empty string if not detected.
+        """
+        probe_url = f"http://{self.ip_address}:{CAMERA_STREAM_PORT}/?action=stream"
+        timeout = aiohttp.ClientTimeout(total=timeout_ms / 1000)
+
+        if await self._probe_camera_stream_with_method("head", probe_url, timeout):
+            return probe_url
+
+        if await self._probe_camera_stream_with_method("get", probe_url, timeout):
+            return probe_url
+
+        return ""
+
+    async def _probe_camera_stream_with_method(
+        self,
+        method: str,
+        probe_url: str,
+        timeout: aiohttp.ClientTimeout,
+    ) -> bool:
+        try:
+            session = await self._ensure_http_session()
+            request = session.head if method == "head" else session.get
+
+            async with request(probe_url, timeout=timeout) as response:
+                return self._is_valid_camera_probe_response(
+                    response.status, response.headers.get("Content-Type", "")
+                )
+        except Exception:
+            return False
+
+    @staticmethod
+    def _is_valid_camera_probe_response(status: int, content_type: str | None) -> bool:
+        if status != 200:
+            return False
+
+        normalized_content_type = (content_type or "").lower()
+        return (
+            normalized_content_type == ""
+            or "multipart" in normalized_content_type
+            or "video/x-mjpeg" in normalized_content_type
+        )
+
+    def cache_details(self, info: FFMachineInfo | None) -> bool:
         """
         Caches machine details from the provided FFMachineInfo object.
 
@@ -183,29 +289,30 @@ class FlashForgeClient:
 
         # Cache all printer information
         self.printer_name = info.name or ""
+        self.is_pro = info.is_pro
         self.firmware_version = info.firmware_version or ""
-        self.firmware_ver = info.firmware_version.split('-')[0] if info.firmware_version else ""
+        self.firmware_ver = info.firmware_version.split("-")[0] if info.firmware_version else ""
         self.mac_address = info.mac_address or ""
         self.flash_cloud_code = info.flash_cloud_register_code or ""
         self.polar_cloud_code = info.polar_cloud_register_code or ""
+        self.camera_stream_url = info.camera_stream_url or ""
         self.lifetime_print_time = info.formatted_total_run_time or ""
         self._is_ad5x = info.is_ad5x
 
         # Format filament usage
-        if info.cumulative_filament is not None:
-            self.lifetime_filament_meters = f"{info.cumulative_filament:.2f}m"
-        else:
-            self.lifetime_filament_meters = "0.00m"
+        filament_value = info.cumulative_filament if info.cumulative_filament is not None else 0.0
+        self.lifetime_filament_meters = f"{filament_value:.2f}m"
+        self._apply_feature_overrides()
 
         return True
 
     def get_endpoint(self, endpoint: str) -> str:
         """
         Constructs the full API endpoint URL.
-        
+
         Args:
             endpoint: The specific API endpoint path
-            
+
         Returns:
             The full URL for the API endpoint
         """
@@ -214,7 +321,7 @@ class FlashForgeClient:
     async def verify_connection(self) -> bool:
         """
         Verifies the connection to the printer by retrieving machine details and TCP information.
-        
+
         Returns:
             True if the connection is verified, False otherwise
         """
@@ -232,12 +339,14 @@ class FlashForgeClient:
                 return False
 
             # Get TCP printer information to check for Pro model
-            tcp_info: Optional[PrinterInfo] = await self.tcp_client.get_printer_info()
+            tcp_info: PrinterInfo | None = await self.tcp_client.get_printer_info()
             if tcp_info:
-                if "Pro" in tcp_info.type_name:
+                if "Pro" in tcp_info.type_name and not machine_info.is_pro and not machine_info.is_ad5x:
                     self.is_pro = True
             else:
-                print("Warning: Unable to get PrinterInfo from TCP API, some features might not work")
+                print(
+                    "Warning: Unable to get PrinterInfo from TCP API, some features might not work"
+                )
 
             # Cache the details
             return self.cache_details(machine_info)
@@ -249,28 +358,24 @@ class FlashForgeClient:
     async def send_product_command(self) -> bool:
         """
         Sends a product command to the printer to retrieve control states.
-        
+
         This method sets the http_client_busy flag while the request is in progress.
-        
+
         Returns:
-            True if the product command is sent successfully and valid data is received, 
+            True if the product command is sent successfully and valid data is received,
             False otherwise
         """
         self._http_client_busy = True
 
-        payload = {
-            "serialNumber": self.serial_number,
-            "checkCode": self.check_code
-        }
+        payload = {"serialNumber": self.serial_number, "checkCode": self.check_code}
 
         try:
             session = await self._ensure_http_session()
             async with session.post(
                 self.get_endpoint(Endpoints.PRODUCT),
                 json=payload,
-                headers={"Content-Type": "application/json"}
+                headers={"Content-Type": "application/json"},
             ) as response:
-
                 if response.status != 200:
                     return False
 
@@ -282,6 +387,7 @@ class FlashForgeClient:
                     # Fallback: manually parse as JSON if Content-Type is malformed
                     text = await response.text()
                     import json
+
                     data = json.loads(text)
 
                 # Validate response structure
@@ -292,11 +398,12 @@ class FlashForgeClient:
                 product_response = ProductResponse(**data)
                 if product_response and product_response.product:
                     product = product_response.product
-                    self.led_control = product.lightCtrlState != 0
-                    self.filtration_control = not (
-                        product.internalFanCtrlState == 0 or
-                        product.externalFanCtrlState == 0
+                    self.product_info = product
+                    self._detected_led_control = product.lightCtrlState != 0
+                    self._detected_filtration_control = not (
+                        product.internalFanCtrlState == 0 or product.externalFanCtrlState == 0
                     )
+                    self._apply_feature_overrides()
                     return True
 
         except Exception as error:
@@ -310,7 +417,7 @@ class FlashForgeClient:
     async def get_http_session(self) -> aiohttp.ClientSession:
         """
         Gets the HTTP session for making requests.
-        
+
         Returns:
             The HTTP session instance
         """
@@ -318,19 +425,19 @@ class FlashForgeClient:
 
     # Additional convenience methods for direct access to common operations
 
-    async def get_printer_status(self) -> Optional[FFMachineInfo]:
+    async def get_printer_status(self) -> FFMachineInfo | None:
         """
         Gets the current printer status and information.
-        
+
         Returns:
             FFMachineInfo object with current printer status, or None if failed
         """
         return await self.info.get()
 
-    async def get_temperatures(self):
+    async def get_temperatures(self) -> TempInfo | None:
         """
         Gets current temperature readings from the printer.
-        
+
         Returns:
             Temperature information from the TCP client
         """
@@ -339,7 +446,7 @@ class FlashForgeClient:
     async def home_all_axes(self) -> bool:
         """
         Homes all axes (X, Y, Z) of the printer.
-        
+
         Returns:
             True if successful, False otherwise
         """
@@ -348,7 +455,7 @@ class FlashForgeClient:
     async def emergency_stop(self) -> bool:
         """
         Performs an emergency stop of the printer.
-        
+
         Returns:
             True if successful, False otherwise
         """
@@ -357,7 +464,7 @@ class FlashForgeClient:
     async def pause_print(self) -> bool:
         """
         Pauses the current print job.
-        
+
         Returns:
             True if successful, False otherwise
         """
@@ -366,12 +473,26 @@ class FlashForgeClient:
     async def resume_print(self) -> bool:
         """
         Resumes a paused print job.
-        
+
         Returns:
             True if successful, False otherwise
         """
         return await self.job_control.resume_print_job()
 
+    def set_feature_overrides(self, *, led_control: bool | None = None) -> None:
+        """Apply manual feature overrides for integrations that need UI-level capability control."""
+        self._led_control_override = led_control
+        self._apply_feature_overrides()
+
+    def _apply_feature_overrides(self) -> None:
+        """Apply any configured manual capability overrides to the cached client state."""
+        self.led_control = (
+            self._led_control_override
+            if self._led_control_override is not None
+            else self._detected_led_control
+        )
+        self.filtration_control = self._detected_filtration_control
+
     def __repr__(self) -> str:
         """String representation of the client."""
         return (

flashforge/discovery/__init__.py

@@ -4,9 +4,36 @@ FlashForge Python API - Discovery Package
 UDP-based printer discovery for finding FlashForge printers on the local network.
 """
 
-from .discovery import FlashForgePrinter, FlashForgePrinterDiscovery
+from .discovery import (
+    DiscoveredPrinter,
+    DiscoveryError,
+    DiscoveryMonitor,
+    DiscoveryOptions,
+    DiscoveryProtocol,
+    DiscoveryTimeoutError,
+    FlashForgePrinter,
+    FlashForgePrinterDiscovery,
+    InvalidResponseError,
+    PrinterDiscovery,
+    PrinterModel,
+    PrinterStatus,
+    SocketCreationError,
+    main,
+)
 
 __all__ = [
-    'FlashForgePrinter',
-    'FlashForgePrinterDiscovery',
+    "PrinterDiscovery",
+    "DiscoveredPrinter",
+    "DiscoveryOptions",
+    "PrinterModel",
+    "DiscoveryProtocol",
+    "PrinterStatus",
+    "DiscoveryMonitor",
+    "DiscoveryError",
+    "InvalidResponseError",
+    "SocketCreationError",
+    "DiscoveryTimeoutError",
+    "FlashForgePrinter",
+    "FlashForgePrinterDiscovery",
+    "main",
 ]