anycubic-cloud-api 0.1.0__py3-none-any.whl

anycubic_cloud_api/api/mqtt.py

@@ -0,0 +1,449 @@
+from __future__ import annotations
+
+import asyncio
+import json
+import ssl
+import traceback
+from collections.abc import Callable
+from os import path
+from typing import TYPE_CHECKING, Any
+
+from paho.mqtt import client as mqtt_client
+
+# paho-mqtt 2.x requires CallbackAPIVersion as the first argument to Client().
+# We pin VERSION1 so the existing callback signatures (on_connect with rc,
+# on_disconnect with rc, on_message with msg, on_subscribe with mid/granted_qos)
+# keep working without rewriting every callback in the file.
+# Fall back to a sentinel for paho-mqtt 1.x where this enum doesn't exist.
+try:
+    from paho.mqtt.enums import CallbackAPIVersion as _CallbackAPIVersion
+    _MQTT_CALLBACK_API_VERSION = _CallbackAPIVersion.VERSION1
+except ImportError:  # paho-mqtt 1.x
+    _MQTT_CALLBACK_API_VERSION = None
+
+from ..const.mqtt import (
+    MQTT_HOST,
+    MQTT_PORT,
+    MQTT_ROOT_TOPIC_PLUS,
+    MQTT_ROOT_TOPIC_PRINTER,
+    MQTT_ROOT_TOPIC_PUBLISH_PRINTER,
+    MQTT_ROOT_TOPIC_SERVER,
+    MQTT_TIMEOUT,
+)
+from ..data_models.consumable import AnycubicConsumableData
+from ..exceptions.error_strings import ErrorsMQTTClient
+from ..exceptions.exceptions import (
+    AnycubicMQTTClientError,
+    AnycubicMQTTUnhandledData,
+    AnycubicMQTTUnknownUpdate,
+)
+from ..helpers.helpers import (
+    get_mqtt_ssl_path_ca,
+    get_mqtt_ssl_path_cert,
+    get_mqtt_ssl_path_key,
+    get_part_from_mqtt_topic,
+    get_ssl_cert_directory,
+    redact_part_from_mqtt_topic,
+)
+from .functions import AnycubicAPIFunctions
+
+if TYPE_CHECKING:
+    from ..data_models.printer import AnycubicPrinter
+
+
+class AnycubicMQTTAPI(AnycubicAPIFunctions):
+    __slots__ = (
+        "_mqtt_client",
+        "_mqtt_subscribed_printers",
+        "_mqtt_log_all_messages",
+        "_mqtt_connected",
+        "_mqtt_disconnected",
+        "_mqtt_callback_printer_update",
+        "_mqtt_callback_printer_busy",
+        "_mqtt_callback_subscribed",
+    )
+
+    def __init__(
+        self,
+        *args: Any,
+        mqtt_callback_printer_update: Callable[[], None] | None = None,
+        mqtt_callback_printer_busy: Callable[[], None] | None = None,
+        mqtt_callback_subscribed: Callable[[], None] | None = None,
+        **kwargs: Any,
+    ) -> None:
+        self._mqtt_client: mqtt_client.Client | None = None
+        self._mqtt_subscribed_printers: dict[str, AnycubicPrinter] = dict()
+        self._mqtt_log_all_messages: bool = False
+        self._mqtt_connected: asyncio.Event | None = None
+        self._mqtt_disconnected: asyncio.Event | None = None
+        self._mqtt_callback_printer_update: Callable[[], None] | None = mqtt_callback_printer_update
+        self._mqtt_callback_printer_busy: Callable[[], None] | None = mqtt_callback_printer_busy
+        self._mqtt_callback_subscribed: Callable[[], None] | None = mqtt_callback_subscribed
+        super().__init__(*args, **kwargs)
+
+    @property
+    def mqtt_is_started(self) -> bool:
+        return self._mqtt_client is not None
+
+    def set_mqtt_log_all_messages(self, val: bool) -> None:
+        self._mqtt_log_all_messages = bool(val)
+
+    async def mqtt_wait_for_connect(self) -> bool:
+        if self._mqtt_connected is None:
+            return True
+
+        try:
+            async with asyncio.timeout(10):
+                await self._mqtt_connected.wait()
+            self._mqtt_connected = None
+            await asyncio.sleep(2)
+            return True
+        except (asyncio.TimeoutError, asyncio.CancelledError):
+            return False
+
+    async def mqtt_wait_for_disconnect(self) -> bool:
+        if self._mqtt_disconnected is None:
+            return True
+
+        try:
+            async with asyncio.timeout(10):
+                await self._mqtt_disconnected.wait()
+            self._mqtt_disconnected = None
+            return True
+        except (asyncio.TimeoutError, asyncio.CancelledError):
+            return False
+
+    def _build_mqtt_printer_subscription(self, printer: AnycubicPrinter) -> list[str]:
+        # topic_slicer = f"{MQTT_ROOT_TOPIC_SLICER}{printer.machine_type}/{printer.key}/#"
+        topic_printer = f"{MQTT_ROOT_TOPIC_PRINTER}{printer.machine_type}/{printer.key}/#"
+        topic_plus = f"{MQTT_ROOT_TOPIC_PLUS}{printer.machine_type}/{printer.key}/#"
+        return list([
+            # topic_slicer,
+            topic_printer,
+            topic_plus
+        ])
+
+    def _build_mqtt_printer_publish_topic(self, printer: AnycubicPrinter, endpoint: str) -> str:
+        return f"{MQTT_ROOT_TOPIC_PUBLISH_PRINTER}{printer.machine_type}/{printer.key}/{endpoint}"
+
+    def _build_mqtt_user_subscription(self) -> list[str]:
+        user_id, user_id_md5 = self.anycubic_auth.get_user_id_md5_tuple()
+        root = f"{MQTT_ROOT_TOPIC_SERVER}{user_id}/{user_id_md5}"
+        topic_slice_report = f"{root}/slice/report"
+        topic_fdm_slice_report = f"{root}/fdmslice/report"
+
+        return list([topic_slice_report, topic_fdm_slice_report])
+
+    def _mqtt_topic_is_user_topic(self, topic: str) -> bool:
+        return get_part_from_mqtt_topic(topic, 3) == 'server'
+
+    def _mqtt_message_router(self, message: mqtt_client.MQTTMessage) -> None:
+        try:
+            topic = str(message.topic)
+            payload = json.loads(message.payload.decode('utf-8'))
+        except Exception as e:
+            self._log_to_error(
+                f"Anycubic MQTT Message decode error: {e}\n"
+                f"  on MQTT topic: {message.topic}\n"
+                f"    {message.payload!r}"
+            )
+            return
+
+        if self._mqtt_topic_is_user_topic(topic):
+            self._log_to_debug(
+                f"Anycubic MQTT USER Msg Received on `{topic}`:\n"
+                f"    {payload}"
+            )
+
+        else:
+            printer_key = get_part_from_mqtt_topic(topic, 6)
+
+            if get_part_from_mqtt_topic(topic, 7) == 'response' and len(payload.keys()) == 1:
+                return
+
+            if printer_key not in self._mqtt_subscribed_printers:
+                return
+
+            printer = self._mqtt_subscribed_printers[printer_key]
+
+            printer_was_available = printer.is_available
+
+            try:
+                printer.process_mqtt_update(topic, AnycubicConsumableData(payload))
+
+            except AnycubicMQTTUnhandledData as e:
+                redacted_topic = redact_part_from_mqtt_topic(topic, 6)
+                self._log_to_warn(
+                    f"Anycubic MQTT Message unhandled data in: {e}\n"
+                    f"  on MQTT topic: {redacted_topic}\n"
+                    f"  with type: {e.unhandled_mqtt_type}, "
+                    f"action: {e.unhandled_mqtt_action}, "
+                    f"state: {e.unhandled_mqtt_state}\n"
+                    f"    unhandled data: {e.unhandled_mqtt_data}"
+                )
+
+            except AnycubicMQTTUnknownUpdate as e:
+                # A message type this version doesn't parse yet. Nothing is
+                # broken and there is nothing the user can act on, so log a
+                # single debug line rather than an ERROR with a traceback.
+                redacted_topic = redact_part_from_mqtt_topic(topic, 6)
+                self._log_to_debug(
+                    f"Anycubic MQTT Message not understood: {e}\n"
+                    f"  on MQTT topic: {redacted_topic}\n"
+                    f"    {payload}"
+                )
+
+            except Exception as e:
+                tb = traceback.format_exc()
+                redacted_topic = redact_part_from_mqtt_topic(topic, 6)
+                error_type = type(e)
+                self._log_to_error(
+                    f"Anycubic MQTT Message error: {error_type}: {e}\n"
+                    f"  on MQTT topic: {redacted_topic}\n"
+                    f"    {payload}\n"
+                    f"{tb}"
+                )
+
+            try:
+                if self._mqtt_callback_printer_update:
+                    self._mqtt_callback_printer_update()
+
+                if (
+                    self._mqtt_callback_printer_busy and
+                    printer_was_available and printer.is_busy
+                ):
+                    self._mqtt_callback_printer_busy()
+
+            except Exception as e:
+                tb = traceback.format_exc()
+                self._log_to_error(
+                    f"Anycubic MQTT Callback error: {e}\n"
+                    f"{tb}"
+                )
+
+            if self._mqtt_log_all_messages:
+                # Redact the printer key like the warning/error paths do --
+                # debug logs get pasted into issue reports.
+                self._log_to_debug(
+                    f"Anycubic MQTT Message processed on topic: "
+                    f"{redact_part_from_mqtt_topic(topic, 6)}\n"
+                    f"    {payload}"
+                )
+
+    def _mqtt_publish_on_topic(
+        self,
+        topic: str,
+        payload: dict[str, Any] | str,
+    ) -> None:
+        if self._mqtt_client is None:
+            return
+
+        mqtt_payload = json.dumps(payload) if isinstance(payload, dict) else payload
+
+        self._mqtt_client.publish(topic, payload=mqtt_payload)
+
+    def _mqtt_publish_to_printer(
+        self,
+        printer: AnycubicPrinter,
+        endpoint: str,
+        payload: dict[str, Any] | str,
+    ) -> None:
+        mqtt_topic = self._build_mqtt_printer_publish_topic(printer, endpoint)
+        self._mqtt_publish_on_topic(mqtt_topic, payload=payload)
+
+    def _mqtt_build_ssl_context(self) -> ssl.SSLContext:
+        ssl_root = get_ssl_cert_directory()
+
+        crt_path = get_mqtt_ssl_path_cert(ssl_root)
+
+        if not path.exists(crt_path):
+            self._log_to_error(f"Anycubic MQTT unable to start, no certificate found in root: {ssl_root}.")
+            raise AnycubicMQTTClientError(ErrorsMQTTClient.cert_missing)
+
+        # Anycubic's broker is a fixed cloud endpoint, so verify it properly.
+        # PROTOCOL_TLS_CLIENT enables certificate verification and hostname
+        # checking by default; both are set explicitly below to make that clear.
+        ssl_context = ssl.SSLContext(ssl.PROTOCOL_TLS_CLIENT)
+        ssl_context.minimum_version = ssl.TLSVersion.TLSv1_2
+
+        # Anycubic's client certificate is SHA-1 signed, which OpenSSL 3.x will
+        # not load at the default security level. Narrowed from upstream's
+        # "ALL:" so the normal cipher list still applies -- this relaxes the
+        # certificate signature check only.
+        ssl_context.set_ciphers('DEFAULT:@SECLEVEL=0')
+
+        # Anycubic's root CA omits the keyUsage extension. Python 3.13+ enables
+        # VERIFY_X509_STRICT by default, which rejects such a CA as a trust
+        # anchor outright. Clearing that single flag keeps full chain and
+        # hostname verification intact. No-op on older Python versions.
+        ssl_context.verify_flags &= ~ssl.VERIFY_X509_STRICT
+
+        ssl_context.check_hostname = True
+        ssl_context.verify_mode = ssl.CERT_REQUIRED
+
+        # Pin Anycubic's own root CA -- their broker certificate is issued by a
+        # private CA and is not present in any public trust store.
+        ssl_context.load_verify_locations(get_mqtt_ssl_path_ca(ssl_root))
+        ssl_context.load_cert_chain(
+            crt_path,
+            get_mqtt_ssl_path_key(ssl_root),
+            None,
+        )
+
+        return ssl_context
+
+    def _mqtt_on_subscribe(
+        self,
+        client: mqtt_client.Client,
+        userdata: Any,
+        mid: int,
+        granted_qos: tuple[int],
+    ) -> None:
+        if self._mqtt_connected is not None:
+            self._mqtt_connected.set()
+
+    def _mqtt_on_message(
+        self,
+        client: mqtt_client.Client,
+        userdata: Any,
+        message: mqtt_client.MQTTMessage,
+    ) -> None:
+        try:
+            self._mqtt_message_router(message)
+        except Exception as e:
+            tb = traceback.format_exc()
+            self._log_to_error(f"Anycubic MQTT internal error: {e}\n{tb}")
+            return
+
+    def _mqtt_on_disconnect(
+        self,
+        client: mqtt_client.Client,
+        userdata: Any,
+        rc: int,
+    ) -> None:
+        if rc == 0:
+            self._mqtt_client = None
+            self._log_to_debug("Anycubic MQTT Disconnected.")
+            if self._mqtt_disconnected is not None:
+                self._mqtt_disconnected.set()
+        else:
+            self._set_mqtt_username_password()
+            self._log_to_debug("Anycubic MQTT unintentionally disconnected, will reconnect.")
+
+    def _mqtt_on_connect(
+        self,
+        client: mqtt_client.Client,
+        userdata: Any,
+        flags: dict[str, Any],
+        rc: int,
+    ) -> None:
+        if rc == 0:
+            if self._mqtt_connected is None:
+                self._mqtt_connected = asyncio.Event()
+
+            self._log_to_debug("Anycubic MQTT Connected.")
+
+            if not self._mqtt_client:
+                raise AnycubicMQTTClientError(ErrorsMQTTClient.connect_client_missing)
+
+            for sub in self._build_mqtt_user_subscription():
+                self._log_to_debug(f"Anycubic MQTT Subscribing to USER {sub}.")
+                self._mqtt_client.subscribe(sub)
+
+            for printer_id, printer in self._mqtt_subscribed_printers.items():
+                self._mqtt_subscribe_printer_status(printer)
+
+            self._log_to_debug("Anycubic MQTT Subscribed.")
+
+            if (self._mqtt_callback_subscribed):
+                self._mqtt_callback_subscribed()
+        else:
+            self._log_to_warn(f"Anycubic MQTT Failed to connect, return code {rc}")
+
+    def _set_mqtt_username_password(self) -> None:
+        mqtt_username, mqtt_password = self.anycubic_auth.get_mqtt_login_info()
+
+        if self._mqtt_client is None:
+            return
+
+        self._mqtt_client.username_pw_set(
+            username=mqtt_username,
+            password=mqtt_password,
+        )
+
+    def connect_mqtt(self) -> None:
+        self._mqtt_connected = asyncio.Event()
+        self._mqtt_disconnected = asyncio.Event()
+
+        self._log_to_debug("Anycubic MQTT Connecting.")
+
+        # paho-mqtt 2.x: pass callback_api_version positionally; 1.x: omit.
+        if _MQTT_CALLBACK_API_VERSION is not None:
+            self._mqtt_client = mqtt_client.Client(
+                _MQTT_CALLBACK_API_VERSION,
+                client_id=self.anycubic_auth.get_mqtt_client_id(),
+                clean_session=True,
+            )
+        else:
+            self._mqtt_client = mqtt_client.Client(
+                client_id=self.anycubic_auth.get_mqtt_client_id(),
+                clean_session=True,
+            )
+
+        self._mqtt_client.on_connect = self._mqtt_on_connect
+        self._mqtt_client.on_disconnect = self._mqtt_on_disconnect
+        self._mqtt_client.on_message = self._mqtt_on_message
+        self._mqtt_client.on_subscribe = self._mqtt_on_subscribe
+
+        self._set_mqtt_username_password()
+
+        self._mqtt_client.tls_set_context(self._mqtt_build_ssl_context())
+
+        self._mqtt_client.reconnect_delay_set(5)
+
+        self._mqtt_client.connect(
+            host=MQTT_HOST,
+            port=MQTT_PORT,
+            keepalive=MQTT_TIMEOUT,
+        )
+
+        self._mqtt_client.loop_forever()
+        self._mqtt_client = None
+        if self._mqtt_disconnected is not None:
+            self._mqtt_disconnected.set()
+        self._mqtt_connected = None
+        self._mqtt_disconnected = None
+        self._log_to_debug("Anycubic MQTT Client removed.")
+
+    def disconnect_mqtt(self) -> None:
+        self._log_to_debug("Anycubic MQTT Disconnecting.")
+        if self._mqtt_client is None:
+            return
+
+        self._mqtt_client.disconnect()
+
+    def _mqtt_subscribe_printer_status(self, printer: AnycubicPrinter) -> None:
+        if not self._mqtt_client:
+            raise AnycubicMQTTClientError(ErrorsMQTTClient.sub_printer_status_client_missing)
+        for sub in self._build_mqtt_printer_subscription(printer):
+            self._log_to_debug(f"Anycubic MQTT Subscribing to PRINTER {sub}.")
+            self._mqtt_client.subscribe(sub)
+
+    def mqtt_add_subscribed_printer(self, printer: AnycubicPrinter) -> None:
+        if not printer.key:
+            raise AnycubicMQTTClientError(ErrorsMQTTClient.sub_printer_key_missing)
+
+        if printer.key in self._mqtt_subscribed_printers:
+            return
+
+        self._mqtt_subscribed_printers[printer.key] = printer
+
+    def mqtt_unsubscribe_printer_status(self, printer: AnycubicPrinter) -> None:
+
+        if printer.key in self._mqtt_subscribed_printers:
+            if self._mqtt_client is not None:
+                for sub in self._build_mqtt_printer_subscription(printer):
+                    self._log_to_debug(f"Anycubic MQTT Ubsubscribing to PRINTER {sub}.")
+                    self._mqtt_client.unsubscribe(sub)
+
+            del self._mqtt_subscribed_printers[printer.key]

anycubic_cloud_api/const/api_endpoints.py

@@ -0,0 +1,106 @@
+from __future__ import annotations
+
+from ..models.http import HTTP_METHODS, AnycubicAPIEndpoint
+
+
+class API_ENDPOINT:
+    oauth_token_url = AnycubicAPIEndpoint(
+        HTTP_METHODS.GET,
+        '/v3/public/getoauthToken',
+    )
+    auth_sig_token = AnycubicAPIEndpoint(
+        HTTP_METHODS.POST,
+        '/v3/public/loginWithAccessToken',
+    )
+    user_store = AnycubicAPIEndpoint(
+        HTTP_METHODS.POST,
+        '/work/index/getUserStore',
+    )
+    lock_storage_space = AnycubicAPIEndpoint(
+        HTTP_METHODS.POST,
+        '/v2/cloud_storage/lockStorageSpace',
+    )
+    unlock_storage_space = AnycubicAPIEndpoint(
+        HTTP_METHODS.POST,
+        '/v2/cloud_storage/unlockStorageSpace',
+    )
+    new_file_upload = AnycubicAPIEndpoint(
+        HTTP_METHODS.POST,
+        '/v2/profile/newUploadFile',
+    )
+    delete_cloud_file = AnycubicAPIEndpoint(
+        HTTP_METHODS.POST,
+        '/work/index/delFiles',
+    )
+    user_files = AnycubicAPIEndpoint(
+        HTTP_METHODS.POST,
+        '/work/index/files',
+    )
+    user_info = AnycubicAPIEndpoint(
+        HTTP_METHODS.GET,
+        '/user/profile/userInfo',
+    )
+    printer_status = AnycubicAPIEndpoint(
+        HTTP_METHODS.GET,
+        '/v2/Printer/status',
+    )
+    printer_info = AnycubicAPIEndpoint(
+        HTTP_METHODS.GET,
+        '/v2/printer/info',
+    )
+    printer_tool = AnycubicAPIEndpoint(
+        HTTP_METHODS.GET,
+        '/v2/printer/tool',
+    )
+    printer_functions = AnycubicAPIEndpoint(
+        HTTP_METHODS.GET,
+        '/v2/printer/functions',
+    )
+    printer_all = AnycubicAPIEndpoint(
+        HTTP_METHODS.GET,
+        '/v2/printer/all',
+    )
+    printers_status = AnycubicAPIEndpoint(
+        HTTP_METHODS.GET,
+        '/work/printer/printersStatus',
+    )
+    printer_get_printers = AnycubicAPIEndpoint(
+        HTTP_METHODS.GET,
+        '/work/printer/getPrinters',
+    )
+    print_history = AnycubicAPIEndpoint(
+        HTTP_METHODS.GET,
+        '/v2/project/printHistory',
+    )
+    project_info = AnycubicAPIEndpoint(
+        HTTP_METHODS.GET,
+        '/v2/project/info',
+    )
+    project_monitor = AnycubicAPIEndpoint(
+        HTTP_METHODS.GET,
+        '/v2/project/monitor',
+    )
+    project_get_projects = AnycubicAPIEndpoint(
+        HTTP_METHODS.GET,
+        '/work/project/getProjects',
+    )
+    project_gcode_info_fdm = AnycubicAPIEndpoint(
+        HTTP_METHODS.GET,
+        '/work/gcode/infoFdm',
+    )
+    send_order = AnycubicAPIEndpoint(
+        HTTP_METHODS.POST,
+        '/work/operation/sendOrder',
+    )
+    printer_update_name = AnycubicAPIEndpoint(
+        HTTP_METHODS.POST,
+        '/work/printer/Info',
+    )
+    printer_firmware_update = AnycubicAPIEndpoint(
+        HTTP_METHODS.GET,
+        '/work/printer/update_version',
+    )
+    printer_multi_color_box_firmware_update = AnycubicAPIEndpoint(
+        HTTP_METHODS.POST,
+        '/v2/printer/update_multi_color_box_version'
+    )

anycubic_cloud_api/const/const.py

@@ -0,0 +1,47 @@
+import re
+
+BASE_DOMAIN = "cloud-universe.anycubic.com"
+APP_REDIRECT_URI = "anycubic-i18n://cloud.anycubic.com:8088"
+AUTH_DOMAIN = "uc.makeronline.com"
+
+PUBLIC_API_ENDPOINT = "p/p/workbench/api"
+
+PROJECT_IMAGE_URL_BASE = "https://workbentch.s3.us-east-2.amazonaws.com/"
+
+REX_JS_FILE = re.compile(r'src="(/js/app\.[^.]+\.js)"')
+# REX_CLIENT_ID = re.compile(r',clientId:"([^"]+)",')
+REX_CLIENT_ID = re.compile(r'\'(?!getEl)([a-zA-Z0-9]{20})\'')
+REX_APP_ID_BASIC = re.compile(r'appid["\']?:["\']([^"\']+)["\'],')
+REX_APP_ID_OBF = re.compile(r'(?<!:)\'([a-zA-Z0-9]{32})\'')
+REX_APP_VERSION = re.compile(r'version["\']?:["\']([^"\']+)["\'],')
+REX_APP_SECRET_BASIC = re.compile(r'appSecret["\']?:["\']([^"\']+)["\'],')
+REX_APP_SECRET_OBF = re.compile(r'(?<!:)\'([a-zA-Z0-9]{32})\'')
+REX_GCODE_EXT = re.compile(r'\.gcode$')
+
+DEFAULT_USER_AGENT = (
+    'Mozilla/5.0 (Macintosh; Intel Mac OS X 10_15_7) '
+    'AppleWebKit/537.36 (KHTML, like Gecko) Chrome/125.0.0.0 '
+    'Safari/537.36'
+)
+
+AC_KNOWN_CID_WEB = '672efcd4ec11a66c8513'
+AC_KNOWN_CID_APP = 'ca4c8416cced85a1dc02'
+AC_KNOWN_AID = 'f9b3528877c94d5c9c5af32245db46ef'
+AC_KNOWN_VID_WEB = '1.0.0'
+AC_KNOWN_VID_APP = '1.4.8'
+AC_KNOWN_VID_SLICER_NEXT = 'V3.0.0'
+AC_KNOWN_SEC = '0cf75926606049a3937f56b0373b99fb'
+
+MAX_PROJECT_LIST_RESULTS = 2000
+MAX_PROJECT_IMAGE_SEARCH_COUNT = 200
+
+MAX_API_FETCH_TIME_WARN = 20
+
+WARN_INTERVAL_API_DURATION = 60 * 10
+
+ACCESS_TOKEN_LOGIN_RETRIES = 2
+ACCESS_TOKEN_LOGIN_RETRY_INTERVAL = 2
+
+
+class AnycubicServerMessage:
+    FILE_NOT_FOUND = "No file found"

anycubic_cloud_api/const/enums.py

@@ -0,0 +1,97 @@
+from enum import IntEnum, StrEnum
+
+
+class AnycubicFeedType(IntEnum):
+    Feed = 1
+    Retract = 2
+    Finish = 3
+
+
+class AnycubicPrintStatus(IntEnum):
+    Printing = 1
+    Complete = 2
+    Cancelled = 3
+    Downloading = 4
+    Checking = 5
+    Preheating = 6
+    Slicing = 7
+
+
+class AnycubicOrderID(IntEnum):
+    START_PRINT = 1
+    PAUSE_PRINT = 2
+    RESUME_PRINT = 3
+    STOP_PRINT = 4
+    PRINT_SETTINGS = 6
+    IGNORE = 11  # Not handled
+    DETECT = 12  # Not handled, appears un-used.
+    STOP_PRINT_FORCE = 44
+    LIST_UDISK_FILES = 101
+    DELETE_UDISK_FILE = 102
+    LIST_LOCAL_FILES = 103
+    DELETE_LOCAL_FILE = 104
+    MOVE_AXLE = 201  # Not handled
+    MOVE_AXLE_TO_COORDINATES = 202  # Not handled, appears un-used.
+    START_EXPOSURE = 301  # Not handled, appears un-used.
+    CANCEL_EXPOSURE = 302  # Not handled, appears un-used.
+    START_RESIDUAL = 501  # Not handled, appears un-used.
+    CANCEL_RESIDUAL = 502  # Not handled
+    SET_DEVICE_SELF_TEST = 601  # Not handled, appears un-used.
+    GET_DEVICE_SELF_TEST = 602  # Not handled
+    SET_AUTO_OPERATION = 701  # Not handled, appears un-used.
+    GET_AUTO_OPERATION = 702  # Not handled
+    RESET_RELEASE_FILM = 801  # Not handled
+    GET_RELEASE_FILM = 802  # Not handled
+    SET_PRINT_STATUS_FREE = 901  # Not handled, appears un-used.
+    CAMERA_OPEN = 1001
+    CAMERA_CLOSE = 1002  # Not handled, appears un-used.
+    MULTI_COLOR_BOX_GET_INFO = 1206
+    MULTI_COLOR_BOX_DRY = 1207
+    FEED_FILAMENT = 1208
+    FEED_FILAMENT_FINISH = 1209  # Not handled, appears un-used.
+    MULTI_COLOR_BOX_REFRESH_SLOT = 1210  # Not handled
+    MULTI_COLOR_BOX_SET_SLOT = 1211
+    MULTI_COLOR_BOX_AUTO_FEED = 1212
+    MOVE_AXLE_TURN_OFF = 1213  # Not handled
+    FILAMENT_CONTROL = 1215  # Not handled
+    FEED_RESIN = 1224  # Not handled
+    M7_AUTO_OPERATION = 1225  # Not handled
+    CYCLIC_CLEANING = 1226  # Not handled
+    SET_AUTO_FEED_INFO = 1227  # Not handled, appears un-used.
+    GET_M7_AUTO_OPERATION = 1228  # Not handled
+    EXTFILBOX = 1229  # Not handled
+    GET_EXTFILBOX_INFO = 1230  # Not handled
+    QUERY_PERIPHERALS = 1231
+    GET_LIGHT_STATUS = 1232
+    SET_LIGHT_STATUS = 1233
+
+
+class AnycubicFunctionID(IntEnum):
+    AXLE_MOVEMENT = 1
+    FILE_MANAGER = 2
+    EXPOSURE_TEST = 3
+    LCD_PEER_VIDEO = 7
+    FDM_AXIS_MOVE = 13
+    FDM_PEER_VIDEO = 22
+    DEVICE_STARTUP_SELF_TEST = 26
+    PRINT_STARTUP_SELF_TEST = 27
+    AUTOMATIC_OPERATION = 28
+    RESIDUE_CLEAN = 29
+    NOVICE_GUIDE = 30
+    RELEASE_FILM = 31
+    TASK_MODE = 32
+    LCD_INTELLIGENT_MATERIALS_BOX = 33
+    LCD_AUTO_OUT_IN_MATERIALS = 34
+    M7PRO_AUTOMATIC_OPERATION = 35
+    AI_DETECTION = 36
+    AUTO_LEVELER = 37
+    VIBRATION_COMPENSATION = 38
+    TIME_LAPSE = 39
+    VIDEO_LIGHT = 40
+    BOX_LIGHT = 41
+    MULTI_COLOR_BOX = 2006
+
+
+class AnycubicPrinterMaterialType(StrEnum):
+    FILAMENT = "Filament"
+    RESIN = "Resin"