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

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,23 +199,26 @@ 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")
+    current_print_speed: int | None = Field(default=None, ge=0, le=1000, alias="currentPrintSpeed")
     door_status: str | None = Field(default=None, alias="doorStatus")
     error_code: str | None = Field(default=None, alias="errorCode")
     estimated_left_len: float | None = Field(default=None, ge=0, alias="estimatedLeftLen")
@@ -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")
@@ -254,7 +259,7 @@ class FFPrinterDetail(BaseModel):
     print_file_thumb_url: str | None = Field(default=None, alias="printFileThumbUrl")
     print_layer: int | None = Field(default=None, ge=0, alias="printLayer")
     print_progress: float | None = Field(default=None, ge=0, le=100, alias="printProgress")
-    print_speed_adjust: int | None = Field(default=None, ge=0, le=200, alias="printSpeedAdjust")
+    print_speed_adjust: int | None = Field(default=None, ge=0, le=1000, alias="printSpeedAdjust")
     remaining_disk_space: float | None = Field(default=None, ge=0, alias="remainingDiskSpace")
     right_filament_type: str | None = Field(default=None, alias="rightFilamentType")
     right_target_temp: float | None = Field(default=None, ge=-50, le=500, alias="rightTargetTemp")

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.1.dist-info/METADATA

@@ -0,0 +1,133 @@
+Metadata-Version: 2.4
+Name: flashforge-python-api
+Version: 1.2.1
+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.1.dist-info}/RECORD

@@ -1,14 +1,14 @@
-flashforge/__init__.py,sha256=k67UUBpSPMCRlexqn43RRHIh8XyNb9Bq5yXOpwChsFo,5170
-flashforge/client.py,sha256=XP_l5FsaUXKWjkRMWxbz7F1d7_8Xdh7oD5zpThtBFhM,15462
+flashforge/__init__.py,sha256=3fmBeEJ4vFJDSsOQV0Yixb1yLyUw8nHDZKQHbXIbtmo,5336
+flashforge/client.py,sha256=lplKJxNOLhUJMusm025cj7rZvWRAiv2j5qENdBIctuA,16920
 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
-flashforge/api/controls/info.py,sha256=r_gi20ZlgpdtCJVqtoyncV714-MQcDjg4Qg4xeTWHNA,12969
-flashforge/api/controls/job_control.py,sha256=uhuQE3weXJPvWBER0P7lvqWEzAVHXFNXWWBFfnZwtR8,23656
+flashforge/api/controls/control.py,sha256=8wK2YOGf9NphWXsjIDapyQEfx-qGZgytXZFsjKeWvSA,11291
+flashforge/api/controls/files.py,sha256=8T9kzgss_2DYFL4WVuEFj8W9sOPPPMIMq3dTq1d551w,6560
+flashforge/api/controls/info.py,sha256=KVExwaeDd1SYiSOBZVVtif3Rf_cJkw4Bizhgm6dbAS8,12398
+flashforge/api/controls/job_control.py,sha256=-DglR97DWBzl45mmqGkauYpUM_I-C0tXrbp9SKPYOVs,21814
 flashforge/api/controls/temp_control.py,sha256=TGkX63WHygVA9DeYfLARbktZ0o-bYX6MNyYOX6V_RB4,3034
 flashforge/api/filament/__init__.py,sha256=isT2dl0hzUS0xMTXMm4Tip0GTG1gCsm8LKWa9xPu4Y8,104
 flashforge/api/filament/filament.py,sha256=TtcC2G2nD9Sq4cOrCZzFLZ6Q0Ve-zfrfuEF9uQ8M3eE,1214
@@ -17,14 +17,15 @@ flashforge/api/misc/scientific_notation.py,sha256=KSMTrrYhPWLv0gbcEAD6u-jEOcIwUj
 flashforge/api/misc/temperature.py,sha256=qeHlCdPzLyqGDEB874Ib5AgYHMR9Qtw61shnw4G095E,1066
 flashforge/api/network/__init__.py,sha256=G5fBoAlq-NQPDkWp579mFIqsj0v7B1Lb2TAzO6IZA0Q,164
 flashforge/api/network/fnet_code.py,sha256=BR2niVKKk4ZfXtizUDIMXzDhlCxPHzqWg5AQQIcoj3g,402
-flashforge/api/network/utils.py,sha256=jwqyJaByr4q80_MJOTwS0nX8I8FZ54T_CHBwkKTXptA,1519
+flashforge/api/network/utils.py,sha256=hh-9SGI61ii0CRkLVnAp-Eq2E0a9PAKPyNLMGaYPNsI,2065
 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=t7TJk03PG8kf-g6XnWd3NiWuCVLY1Wuod-aI4zdXu4Y,14976
 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.1.dist-info/METADATA,sha256=eMFS4ENMi13-7DADIKwTNTSQyBoFjHrGrLMb_gw4dZw,4194
+flashforge_python_api-1.2.1.dist-info/WHEEL,sha256=QccIxa26bgl1E6uMy58deGWi-0aeIkkangHcxk2kWfw,87
+flashforge_python_api-1.2.1.dist-info/entry_points.txt,sha256=AkOxlsLvQ7cvMLxn7tlzfKp_DCH2hXhbVceHIXxawpU,66
+flashforge_python_api-1.2.1.dist-info/licenses/LICENSE,sha256=-cTA-hrmvlb3pqlQrBZQXUnKayhUjsLJMPb7TD91frM,1067
+flashforge_python_api-1.2.1.dist-info/RECORD,,