flashforge-python-api 1.0.0__py3-none-any.whl

flashforge/discovery/discovery.py

@@ -0,0 +1,388 @@
+"""
+FlashForge Python API - Printer Discovery (FIXED VERSION)
+
+UDP-based printer discovery implementation that finds FlashForge printers on the local network.
+Fixed to match the original TypeScript implementation behavior.
+"""
+import asyncio
+import logging
+import socket
+from dataclasses import dataclass
+from typing import List, Optional
+
+import netifaces
+
+logger = logging.getLogger(__name__)
+
+
+@dataclass
+class FlashForgePrinter:
+    """
+    Represents a discovered FlashForge 3D printer.
+    Stores information such as name, serial number, and IP address.
+    """
+    name: str = ""
+    serial_number: str = ""
+    ip_address: str = ""
+
+    def __str__(self) -> str:
+        """Returns a string representation of the FlashForgePrinter object."""
+        return f"Name: {self.name}, Serial: {self.serial_number}, IP: {self.ip_address}"
+
+    def __repr__(self) -> str:
+        """Returns a detailed string representation for debugging."""
+        return f"FlashForgePrinter(name='{self.name}', serial_number='{self.serial_number}', ip_address='{self.ip_address}')"
+
+
+class FlashForgePrinterDiscovery:
+    """
+    Handles the discovery of FlashForge printers on the local network.
+    Uses UDP broadcast messages to find printers and parses their responses.
+    """
+
+    # The UDP port used for sending discovery messages to FlashForge printers
+    DISCOVERY_PORT = 48899
+    # The port we listen on for responses (must match TypeScript implementation)
+    LISTEN_PORT = 18007
+
+    def __init__(self):
+        """Initialize the printer discovery client."""
+        self.discovery_port = self.DISCOVERY_PORT
+        self.listen_port = self.LISTEN_PORT
+
+        # The discovery UDP packet is a 20-byte message.
+        # It starts with "www.usr" followed by specific bytes.
+        # This packet structure is based on observations from FlashPrint software.
+        self.discovery_message = bytes([
+            0x77, 0x77, 0x77, 0x2e, 0x75, 0x73, 0x72, 0x22,  # "www.usr"
+            0x65, 0x36, 0xc0, 0x00, 0x00, 0x00, 0x00, 0x00,
+            0x00, 0x00, 0x00, 0x00
+        ])
+
+    async def discover_printers_async(
+        self,
+        timeout_ms: int = 10000,
+        idle_timeout_ms: int = 1500,
+        max_retries: int = 3
+    ) -> List[FlashForgePrinter]:
+        """
+        Discovers FlashForge printers on the network asynchronously.
+        
+        FIXED VERSION - Uses proper asyncio UDP socket handling that matches the TypeScript implementation.
+        
+        Args:
+            timeout_ms: The total time (in milliseconds) to wait for printer responses
+            idle_timeout_ms: The time (in milliseconds) to wait for additional responses 
+                           after the last received one
+            max_retries: The maximum number of discovery attempts
+            
+        Returns:
+            A list of FlashForgePrinter objects found on the network
+        """
+        printers: List[FlashForgePrinter] = []
+        broadcast_addresses = self._get_broadcast_addresses()
+        attempt = 0
+
+        logger.info(f"Starting printer discovery with {len(broadcast_addresses)} broadcast addresses")
+
+        while attempt < max_retries:
+            attempt += 1
+            logger.debug(f"Discovery attempt {attempt}/{max_retries}")
+
+            try:
+                # Use asyncio datagram endpoint for proper UDP handling
+                transport, protocol = await asyncio.get_event_loop().create_datagram_endpoint(
+                    lambda: DiscoveryProtocol(self),
+                    local_addr=('0.0.0.0', self.listen_port),
+                    allow_broadcast=True
+                )
+
+                try:
+                    # Send discovery messages to all broadcast addresses
+                    for broadcast_address in broadcast_addresses:
+                        try:
+                            transport.sendto(self.discovery_message, (broadcast_address, self.discovery_port))
+                            logger.debug(f"Sent discovery message to {broadcast_address}:{self.discovery_port}")
+                        except Exception as e:
+                            logger.warning(f"Failed to send to {broadcast_address}: {e}")
+
+                    # Wait for responses using the protocol
+                    found_printers = await protocol.wait_for_responses(
+                        timeout_ms / 1000.0, idle_timeout_ms / 1000.0
+                    )
+                    printers.extend(found_printers)
+
+                finally:
+                    transport.close()
+
+                if printers:
+                    break  # Printers found, exit retry loop
+
+                if attempt < max_retries:
+                    logger.debug(f"No printers found, waiting before retry {attempt + 1}")
+                    await asyncio.sleep(1.0)  # Wait before retrying
+
+            except Exception as e:
+                logger.error(f"Error during discovery attempt {attempt}: {e}")
+                if attempt < max_retries:
+                    await asyncio.sleep(1.0)
+
+        # Remove duplicates based on IP address
+        unique_printers = {}
+        for printer in printers:
+            if printer.ip_address not in unique_printers:
+                unique_printers[printer.ip_address] = printer
+
+        final_printers = list(unique_printers.values())
+        logger.info(f"Discovery completed. Found {len(final_printers)} unique printers")
+
+        return final_printers
+
+    def _parse_printer_response(self, response: bytes, ip_address: str) -> Optional[FlashForgePrinter]:
+        """
+        Parses the UDP response received from a FlashForge printer.
+        
+        The response is a buffer containing printer information at specific offsets:
+        - Printer Name: ASCII string at offset 0x00 (32 bytes)
+        - Serial Number: ASCII string at offset 0x92 (32 bytes)
+        
+        Args:
+            response: The bytes containing the printer's response
+            ip_address: The IP address from which the response was received
+            
+        Returns:
+            A FlashForgePrinter object if parsing is successful, otherwise None
+        """
+        # Expected response length is at least 0xC4 (196 bytes) to contain name and serial
+        if not response:
+            logger.warning(f"Invalid response from {ip_address}: response is None or empty")
+            return None
+
+        if len(response) < 0xC4:
+            logger.warning(f"Invalid response from {ip_address}, length: {len(response)}")
+            return None
+
+        try:
+            # Printer name is at offset 0x00, padded with null characters
+            name = response[0:32].decode('ascii', errors='ignore').rstrip('\x00')
+
+            # Serial number is at offset 0x92, padded with null characters
+            serial_number = response[0x92:0x92 + 32].decode('ascii', errors='ignore').rstrip('\x00')
+
+            if not name and not serial_number:
+                logger.warning(f"Empty name and serial from {ip_address}")
+                return None
+
+            printer = FlashForgePrinter(
+                name=name,
+                serial_number=serial_number,
+                ip_address=ip_address
+            )
+
+            return printer
+
+        except Exception as e:
+            logger.error(f"Error parsing response from {ip_address}: {e}")
+            return None
+
+    def _get_broadcast_addresses(self) -> List[str]:
+        """
+        Retrieves a list of broadcast addresses for all active IPv4 network interfaces.
+        
+        Returns:
+            A list of broadcast address strings
+        """
+        broadcast_addresses: List[str] = []
+
+        try:
+            # Get all network interfaces
+            for interface_name in netifaces.interfaces():
+                try:
+                    # Get IPv4 addresses for this interface
+                    addresses = netifaces.ifaddresses(interface_name)
+                    if netifaces.AF_INET not in addresses:
+                        continue
+
+                    for addr_info in addresses[netifaces.AF_INET]:
+                        # Skip loopback interfaces
+                        if addr_info.get('addr', '').startswith('127.'):
+                            continue
+
+                        # Calculate broadcast address if netmask is available
+                        ip_addr = addr_info.get('addr')
+                        netmask = addr_info.get('netmask')
+
+                        if ip_addr and netmask:
+                            broadcast = self._calculate_broadcast_address(ip_addr, netmask)
+                            if broadcast and broadcast not in broadcast_addresses:
+                                broadcast_addresses.append(broadcast)
+                                logger.debug(f"Added broadcast address: {broadcast} (interface: {interface_name})")
+
+                except Exception as e:
+                    logger.warning(f"Error processing interface {interface_name}: {e}")
+                    continue
+
+        except Exception as e:
+            logger.error(f"Error getting network interfaces: {e}")
+            # Fallback to common broadcast addresses
+            broadcast_addresses = ['255.255.255.255', '192.168.1.255', '192.168.0.255']
+            logger.info("Using fallback broadcast addresses")
+
+        # Always include the general broadcast address
+        if '255.255.255.255' not in broadcast_addresses:
+            broadcast_addresses.append('255.255.255.255')
+
+        logger.debug(f"Using broadcast addresses: {broadcast_addresses}")
+        return broadcast_addresses
+
+    def _calculate_broadcast_address(self, ip_address: str, subnet_mask: str) -> Optional[str]:
+        """
+        Calculates the broadcast address for a given IP address and subnet mask.
+        
+        Args:
+            ip_address: The IPv4 address string (e.g., "192.168.1.10")
+            subnet_mask: The IPv4 subnet mask string (e.g., "255.255.255.0")
+            
+        Returns:
+            The calculated broadcast address string, or None if input is invalid
+        """
+        try:
+            # Convert IP and subnet to arrays of numbers
+            ip_parts = [int(x) for x in ip_address.split('.')]
+            mask_parts = [int(x) for x in subnet_mask.split('.')]
+
+            if len(ip_parts) != 4 or len(mask_parts) != 4:
+                return None
+
+            # Calculate broadcast address: IP | (~MASK)
+            broadcast_parts = [ip_parts[i] | (~mask_parts[i] & 255) for i in range(4)]
+            return '.'.join(map(str, broadcast_parts))
+
+        except Exception as e:
+            logger.warning(f"Error calculating broadcast address for {ip_address}/{subnet_mask}: {e}")
+            return None
+
+    def print_debug_info(self, response: bytes, ip_address: str) -> None:
+        """
+        Prints detailed debugging information about a received UDP response.
+        
+        Args:
+            response: The bytes containing the response data
+            ip_address: The IP address from which the response was received
+        """
+        print(f"Received response from {ip_address}:")
+        print(f"Response length: {len(response)} bytes")
+
+        # Hex dump
+        print("Hex dump:")
+        for i in range(0, len(response), 16):
+            line = f"{i:04x}   "
+
+            # Hex values
+            for j in range(16):
+                if i + j < len(response):
+                    line += f"{response[i + j]:02x} "
+                else:
+                    line += "   "
+
+                if j == 7:
+                    line += " "
+
+            # ASCII representation
+            line += "  "
+            for j in range(16):
+                if i + j < len(response):
+                    c = response[i + j]
+                    line += chr(c) if 32 <= c <= 126 else '.'
+
+            print(line)
+
+        # ASCII dump
+        print("ASCII dump:")
+        try:
+            ascii_content = response.decode('ascii', errors='replace')
+            print(repr(ascii_content))
+        except Exception as e:
+            print(f"Error decoding ASCII: {e}")
+
+
+class DiscoveryProtocol(asyncio.DatagramProtocol):
+    """
+    Asyncio datagram protocol for handling UDP discovery responses.
+    This matches the event-driven approach used in the TypeScript implementation.
+    """
+
+    def __init__(self, discovery: FlashForgePrinterDiscovery):
+        self.discovery = discovery
+        self.printers: List[FlashForgePrinter] = []
+        self.response_event = asyncio.Event()
+        self.last_response_time = 0.0
+
+    def connection_made(self, transport):
+        self.transport = transport
+        logger.debug("Discovery protocol connection established")
+
+    def datagram_received(self, data: bytes, addr):
+        """Handle incoming UDP datagram (printer response)."""
+        ip_address = addr[0]
+        logger.debug(f"Received {len(data)} bytes from {ip_address}")
+
+        # Parse the response
+        printer = self.discovery._parse_printer_response(data, ip_address)
+        if printer:
+            self.printers.append(printer)
+            logger.info(f"Discovered printer: {printer}")
+
+        # Update last response time and signal that we got a response
+        self.last_response_time = asyncio.get_event_loop().time()
+        self.response_event.set()
+        self.response_event.clear()  # Reset for next response
+
+    def error_received(self, exc):
+        logger.error(f"Discovery protocol error: {exc}")
+
+    async def wait_for_responses(self, total_timeout: float, idle_timeout: float) -> List[FlashForgePrinter]:
+        """
+        Wait for printer responses with total and idle timeouts.
+        
+        Args:
+            total_timeout: Maximum total time to wait for responses
+            idle_timeout: Maximum time to wait between responses
+            
+        Returns:
+            List of discovered printers
+        """
+        start_time = asyncio.get_event_loop().time()
+        self.last_response_time = start_time
+
+        logger.debug(f"Waiting for responses (total timeout: {total_timeout}s, idle timeout: {idle_timeout}s)")
+
+        while True:
+            current_time = asyncio.get_event_loop().time()
+
+            # Check total timeout
+            if current_time - start_time >= total_timeout:
+                logger.debug("Total timeout reached")
+                break
+
+            # Check idle timeout
+            if current_time - self.last_response_time >= idle_timeout:
+                logger.debug("Idle timeout reached")
+                break
+
+            # Wait for next response or timeout
+            try:
+                remaining_total = total_timeout - (current_time - start_time)
+                remaining_idle = idle_timeout - (current_time - self.last_response_time)
+                wait_time = min(remaining_total, remaining_idle, 0.1)  # Max 100ms wait
+                
+                if wait_time <= 0:
+                    break
+                    
+                await asyncio.wait_for(self.response_event.wait(), timeout=wait_time)
+            except asyncio.TimeoutError:
+                # Continue to check timeouts
+                continue
+
+        logger.debug(f"Finished waiting, found {len(self.printers)} printers")
+        return self.printers

flashforge/models/__init__.py

@@ -0,0 +1,50 @@
+"""
+FlashForge Python API - Models Package
+"""
+from .machine_info import (
+    FFMachineInfo,
+    FFPrinterDetail,
+    FFGcodeFileEntry,
+    FFGcodeToolData,
+    MachineState,
+    Temperature,
+    SlotInfo,
+    MatlStationInfo,
+    IndepMatlInfo,
+)
+from .responses import (
+    DetailResponse,
+    FilamentArgs,
+    GenericResponse,
+    Product,
+    ProductResponse,
+    AD5XMaterialMapping,
+    AD5XLocalJobParams,
+    AD5XSingleColorJobParams,
+    AD5XUploadParams,
+    GCodeListResponse,
+    ThumbnailResponse,
+)
+
+__all__ = [
+    "FFMachineInfo",
+    "FFPrinterDetail",
+    "FFGcodeFileEntry",
+    "FFGcodeToolData",
+    "MachineState",
+    "Temperature",
+    "SlotInfo",
+    "MatlStationInfo",
+    "IndepMatlInfo",
+    "DetailResponse",
+    "FilamentArgs",
+    "GenericResponse",
+    "Product",
+    "ProductResponse",
+    "AD5XMaterialMapping",
+    "AD5XLocalJobParams",
+    "AD5XSingleColorJobParams",
+    "AD5XUploadParams",
+    "GCodeListResponse",
+    "ThumbnailResponse",
+]

flashforge/models/machine_info.py

@@ -0,0 +1,247 @@
+"""
+FlashForge Python API - Data Models
+"""
+from __future__ import annotations
+
+from datetime import datetime
+from enum import Enum
+from typing import Optional
+
+from pydantic import BaseModel, Field
+
+
+class MachineState(Enum):
+    """Enumerates the possible operational states of the FlashForge 3D printer."""
+    READY = "ready"
+    BUSY = "busy"
+    CALIBRATING = "calibrating"
+    ERROR = "error"
+    HEATING = "heating"
+    PRINTING = "printing"
+    PAUSING = "pausing"
+    PAUSED = "paused"
+    CANCELLED = "cancelled"
+    COMPLETED = "completed"
+    UNKNOWN = "unknown"
+
+
+class Temperature(BaseModel):
+    """Represents a pair of current and target temperatures for a component like an extruder or print bed."""
+    current: float = Field(default=0.0, description="The current temperature in Celsius")
+    set: float = Field(default=0.0, description="The target (set) temperature in Celsius")
+
+
+class SlotInfo(BaseModel):
+    """Information about a single slot in the material station."""
+    has_filament: bool = Field(alias="hasFilament", description="Indicates if filament is present in this slot")
+    material_color: str = Field(alias="materialColor", description="Color of the material in this slot (e.g., '#FFFFFF')")
+    material_name: str = Field(alias="materialName", description="Name of the material in this slot (e.g., 'PLA')")
+    slot_id: int = Field(alias="slotId", description="Identifier for this slot")
+
+    class Config:
+        populate_by_name = True
+
+
+class MatlStationInfo(BaseModel):
+    """Detailed information about the material station."""
+    current_load_slot: int = Field(alias="currentLoadSlot", description="Currently loading slot ID (0 if none)")
+    current_slot: int = Field(alias="currentSlot", description="Currently active/printing slot ID (0 if none)")
+    slot_cnt: int = Field(alias="slotCnt", description="Total number of slots in the station")
+    slot_infos: list[SlotInfo] = Field(default_factory=list, alias="slotInfos", description="Array of information for each slot")
+    state_action: int = Field(alias="stateAction", description="Current action state of the material station")
+    state_step: int = Field(alias="stateStep", description="Current step within the state action")
+
+    class Config:
+        populate_by_name = True
+
+
+class IndepMatlInfo(BaseModel):
+    """Information related to independent material loading, often used when a single extruder printer has a material station."""
+    material_color: str = Field(alias="materialColor", description="Color of the material")
+    material_name: str = Field(alias="materialName", description="Name of the material (can be '?' if unknown)")
+    state_action: int = Field(alias="stateAction", description="Current action state")
+    state_step: int = Field(alias="stateStep", description="Current step within the state action")
+
+    class Config:
+        populate_by_name = True
+
+
+class FFGcodeToolData(BaseModel):
+    """Represents data for a single tool/material used in a G-code file, typically part of a multi-material print."""
+    filament_weight: float = Field(alias="filamentWeight", description="Calculated filament weight for this tool/material in the print")
+    material_color: str = Field(alias="materialColor", description="Material color hex string (e.g., '#FFFF00')")
+    material_name: str = Field(alias="materialName", description="Name of the material (e.g., 'PLA')")
+    slot_id: int = Field(alias="slotId", description="Slot ID from the material station, if applicable (0 if not or direct)")
+    tool_id: int = Field(alias="toolId", description="Tool ID or extruder number")
+
+    class Config:
+        populate_by_name = True
+
+
+class FFGcodeFileEntry(BaseModel):
+    """Represents a single G-code file entry as returned by the /gcodeList endpoint, especially for printers like AD5X that provide detailed material info."""
+    gcode_file_name: str = Field(alias="gcodeFileName", description="The name of the G-code file (e.g., 'FISH_PLA.3mf')")
+    gcode_tool_cnt: Optional[int] = Field(default=None, alias="gcodeToolCnt", description="Number of tools/materials used in this G-code file")
+    gcode_tool_datas: Optional[list[FFGcodeToolData]] = Field(default=None, alias="gcodeToolDatas", description="Array of detailed information for each tool/material")
+    printing_time: int = Field(alias="printingTime", description="Estimated printing time in seconds")
+    total_filament_weight: Optional[float] = Field(default=None, alias="totalFilamentWeight", description="Total estimated filament weight for the print")
+    use_matl_station: Optional[bool] = Field(default=None, alias="useMatlStation", description="Indicates if the G-code file is intended for use with a material station")
+
+    class Config:
+        populate_by_name = True
+
+
+class FFPrinterDetail(BaseModel):
+    """
+    Represents the raw detailed information about a FlashForge 3D printer as obtained from its API.
+    Properties are often in the printer's native naming format and may include string representations
+    of boolean states (e.g., "open", "close").
+    """
+    auto_shutdown: Optional[str] = Field(default=None, alias="autoShutdown")
+    auto_shutdown_time: Optional[int] = Field(default=None, alias="autoShutdownTime")
+    camera_stream_url: Optional[str] = Field(default=None, alias="cameraStreamUrl")
+    chamber_fan_speed: Optional[int] = Field(default=None, alias="chamberFanSpeed")
+    chamber_target_temp: Optional[float] = Field(default=None, alias="chamberTargetTemp")
+    chamber_temp: Optional[float] = Field(default=None, alias="chamberTemp")
+    cooling_fan_speed: Optional[int] = Field(default=None, alias="coolingFanSpeed")
+    cooling_fan_left_speed: Optional[int] = Field(default=None, alias="coolingFanLeftSpeed")
+    cumulative_filament: Optional[float] = Field(default=None, alias="cumulativeFilament")
+    cumulative_print_time: Optional[int] = Field(default=None, alias="cumulativePrintTime")
+    current_print_speed: Optional[int] = Field(default=None, alias="currentPrintSpeed")
+    door_status: Optional[str] = Field(default=None, alias="doorStatus")
+    error_code: Optional[str] = Field(default=None, alias="errorCode")
+    estimated_left_len: Optional[float] = Field(default=None, alias="estimatedLeftLen")
+    estimated_left_weight: Optional[float] = Field(default=None, alias="estimatedLeftWeight")
+    estimated_right_len: Optional[float] = Field(default=None, alias="estimatedRightLen")
+    estimated_right_weight: Optional[float] = Field(default=None, alias="estimatedRightWeight")
+    estimated_time: Optional[int] = Field(default=None, alias="estimatedTime")
+    external_fan_status: Optional[str] = Field(default=None, alias="externalFanStatus")
+    fill_amount: Optional[float] = Field(default=None, alias="fillAmount")
+    firmware_version: Optional[str] = Field(default=None, alias="firmwareVersion")
+    flash_register_code: Optional[str] = Field(default=None, alias="flashRegisterCode")
+    has_matl_station: Optional[bool] = Field(default=None, alias="hasMatlStation")
+    matl_station_info: Optional[MatlStationInfo] = Field(default=None, alias="matlStationInfo")
+    indep_matl_info: Optional[IndepMatlInfo] = Field(default=None, alias="indepMatlInfo")
+    has_left_filament: Optional[bool] = Field(default=None, alias="hasLeftFilament")
+    has_right_filament: Optional[bool] = Field(default=None, alias="hasRightFilament")
+    internal_fan_status: Optional[str] = Field(default=None, alias="internalFanStatus")
+    ip_addr: Optional[str] = Field(default=None, alias="ipAddr")
+    left_filament_type: Optional[str] = Field(default=None, alias="leftFilamentType")
+    left_target_temp: Optional[float] = Field(default=None, alias="leftTargetTemp")
+    left_temp: Optional[float] = Field(default=None, alias="leftTemp")
+    light_status: Optional[str] = Field(default=None, alias="lightStatus")
+    location: Optional[str] = Field(default=None, alias="location")
+    mac_addr: Optional[str] = Field(default=None, alias="macAddr")
+    measure: Optional[str] = Field(default=None, alias="measure")
+    name: Optional[str] = Field(default=None, alias="name")
+    nozzle_cnt: Optional[int] = Field(default=None, alias="nozzleCnt")
+    nozzle_model: Optional[str] = Field(default=None, alias="nozzleModel")
+    nozzle_style: Optional[int] = Field(default=None, alias="nozzleStyle")
+    pid: Optional[int] = Field(default=None, alias="pid")
+    plat_target_temp: Optional[float] = Field(default=None, alias="platTargetTemp")
+    plat_temp: Optional[float] = Field(default=None, alias="platTemp")
+    polar_register_code: Optional[str] = Field(default=None, alias="polarRegisterCode")
+    print_duration: Optional[int] = Field(default=None, alias="printDuration")
+    print_file_name: Optional[str] = Field(default=None, alias="printFileName")
+    print_file_thumb_url: Optional[str] = Field(default=None, alias="printFileThumbUrl")
+    print_layer: Optional[int] = Field(default=None, alias="printLayer")
+    print_progress: Optional[float] = Field(default=None, alias="printProgress")
+    print_speed_adjust: Optional[int] = Field(default=None, alias="printSpeedAdjust")
+    remaining_disk_space: Optional[float] = Field(default=None, alias="remainingDiskSpace")
+    right_filament_type: Optional[str] = Field(default=None, alias="rightFilamentType")
+    right_target_temp: Optional[float] = Field(default=None, alias="rightTargetTemp")
+    right_temp: Optional[float] = Field(default=None, alias="rightTemp")
+    status: Optional[str] = Field(default=None, alias="status")
+    target_print_layer: Optional[int] = Field(default=None, alias="targetPrintLayer")
+    tvoc: Optional[float] = Field(default=None, alias="tvoc")
+    z_axis_compensation: Optional[float] = Field(default=None, alias="zAxisCompensation")
+
+
+class FFMachineInfo(BaseModel):
+    """
+    Represents a structured and user-friendly model of the printer's information and state.
+    This interface is populated by transforming data from FFPrinterDetail.
+    """
+    # Auto-shutdown settings
+    auto_shutdown: bool = False
+    auto_shutdown_time: int = 0
+
+    # Camera
+    camera_stream_url: str = ""
+
+    # Fan speeds
+    chamber_fan_speed: int = 0
+    cooling_fan_speed: int = 0
+    cooling_fan_left_speed: Optional[int] = None
+
+    # Cumulative stats
+    cumulative_filament: float = 0.0
+    cumulative_print_time: int = 0
+
+    # Current print speed
+    current_print_speed: int = 0
+
+    # Disk space
+    free_disk_space: str = "0.00"
+
+    # Door and error status
+    door_open: bool = False
+    error_code: str = ""
+
+    # Current print estimates
+    est_length: float = 0.0
+    est_weight: float = 0.0
+    estimated_time: int = 0
+
+    # Fans & LED status
+    external_fan_on: bool = False
+    internal_fan_on: bool = False
+    lights_on: bool = False
+
+    # Network
+    ip_address: str = ""
+    mac_address: str = ""
+
+    # Print settings
+    fill_amount: float = 0.0
+    firmware_version: str = ""
+    name: str = ""
+    is_pro: bool = False
+    is_ad5x: bool = False
+    nozzle_size: str = ""
+
+    # Temperatures
+    print_bed: Temperature = Field(default_factory=Temperature)
+    extruder: Temperature = Field(default_factory=Temperature)
+
+    # Current print stats
+    print_duration: int = 0
+    print_file_name: str = ""
+    print_file_thumb_url: str = ""
+    current_print_layer: int = 0
+    print_progress: float = 0.0
+    print_progress_int: int = 0
+    print_speed_adjust: int = 0
+    filament_type: str = ""
+
+    # Machine state
+    machine_state: MachineState = MachineState.UNKNOWN
+    status: str = ""
+    total_print_layers: int = 0
+    tvoc: float = 0.0
+    z_axis_compensation: float = 0.0
+
+    # Cloud codes
+    flash_cloud_register_code: str = ""
+    polar_cloud_register_code: str = ""
+
+    # Extras
+    print_eta: str = "00:00"
+    completion_time: datetime = Field(default_factory=datetime.now)
+    formatted_run_time: str = "00:00"
+    formatted_total_run_time: str = "0h:0m"
+
+    # AD5X Material Station
+    has_matl_station: Optional[bool] = None
+    matl_station_info: Optional[MatlStationInfo] = None
+    indep_matl_info: Optional[IndepMatlInfo] = None