flashforge-python-api 1.1.0__py3-none-any.whl → 1.2.1__py3-none-any.whl

flashforge/__init__.py

@@ -99,9 +99,13 @@ from .tcp import (
     A3GCodeController,
     A3PrinterInfo,
     A3Thumbnail,
+    A4BuildVolume,
+    A4FileEntry,
+    A4PrinterInfo,
     Endstop,
     EndstopStatus,
     FlashForgeA3Client,
+    FlashForgeA4Client,
     FlashForgeTcpClient,
     FlashForgeTcpClientOptions,
     GCodeController,
@@ -123,7 +127,7 @@ from .tcp import (
 )
 
 FiveMClient = FlashForgeClient
-__version__ = "1.1.0"
+__version__ = "1.1.1"
 __author__ = "FlashForge Python API Contributors"
 __email__ = "notghosttypes@gmail.com"
 __description__ = "Python library for controlling FlashForge 3D printers"
@@ -167,6 +171,7 @@ __all__ = [
     "FlashForgeTcpClient",
     "FlashForgeTcpClientOptions",
     "FlashForgeA3Client",
+    "FlashForgeA4Client",
     "PrinterInfo",
     "TempInfo",
     "TempData",
@@ -185,6 +190,9 @@ __all__ = [
     "A3PrinterInfo",
     "A3FileEntry",
     "A3Thumbnail",
+    "A4BuildVolume",
+    "A4PrinterInfo",
+    "A4FileEntry",
     # Discovery classes
     "PrinterDiscovery",
     "DiscoveredPrinter",

flashforge/api/constants/endpoints.py

@@ -1,3 +1,9 @@
+from typing import Final
+
+
+CAMERA_STREAM_PORT: Final[int] = 8080
+
+
 class Endpoints:
     """
     Endpoints for the "new" HTTP API

flashforge/api/controls/control.py

@@ -4,12 +4,10 @@ FlashForge Python API - Control Module
 
 from typing import TYPE_CHECKING, Any
 
-import aiohttp
-
 from ...models.responses import FilamentArgs
 from ..constants.commands import Commands
 from ..constants.endpoints import Endpoints
-from ..network.utils import NetworkUtils
+from ..network.utils import NetworkUtils, json_from_response
 
 if TYPE_CHECKING:
     from ...client import FlashForgeClient
@@ -239,26 +237,16 @@ class Control:
         try:
             await self.client.is_http_client_busy()
 
-            async with aiohttp.ClientSession() as session:
-                async with session.post(
-                    self.client.get_endpoint(Endpoints.CONTROL),
-                    json=payload,
-                    headers={"Content-Type": "application/json"},
-                ) as response:
-                    # Fix for FlashForge printer's malformed Content-Type header
-                    # Some printers return "appliation/json" instead of "application/json"
-                    try:
-                        data = await response.json()
-                    except aiohttp.ContentTypeError:
-                        # Fallback: manually parse as JSON if Content-Type is malformed
-                        text = await response.text()
-                        import json
-
-                        data = json.loads(text)
-
-                    print(f"Command reply: {data}")
-
-                    return NetworkUtils.is_ok(data)
+            session = await self.client.get_http_session()
+            async with session.post(
+                self.client.get_endpoint(Endpoints.CONTROL),
+                json=payload,
+                headers={"Content-Type": "application/json"},
+            ) as response:
+                data = await json_from_response(response)
+                print(f"Command reply: {data}")
+
+                return NetworkUtils.is_ok(data)
 
         except Exception as e:
             print(f"Error in send_control_command: {e}")

flashforge/api/controls/files.py

@@ -5,13 +5,12 @@ FlashForge Python API - Files Module
 import base64
 from typing import TYPE_CHECKING
 
-import aiohttp
 from pydantic import ValidationError
 
 from ...models.machine_info import FFGcodeFileEntry
 from ...models.responses import GCodeListResponse, ThumbnailResponse
 from ..constants.endpoints import Endpoints
-from ..network.utils import NetworkUtils
+from ..network.utils import NetworkUtils, json_from_response
 
 if TYPE_CHECKING:
     from ...client import FlashForgeClient
@@ -65,74 +64,65 @@ class Files:
         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"},
-                ) as response:
-                    if response.status != 200:
-                        return []
-
-                    # Fix for FlashForge printer's malformed Content-Type header
-                    # Some printers return "appliation/json" instead of "application/json"
-                    try:
-                        data = await response.json()
-                    except aiohttp.ContentTypeError:
-                        # 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):
-                        print(f"Error retrieving file list: {NetworkUtils.get_error_message(data)}")
-                        return []
-
-                    # Parse the response using GCodeListResponse
-                    try:
-                        result = GCodeListResponse(**data)
-                    except ValidationError:
-                        raw_list = data.get("gcodeList", [])
-                        if isinstance(raw_list, list):
-                            entries: list[FFGcodeFileEntry] = []
-                            for file_name in raw_list:
-                                if isinstance(file_name, str):
-                                    entries.append(
-                                        FFGcodeFileEntry(
-                                            gcodeFileName=file_name,
-                                            printingTime=0,
-                                        )
-                                    )
-                            return entries
-                        return []
-
-                    # AD5X and newer printers provide detailed info in gcodeListDetail
-                    if result.gcode_list_detail and len(result.gcode_list_detail) > 0:
-                        return result.gcode_list_detail
-
-                    # Fallback for older printers using gcodeList
-                    if result.gcode_list and len(result.gcode_list) > 0:
-                        # Check if it's a list of strings or already FFGcodeFileEntry objects
-                        first_item = result.gcode_list[0]
-
-                        if isinstance(first_item, str):
-                            # Convert string array to FFGcodeFileEntry objects
-                            return [
-                                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)
-                            ]
+            session = await self.client.get_http_session()
+            async with session.post(
+                self.client.get_endpoint(Endpoints.GCODE_LIST),
+                json=payload,
+                headers={"Content-Type": "application/json"},
+            ) as response:
+                if response.status != 200:
+                    return []
 
+                data = await json_from_response(response)
+
+                if not NetworkUtils.is_ok(data):
+                    print(f"Error retrieving file list: {NetworkUtils.get_error_message(data)}")
                     return []
 
+                # Parse the response using GCodeListResponse
+                try:
+                    result = GCodeListResponse(**data)
+                except ValidationError:
+                    raw_list = data.get("gcodeList", [])
+                    if isinstance(raw_list, list):
+                        entries: list[FFGcodeFileEntry] = []
+                        for file_name in raw_list:
+                            if isinstance(file_name, str):
+                                entries.append(
+                                    FFGcodeFileEntry(
+                                        gcodeFileName=file_name,
+                                        printingTime=0,
+                                    )
+                                )
+                        return entries
+                    return []
+
+                # AD5X and newer printers provide detailed info in gcodeListDetail
+                if result.gcode_list_detail and len(result.gcode_list_detail) > 0:
+                    return result.gcode_list_detail
+
+                # Fallback for older printers using gcodeList
+                if result.gcode_list and len(result.gcode_list) > 0:
+                    # Check if it's a list of strings or already FFGcodeFileEntry objects
+                    first_item = result.gcode_list[0]
+
+                    if isinstance(first_item, str):
+                        # Convert string array to FFGcodeFileEntry objects
+                        return [
+                            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)
+                        ]
+
+                return []
+
         except Exception as err:
             print(f"GetRecentFileList error: {err}")
             return []
@@ -156,33 +146,24 @@ class Files:
         }
 
         try:
-            async with aiohttp.ClientSession() as session:
-                async with session.post(
-                    self.client.get_endpoint(Endpoints.GCODE_THUMB),
-                    json=payload,
-                    headers={"Content-Type": "application/json"},
-                ) as response:
-                    if response.status != 200:
-                        return None
-
-                    # Fix for FlashForge printer's malformed Content-Type header
-                    # Some printers return "appliation/json" instead of "application/json"
-                    try:
-                        data = await response.json()
-                    except aiohttp.ContentTypeError:
-                        # 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):
-                        # Parse response and return decoded image bytes
-                        result = ThumbnailResponse(**data)
-                        return base64.b64decode(result.image_data)
-                    else:
-                        print(f"Error retrieving thumbnail: {NetworkUtils.get_error_message(data)}")
-                        return None
+            session = await self.client.get_http_session()
+            async with session.post(
+                self.client.get_endpoint(Endpoints.GCODE_THUMB),
+                json=payload,
+                headers={"Content-Type": "application/json"},
+            ) as response:
+                if response.status != 200:
+                    return None
+
+                data = await json_from_response(response)
+
+                if NetworkUtils.is_ok(data):
+                    # Parse response and return decoded image bytes
+                    result = ThumbnailResponse(**data)
+                    return base64.b64decode(result.image_data)
+                else:
+                    print(f"Error retrieving thumbnail: {NetworkUtils.get_error_message(data)}")
+                    return None
 
         except Exception as err:
             print(f"GetGcodeThumbnail error: {err}")

flashforge/api/controls/info.py

@@ -5,11 +5,10 @@ FlashForge Python API - Info Module
 from datetime import datetime, timedelta
 from typing import TYPE_CHECKING
 
-import aiohttp
-
 from ...models.machine_info import FFMachineInfo, MachineState, Temperature
 from ...models.responses import DetailResponse, FFPrinterDetail
 from ..constants.endpoints import Endpoints
+from ..network.utils import json_from_response
 
 if TYPE_CHECKING:
     from ...client import FlashForgeClient
@@ -262,29 +261,18 @@ class Info:
         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"},
-                ) as response:
-                    if response.status != 200:
-                        print(f"Non-200 status from detail endpoint: {response.status}")
-                        return None
-
-                    # Fix for FlashForge printer's malformed Content-Type header
-                    # Some printers return "appliation/json" instead of "application/json"
-                    # We'll manually parse the text as JSON to bypass Content-Type validation
-                    try:
-                        data = await response.json()
-                    except aiohttp.ContentTypeError:
-                        # Fallback: manually parse as JSON if Content-Type is malformed
-                        text = await response.text()
-                        import json
-
-                        data = json.loads(text)
-
-                    return DetailResponse(**data)
+            session = await self.client.get_http_session()
+            async with session.post(
+                self.client.get_endpoint(Endpoints.DETAIL),
+                json=payload,
+                headers={"Content-Type": "application/json"},
+            ) as response:
+                if response.status != 200:
+                    print(f"Non-200 status from detail endpoint: {response.status}")
+                    return None
+
+                data = await json_from_response(response)
+                return DetailResponse(**data)
 
         except Exception as error:
             print(f"GetDetailResponse Request error: {error}")

flashforge/api/controls/job_control.py

@@ -17,7 +17,7 @@ from ...models.responses import (
     AD5XUploadParams,
 )
 from ..constants.endpoints import Endpoints
-from ..network.utils import NetworkUtils
+from ..network.utils import NetworkUtils, json_from_response
 
 if TYPE_CHECKING:
     from ...client import FlashForgeClient
@@ -180,17 +180,7 @@ class JobControl:
                             print(f"Upload failed: Printer responded with status {response.status}")
                             return False
 
-                        # Fix for FlashForge printer's malformed Content-Type header
-                        # Some printers return "appliation/json" instead of "application/json"
-                        try:
-                            result = await response.json()
-                        except aiohttp.ContentTypeError:
-                            # Fallback: manually parse as JSON if Content-Type is malformed
-                            text = await response.text()
-                            import json
-
-                            result = json.loads(text)
-
+                        result = await json_from_response(response)
                         print("Upload Response Data:", result)
 
                         if NetworkUtils.is_ok(result):
@@ -240,27 +230,17 @@ class JobControl:
             }
 
         try:
-            async with aiohttp.ClientSession() as session:
-                async with session.post(
-                    self.client.get_endpoint(Endpoints.GCODE_PRINT),
-                    json=payload,
-                    headers={"Content-Type": "application/json"},
-                ) as response:
-                    if response.status != 200:
-                        return False
-
-                    # Fix for FlashForge printer's malformed Content-Type header
-                    # Some printers return "appliation/json" instead of "application/json"
-                    try:
-                        result = await response.json()
-                    except aiohttp.ContentTypeError:
-                        # Fallback: manually parse as JSON if Content-Type is malformed
-                        text = await response.text()
-                        import json
-
-                        result = json.loads(text)
-
-                    return NetworkUtils.is_ok(result)
+            session = await self.client.get_http_session()
+            async with session.post(
+                self.client.get_endpoint(Endpoints.GCODE_PRINT),
+                json=payload,
+                headers={"Content-Type": "application/json"},
+            ) as response:
+                if response.status != 200:
+                    return False
+
+                result = await json_from_response(response)
+                return NetworkUtils.is_ok(result)
 
         except Exception as error:
             print(f"PrintLocalFile error: {error}")
@@ -344,13 +324,7 @@ class JobControl:
                             )
                             return False
 
-                        # Fix for FlashForge printer's malformed Content-Type header
-                        try:
-                            result = await response.json()
-                        except aiohttp.ContentTypeError:
-                            text = await response.text()
-                            result = json.loads(text)
-
+                        result = await json_from_response(response)
                         print("AD5X Upload Response Data:", result)
 
                         if NetworkUtils.is_ok(result):
@@ -415,23 +389,17 @@ class JobControl:
         }
 
         try:
-            async with aiohttp.ClientSession() as session:
-                async with session.post(
-                    self.client.get_endpoint(Endpoints.GCODE_PRINT),
-                    json=payload,
-                    headers={"Content-Type": "application/json"},
-                ) as response:
-                    if response.status != 200:
-                        return False
-
-                    # Fix for FlashForge printer's malformed Content-Type header
-                    try:
-                        result = await response.json()
-                    except aiohttp.ContentTypeError:
-                        text = await response.text()
-                        result = json.loads(text)
-
-                    return NetworkUtils.is_ok(result)
+            session = await self.client.get_http_session()
+            async with session.post(
+                self.client.get_endpoint(Endpoints.GCODE_PRINT),
+                json=payload,
+                headers={"Content-Type": "application/json"},
+            ) as response:
+                if response.status != 200:
+                    return False
+
+                result = await json_from_response(response)
+                return NetworkUtils.is_ok(result)
 
         except Exception as error:
             print(f"AD5X Multi-Color Job error: {error}")
@@ -473,23 +441,17 @@ class JobControl:
         }
 
         try:
-            async with aiohttp.ClientSession() as session:
-                async with session.post(
-                    self.client.get_endpoint(Endpoints.GCODE_PRINT),
-                    json=payload,
-                    headers={"Content-Type": "application/json"},
-                ) as response:
-                    if response.status != 200:
-                        return False
-
-                    # Fix for FlashForge printer's malformed Content-Type header
-                    try:
-                        result = await response.json()
-                    except aiohttp.ContentTypeError:
-                        text = await response.text()
-                        result = json.loads(text)
-
-                    return NetworkUtils.is_ok(result)
+            session = await self.client.get_http_session()
+            async with session.post(
+                self.client.get_endpoint(Endpoints.GCODE_PRINT),
+                json=payload,
+                headers={"Content-Type": "application/json"},
+            ) as response:
+                if response.status != 200:
+                    return False
+
+                result = await json_from_response(response)
+                return NetworkUtils.is_ok(result)
 
         except Exception as error:
             print(f"AD5X Single-Color Job error: {error}")

flashforge/api/network/utils.py

@@ -2,9 +2,26 @@
 FlashForge Python API - Network Utilities
 """
 
+import json
+
+import aiohttp
+
 from ...models.responses import GenericResponse
 
 
+async def json_from_response(response: aiohttp.ClientResponse) -> dict:
+    """Parse JSON from a response, with a fallback for malformed Content-Type headers.
+
+    Some FlashForge printers return "appliation/json" instead of "application/json",
+    causing aiohttp to raise ContentTypeError. This helper handles both cases.
+    """
+    try:
+        return await response.json()  # type: ignore[no-any-return]
+    except aiohttp.ContentTypeError:
+        text = await response.text()
+        return json.loads(text)
+
+
 class NetworkUtils:
     """Utility class for handling network responses and status codes."""
 

flashforge/client.py

@@ -10,10 +10,10 @@ 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 .api.network.utils import NetworkUtils, json_from_response
 from .models import FFMachineInfo, Product, ProductResponse
 from .tcp import FlashForgeClient as TcpClient
 from .tcp import FlashForgeTcpClientOptions, PrinterInfo
@@ -60,7 +60,7 @@ class FlashForgeClient:
 
         # Constants
         self._PORT = options.http_port if options and options.http_port is not None else 8898
-        self._HTTP_TIMEOUT = 5.0
+        self._HTTP_TIMEOUT = 15.0
 
         # HTTP client state
         self._http_session: aiohttp.ClientSession | None = None
@@ -221,6 +221,59 @@ class FlashForgeClient:
 
         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.
@@ -326,16 +379,7 @@ class FlashForgeClient:
                 if response.status != 200:
                     return False
 
-                # Fix for FlashForge printer's malformed Content-Type header
-                # Some printers return "appliation/json" instead of "application/json"
-                try:
-                    data = await response.json()
-                except aiohttp.ContentTypeError:
-                    # Fallback: manually parse as JSON if Content-Type is malformed
-                    text = await response.text()
-                    import json
-
-                    data = json.loads(text)
+                data = await json_from_response(response)
 
                 # Validate response structure
                 if not NetworkUtils.is_ok(data):