flashforge-python-api 1.2.3__py3-none-any.whl → 1.3.0__py3-none-any.whl

flashforge/api/controls/temp_control.py

@@ -1,18 +1,45 @@
 """
 FlashForge Python API - Temperature Control Module
+
+Sets and cancels extruder/bed/chamber temperatures. The 5M / 5M Pro / AD5X use
+direct TCP G-code/M-code commands; HTTP-only printers (Creator 5 / 5 Pro, no TCP
+channel) use the HTTP ``temperatureCtl_cmd`` instead.
 """
 
 from typing import TYPE_CHECKING
 
+from ..constants.commands import Commands
+
 if TYPE_CHECKING:
     from ...client import FlashForgeClient
     from ...tcp.ff_client import FlashForgeClient as TcpClient
 
 
+# Sentinel value for `temperatureCtl_cmd` meaning "leave this heater unchanged"
+# (partial update). Sending a real 0 / -100 would turn the heater off.
+TEMP_NO_CHANGE = -200
+# `temperatureCtl_cmd` value that turns a SCALAR heater (platform / chamber /
+# rightNozzle) off.
+TEMP_OFF = -100
+# Value that turns a tool/nozzle OFF inside the `nozzles` array. Unlike the scalar
+# heater fields (which accept TEMP_OFF = -100), the Creator 5 firmware's
+# per-nozzle parser only treats a literal 0 as "off" — it ignores -100 in the
+# `nozzles` array and the tool keeps heating. (Firmware-confirmed via tester
+# report; this is the v1.6.1 nozzle-off bugfix.)
+NOZZLE_OFF = 0
+# Number of tool/nozzle entries the Creator 5 firmware requires in the
+# `nozzles` array. The firmware ignores the array unless its length is exactly
+# this (confirmed via Ghidra: `size() == 4` check in the temp parser).
+NOZZLE_COUNT = 4
+
+
 class TempControl:
     """
     Provides methods for controlling the temperatures of various printer components,
     including extruders and the print bed.
+
+    Dual-API printers (5M / 5M Pro / AD5X) use TCP G-code commands; HTTP-only
+    printers (Creator 5 / 5 Pro) route through the HTTP ``temperatureCtl_cmd``.
     """
 
     def __init__(self, client: "FlashForgeClient"):
@@ -32,61 +59,244 @@ class TempControl:
             self._tcp_client = self.client.tcp_client
         return self._tcp_client
 
+    async def _send_http_temp_command(
+        self,
+        right_nozzle: int | None = None,
+        left_nozzle: int | None = None,
+        platform: int | None = None,
+        chamber: int | None = None,
+        nozzles: list[int] | None = None,
+    ) -> bool:
+        """
+        Sends a ``temperatureCtl_cmd`` over HTTP with the given setpoints.
+        Unspecified heaters are left unchanged via the :data:`TEMP_NO_CHANGE`
+        sentinel.
+
+        The ``nozzles`` array is Creator 5-only (its 4-nozzle tool changer). The
+        confirmed C5 payload ALWAYS carries a 4-entry array, even on a bed- or
+        chamber-only command, so always include it on the C5 — defaulting
+        unspecified tools to :data:`TEMP_NO_CHANGE` so a bed/chamber adjustment
+        leaves the tools untouched.
+
+        Returns:
+            True if the command is acknowledged, False otherwise.
+        """
+        payload: dict[str, int | list[int]] = {
+            "rightNozzle": right_nozzle if right_nozzle is not None else TEMP_NO_CHANGE,
+            "leftNozzle": left_nozzle if left_nozzle is not None else TEMP_NO_CHANGE,
+            "platform": platform if platform is not None else TEMP_NO_CHANGE,
+            "chamber": chamber if chamber is not None else TEMP_NO_CHANGE,
+        }
+        # The `nozzles` array is Creator 5-only. The confirmed C5 payload always
+        # carries a 4-entry array, even on a bed- or chamber-only command, so
+        # always include it on the C5 — defaulting unspecified tools to
+        # TEMP_NO_CHANGE so a bed/chamber adjustment leaves the tools untouched.
+        if nozzles is not None:
+            payload["nozzles"] = nozzles
+        elif self.client.is_creator5:
+            payload["nozzles"] = [TEMP_NO_CHANGE] * NOZZLE_COUNT
+        return await self.client.control.send_control_command(Commands.TEMP_CONTROL_CMD, payload)
+
+    def _build_nozzle_array(self, tool_index: int, value: int) -> list[int] | None:
+        """
+        Builds a :data:`NOZZLE_COUNT`-length ``nozzles`` array of
+        :data:`TEMP_NO_CHANGE` placeholders with a single tool set to ``value``.
+
+        Returns:
+            The array, or None if ``tool_index`` is out of range.
+        """
+        if not isinstance(tool_index, int) or tool_index < 0 or tool_index >= NOZZLE_COUNT:
+            print(f"TempControl: toolIndex {tool_index} out of range (0-{NOZZLE_COUNT - 1}).")
+            return None
+        nozzles = [TEMP_NO_CHANGE] * NOZZLE_COUNT
+        nozzles[tool_index] = value
+        return nozzles
+
+    async def set_tool_temp(self, tool_index: int, temp: int) -> bool:
+        """
+        Sets the target temperature for a single tool/nozzle on a Creator 5 series
+        tool-changer, leaving the other tools unchanged. Sent as a ``nozzles``
+        array (Creator 5 / 5 Pro, HTTP-only).
+
+        Args:
+            tool_index: Zero-based tool index (0-3 for T0-T3).
+            temp: Target temperature in Celsius.
+
+        Returns:
+            True if the command is acknowledged, False otherwise.
+        """
+        nozzles = self._build_nozzle_array(tool_index, temp)
+        if nozzles is None:
+            return False
+        return await self._send_http_temp_command(nozzles=nozzles)
+
+    async def set_tool_temps(self, temps: list[int]) -> bool:
+        """
+        Sets the target temperatures for all tools/nozzles on a Creator 5 series
+        tool-changer in one command. Use :data:`TEMP_NO_CHANGE` (-200) to leave a
+        tool unchanged or :data:`NOZZLE_OFF` (0) to turn one off (the firmware
+        ignores the -100 sentinel inside the ``nozzles`` array). Must contain
+        exactly :data:`NOZZLE_COUNT` entries.
+
+        Args:
+            temps: Per-tool target temperatures, ordered T0..T3.
+
+        Returns:
+            True if the command is acknowledged, False otherwise.
+        """
+        if len(temps) != NOZZLE_COUNT:
+            print(f"set_tool_temps: expected {NOZZLE_COUNT} temps, got {len(temps)}.")
+            return False
+        return await self._send_http_temp_command(nozzles=list(temps))
+
+    async def cancel_tool_temp(self, tool_index: int) -> bool:
+        """
+        Cancels heating for a single tool/nozzle on a Creator 5 series tool-changer
+        (sets its target to 0 via :data:`NOZZLE_OFF`), leaving the other tools
+        unchanged.
+
+        Args:
+            tool_index: Zero-based tool index (0-3 for T0-T3).
+
+        Returns:
+            True if the command is acknowledged, False otherwise.
+        """
+        nozzles = self._build_nozzle_array(tool_index, NOZZLE_OFF)
+        if nozzles is None:
+            return False
+        return await self._send_http_temp_command(nozzles=nozzles)
+
     async def set_extruder_temp(self, temperature: int, wait_for: bool = False) -> bool:
         """
-        Sets the target temperature for an extruder.
+        Sets the target temperature for the printer's extruder.
+
+        On HTTP-only printers this routes to ``temperatureCtl_cmd``: the Creator 5
+        drives its tools only via the ``nozzles`` array (targeting T0), while a
+        forced-http_only AD5X / 5M keeps the ``rightNozzle`` scalar.
 
         Args:
             temperature: The target temperature in Celsius.
-            wait_for: Whether to wait for the heating operation to complete
+            wait_for: Whether to wait for the heating operation to complete (TCP only).
 
         Returns:
             True if the command is successful, False otherwise.
         """
+        if self.client.http_only:
+            # Creator 5 tools are driven ONLY via the `nozzles` array — the
+            # firmware's doTemperatureControl handler never reads
+            # rightNozzle/leftNozzle. Target the primary tool (T0): the active
+            # tool isn't reliably known over HTTP, so callers that need a
+            # specific tool should use set_tool_temp(index, temp).
+            if self.client.is_creator5:
+                nozzles = self._build_nozzle_array(0, temperature)
+                if nozzles is None:
+                    return False
+                return await self._send_http_temp_command(nozzles=nozzles)
+            # Single-tool AD5X / 5M only reachable here if forced into http_only
+            # mode; they keep the rightNozzle field (unchanged).
+            return await self._send_http_temp_command(right_nozzle=temperature)
         return await self.tcp_client.set_extruder_temp(temperature, wait_for)
 
     async def set_bed_temp(self, temperature: int, wait_for: bool = False) -> bool:
         """
-        Sets the target temperature for the print bed.
+        Sets the target temperature for the printer's print bed.
 
         Args:
             temperature: The target bed temperature in Celsius.
-            wait_for: Whether to wait for the heating operation to complete
+            wait_for: Whether to wait for the heating operation to complete (TCP only).
 
         Returns:
             True if the command is successful, False otherwise.
         """
+        if self.client.http_only:
+            return await self._send_http_temp_command(platform=temperature)
         return await self.tcp_client.set_bed_temp(temperature, wait_for)
 
     async def cancel_extruder_temp(self) -> bool:
         """
-        Cancels the heating of an extruder (sets target temperature to 0).
+        Cancels any ongoing extruder heating and sets its target temperature to 0.
 
         Returns:
             True if the command is successful, False otherwise.
         """
+        if self.client.http_only:
+            # See set_extruder_temp: Creator 5 tools are driven only via
+            # `nozzles`. Turn the primary tool (T0) off (target 0, not the -100
+            # sentinel the nozzles array ignores) while leaving the other tools
+            # unchanged.
+            if self.client.is_creator5:
+                nozzles = self._build_nozzle_array(0, NOZZLE_OFF)
+                if nozzles is None:
+                    return False
+                return await self._send_http_temp_command(nozzles=nozzles)
+            # Single-tool AD5X / 5M (forced http_only) keep rightNozzle (unchanged).
+            return await self._send_http_temp_command(right_nozzle=TEMP_OFF)
         return await self.tcp_client.cancel_extruder_temp()
 
     async def cancel_bed_temp(self) -> bool:
         """
-        Cancels the heating of the print bed (sets target temperature to 0).
+        Cancels any ongoing print bed heating and sets its target temperature to 0.
 
         Returns:
             True if the command is successful, False otherwise.
         """
+        if self.client.http_only:
+            return await self._send_http_temp_command(platform=TEMP_OFF)
         return await self.tcp_client.cancel_bed_temp()
 
+    async def set_chamber_temp(self, temp: int) -> bool:
+        """
+        Sets the target temperature for the printer's heated chamber. Only the
+        Creator 5 series has a chamber heater, and those printers are HTTP-only,
+        so this always goes over the HTTP ``temperatureCtl_cmd``. The firmware
+        caps the chamber at 80°C.
+
+        Args:
+            temp: The target temperature in Celsius.
+
+        Returns:
+            True if the command is acknowledged, False otherwise.
+        """
+        if not self.client.is_creator5 and not self.client.is_creator5_pro:
+            print("set_chamber_temp() error, chamber heater only available on Creator 5 series.")
+            return False
+        return await self._send_http_temp_command(chamber=temp)
+
+    async def cancel_chamber_temp(self) -> bool:
+        """
+        Cancels any ongoing chamber heating and sets its target temperature to 0.
+
+        Returns:
+            True if the command is acknowledged, False otherwise.
+        """
+        if not self.client.is_creator5 and not self.client.is_creator5_pro:
+            print(
+                "cancel_chamber_temp() error, chamber heater only available on Creator 5 series."
+            )
+            return False
+        return await self._send_http_temp_command(chamber=TEMP_OFF)
+
     async def wait_for_part_cool(
         self, target_temp: float = 50.0, timeout_seconds: int = 1800
     ) -> bool:
         """
         Waits for printer components to cool down to a safe temperature.
 
+        Relies on TCP G-code polling and is therefore unavailable on HTTP-only
+        printers (Creator 5 / 5 Pro); callers should poll ``info.get()`` instead.
+
         Args:
             target_temp: The target temperature to wait for (default: 50°C).
             timeout_seconds: Maximum time to wait in seconds (default: 30 minutes).
 
         Returns:
-            True if components cooled to target temperature, False if timeout or error.
+            True if components cooled to target temperature, False if timeout, error,
+            or HTTP-only (no TCP polling channel).
         """
+        if self.client.http_only:
+            print(
+                "wait_for_part_cool() unavailable over HTTP-only connection; "
+                "poll info.get() instead."
+            )
+            return False
         return await self.tcp_client.wait_for_part_cool(target_temp, timeout_seconds)

flashforge/api/network/utils.py

@@ -19,7 +19,7 @@ async def json_from_response(response: aiohttp.ClientResponse) -> dict:
         return await response.json()  # type: ignore[no-any-return]
     except aiohttp.ContentTypeError:
         text = await response.text()
-        return json.loads(text)
+        return json.loads(text)  # type: ignore[no-any-return]
 
 
 class NetworkUtils:

flashforge/client.py

@@ -27,6 +27,10 @@ class FiveMClientConnectionOptions:
     http_port: int | None = None
     tcp_port: int | None = None
     led_control_override: bool | None = None
+    # Force HTTP-only transport (skip the TCP/8899 handshake). Set this for a
+    # Creator 5 / Creator 5 Pro, which exposes no TCP service; otherwise it is
+    # auto-detected from the firmware-reported model after `verify_connection`.
+    http_only: bool | None = None
 
 
 class FlashForgeClient:
@@ -84,6 +88,8 @@ class FlashForgeClient:
         self.printer_name: str = ""
         self.is_pro: bool = False
         self._is_ad5x: bool = False
+        self.is_creator5: bool = False
+        self.is_creator5_pro: bool = False
         self.firmware_version: str = ""
         self.firmware_ver: str = ""
         self.mac_address: str = ""
@@ -106,6 +112,15 @@ class FlashForgeClient:
         )
         self._apply_feature_overrides()
 
+        # Transport selection. Creator 5 / Creator 5 Pro have no TCP/8899
+        # service, so they must run HTTP-only. An explicit override wins;
+        # otherwise http_only is auto-set from the detected model in
+        # `verify_connection` / `cache_details`.
+        self._http_only_override: bool | None = (
+            options.http_only if options and options.http_only is not None else None
+        )
+        self._http_only: bool = bool(self._http_only_override)
+
     @property
     def is_ad5x(self) -> bool:
         """
@@ -116,6 +131,46 @@ class FlashForgeClient:
         """
         return self._is_ad5x
 
+    @property
+    def http_only(self) -> bool:
+        """
+        Indicates whether the client should avoid the TCP transport.
+
+        True for Creator 5 / Creator 5 Pro (no TCP/8899 service) or when an
+        explicit ``http_only`` override was supplied at construction. When True,
+        TCP-only operations are unavailable (see :meth:`can_use_tcp`).
+
+        Returns:
+            True if the client must operate over HTTP only
+        """
+        return self._http_only
+
+    def can_use_tcp(self, op: str = "") -> bool:
+        """
+        Report whether a TCP-backed operation may be attempted.
+
+        Returns False whenever this client is HTTP-only (e.g. a Creator 5 with
+        no TCP/8899 service). TCP-delegating control/temperature methods check
+        this and no-op (return False) instead of hanging on a dead socket.
+
+        Args:
+            op: Optional operation name, included in the warning log.
+
+        Returns:
+            True if TCP operations are permitted, False otherwise
+        """
+        if self._http_only:
+            print(f"{op}() unavailable: printer has no TCP control channel (HTTP-only).")
+            return False
+        return True
+
+    def _update_http_only_from_model(self) -> None:
+        """Recompute ``http_only`` from the detected model unless overridden."""
+        if self._http_only_override is not None:
+            self._http_only = bool(self._http_only_override)
+        else:
+            self._http_only = self.is_creator5 or self.is_creator5_pro
+
     async def __aenter__(self) -> "FlashForgeClient":
         """Async context manager entry."""
         await self._ensure_http_session()
@@ -209,11 +264,15 @@ class FlashForgeClient:
         Disposes of the FlashForgeClient instance, stopping keep-alive messages
         and cleaning up resources.
         """
-        # Stop TCP keep-alive and dispose
-        if hasattr(self.tcp_client, "stop_keep_alive"):
-            await self.tcp_client.stop_keep_alive(True)
-        if hasattr(self.tcp_client, "dispose"):
-            await self.tcp_client.dispose()
+        # Stop TCP keep-alive and dispose. An HTTP-only client (e.g. Creator 5,
+        # which has no TCP/8899 service) never opened a TCP socket, so skip the
+        # cleanup handshake -- otherwise the logout send would attempt (and time
+        # out on) a connection that was never established.
+        if not self._http_only:
+            if hasattr(self.tcp_client, "stop_keep_alive"):
+                await self.tcp_client.stop_keep_alive(True)
+            if hasattr(self.tcp_client, "dispose"):
+                await self.tcp_client.dispose()
 
         # Close HTTP session
         if self._http_session and not self._http_session.closed:
@@ -298,6 +357,10 @@ class FlashForgeClient:
         self.camera_stream_url = info.camera_stream_url or ""
         self.lifetime_print_time = info.formatted_total_run_time or ""
         self._is_ad5x = info.is_ad5x
+        self.is_creator5 = info.is_creator5
+        self.is_creator5_pro = info.is_creator5_pro
+        # Refresh transport selection now that the model flags are cached.
+        self._update_http_only_from_model()
 
         # Format filament usage
         filament_value = info.cumulative_filament if info.cumulative_filament is not None else 0.0
@@ -338,15 +401,31 @@ class FlashForgeClient:
                 print("Failed to parse machine info from detail response")
                 return False
 
-            # Get TCP printer information to check for Pro model
-            tcp_info: PrinterInfo | None = await self.tcp_client.get_printer_info()
-            if tcp_info:
-                if "Pro" in tcp_info.type_name and not machine_info.is_pro and not machine_info.is_ad5x:
-                    self.is_pro = True
+            # Detect http_only from the parsed model BEFORE touching TCP. The
+            # Creator 5 / Creator 5 Pro expose no TCP/8899 service, so the M115
+            # handshake would hang until the connect timeout. An explicit
+            # override always wins.
+            if self._http_only_override is not None:
+                self._http_only = bool(self._http_only_override)
             else:
-                print(
-                    "Warning: Unable to get PrinterInfo from TCP API, some features might not work"
-                )
+                self._http_only = machine_info.is_creator5
+
+            # Get TCP printer information to check for Pro model
+            tcp_info: PrinterInfo | None = None
+            if not self._http_only:
+                tcp_info = await self.tcp_client.get_printer_info()
+                if tcp_info:
+                    if (
+                        "Pro" in tcp_info.type_name
+                        and not machine_info.is_pro
+                        and not machine_info.is_ad5x
+                    ):
+                        self.is_pro = True
+                else:
+                    print(
+                        "Warning: Unable to get PrinterInfo from TCP API, "
+                        "some features might not work"
+                    )
 
             # Cache the details
             return self.cache_details(machine_info)

flashforge/discovery/discovery.py

@@ -67,9 +67,25 @@ class PrinterModel(StrEnum):
     ADVENTURER_5M_PRO = "Adventurer5MPro"
     ADVENTURER_4 = "Adventurer4"
     ADVENTURER_3 = "Adventurer3"
+    CREATOR_5 = "Creator5"
+    CREATOR_5_PRO = "Creator5Pro"
     UNKNOWN = "Unknown"
 
 
+# Canonical USB Product IDs (discovery packet offset 0x88) for modern printers.
+# Same value space as the firmware /detail `pid` field and the FlashForge
+# update-checker keys, so it is the authoritative model discriminator -- unlike
+# `product_type` (0x5A02), which only identifies the 5M *family* and cannot tell
+# 5M / 5M Pro / AD5X / Creator 5 apart.
+MODERN_PRODUCT_IDS = {
+    0x0023: PrinterModel.ADVENTURER_5M,
+    0x0024: PrinterModel.ADVENTURER_5M_PRO,
+    0x0026: PrinterModel.AD5X,
+    0x0028: PrinterModel.CREATOR_5,
+    0x0029: PrinterModel.CREATOR_5_PRO,
+}
+
+
 class DiscoveryProtocol(StrEnum):
     """Discovery response wire formats."""
 
@@ -439,7 +455,7 @@ class PrinterDiscovery:
         product_type = int.from_bytes(buffer[0x8C:0x8E], byteorder="big")
         event_port = int.from_bytes(buffer[0x8E:0x90], byteorder="big")
         serial_number = buffer[0x92 : 0x92 + 128].decode("utf-8", errors="ignore").split("\x00", 1)[0]
-        model = self.detect_modern_model(name, product_type)
+        model = self.detect_modern_model(name, product_type, product_id)
 
         return DiscoveredPrinter(
             model=model,
@@ -480,18 +496,39 @@ class PrinterDiscovery:
             status=self.map_status_code(status_code),
         )
 
-    def detect_modern_model(self, name: str, product_type: int) -> PrinterModel:
-        """Detect a modern printer model from discovery metadata."""
-        upper_name = name.upper()
+    def detect_modern_model(
+        self,
+        name: str,
+        product_type: int,
+        product_id: int | None = None,
+    ) -> PrinterModel:
+        """Detect a modern printer model from discovery metadata.
+
+        Resolution order:
+          1. USB product ID (offset 0x88) -- authoritative, user-immutable, and
+             the only signal that distinguishes 5M / 5M Pro / AD5X / Creator 5.
+          2. product_type 0x5A02 (5M *family*) + name -- fallback for firmware
+             reporting an unknown/zero product ID.
+          3. Name heuristics -- last resort.
+        """
+        # Product ID is authoritative (firmware-set, not user-mutable).
+        if product_id is not None and product_id in MODERN_PRODUCT_IDS:
+            return MODERN_PRODUCT_IDS[product_id]
 
-        if upper_name == "AD5X":
-            return PrinterModel.AD5X
+        upper_name = name.upper()
 
+        # 0x5A02 identifies the 5M family but not the specific model, so we still
+        # need the name to separate base from Pro.
         if product_type == 0x5A02:
+            if upper_name == "AD5X":
+                return PrinterModel.AD5X
             if "PRO" in upper_name:
                 return PrinterModel.ADVENTURER_5M_PRO
             return PrinterModel.ADVENTURER_5M
 
+        if upper_name == "AD5X":
+            return PrinterModel.AD5X
+
         if "ADVENTURER 5M" in upper_name or "AD5M" in upper_name:
             if "PRO" in upper_name:
                 return PrinterModel.ADVENTURER_5M_PRO

flashforge/models/__init__.py

@@ -18,6 +18,8 @@ from .responses import (
     AD5XMaterialMapping,
     AD5XSingleColorJobParams,
     AD5XUploadParams,
+    Creator5JobParams,
+    Creator5UploadParams,
     DetailResponse,
     FilamentArgs,
     GCodeListResponse,
@@ -46,6 +48,8 @@ __all__ = [
     "AD5XLocalJobParams",
     "AD5XSingleColorJobParams",
     "AD5XUploadParams",
+    "Creator5JobParams",
+    "Creator5UploadParams",
     "GCodeListResponse",
     "ThumbnailResponse",
 ]

flashforge/models/machine_info.py

@@ -250,6 +250,17 @@ class FFPrinterDetail(BaseModel):
     nozzle_cnt: int | None = Field(default=None, ge=1, le=4, alias="nozzleCnt")
     nozzle_model: str | None = Field(default=None, alias="nozzleModel")
     nozzle_style: int | None = Field(default=None, ge=0, alias="nozzleStyle")
+    # --- Creator 5 series raw fields ---
+    # Immutable factory model name (e.g. "Creator 5 Pro"); unlike `name` this is
+    # not user-editable. May be absent on older firmware.
+    model: str | None = Field(default=None, alias="model")
+    # Per-tool current nozzle temperatures (one entry per nozzle). Multi-nozzle
+    # Creator 5 series report these; single-nozzle models use rightTemp/leftTemp.
+    nozzle_temps: list[float] | None = Field(default=None, alias="nozzleTemps")
+    # Per-tool target nozzle temperatures (one entry per nozzle).
+    nozzle_target_temps: list[float] | None = Field(default=None, alias="nozzleTargetTemps")
+    # Lidar / first-layer scanner presence flag (1 = present, 0 = absent).
+    lidar: int | None = Field(default=None, ge=0, alias="lidar")
     pid: int | None = Field(default=None, ge=0, alias="pid")
     plat_target_temp: float | None = Field(default=None, ge=-50, le=500, alias="platTargetTemp")
     plat_temp: float | None = Field(default=None, ge=-50, le=500, alias="platTemp")
@@ -327,11 +338,35 @@ class FFMachineInfo(BaseModel):
     pid: int | None = None
     is_pro: bool = False
     is_ad5x: bool = False
+    # Creator 5 / Creator 5 Pro (4-head tool-changer) detection. Drives the
+    # http_only transport decision and Pro-only capabilities (door sensor).
+    is_creator5: bool = False
+    is_creator5_pro: bool = False
+    # Immutable factory model name (e.g. "Creator 5 Pro"). Falls back to a
+    # PID-derived name, then the user-set `name`, when the printer doesn't
+    # report the `model` field.
+    model: str | None = None
     nozzle_size: str = ""
+    # Number of tools/nozzles the printer reports. Creator 5 series = 4
+    # (tool-changer); single-nozzle models = 1. Mirrors len(tool_temps).
+    nozzle_count: int | None = None
 
     # Temperatures
     print_bed: Temperature = Field(default_factory=Temperature)
     extruder: Temperature = Field(default_factory=Temperature)
+    # Heated chamber. Only the Creator 5 series has one; other models report 0/0.
+    chamber: Temperature | None = None
+    # Current/target temperatures for every tool/nozzle. Single-nozzle models
+    # report a 1-element array mirroring `extruder`; Creator 5 series report
+    # one entry per nozzle.
+    tool_temps: list[Temperature] = Field(default_factory=list)
+
+    # Capability flags (presence-derived, never assumed from model family)
+    has_camera: bool = False
+    has_lidar: bool = False
+    # Only true on models with confirmed hardware (Creator 5 Pro). When false,
+    # `door_open` is cosmetic and should not be surfaced.
+    has_door_sensor: bool = False
 
     # Current print stats
     print_duration: int = 0

flashforge/models/responses.py

@@ -164,6 +164,65 @@ class AD5XUploadParams(BaseModel):
     )
 
 
+class Creator5JobParams(BaseModel):
+    """Parameters for starting a Creator 5 / Creator 5 Pro local print job.
+
+    Distinct from the AD5X job params: the Creator 5 maps materials at print-start
+    (POST /printGcode) rather than upload time, so the body carries NO
+    ``useMatlStation`` / ``gcodeToolCnt`` / ``firstLayerInspection`` (the latter
+    doesn't exist on the C5). ``flowCalibration`` and ``timeLapseVideo`` are always
+    present (default False); ``material_mappings`` is optional for a single-tool
+    print.
+    """
+
+    model_config = ConfigDict(extra="forbid", populate_by_name=True)
+
+    file_name: str = Field(description="Name of the file on the printer to start")
+    leveling_before_print: bool = Field(
+        description="Whether to perform bed leveling before printing"
+    )
+    flow_calibration: bool = Field(
+        default=False, description="Whether to enable flow calibration"
+    )
+    time_lapse_video: bool = Field(
+        default=False, description="Whether to enable time lapse video recording"
+    )
+    material_mappings: list[AD5XMaterialMapping] | None = Field(
+        default=None,
+        max_length=4,
+        description="Optional per-tool material mappings (1-4 items); omit for single-tool",
+    )
+
+
+class Creator5UploadParams(BaseModel):
+    """Parameters for uploading a file to a Creator 5 / Creator 5 Pro.
+
+    Mirrors the AD5X upload but omits ``firstLayerInspection`` (absent on the C5)
+    and the ``materialMappings`` header (the C5 maps materials at print-start, not
+    upload). The C5 firmware checks the booleans as the string "true"/"false".
+    """
+
+    model_config = ConfigDict(extra="forbid", populate_by_name=True)
+
+    file_path: str = Field(description="Local file path to upload")
+    start_print: bool = Field(description="Whether to start printing immediately after upload")
+    leveling_before_print: bool = Field(
+        description="Whether to perform bed leveling before printing"
+    )
+    flow_calibration: bool = Field(
+        default=False, description="Whether to enable flow calibration"
+    )
+    time_lapse_video: bool = Field(
+        default=False, description="Whether to enable time lapse video recording"
+    )
+    use_matl_station: bool = Field(
+        description="Whether this is a multi-tool material-station job"
+    )
+    gcode_tool_cnt: int = Field(
+        ge=1, le=4, description="Number of tools in the G-code (1-4 for the C5)"
+    )
+
+
 class GCodeListResponse(GenericResponse):
     """Represents the response structure for a G-code file list request."""