flashforge-python-api 1.1.0__py3-none-any.whl → 1.2.0__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/client.py

@@ -10,7 +10,7 @@ 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
@@ -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.

flashforge/discovery/discovery.py

@@ -22,7 +22,8 @@ LEGACY_PROTOCOL_SIZE = 140
 
 LEGACY_PRODUCT_IDS = {
     "Adventurer3": 0x0008,
-    "Adventurer4": 0x001E,
+    "Adventurer4Lite": 0x0016,
+    "Adventurer4Pro": 0x001E,
 }
 
 
@@ -426,7 +427,7 @@ class PrinterDiscovery:
             return None
 
     def parse_modern_protocol(self, buffer: bytes, ip_address: str) -> DiscoveredPrinter:
-        """Parse a modern 276-byte discovery response."""
+        """Parse a modern 276-byte (0x114) discovery response."""
         if len(buffer) < MODERN_PROTOCOL_SIZE:
             raise InvalidResponseError(len(buffer), ip_address)
 
@@ -434,10 +435,10 @@ class PrinterDiscovery:
         command_port = int.from_bytes(buffer[0x84:0x86], byteorder="big")
         vendor_id = int.from_bytes(buffer[0x86:0x88], byteorder="big")
         product_id = int.from_bytes(buffer[0x88:0x8A], byteorder="big")
+        status_code = int.from_bytes(buffer[0x8A:0x8C], byteorder="big")
         product_type = int.from_bytes(buffer[0x8C:0x8E], byteorder="big")
         event_port = int.from_bytes(buffer[0x8E:0x90], byteorder="big")
-        status_code = int.from_bytes(buffer[0x90:0x92], byteorder="big")
-        serial_number = buffer[0x92 : 0x92 + 130].decode("utf-8", errors="ignore").split("\x00", 1)[0]
+        serial_number = buffer[0x92 : 0x92 + 128].decode("utf-8", errors="ignore").split("\x00", 1)[0]
         model = self.detect_modern_model(name, product_type)
 
         return DiscoveredPrinter(
@@ -508,7 +509,10 @@ class PrinterDiscovery:
         if "ADVENTURER 3" in upper_name or "ADVENTURER3" in upper_name or "AD3" in upper_name:
             return PrinterModel.ADVENTURER_3
 
-        if product_id == LEGACY_PRODUCT_IDS["Adventurer4"]:
+        if product_id in {
+            LEGACY_PRODUCT_IDS["Adventurer4Lite"],
+            LEGACY_PRODUCT_IDS["Adventurer4Pro"],
+        }:
             return PrinterModel.ADVENTURER_4
 
         if product_id == LEGACY_PRODUCT_IDS["Adventurer3"]:

flashforge/models/machine_info.py

@@ -199,20 +199,23 @@ class FFPrinterDetail(BaseModel):
     of boolean states (e.g., "open", "close").
     """
 
-    model_config = ConfigDict(extra="forbid")
+    model_config = ConfigDict(extra="allow")
 
     auto_shutdown: str | None = Field(default=None, alias="autoShutdown")
     auto_shutdown_time: int | None = Field(default=None, ge=0, alias="autoShutdownTime")
+    camera: int | None = Field(default=None, ge=0, alias="camera")
     camera_stream_url: str | None = Field(default=None, alias="cameraStreamUrl")
     chamber_fan_speed: int | None = Field(default=None, ge=0, le=100, alias="chamberFanSpeed")
     chamber_target_temp: float | None = Field(
         default=None, ge=-50, le=500, alias="chamberTargetTemp"
     )
     chamber_temp: float | None = Field(default=None, ge=-50, le=500, alias="chamberTemp")
+    clear_fan_status: str | None = Field(default=None, alias="clearFanStatus")
     cooling_fan_speed: int | None = Field(default=None, ge=0, le=100, alias="coolingFanSpeed")
     cooling_fan_left_speed: int | None = Field(
         default=None, ge=0, le=100, alias="coolingFanLeftSpeed"
     )
+    coordinate: list[float] | None = Field(default=None, alias="coordinate")
     cumulative_filament: float | None = Field(default=None, ge=0, alias="cumulativeFilament")
     cumulative_print_time: int | None = Field(default=None, ge=0, alias="cumulativePrintTime")
     current_print_speed: int | None = Field(default=None, ge=0, le=200, alias="currentPrintSpeed")
@@ -223,6 +226,7 @@ class FFPrinterDetail(BaseModel):
     estimated_right_len: float | None = Field(default=None, ge=0, alias="estimatedRightLen")
     estimated_right_weight: float | None = Field(default=None, ge=0, alias="estimatedRightWeight")
     estimated_time: float | None = Field(default=None, ge=0, alias="estimatedTime")
+    extrude_ctrl: int | None = Field(default=None, ge=0, alias="extrudeCtrl")
     external_fan_status: str | None = Field(default=None, alias="externalFanStatus")
     fill_amount: float | None = Field(default=None, ge=0, le=100, alias="fillAmount")
     firmware_version: str | None = Field(default=None, alias="firmwareVersion")
@@ -241,6 +245,7 @@ class FFPrinterDetail(BaseModel):
     location: str | None = Field(default=None, alias="location")
     mac_addr: str | None = Field(default=None, alias="macAddr")
     measure: str | None = Field(default=None, alias="measure")
+    move_ctrl: int | None = Field(default=None, ge=0, alias="moveCtrl")
     name: str | None = Field(default=None, alias="name")
     nozzle_cnt: int | None = Field(default=None, ge=1, le=4, alias="nozzleCnt")
     nozzle_model: str | None = Field(default=None, alias="nozzleModel")

flashforge/tcp/__init__.py

@@ -6,6 +6,7 @@ for controlling FlashForge printers via their TCP API.
 """
 
 from .a3_client import A3BuildVolume, A3FileEntry, A3PrinterInfo, A3Thumbnail, FlashForgeA3Client
+from .a4_client import A4BuildVolume, A4FileEntry, A4PrinterInfo, FlashForgeA4Client
 from .ff_client import FlashForgeClient
 from .gcode import A3GCodeController, GCodeController, GCodes
 from .parsers import (
@@ -28,6 +29,7 @@ __all__ = [
     "FlashForgeTcpClientOptions",
     "FlashForgeClient",
     "FlashForgeA3Client",
+    "FlashForgeA4Client",
     "GCodes",
     "GCodeController",
     "A3GCodeController",
@@ -35,6 +37,9 @@ __all__ = [
     "A3PrinterInfo",
     "A3FileEntry",
     "A3Thumbnail",
+    "A4BuildVolume",
+    "A4PrinterInfo",
+    "A4FileEntry",
     "PrinterInfo",
     "TempInfo",
     "TempData",

flashforge/tcp/a3_client.py

@@ -9,6 +9,7 @@ import re
 from dataclasses import dataclass
 from typing import TYPE_CHECKING
 
+from .gcode.gcodes import GCodes
 from .parsers import EndstopStatus, LocationInfo, PrintStatus, TempInfo
 from .tcp_client import FlashForgeTcpClient, FlashForgeTcpClientOptions
 
@@ -112,15 +113,15 @@ class FlashForgeA3Client(FlashForgeTcpClient):
         return self._normalize_a3_text_response(response)
 
     async def init_control(self) -> bool:
-        """Initialize control by sending M601."""
+        """Initialize control by sending the legacy M601 S1 login command."""
         try:
             await asyncio.sleep(0.5)
-            response = await self.send_command_async("~M601")
+            response = await self.send_command_async(GCodes.CMD_LOGIN)
             if response is None:
                 return False
             if "Error: have been connected" in response:
                 return True
-            return self._is_successful_command_response("~M601", response)
+            return self._is_successful_command_response(GCodes.CMD_LOGIN, response)
         except Exception:
             return False
 
@@ -150,6 +151,8 @@ class FlashForgeA3Client(FlashForgeTcpClient):
                 info.machine_name = line.replace("Machine Name:", "", 1).strip()
             elif line.startswith("Firmware:"):
                 info.firmware = line.replace("Firmware:", "", 1).strip()
+            elif line.startswith("SN:"):
+                info.serial_number = line.replace("SN:", "", 1).strip()
             elif line.startswith("Serial Number:"):
                 info.serial_number = line.replace("Serial Number:", "", 1).strip()
             elif line.startswith("Tool Count:"):

flashforge/tcp/a4_client.py

@@ -0,0 +1,300 @@
+"""
+Adventurer 4 TCP client and typed helpers.
+"""
+
+from __future__ import annotations
+
+import asyncio
+import logging
+from dataclasses import dataclass
+from typing import Literal
+
+from .gcode import GCodeController, GCodes
+from .parsers import EndstopStatus, LocationInfo, PrintStatus, TempInfo, ThumbnailInfo
+from .tcp_client import FlashForgeTcpClient, FlashForgeTcpClientOptions
+
+logger = logging.getLogger(__name__)
+
+A4PrinterVariant = Literal["lite", "pro", "unknown"]
+
+
+@dataclass(slots=True)
+class A4BuildVolume:
+    """Build volume metadata reported by Adventurer 4 M115 replies."""
+
+    x: int
+    y: int
+    z: int
+
+
+@dataclass(slots=True)
+class A4PrinterInfo:
+    """Structured Adventurer 4 printer info parsed from M115."""
+
+    machine_type: str
+    machine_name: str
+    firmware: str
+    serial_number: str | None
+    build_volume: A4BuildVolume
+    tool_count: int
+    mac_address: str
+    variant: A4PrinterVariant
+    raw: str
+
+
+@dataclass(slots=True)
+class A4FileEntry:
+    """Normalized file entry returned by the Adventurer 4 TCP client."""
+
+    name: str
+    path: str
+
+
+class FlashForgeA4Client(FlashForgeTcpClient):
+    """TCP client for FlashForge Adventurer 4 Lite and Pro printers."""
+
+    def __init__(self, hostname: str, options: FlashForgeTcpClientOptions | None = None) -> None:
+        super().__init__(hostname, options)
+        self._control = GCodeController(self)
+
+    def get_ip(self) -> str:
+        """Return the configured printer hostname or IP address."""
+        return self.hostname
+
+    def gcode(self) -> GCodeController:
+        """Return the shared G-code controller."""
+        return self._control
+
+    async def init_control(self) -> bool:
+        """Initialize control using the legacy M601 S1 login flow."""
+        try:
+            response = await self.send_command_async(GCodes.CMD_LOGIN)
+            if response is None:
+                logger.error("A4: failed to send M601 S1 login command")
+                return False
+
+            if "Error: have been connected" in response:
+                logger.warning("A4: already connected to printer")
+                return True
+
+            if not self._is_successful_command_response(GCodes.CMD_LOGIN, response):
+                return False
+
+            await asyncio.sleep(0.1)
+            info = await self.get_printer_info()
+            if not info:
+                logger.error("A4: failed to retrieve printer info after M601 S1")
+                return False
+
+            await self.start_keep_alive()
+            return True
+        except Exception as error:
+            logger.error("A4: init_control error: %s", error)
+            return False
+
+    async def led_on(self) -> bool:
+        return await self._control.led_on()
+
+    async def led_off(self) -> bool:
+        return await self._control.led_off()
+
+    async def pause_job(self) -> bool:
+        return await self._control.pause_job()
+
+    async def resume_job(self) -> bool:
+        return await self._control.resume_job()
+
+    async def stop_job(self) -> bool:
+        return await self._control.stop_job()
+
+    async def start_job(self, name: str) -> bool:
+        return await self._control.start_job(name)
+
+    async def home_axes(self) -> bool:
+        return await self._control.home()
+
+    async def rapid_home(self) -> bool:
+        return await self._control.rapid_home()
+
+    async def set_extruder_temp(self, temp: int, wait_for: bool = False) -> bool:
+        return await self._control.set_extruder_temp(temp, wait_for)
+
+    async def cancel_extruder_temp(self) -> bool:
+        return await self._control.cancel_extruder_temp()
+
+    async def set_bed_temp(self, temp: int, wait_for: bool = False) -> bool:
+        return await self._control.set_bed_temp(temp, wait_for)
+
+    async def cancel_bed_temp(self, wait_for_cool: bool = False) -> bool:
+        return await self._control.cancel_bed_temp(wait_for_cool)
+
+    async def extrude(self, length: float, feedrate: int = 450) -> bool:
+        return await self.send_cmd_ok(f"~G1 E{length} F{feedrate}")
+
+    async def move_extruder(self, x: float, y: float, feedrate: int) -> bool:
+        return await self.send_cmd_ok(f"~G1 X{x} Y{y} F{feedrate}")
+
+    async def move(self, x: float, y: float, z: float, feedrate: int) -> bool:
+        return await self.send_cmd_ok(f"~G1 X{x} Y{y} Z{z} F{feedrate}")
+
+    async def send_cmd_ok(self, cmd: str) -> bool:
+        """Send a command and apply Adventurer 4 success semantics."""
+        try:
+            response = await self.send_command_async(cmd)
+            if response is None:
+                return False
+            return self._is_successful_command_response(cmd, response)
+        except Exception as error:
+            logger.error("A4: send_cmd_ok failed for %s: %s", cmd, error)
+            return False
+
+    async def send_raw_cmd(self, cmd: str) -> str:
+        """Send a raw command and return the raw string response."""
+        if "M661" not in cmd:
+            response = await self.send_command_async(cmd)
+            return response or ""
+
+        files = await self.get_file_list_async()
+        return "\n".join(files)
+
+    async def get_printer_info(self) -> A4PrinterInfo | None:
+        """Get printer information using the documented Adventurer 4 M115 response."""
+        response = await self.send_command_async(GCodes.CMD_INFO_STATUS)
+        if response is None:
+            return None
+
+        normalized = self._normalize_a4_text_response(response)
+        lines = self._get_normalized_lines(normalized)
+        info = A4PrinterInfo(
+            machine_type="",
+            machine_name="",
+            firmware="",
+            serial_number=None,
+            build_volume=A4BuildVolume(x=220, y=200, z=250),
+            tool_count=1,
+            mac_address="",
+            variant="unknown",
+            raw=normalized,
+        )
+
+        for line in lines:
+            if line.startswith("Machine Type:"):
+                info.machine_type = line.replace("Machine Type:", "", 1).strip()
+                info.variant = self._detect_variant(info.machine_type)
+            elif line.startswith("Machine Name:"):
+                info.machine_name = line.replace("Machine Name:", "", 1).strip()
+            elif line.startswith("Firmware:"):
+                info.firmware = line.replace("Firmware:", "", 1).strip()
+            elif line.startswith("SN:"):
+                info.serial_number = line.replace("SN:", "", 1).strip()
+            elif line.startswith("Serial Number:"):
+                info.serial_number = line.replace("Serial Number:", "", 1).strip()
+            elif line.startswith("Tool Count:") or line.startswith("Tool count:"):
+                try:
+                    info.tool_count = int(line.split(":", 1)[1].strip())
+                except (IndexError, ValueError):
+                    info.tool_count = 1
+            elif line.startswith("Mac Address:"):
+                info.mac_address = line.replace("Mac Address:", "", 1).strip()
+            elif "X:" in line and "Y:" in line and "Z:" in line:
+                volume_tokens = line.replace(":", "").split()
+                try:
+                    info.build_volume = A4BuildVolume(
+                        x=int(volume_tokens[1]),
+                        y=int(volume_tokens[3]),
+                        z=int(volume_tokens[5]),
+                    )
+                except (IndexError, ValueError):
+                    pass
+
+        if not info.machine_type or not info.firmware:
+            return None
+
+        return info
+
+    async def get_temp_info(self) -> TempInfo | None:
+        response = await self.send_command_async(GCodes.CMD_TEMP)
+        if response:
+            return TempInfo().from_replay(self._normalize_a4_text_response(response))
+        return None
+
+    async def get_endstop_status(self) -> EndstopStatus | None:
+        response = await self.send_command_async(GCodes.CMD_ENDSTOP_INFO)
+        if response:
+            return EndstopStatus().from_replay(self._normalize_a4_text_response(response))
+        return None
+
+    async def get_endstop_info(self) -> EndstopStatus | None:
+        return await self.get_endstop_status()
+
+    async def get_print_status(self) -> PrintStatus | None:
+        response = await self.send_command_async(GCodes.CMD_PRINT_STATUS)
+        if response:
+            return PrintStatus().from_replay(self._normalize_a4_text_response(response))
+        return None
+
+    async def get_location_info(self) -> LocationInfo | None:
+        response = await self.send_command_async(GCodes.CMD_INFO_XYZAB)
+        if response:
+            return LocationInfo().from_replay(self._normalize_a4_text_response(response))
+        return None
+
+    async def list_files(self) -> list[A4FileEntry]:
+        files = await self.get_file_list_async()
+        entries: list[A4FileEntry] = []
+        for relative_path in files:
+            normalized_path = (
+                relative_path if relative_path.startswith("/data/") else f"/data/{relative_path}"
+            )
+            entries.append(
+                A4FileEntry(
+                    name=normalized_path.split("/")[-1] or relative_path,
+                    path=normalized_path,
+                )
+            )
+        return entries
+
+    async def get_thumbnail(self, file_name: str) -> ThumbnailInfo | None:
+        file_path = file_name if file_name.startswith("/data/") else f"/data/{file_name}"
+        response = await self.send_command_async(f"{GCodes.CMD_GET_THUMBNAIL} {file_path}")
+        if response:
+            return ThumbnailInfo().from_replay(response, file_name)
+        return None
+
+    def _normalize_a4_text_response(self, response: str) -> str:
+        normalized = response.replace("\r\n", "\n").replace("\r", "\n").rstrip()
+        lines = normalized.split("\n")
+        if lines:
+            lines[0] = lines[0].removeprefix("ack: ").removeprefix("echo: ")
+        normalized = "\n".join(lines).rstrip()
+
+        if normalized.startswith('"') and normalized.endswith('"'):
+            normalized = normalized[1:-1].rstrip()
+
+        return normalized
+
+    def _get_normalized_lines(self, response: str) -> list[str]:
+        return [line.strip() for line in self._normalize_a4_text_response(response).split("\n") if line.strip()]
+
+    def _detect_variant(self, machine_type: str) -> A4PrinterVariant:
+        normalized_type = machine_type.upper()
+        if "PRO" in normalized_type:
+            return "pro"
+        if "ADVENTURER 4" in normalized_type or "ADVENTURER4" in normalized_type:
+            return "lite"
+        return "unknown"
+
+    def _is_successful_command_response(self, cmd: str, response: str) -> bool:
+        normalized = self._normalize_a4_text_response(response).strip()
+        if not normalized:
+            return False
+
+        lowered = normalized.lower()
+        if "error:" in lowered or "control failed." in lowered:
+            return False
+
+        bare_cmd = cmd.strip().removeprefix("~").split(maxsplit=1)[0]
+        if bare_cmd == "M23":
+            return "File opened" in normalized or "ok" in lowered
+
+        return "ok" in lowered or "Received." in normalized or normalized.startswith(bare_cmd)

flashforge_python_api-1.2.0.dist-info/METADATA

@@ -0,0 +1,133 @@
+Metadata-Version: 2.4
+Name: flashforge-python-api
+Version: 1.2.0
+Summary: A comprehensive Python library for controlling FlashForge 3D printers
+Project-URL: Homepage, https://github.com/GhostTypes/ff-5mp-api-py
+Project-URL: Documentation, https://github.com/GhostTypes/ff-5mp-api-py#readme
+Project-URL: Repository, https://github.com/GhostTypes/ff-5mp-api-py.git
+Project-URL: Issues, https://github.com/GhostTypes/ff-5mp-api-py/issues
+Author-email: GhostTypes <notghosttypes@gmail.com>
+License-Expression: MIT
+License-File: LICENSE
+Keywords: 3d-printer,api,async,control,flashforge,python
+Classifier: Development Status :: 5 - Production/Stable
+Classifier: Intended Audience :: Developers
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
+Classifier: Programming Language :: Python :: 3.13
+Classifier: Topic :: Scientific/Engineering
+Classifier: Topic :: Software Development :: Libraries :: Python Modules
+Classifier: Topic :: System :: Hardware :: Hardware Drivers
+Requires-Python: >=3.11
+Requires-Dist: aiohttp>=3.8.0
+Requires-Dist: netifaces>=0.11.0
+Requires-Dist: pydantic>=2.0.0
+Requires-Dist: requests>=2.31.0
+Provides-Extra: all
+Requires-Dist: black>=23.0.0; extra == 'all'
+Requires-Dist: mypy>=1.0.0; extra == 'all'
+Requires-Dist: pillow>=10.0.0; extra == 'all'
+Requires-Dist: pre-commit>=3.0.0; extra == 'all'
+Requires-Dist: pytest-asyncio>=0.21.0; extra == 'all'
+Requires-Dist: pytest-cov>=4.0.0; extra == 'all'
+Requires-Dist: pytest>=7.0.0; extra == 'all'
+Requires-Dist: ruff>=0.1.0; extra == 'all'
+Provides-Extra: dev
+Requires-Dist: black>=23.0.0; extra == 'dev'
+Requires-Dist: mypy>=1.0.0; extra == 'dev'
+Requires-Dist: pre-commit>=3.0.0; extra == 'dev'
+Requires-Dist: pytest-asyncio>=0.21.0; extra == 'dev'
+Requires-Dist: pytest-cov>=4.0.0; extra == 'dev'
+Requires-Dist: pytest>=7.0.0; extra == 'dev'
+Requires-Dist: ruff>=0.1.0; extra == 'dev'
+Provides-Extra: imaging
+Requires-Dist: pillow>=10.0.0; extra == 'imaging'
+Description-Content-Type: text/markdown
+
+# FlashForge Python API
+
+Python library for controlling FlashForge 3D printers with async support for the modern HTTP API and the legacy TCP protocol.
+
+## Supported Printers
+
+| Printer | Support |
+| --- | --- |
+| Adventurer 5M | Full |
+| Adventurer 5M Pro | Full |
+| AD5X | Full |
+| Adventurer 3 / 4 | Dedicated TCP clients |
+
+## Installation
+
+```bash
+pip install flashforge-python-api
+```
+
+## Quick Start
+
+Modern LAN-mode HTTP printers require:
+
+- printer IP address
+- serial number
+- check code
+
+```python
+import asyncio
+from flashforge import FlashForgeClient, PrinterDiscovery
+
+
+async def main():
+    discovery = PrinterDiscovery()
+    printers = await discovery.discover()
+
+    if not printers:
+        print("No printers found")
+        return
+
+    printer = printers[0]
+
+    async with FlashForgeClient(
+        printer.ip_address,
+        printer.serial_number or "SERIAL_NUMBER",
+        "CHECK_CODE",
+    ) as client:
+        if not await client.initialize():
+            return
+
+        await client.init_control()
+
+        status = await client.get_printer_status()
+        print(f"Printer: {client.printer_name}")
+        print(f"State: {status.machine_state if status else 'unknown'}")
+
+        await client.control.home_axes()
+
+
+asyncio.run(main())
+```
+
+## Main Entry Points
+
+- `FlashForgeClient`: primary client for modern printers
+- `PrinterDiscovery`: recommended discovery API
+- `FlashForgeA4Client`: documented TCP client for Adventurer 4 Lite / Pro printers
+- `FlashForgeA3Client`: documented TCP client for Adventurer 3 printers
+- `FlashForgeTcpClient` and `client.tcp_client`: lower-level TCP access for direct commands and generic legacy workflows
+
+## Capabilities
+
+- printer discovery
+- printer status and machine information
+- job control
+- file listing, uploads, and thumbnails
+- temperature and motion control
+- LED, camera, and filtration control where supported
+- AD5X-specific job and material-station support
+
+## Documentation
+
+- [docs/README.md](docs/README.md)
+- [docs/client.md](docs/client.md)
+- [docs/protocols.md](docs/protocols.md)
+- [docs/api_reference.md](docs/api_reference.md)

{flashforge_python_api-1.1.0.dist-info → flashforge_python_api-1.2.0.dist-info}/RECORD

@@ -1,9 +1,9 @@
-flashforge/__init__.py,sha256=k67UUBpSPMCRlexqn43RRHIh8XyNb9Bq5yXOpwChsFo,5170
-flashforge/client.py,sha256=XP_l5FsaUXKWjkRMWxbz7F1d7_8Xdh7oD5zpThtBFhM,15462
+flashforge/__init__.py,sha256=3fmBeEJ4vFJDSsOQV0Yixb1yLyUw8nHDZKQHbXIbtmo,5336
+flashforge/client.py,sha256=lmkPfkhcfDslbROv6XouwTIHshz4rHS0wNNJeicBHiA,17334
 flashforge/api/__init__.py,sha256=vQz-DkG6LTH39bI4fyiUc0D9jQzemLh45pORLptSOlg,335
 flashforge/api/constants/__init__.py,sha256=Q0HL2tqSBYPd4Oz49VHLS3qUvRuv__GCvTGecaLrQ-Y,163
 flashforge/api/constants/commands.py,sha256=S9cBgU3pBXQm-dp3Bv4795NL059pmTY1NtxWzPA5gWU,329
-flashforge/api/constants/endpoints.py,sha256=3CSCvilBJ1uAM_dZiY5NgbYl4rub1RsZZRpCBRZCqH4,271
+flashforge/api/constants/endpoints.py,sha256=zU_ONPyLUATr1KPlk0x8SLrK4ojs4QiiWr1-WwLVwTY,338
 flashforge/api/controls/__init__.py,sha256=53s-H25Pjwr0kvPk8MZ2Twy8VHGqGcO6Q6uBphhEOh4,293
 flashforge/api/controls/control.py,sha256=hifFWRPs2fRvNaJMSLgDJ4ytkHrEMGqzgCazuAC6ewA,11787
 flashforge/api/controls/files.py,sha256=fFjxOCVbK7q1P4GM9RcgB2tsJsywT_HiTBcL3-U0_Yo,7749
@@ -19,12 +19,13 @@ flashforge/api/network/__init__.py,sha256=G5fBoAlq-NQPDkWp579mFIqsj0v7B1Lb2TAzO6
 flashforge/api/network/fnet_code.py,sha256=BR2niVKKk4ZfXtizUDIMXzDhlCxPHzqWg5AQQIcoj3g,402
 flashforge/api/network/utils.py,sha256=jwqyJaByr4q80_MJOTwS0nX8I8FZ54T_CHBwkKTXptA,1519
 flashforge/discovery/__init__.py,sha256=G0WiP70EhfHdjXR1RNlv6xjhyHOdo-HWyOm9J0ds4SM,828
-flashforge/discovery/discovery.py,sha256=qlyLxITY9JMKY_quONdWeZ5sbsF_pXfqRXqk7DwDGfs,26042
+flashforge/discovery/discovery.py,sha256=lNyD-nDDdYKV23kUOQpuA5ZX4r9T7_Zk3SzXoUwgMPI,26163
 flashforge/models/__init__.py,sha256=MNpnXdS6Yah5kSwBB7cbA2Hd-8azffE62pgUrrKSZk4,984
-flashforge/models/machine_info.py,sha256=tMec0qSq9iTVfUvLl72vL5jlDrBW2mn132dzL8842mA,14602
+flashforge/models/machine_info.py,sha256=BvIaefjpApsbSVQA8eOG3NSm2L1ltZ1kcHH1118frZc,14974
 flashforge/models/responses.py,sha256=befMeXAc7XXiK7emF8Ep2cd1GuhZ-zyYPbbPqS2lcQI,7214
-flashforge/tcp/__init__.py,sha256=g0xAZf0ZDKnH2g79tK5FeAATRo90GfDB7Lkws1LsZxU,1145
-flashforge/tcp/a3_client.py,sha256=n7Kw0Dn9MYjjj0r2GPEiQFBKZfzuE9lboziuRt2bKgM,15411
+flashforge/tcp/__init__.py,sha256=hpnqoWHeRtTwJPzdsVlwGt1njKbAkrgIHKADkLSIRec,1317
+flashforge/tcp/a3_client.py,sha256=a1jdDcBnTSNrzJFKTuVV13fSLbZmxKEZ94n3cGf3wOA,15603
+flashforge/tcp/a4_client.py,sha256=0KH5zfsbWaPRd7xSKb7YA3oZTkCVdsdcTA9LPl3S55Q,11167
 flashforge/tcp/ff_client.py,sha256=CJXk0Qei2FVSpbXxZhiEQgAEcTJaBab1ouooqyC4OL4,20235
 flashforge/tcp/tcp_client.py,sha256=KjymxUXiXgEp9y7mjr5tNO_Y2-bsGEyP-oG5en7rCCs,16996
 flashforge/tcp/gcode/__init__.py,sha256=tFGlqCPFxVJNizXsIG4pMOK7IPFNnc_vIEMciULYkMY,271
@@ -38,8 +39,8 @@ flashforge/tcp/parsers/print_status.py,sha256=4q9ZlJfO0c7_t1o15tgxbguMxpDjEW9pMy
 flashforge/tcp/parsers/printer_info.py,sha256=QY6LECfcOhVHSIdsvQZwJago0OjXroUwiX0H-uQaH2A,5411
 flashforge/tcp/parsers/temp_info.py,sha256=9Waf68tt-4QBcChyUwfMHDwWdIzM4mmDpZAKeAzklgs,7908
 flashforge/tcp/parsers/thumbnail_info.py,sha256=ZmxdEbVFOzqR1AfhXXZyjENVI66BdRdE7Q8LQ8an9FY,10201
-flashforge_python_api-1.1.0.dist-info/METADATA,sha256=H9Lv3ThMilNw6H-BMtsi2-vdsL0u6f4u7QtGkh-6vlQ,11038
-flashforge_python_api-1.1.0.dist-info/WHEEL,sha256=QccIxa26bgl1E6uMy58deGWi-0aeIkkangHcxk2kWfw,87
-flashforge_python_api-1.1.0.dist-info/entry_points.txt,sha256=AkOxlsLvQ7cvMLxn7tlzfKp_DCH2hXhbVceHIXxawpU,66
-flashforge_python_api-1.1.0.dist-info/licenses/LICENSE,sha256=-cTA-hrmvlb3pqlQrBZQXUnKayhUjsLJMPb7TD91frM,1067
-flashforge_python_api-1.1.0.dist-info/RECORD,,
+flashforge_python_api-1.2.0.dist-info/METADATA,sha256=UYZ0LVlLhqxWzMWv0-IjO35VefbUEBBqN3NZhK21uD4,4194
+flashforge_python_api-1.2.0.dist-info/WHEEL,sha256=QccIxa26bgl1E6uMy58deGWi-0aeIkkangHcxk2kWfw,87
+flashforge_python_api-1.2.0.dist-info/entry_points.txt,sha256=AkOxlsLvQ7cvMLxn7tlzfKp_DCH2hXhbVceHIXxawpU,66
+flashforge_python_api-1.2.0.dist-info/licenses/LICENSE,sha256=-cTA-hrmvlb3pqlQrBZQXUnKayhUjsLJMPb7TD91frM,1067
+flashforge_python_api-1.2.0.dist-info/RECORD,,

flashforge_python_api-1.1.0.dist-info/METADATA

@@ -1,305 +0,0 @@
-Metadata-Version: 2.4
-Name: flashforge-python-api
-Version: 1.1.0
-Summary: A comprehensive Python library for controlling FlashForge 3D printers
-Project-URL: Homepage, https://github.com/GhostTypes/ff-5mp-api-py
-Project-URL: Documentation, https://github.com/GhostTypes/ff-5mp-api-py#readme
-Project-URL: Repository, https://github.com/GhostTypes/ff-5mp-api-py.git
-Project-URL: Issues, https://github.com/GhostTypes/ff-5mp-api-py/issues
-Author-email: GhostTypes <notghosttypes@gmail.com>
-License-Expression: MIT
-License-File: LICENSE
-Keywords: 3d-printer,api,async,control,flashforge,python
-Classifier: Development Status :: 5 - Production/Stable
-Classifier: Intended Audience :: Developers
-Classifier: Programming Language :: Python :: 3
-Classifier: Programming Language :: Python :: 3.11
-Classifier: Programming Language :: Python :: 3.12
-Classifier: Programming Language :: Python :: 3.13
-Classifier: Topic :: Scientific/Engineering
-Classifier: Topic :: Software Development :: Libraries :: Python Modules
-Classifier: Topic :: System :: Hardware :: Hardware Drivers
-Requires-Python: >=3.11
-Requires-Dist: aiohttp>=3.8.0
-Requires-Dist: netifaces>=0.11.0
-Requires-Dist: pydantic>=2.0.0
-Requires-Dist: requests>=2.31.0
-Provides-Extra: all
-Requires-Dist: black>=23.0.0; extra == 'all'
-Requires-Dist: mypy>=1.0.0; extra == 'all'
-Requires-Dist: pillow>=10.0.0; extra == 'all'
-Requires-Dist: pre-commit>=3.0.0; extra == 'all'
-Requires-Dist: pytest-asyncio>=0.21.0; extra == 'all'
-Requires-Dist: pytest-cov>=4.0.0; extra == 'all'
-Requires-Dist: pytest>=7.0.0; extra == 'all'
-Requires-Dist: ruff>=0.1.0; extra == 'all'
-Provides-Extra: dev
-Requires-Dist: black>=23.0.0; extra == 'dev'
-Requires-Dist: mypy>=1.0.0; extra == 'dev'
-Requires-Dist: pre-commit>=3.0.0; extra == 'dev'
-Requires-Dist: pytest-asyncio>=0.21.0; extra == 'dev'
-Requires-Dist: pytest-cov>=4.0.0; extra == 'dev'
-Requires-Dist: pytest>=7.0.0; extra == 'dev'
-Requires-Dist: ruff>=0.1.0; extra == 'dev'
-Provides-Extra: imaging
-Requires-Dist: pillow>=10.0.0; extra == 'imaging'
-Description-Content-Type: text/markdown
-
-<div align="center">
-
-# FlashForge Python API
-
-**A comprehensive Python library for controlling FlashForge 3D printers**
-
-![PyPI](https://img.shields.io/pypi/v/flashforge-python-api?style=flat&color=3776ab) ![Python](https://img.shields.io/badge/Python-3.11%2B-3776ab?style=flat) ![License](https://img.shields.io/badge/License-MIT-brightgreen?style=flat) ![Status](https://img.shields.io/badge/Status-Stable-brightgreen?style=flat)
-
-![aiohttp](https://img.shields.io/badge/aiohttp-%E2%89%A53.8.0-blue?style=flat) ![pydantic](https://img.shields.io/badge/pydantic-%E2%89%A52.0.0-e92063?style=flat) ![netifaces](https://img.shields.io/badge/netifaces-%E2%89%A50.11.0-orange?style=flat) ![requests](https://img.shields.io/badge/requests-%E2%89%A52.31.0-blue?style=flat) ![pillow](https://img.shields.io/badge/pillow-%E2%89%A510.0.0-yellow?style=flat)
-
-**Dual-protocol support with modern async/await architecture for seamless printer control and monitoring**
-
-</div>
-
----
-
-<div align="center">
-
-## Features
-
-| Capability | Details |
-| --- | --- |
-| **Dual Protocol Support** | Modern HTTP REST API for Adventurer 5M/5X series • Legacy TCP G-code protocol for all networked FlashForge printers |
-| **Printer Discovery** | Automatic UDP broadcast discovery • Returns printer name, serial number, and IP address |
-| **Full Control** | Movement and homing • Temperature control • Fan speed adjustment • LED lighting • Camera control • Air filtration system |
-| **Real-time Monitoring** | Printer status and machine state • Current and target temperatures • Print progress and layer tracking • Estimated time remaining |
-| **Job Management** | Start, pause, resume, and cancel print jobs • Progress monitoring |
-| **File Operations** | List, upload, and download files • Extract print thumbnails • File metadata retrieval |
-| **Async Architecture** | Native async/await implementation • Non-blocking network operations • Concurrent operations support |
-| **Type Safety** | Full type hints for IDE autocomplete • Pydantic models for data validation • mypy strict mode compatible |
-| **Model Detection** | Automatic capability detection • Runtime camera stream detection via `camera_stream_url` • Graceful degradation for older models |
-
-</div>
-
----
-
-<div align="center">
-
-## Printer Testing & Coverage
-
-| Printer Model | Support Status | Testing Status | API Type |
-| --- | --- | --- | --- |
-| **AD5X** | Full | Tested | HTTP (New) + TCP |
-| **Adventurer 5M/Pro** | Full | Tested | HTTP (New) + TCP |
-| **Adventurer 3/4** | Partial | Partial | TCP (Legacy) |
-
-</div>
-
----
-
-<div align="center">
-
-## Installation
-
-| Method | Command |
-| --- | --- |
-| **PyPI (Recommended)** | `pip install flashforge-python-api` |
-| **Development Install** | `pip install -e ".[dev]"` |
-| **With Imaging Support** | `pip install flashforge-python-api[imaging]` |
-| **All Optional Dependencies** | `pip install flashforge-python-api[all]` |
-
-</div>
-
----
-
-## Quick Start
-
-<div align="center">
-
-**Important: LAN-Only Mode Required**
-
-Your printer must be in **LAN-only mode** to communicate with this library. See the [official FlashForge guide](https://wiki.flashforge.com/en/Orca-Flashforge-and-Flashmaker/orca-flashforge-quick-start-guide#connect-via-lan-only-mode) for setup instructions and to obtain your check code.
-
-</div>
-
-### Printer Discovery
-
-Discover FlashForge printers on your local network automatically:
-
-```python
-from flashforge import FlashForgePrinterDiscovery
-import asyncio
-
-async def discover():
-    discovery = FlashForgePrinterDiscovery()
-    printers = await discovery.discover_printers_async()
-
-    for printer in printers:
-        print(f"Found: {printer.name} at {printer.ip_address}")
-        print(f"Serial: {printer.serial_number}")
-
-asyncio.run(discover())
-```
-
-### Basic Printer Control
-
-Connect to a printer and perform basic operations:
-
-```python
-from flashforge import FlashForgeClient
-import asyncio
-
-async def control_printer():
-    # Initialize client with printer credentials
-    client = FlashForgeClient("192.168.1.100", "SERIAL_NUMBER", "CHECK_CODE")
-
-    # Always initialize before operations
-    if await client.initialize():
-        print(f"Connected to {client.printer_name}")
-        print(f"Firmware: {client.firmware_version}")
-
-        # Set temperatures
-        await client.temp_control.set_bed_temp(60)
-        await client.temp_control.set_extruder_temp(220)
-
-        # Home all axes
-        await client.control.home_xyz()
-
-        # Turn on LED lights (AD5M/5X only)
-        if client.is_ad5x:
-            await client.control.set_led_on()
-
-        # Clean up
-        await client.dispose()
-
-asyncio.run(control_printer())
-```
-
-### Real-time Status Monitoring
-
-Monitor printer status, temperatures, and print progress:
-
-```python
-from flashforge import FlashForgeClient
-import asyncio
-
-async def monitor_printer():
-    async with FlashForgeClient("192.168.1.100", "SERIAL", "CODE") as client:
-        # Get comprehensive status via HTTP
-        status = await client.get_printer_status()
-        print(f"State: {status.machine_state}")
-        print(f"Progress: {status.print_progress}%")
-
-        # Get real-time temperatures via TCP
-        temps = await client.tcp_client.get_temp_info()
-        if temps:
-            bed = temps.get_bed_temp()
-            extruder = temps.get_extruder_temp()
-            print(f"Bed: {bed.get_current()}°C / {bed.get_target()}°C")
-            print(f"Extruder: {extruder.get_current()}°C / {extruder.get_target()}°C")
-
-        # Check print progress via TCP
-        layer_p, sd_p, current_layer = await client.tcp_client.get_print_progress()
-        print(f"Layer Progress: {layer_p}% (Layer {current_layer})")
-
-asyncio.run(monitor_printer())
-```
-
-### Camera Stream Detection
-
-Use the printer-reported runtime camera stream URL as the OEM camera source of truth:
-
-```python
-from flashforge import FlashForgeClient
-import asyncio
-
-async def check_camera():
-    async with FlashForgeClient("192.168.1.100", "SERIAL", "CODE") as client:
-        if not await client.initialize():
-            return
-
-        if client.camera_stream_url:
-            print(f"OEM camera stream: {client.camera_stream_url}")
-        else:
-            print("Printer is not reporting an active OEM camera stream")
-
-        # Camera power control remains Pro-only.
-        if client.is_pro:
-            await client.control.turn_camera_on()
-
-asyncio.run(check_camera())
-```
-
-### File Operations and Thumbnails
-
-List files and extract G-code thumbnails:
-
-```python
-from flashforge import FlashForgeClient
-import asyncio
-
-async def file_operations():
-    async with FlashForgeClient("192.168.1.100", "SERIAL", "CODE") as client:
-        # List all files on printer
-        files = await client.files.get_file_list()
-        print(f"Found {len(files)} files")
-
-        for filename in files:
-            print(f"\nFile: {filename}")
-
-            # Extract thumbnail image
-            thumb = await client.tcp_client.get_thumbnail(filename)
-            if thumb and thumb.has_image_data():
-                print(f"Thumbnail: {len(thumb.get_image_bytes())} bytes")
-
-                # Save thumbnail to disk
-                thumb.save_to_file_sync(f"{filename}.png")
-                print(f"Saved thumbnail as {filename}.png")
-
-asyncio.run(file_operations())
-```
-
----
-
-<div align="center">
-
-## Documentation
-
-| Resource | Description |
-| --- | --- |
-| **[Client API Reference](docs/client.md)** | Complete API reference for `FlashForgeClient` and all control modules |
-| **[Data Models](docs/models.md)** | Pydantic model documentation for status objects and responses |
-| **[Protocols (HTTP/TCP)](docs/protocols.md)** | Understanding the dual-protocol architecture and when to use each |
-| **[Advanced Usage](docs/advanced.md)** | Async patterns, error handling, concurrent operations, and best practices |
-| **[Complete API Reference](docs/api_reference.md)** | Full class hierarchy and method listing |
-
-</div>
-
----
-
-<div align="center">
-
-## Development
-
-| Task | Command | Description |
-| --- | --- | --- |
-| **Setup Environment** | `python -m venv .venv && .venv\Scripts\activate` | Create and activate virtual environment |
-| **Install Dependencies** | `pip install -e ".[dev]"` | Install package with development tools |
-| **Run Tests** | `pytest` | Execute test suite |
-| **Type Check** | `mypy flashforge/` | Run strict type checking with mypy |
-| **Format Code** | `black flashforge/ tests/` | Format code with Black (line length: 100) |
-| **Lint** | `ruff check flashforge/ tests/` | Lint code with Ruff |
-| **Coverage Report** | `pytest --cov=flashforge --cov-report=html` | Generate test coverage report |
-| **Build Package** | `python -m build` | Build distribution packages |
-| **Run Pre-commit** | `pre-commit run --all-files` | Execute all pre-commit hooks |
-
-</div>
-
----
-
-<div align="center">
-
-## License
-
-**MIT License** - See [LICENSE](LICENSE) for details
-
-</div>
-