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

flashforge/__init__.py

@@ -127,7 +127,7 @@ from .tcp import (
 )
 
 FiveMClient = FlashForgeClient
-__version__ = "1.1.1"
+__version__ = "1.2.2"
 __author__ = "FlashForge Python API Contributors"
 __email__ = "notghosttypes@gmail.com"
 __description__ = "Python library for controlling FlashForge 3D printers"

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

@@ -13,7 +13,7 @@ import aiohttp
 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
@@ -379,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):

flashforge/discovery/discovery.py

@@ -12,7 +12,7 @@ from dataclasses import dataclass, field
 from enum import IntEnum, StrEnum
 from typing import Any
 
-import netifaces
+import ifaddr
 
 logger = logging.getLogger(__name__)
 
@@ -535,26 +535,27 @@ class PrinterDiscovery:
         broadcast_addresses: list[str] = []
 
         try:
-            for interface_name in netifaces.interfaces():
-                try:
-                    addresses = netifaces.ifaddresses(interface_name)
-                    if netifaces.AF_INET not in addresses:
+            for adapter in ifaddr.get_adapters():
+                for ip in adapter.ips:
+                    if not ip.is_IPv4:
+                        continue
+
+                    ip_addr = ip.ip
+                    if not isinstance(ip_addr, str) or ip_addr.startswith("127."):
                         continue
 
-                    for addr_info in addresses[netifaces.AF_INET]:
-                        if addr_info.get("addr", "").startswith("127."):
-                            continue
+                    prefix = ip.network_prefix
+                    if not isinstance(prefix, int) or not 0 < prefix <= 32:
+                        continue
 
-                        ip_addr = addr_info.get("addr")
-                        netmask = addr_info.get("netmask")
-                        if not ip_addr or not netmask:
-                            continue
+                    mask_int = (0xFFFFFFFF << (32 - prefix)) & 0xFFFFFFFF
+                    netmask = ".".join(
+                        str((mask_int >> (8 * (3 - i))) & 0xFF) for i in range(4)
+                    )
 
-                        broadcast = self.calculate_broadcast_address(ip_addr, netmask)
-                        if broadcast and broadcast not in broadcast_addresses:
-                            broadcast_addresses.append(broadcast)
-                except Exception as error:
-                    logger.warning("Error processing interface %s: %s", interface_name, error)
+                    broadcast = self.calculate_broadcast_address(ip_addr, netmask)
+                    if broadcast and broadcast not in broadcast_addresses:
+                        broadcast_addresses.append(broadcast)
         except Exception as error:
             logger.error("Error getting network interfaces: %s", error)
             broadcast_addresses = ["255.255.255.255", "192.168.1.255", "192.168.0.255"]

flashforge/models/machine_info.py

@@ -218,7 +218,7 @@ class FFPrinterDetail(BaseModel):
     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")
@@ -259,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_python_api-1.2.0.dist-info → flashforge_python_api-1.2.2.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: flashforge-python-api
-Version: 1.2.0
+Version: 1.2.2
 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
@@ -16,12 +16,13 @@ Classifier: Programming Language :: Python :: 3
 Classifier: Programming Language :: Python :: 3.11
 Classifier: Programming Language :: Python :: 3.12
 Classifier: Programming Language :: Python :: 3.13
+Classifier: Programming Language :: Python :: 3.14
 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: ifaddr>=0.2.0
 Requires-Dist: pydantic>=2.0.0
 Requires-Dist: requests>=2.31.0
 Provides-Extra: all
@@ -70,14 +71,20 @@ Modern LAN-mode HTTP printers require:
 
 - printer IP address
 - serial number
-- check code
+- check code (per-printer credential, not returned by discovery)
 
 ```python
 import asyncio
-from flashforge import FlashForgeClient, PrinterDiscovery
+import os
+from flashforge import FlashForgeClient, FiveMClientConnectionOptions, PrinterDiscovery
 
 
 async def main():
+    check_code = os.getenv("FLASHFORGE_CHECK_CODE", "").strip()
+    if not check_code:
+        print("Set FLASHFORGE_CHECK_CODE before running this example")
+        return
+
     discovery = PrinterDiscovery()
     printers = await discovery.discover()
 
@@ -86,13 +93,23 @@ async def main():
         return
 
     printer = printers[0]
+    if not printer.serial_number:
+        print("Discovered printer did not report a serial number")
+        return
+
+    options = FiveMClientConnectionOptions(
+        http_port=printer.event_port,
+        tcp_port=printer.command_port,
+    )
 
     async with FlashForgeClient(
         printer.ip_address,
-        printer.serial_number or "SERIAL_NUMBER",
-        "CHECK_CODE",
+        printer.serial_number,
+        check_code,
+        options=options,
     ) as client:
-        if not await client.initialize():
+        status = await client.get_printer_status()
+        if not status:
             return
 
         await client.init_control()

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

@@ -1,14 +1,14 @@
-flashforge/__init__.py,sha256=3fmBeEJ4vFJDSsOQV0Yixb1yLyUw8nHDZKQHbXIbtmo,5336
-flashforge/client.py,sha256=lmkPfkhcfDslbROv6XouwTIHshz4rHS0wNNJeicBHiA,17334
+flashforge/__init__.py,sha256=NjSFURsQlavWjvD6CikOj01SXqpdmGF-PlAHyLXtc-4,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=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,11 +17,11 @@ 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=lNyD-nDDdYKV23kUOQpuA5ZX4r9T7_Zk3SzXoUwgMPI,26163
+flashforge/discovery/discovery.py,sha256=ka75bIXnn2a14DEpzpmJxUGajF-tpLHUR2EHA88NIGc,26073
 flashforge/models/__init__.py,sha256=MNpnXdS6Yah5kSwBB7cbA2Hd-8azffE62pgUrrKSZk4,984
-flashforge/models/machine_info.py,sha256=BvIaefjpApsbSVQA8eOG3NSm2L1ltZ1kcHH1118frZc,14974
+flashforge/models/machine_info.py,sha256=t7TJk03PG8kf-g6XnWd3NiWuCVLY1Wuod-aI4zdXu4Y,14976
 flashforge/models/responses.py,sha256=befMeXAc7XXiK7emF8Ep2cd1GuhZ-zyYPbbPqS2lcQI,7214
 flashforge/tcp/__init__.py,sha256=hpnqoWHeRtTwJPzdsVlwGt1njKbAkrgIHKADkLSIRec,1317
 flashforge/tcp/a3_client.py,sha256=a1jdDcBnTSNrzJFKTuVV13fSLbZmxKEZ94n3cGf3wOA,15603
@@ -39,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.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.2.2.dist-info/METADATA,sha256=fgIgmb7nLlupuynCJcbY5V-fF_g4hNI48e9d61Qym0s,4787
+flashforge_python_api-1.2.2.dist-info/WHEEL,sha256=QccIxa26bgl1E6uMy58deGWi-0aeIkkangHcxk2kWfw,87
+flashforge_python_api-1.2.2.dist-info/entry_points.txt,sha256=AkOxlsLvQ7cvMLxn7tlzfKp_DCH2hXhbVceHIXxawpU,66
+flashforge_python_api-1.2.2.dist-info/licenses/LICENSE,sha256=-cTA-hrmvlb3pqlQrBZQXUnKayhUjsLJMPb7TD91frM,1067
+flashforge_python_api-1.2.2.dist-info/RECORD,,