bambu-printer-manager 0.0.1__tar.gz

bambu_printer_manager-0.0.1/.gitignore

@@ -0,0 +1,13 @@
+.yarn/*
+!.yarn/patches
+!.yarn/plugins
+!.yarn/releases
+!.yarn/sdks
+!.yarn/versions
+
+# Swap the comments on the following lines if you wish to use zero-installs
+# In that case, don't forget to run `yarn config set enableGlobalCache false`!
+# Documentation here: https://yarnpkg.com/features/caching#zero-installs
+
+#!.yarn/cache
+.pnp.*

bambu_printer_manager-0.0.1/LICENSE

@@ -0,0 +1,13 @@
+            DO WHAT THE FUCK YOU WANT TO PUBLIC LICENSE
+                    Version 2, December 2004
+
+ Copyright (C) 2004 Sam Hocevar <sam@hocevar.net>
+
+ Everyone is permitted to copy and distribute verbatim or modified
+ copies of this license document, and changing it is allowed as long
+ as the name is changed.
+
+            DO WHAT THE FUCK YOU WANT TO PUBLIC LICENSE
+   TERMS AND CONDITIONS FOR COPYING, DISTRIBUTION AND MODIFICATION
+
+  0. You just DO WHAT THE FUCK YOU WANT TO.

bambu_printer_manager-0.0.1/PKG-INFO

@@ -0,0 +1,24 @@
+Metadata-Version: 2.1
+Name: bambu-printer-manager
+Version: 0.0.1
+Summary: A pure python library for managing Bambu Labs printers
+Project-URL: Homepage, https://github.com/synman/bambu-printer-manager
+Project-URL: Issues, https://github.com/pypa/bambu-printer-manager/issues
+Author-email: "Shell M. Shrader" <shell@shellware.com>
+License-File: LICENSE
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Operating System :: OS Independent
+Classifier: Programming Language :: Python :: 3
+Requires-Python: >=3.8
+Requires-Dist: paho-mqtt
+Requires-Dist: webcolors
+Description-Content-Type: text/markdown
+
+# bambu-printer-manager
+
+## <B>Now supports Bambu printers</B>
+
+## Dependencies
+```
+pip install paho.mqtt
+```

bambu_printer_manager-0.0.1/README.md

@@ -0,0 +1,8 @@
+# bambu-printer-manager
+
+## <B>Now supports Bambu printers</B>
+
+## Dependencies
+```
+pip install paho.mqtt
+```

bambu_printer_manager-0.0.1/pyproject.toml

@@ -0,0 +1,29 @@
+[build-system]
+requires = ["hatchling"]
+build-backend = "hatchling.build"
+
+[project]
+name = "bambu-printer-manager"
+version = "0.0.1"
+authors = [
+  { name="Shell M. Shrader", email="shell@shellware.com" },
+]
+description = "A pure python library for managing Bambu Labs printers"
+readme = "README.md"
+requires-python = ">=3.8"
+classifiers = [
+    "Programming Language :: Python :: 3",
+    "License :: OSI Approved :: MIT License",
+    "Operating System :: OS Independent",
+]
+dependencies = [
+  "webcolors",
+  "paho-mqtt",
+]
+
+[tool.hatch.build.targets.wheel]
+packages = ["src/"]
+
+[project.urls]
+Homepage = "https://github.com/synman/bambu-printer-manager"
+Issues = "https://github.com/pypa/bambu-printer-manager/issues"

bambu_printer_manager-0.0.1/src/bambu-printer-manager/bambucommands.py

@@ -0,0 +1,127 @@
+ANNOUNCE_PUSH =             {
+                                "pushing":{
+                                    "command":"pushall",
+                                    "push_target":1,
+                                    "sequence_id":"0",
+                                    "version":1
+                                }
+                            }
+
+ANNOUNCE_VERSION =          {
+                                "info":{
+                                    "command":"get_version",
+                                    "sequence_id":"0"
+                                }
+                            }
+
+CHAMBER_LIGHT_TOGGLE =      {
+                                "system": {
+                                    "sequence_id": "0", 
+                                    "command": "ledctrl", 
+                                    "led_node": "chamber_light", 
+                                    "led_mode": "on",
+                                    "led_on_time": 500, 
+                                    "led_off_time": 500, 
+                                    "loop_times": 0, 
+                                    "interval_time": 0
+                                }
+                            }
+
+SPEED_PROFILE_TEMPLATE =    {
+                                "print": {
+                                    "sequence_id": "0",
+                                    "command": "print_speed", 
+                                    "param": "2"
+                                }
+                            }
+
+PAUSE_PRINT =               {
+                                "print": {
+                                    "sequence_id": "0", 
+                                    "command": "pause"
+                                }
+                            }
+
+RESUME_PRINT =              {
+                                "print": {
+                                    "sequence_id": "0", 
+                                    "command": "resume"
+                                }
+                            }
+
+STOP_PRINT =                {
+                                    "print": {
+                                        "sequence_id": "0", 
+                                        "command": "stop"
+                                    }
+                            }
+
+SEND_GCODE_TEMPLATE =       {
+                                "print": {
+                                    "sequence_id": "0", 
+                                    "command": "gcode_line", 
+                                    "param": ""
+                                }
+                            }
+
+MOVE_RIGHT =                {
+                                "print": {
+                                    "sequence_id": "0", 
+                                    "command": "gcode_line", 
+                                    "param": "G91\nG1 X100 F3600\n"
+                                }
+                            }
+
+MOVE_LEFT =                 {
+                                "print": {
+                                    "sequence_id": "0", 
+                                    "command": "gcode_line", 
+                                    "param": "G91\nG1 X-100 F3600\n"
+                                }
+                            }
+
+UNLOAD_FILAMENT =           {
+                                "print": {
+                                    "sequence_id": "0",
+                                    "command": "unload_filament"
+                                }
+                            }
+
+AMS_FILAMENT_CHANGE =       {
+                                "print": {
+                                    "sequence_id": "0",
+                                    "command": "ams_change_filament",
+                                    "target": 0, 
+                                    "curr_temp": 250, 
+                                    "tar_temp": 250
+                                }
+                            }
+
+PRINT_3MF_FILE =            {
+                                "print": {
+                                    "ams_mapping": [],
+                                    "bed_leveling": True,
+                                    "bed_type": "hot_plate",
+                                    "command": "project_file",
+                                    "file": "Oreo.gcode.3mf",
+                                    "flow_cali": True,
+                                    "layer_inspect": True,
+                                    "md5": "",
+                                    "param": "Metadata/plate_1.gcode",
+                                    "profile_id": "0",
+                                    "project_id": "0",
+                                    "reason": "success",
+                                    "result": "success",
+                                    "sequence_id": "0",
+                                    "subtask_id": "0",
+                                    "subtask_name": "Oreo",
+                                    "task_id": "0",
+                                    "timelapse": False,
+                                    "url": "file:///sdcard/Oreo.gcode.3mf",
+                                    "use_ams": False,
+                                    "vibration_cali": False
+                                }
+                            }
+
+# X1 only currently
+GET_ACCESSORIES = {"system": {"sequence_id": "0", "command": "get_accessories", "accessory_type": "none"}}

bambu_printer_manager-0.0.1/src/bambu-printer-manager/bambuconfig.py

@@ -0,0 +1,109 @@
+import os
+import atexit
+import logging.config
+import logging.handlers
+import json
+
+logger = logging.getLogger("bambuprinter")
+
+class BambuConfig:
+    def __init__(self, hostname=None, 
+                 access_code=None, 
+                 serial_number=None, 
+                 mqtt_port=8883, 
+                 mqtt_client_id="studio_client_id:0c1f",
+                 mqtt_username="bblp",
+                 verbose=False):
+        
+        setup_logging()
+
+        self.hostname = hostname
+        self.access_code = access_code
+        self.serial_number = serial_number
+        self.mqtt_port = mqtt_port
+        self.mqtt_client_id = mqtt_client_id
+        self.mqtt_username = mqtt_username
+        self.firmware_version = "N/A"
+        self.ams_firmware_version = "N/A"
+        self.verbose = verbose
+
+    @property 
+    def hostname(self):
+        return self._hostname
+    @hostname.setter 
+    def hostname(self, value):
+        self._hostname = value
+
+    @property 
+    def access_code(self):
+        return self._access_code
+    @access_code.setter 
+    def access_code(self, value):
+        self._access_code = value
+
+    @property 
+    def serial_number(self):
+        return self._serial_number
+    @serial_number.setter 
+    def serial_number(self, value):
+        self._serial_number = value
+
+    @property 
+    def mqtt_port(self):
+        return self._mqtt_port
+    @mqtt_port.setter 
+    def mqtt_port(self, value):
+        self._mqtt_port = value
+
+    @property 
+    def mqtt_client_id(self):
+        return self._mqtt_client_id
+    @mqtt_client_id.setter 
+    def mqtt_client_id(self, value):
+        self._mqtt_client_id = value
+
+    @property 
+    def mqtt_username(self):
+        return self._mqtt_username
+    @mqtt_username.setter 
+    def mqtt_username(self, value):
+        self._mqtt_username = value
+
+    @property 
+    def firmware_version(self):
+        return self._firmware_version
+    @firmware_version.setter 
+    def firmware_version(self, value):
+        self._firmware_version = value        
+
+    @property 
+    def ams_firmware_version(self):
+        return self._ams_firmware_version
+    @ams_firmware_version.setter 
+    def ams_firmware_version(self, value):
+        self._ams_firmware_version = value        
+
+    @property 
+    def verbose(self):
+        return self._verbose
+    @verbose.setter 
+    def verbose(self, value):
+        self._verbose = value  
+        handler = logging.getHandlerByName("stderr")
+        if self._verbose:
+            handler.setLevel(logging.DEBUG)
+        else:
+            handler.setLevel(logging.WARN)
+        logger.info("log level changed", extra={"new_level": logging.getLevelName(handler.level)})
+
+
+def setup_logging():
+    config_file = os.path.dirname(os.path.realpath(__file__)) + "/bambuprinterlogger.json"
+    with open(config_file) as f_in:
+        config = json.load(f_in)
+
+    logging.config.dictConfig(config)
+    queue_handler = logging.getHandlerByName("queue_handler")
+    if queue_handler is not None:
+        queue_handler.listener.start()
+        atexit.register(queue_handler.listener.stop)      

bambu_printer_manager-0.0.1/src/bambu-printer-manager/bambulogger.py

@@ -0,0 +1,78 @@
+import datetime as dt
+import json
+import logging
+from typing import override
+
+LOG_RECORD_BUILTIN_ATTRS = {
+    "args",
+    "asctime",
+    "created",
+    "exc_info",
+    "exc_text",
+    "filename",
+    "funcName",
+    "levelname",
+    "levelno",
+    "lineno",
+    "module",
+    "msecs",
+    "message",
+    "msg",
+    "name",
+    "pathname",
+    "process",
+    "processName",
+    "relativeCreated",
+    "stack_info",
+    "thread",
+    "threadName",
+    "taskName",
+}
+
+
+class BambuJSONFormatter(logging.Formatter):
+    def __init__(
+        self,
+        *,
+        fmt_keys: dict[str, str] | None = None,
+    ):
+        super().__init__()
+        self.fmt_keys = fmt_keys if fmt_keys is not None else {}
+
+    @override
+    def format(self, record: logging.LogRecord) -> str:
+        message = self._prepare_log_dict(record)
+        return json.dumps(message, default=str)
+
+    def _prepare_log_dict(self, record: logging.LogRecord):
+        always_fields = {
+            "message": record.getMessage(),
+            "timestamp": dt.datetime.fromtimestamp(
+                record.created, tz=dt.timezone.utc
+            ).isoformat(),
+        }
+        if record.exc_info is not None:
+            always_fields["exc_info"] = self.formatException(record.exc_info).replace("\\\\", "\\")
+
+        if record.stack_info is not None:
+            always_fields["stack_info"] = self.formatStack(record.stack_info).replace("\\\\", "\\")
+
+        message = {
+            key: msg_val
+            if (msg_val := always_fields.pop(val, None)) is not None
+            else getattr(record, val)
+            for key, val in self.fmt_keys.items()
+        }
+        message.update(always_fields)
+
+        for key, val in record.__dict__.items():
+            if key not in LOG_RECORD_BUILTIN_ATTRS:
+                message[key] = val
+
+        return message
+
+
+class NonErrorFilter(logging.Filter):
+    @override
+    def filter(self, record: logging.LogRecord) -> bool | logging.LogRecord:
+        return record.levelno <= logging.INFO

bambu_printer_manager-0.0.1/src/bambu-printer-manager/bambuprinter.py

@@ -0,0 +1,518 @@
+import json
+from webcolors import hex_to_name
+import paho.mqtt.client as mqtt
+import threading
+import ssl
+import time
+
+from bambucommands import *
+from bambuspool import BambuSpool
+from bambutools import PrinterState
+from bambutools import parseStage
+from bambuconfig import BambuConfig
+
+import os
+import atexit
+import logging.config
+import logging.handlers
+
+logger = logging.getLogger("bambuprinter")
+
+class BambuPrinter:
+    def __init__(self, config=BambuConfig()):
+        setup_logging()
+
+        self._internalException = None
+        self._lastMessageTime = None
+
+        self._config = config
+        self._state = PrinterState
+
+        self._client = None
+        self._on_update = None
+
+        self._bed_temp = 0.0
+        self._bed_temp_target = 0.0
+        self._tool_temp = 0.0
+        self._tool_temp_target = 0.0
+        self._chamber_temp = 0.0
+        self._chamber_temp_target = 0.0
+
+        self._fan_gear = 0
+        self._heatbreak_fan_speed = 0
+        self._fan_speed = 0
+
+        self._light_state = "N/A"
+        self._wifi_signal = "N/A"
+        self._speed_level = 0
+
+        self._gcode_state = "N/A"
+        self._gcode_file = "N/A"
+        self._print_type = "N/A"
+        self._percent_complete = 0
+        self._time_remaining = 0
+        self._layer_count = 0
+        self._current_layer = 0
+        
+        self._current_stage = 0
+        self._current_stage_text = "N/A"
+
+        self._spools = ()
+        self._target_spool = 255
+        self._active_spool = 255
+        self._spool_state = "N/A"
+        self._ams_status = None
+
+    def start_session(self):
+        logger.debug("session start_session")
+        if self.config.hostname is None or self.config.access_code is None or self.config.serial_number is None:
+            raise Exception("hostname, access_code, and serial_number are required")
+        if self.client and self.client.is_connected():
+            raise Exception("a session is already active")
+
+        def on_connect(client, userdata, flags, rc):
+            logger.debug("session on_connect")
+            if self.state != PrinterState.PAUSED:
+                self.state = PrinterState.CONNECTED
+                client.subscribe(f"device/{self.config.serial_number}/report")
+                logger.debug(f"subscribed to [device/{self.config.serial_number}/report]")
+        def on_disconnect(client, userdata, rc):
+            logger.debug("session on_disconnect")
+            if self._internalException:
+                logger.exception("an internal exception occurred")
+                self.state = PrinterState.QUIT
+                raise self._internalException
+            if self.state != PrinterState.PAUSED:
+                self.state = PrinterState.DISCONNECTED
+        def on_message(client, userdata, msg):
+            if self._lastMessageTime: self._lastMessageTime = time.time()
+            self._on_message(json.loads(msg.payload.decode("utf-8")))
+        def loop_forever(printer):
+            try:
+                printer.client.loop_forever(retry_first_connection=True)            
+            except Exception as e:
+                logger.exception("an internal exception occurred")
+                printer._internalException = e
+                if printer.client and printer.client.is_connected(): printer.client.disconnect() 
+            printer.state = PrinterState.QUIT
+
+        self.client = mqtt.Client()
+
+        self.client.on_connect = on_connect
+        self.client.on_disconnect = on_disconnect
+        self.client.on_message = on_message
+
+        self.client.tls_set(tls_version=ssl.PROTOCOL_TLS, cert_reqs=ssl.CERT_NONE)
+        self.client.tls_insecure_set(True)
+        self.client.reconnect_delay_set(min_delay=1, max_delay=1)
+
+        self.client.username_pw_set(self.config.mqtt_username, password=self.config.access_code)
+        self.client.user_data_set(self.config.mqtt_client_id)
+
+        self.client.connect(self.config.hostname, self.config.mqtt_port, 60)
+        threading.Thread(target=loop_forever, name="bambuprinter-session", args=(self,)).start()
+
+        self._start_watchdog()
+
+    def pause_session(self):
+        if self.state != PrinterState.PAUSED:
+            self.client.unsubscribe(f"device/{self.config.serial_number}/report")
+            logger.debug(f"unsubscribed from [device/{self.config.serial_number}/report]")
+            self.state = PrinterState.PAUSED
+
+    def resume_session(self):
+        if self.client and self.client.is_connected() and self.state == PrinterState.PAUSED:
+            self.client.subscribe(f"device/{self.config.serial_number}/report")
+            logger.debug(f"subscribed to [device/{self.config.serial_number}/report]")
+            self._lastMessageTime = time.time()
+            self.state = PrinterState.CONNECTED
+            return
+        self.state = PrinterState.QUIT
+
+    def quit(self):
+        if self.client and self.client.is_connected():
+            self.client.disconnect()
+            while self.state != PrinterState.QUIT:
+                time.sleep(.1)
+            logger.debug("mqtt client was connected")
+        else:
+            self.state == PrinterState.QUIT
+            logger.debug("mqtt client was already disconnected")
+
+    def refresh(self):
+        if self.state == PrinterState.CONNECTED:
+            self.client.publish(f"device/{self.config.serial_number}/request", json.dumps(ANNOUNCE_PUSH))
+            logger.debug(f"published ANNOUNCE_PUSH to [device/{self.config.serial_number}/request]")
+            self.client.publish(f"device/{self.config.serial_number}/request", json.dumps(ANNOUNCE_VERSION))
+            logger.debug(f"published ANNOUNCE_VERSION to [device/{self.config.serial_number}/request]")
+
+    def unload_filament(self):
+        self.client.publish(f"device/{self.config.serial_number}/request", json.dumps(UNLOAD_FILAMENT))
+        logger.debug(f"published UNLOAD_FILAMENT to [device/{self.config.serial_number}/request]")
+
+    def load_filament(self, slot):
+        msg = AMS_FILAMENT_CHANGE
+        msg["print"]["target"] = int(slot)
+        self.client.publish(f"device/{self.config.serial_number}/request", json.dumps(msg))
+        logger.debug(f"published AMS_FILAMENT_CHANGE to [device/{self.config.serial_number}/request]", extra={"target": slot})
+
+    def send_gcode(self, gcode):
+        cmd = SEND_GCODE_TEMPLATE
+        cmd["print"]["param"] = f"{gcode} \n"
+        self.client.publish(f"device/{self.config.serial_number}/request", json.dumps(cmd))
+        logger.debug(f"published SEND_GCODE_TEMPLATE to [device/{self.config.serial_number}/request]", extra={"gcode": gcode})
+
+    def print_3mf_file(self, name, bed, ams):
+        file = PRINT_3MF_FILE
+        file["print"]["file"] = f"{name}.gcode.3mf"
+        file["print"]["url"] = f"file:///sdcard/jobs/{name}.gcode.3mf"
+        file["print"]["subtask_name"] = name
+        if bed == "1":
+            file["print"]["bed_type"] = "hot_plate"
+        else:
+            file["print"]["bed_type"] = "textured_plate"
+        if len(ams) > 2:
+            file["print"]["use_ams"] = True
+            file["print"]["ams_mapping"] = json.loads(ams)
+        else:
+            file["print"]["use_ams"] = False
+            file["print"]["ams_mapping"] = ""
+        self.client.publish(f"device/{self.config.serial_number}/request", json.dumps(file))
+        logger.debug(f"published PRINT_3MF_FILE to [device/{self.config.serial_number}/request]", extra={"3mf_name": name, "bed": bed, "ams": ams})
+
+    def stop_printing(self):
+        self.client.publish(f"device/{self.config.serial_number}/request", json.dumps(STOP_PRINT))
+        logger.debug(f"published STOP_PRINT to [device/{self.config.serial_number}/request]")
+
+    def pause_printing(self):
+        self.client.publish(f"device/{self.config.serial_number}/request", json.dumps(PAUSE_PRINT))
+        logger.debug(f"published PAUSE_PRINT to [device/{self.config.serial_number}/request]")
+
+    def resume_printing(self):
+        self.client.publish(f"device/{self.config.serial_number}/request", json.dumps(RESUME_PRINT))
+        logger.debug(f"published RESUME_PRINT to [device/{self.config.serial_number}/request]")
+
+
+    def jsonSerializer(self, obj):
+        try:
+            if isinstance(obj, mqtt.Client):
+                return ""
+            if str(obj.__class__).replace("<class '", "").replace("'>", "") == "mappingproxy":
+                return "bambutools.PrinterState"
+            return obj.__dict__
+        except Exception as e:
+            logger.warn("unable to serialize object", extra={"obj": obj})
+            return "not available"
+
+    def _start_watchdog(self): 
+        def watchdog_thread(printer):
+            try:
+                while printer.state != PrinterState.QUIT:
+                    if printer.state == PrinterState.CONNECTED and (printer._lastMessageTime is None or printer._lastMessageTime + 15 < time.time()):
+                        if printer._lastMessageTime: logger.warn("BambuPrinter watchdog timeout")
+                        printer.client.publish(f"device/{printer.config.serial_number}/request", json.dumps(ANNOUNCE_PUSH))
+                        printer.client.publish(f"device/{printer.config.serial_number}/request", json.dumps(ANNOUNCE_VERSION))
+                        printer._lastMessageTime = time.time()
+                    time.sleep(.1)
+            except Exception as e:
+                logger.exception("an internal exception occurred")
+                printer._internalException = e
+                if printer.client and printer.client.is_connected(): printer.client.disconnect()
+
+        threading.Thread(target=watchdog_thread, name="bambuprinter-session-watchdog", args=(self,)).start()
+
+    def _on_message(self, message):
+        if "system" in message:
+            system = message["system"]
+
+        elif "print" in message:
+            status = message["print"]
+                    
+            if "bed_temper" in status: self._bed_temp = float(status["bed_temper"])
+            if "bed_target_temper" in status: self._bed_temp_target = float(status["bed_target_temper"])
+            if "nozzle_temper" in status: self._tool_temp = float(status["nozzle_temper"])
+            if "nozzle_target_temper" in status: self._tool_temp_target = float(status["nozzle_target_temper"])
+
+            if "fan_gear" in status: self._fan_gear = int(status["fan_gear"])
+            if "heatbreak_fan_speed" in status: self._heatbreak_fan_speed = int(status["heatbreak_fan_speed"])
+            if "cooling_fan_speed" in status: self._fan_speed = int(status["cooling_fan_speed"])
+
+            if "wifi_signal" in status: self._wifi_signal = status["wifi_signal"] 
+            if "lights_report" in status: self._light_state = (status["lights_report"])[0]["mode"]
+            if "spd_lvl" in status: self._speed_level = status["spd_lvl"]
+            if "gcode_state" in status: self._gcode_state = status["gcode_state"]
+            if "gcode_file" in status: self._gcode_file = status["gcode_file"]
+            if "print_type" in status: self._print_type = status["print_type"]
+            if "mc_percent" in status: self._percent_complete = status["mc_percent"]
+            if "mc_remaining_time" in status: self._time_remaining = status["mc_remaining_time"]
+            if "total_layer_num" in status: self._layer_count = status["total_layer_num"]
+            if "layer_num" in status: self._current_layer = status["layer_num"]
+
+            if "stg_cur" in status: 
+                self._current_stage = int(status["stg_cur"])
+                self._current_stage_text = parseStage(self._current_stage)
+
+            if "command" in status and status["command"] == "project_file":
+                print(json.dumps(message, indent=4, sort_keys=True).replace("\n", "\r\n"))
+
+            if "ams" in status and "ams" in status["ams"]:
+                spools = []
+                ams = (status["ams"]["ams"])[0]
+                # print(json.dumps(status, indent=4, sort_keys=True).replace("\n", "\r\n"))
+                for tray in ams["tray"]:
+                    try:
+                        tray_color = hex_to_name("#" + tray["tray_color"][:6])
+                    except:
+                        try:
+                            tray_color = tray["tray_color"]
+                        except:
+                            tray_color = "N/A"
+                    
+                    spool = BambuSpool(int(tray["id"]),  tray["tray_id_name"] if "tray_id_name" in tray else "",  tray["tray_type"] if "tray_type" in tray else "", tray["tray_sub_brands"] if "tray_sub_brands" in tray else "", tray_color)
+                    spools.append(spool)
+                self._spools = tuple(spools)
+
+            if "vt_tray" in status:
+                tray = status["vt_tray"]
+                try:
+                    tray_color = hex_to_name("#" + tray["tray_color"][:6])
+                except:
+                    try:
+                        tray_color = tray["tray_color"]
+                    except:
+                        tray_color = "N/A"
+
+                spool = BambuSpool(int(tray["id"]), tray["tray_id_name"],  tray["tray_type"], tray["tray_sub_brands"], tray_color)
+
+                if range(len(self.spools), 1, 2): 
+                    spools = (spool,)
+                else:
+                    spools = list(self.spools)
+                    spools.append(spool)
+                self._spools = tuple(spools)
+
+            tray_tar = None
+            tray_now = None
+
+            if "ams" in status and "tray_tar" in status["ams"]:
+                tray_tar = int(status["ams"]["tray_tar"])
+                if tray_tar != 255: 
+                    self._target_spool = int(tray_tar)
+
+            if "ams" in status and "tray_now" in status["ams"]:
+                tray_now = int(status["ams"]["tray_now"])
+                if tray_now != 255: 
+                    if self.active_spool != tray_now: 
+                        self._spool_state = f"Loading"
+                        self._active_spool = tray_now
+
+            if not tray_tar is None and tray_tar != tray_now: 
+                self._spool_state = f"Unloading"
+                if not tray_now is None: self._active_spool = tray_now
+
+            if "ams" in status and "tray_pre" in status["ams"]:
+                tray_pre = int(status["ams"]["tray_pre"])
+                if self.spool_state == "Unloading":
+                    self._spool_state = "Unloaded"
+
+            if "ams_status" in status:
+                self._ams_status = int(status["ams_status"])
+                if self._ams_status == 768:
+                    self._spool_state = "Loaded"
+                    
+        elif "info" in message and "result" in message["info"] and message["info"]["result"] == "success": 
+            info = message["info"]
+            for module in info["module"]:
+                if "ota" in module["name"]: 
+                    self.config.serial_number = module["sn"]
+                    self.config.firmware_version = module["sw_ver"]
+                if "ams" in module["name"]:
+                    self.config.ams_firmware_version = module["sw_ver"]
+        else:
+            print(json.dumps(message, indent=4, sort_keys=True).replace("\n", "\r\n"))
+            
+        if self.on_update: self.on_update(self)
+
+        logger.debug("message processed", extra={"bambu_msg": message})
+        if self.config.verbose:
+            print("\r" + json.dumps(message, indent=4, sort_keys=True).replace("\n", "\r\n") + "\r")
+
+
+    @property 
+    def config(self):
+        return self._config
+    @config.setter 
+    def config(self, value):
+        self._config = value
+
+    @property 
+    def state(self):
+        return self._state
+    @state.setter 
+    def state(self, value):
+        self._state = value
+
+    @property 
+    def client(self):
+        return self._client
+    @client.setter 
+    def client(self, value):
+        self._client = value
+
+    @property 
+    def on_update(self):
+        return self._on_update
+    @on_update.setter 
+    def on_update(self, value):
+        self._on_update = value
+
+    @property 
+    def bed_temp(self):
+        return self._bed_temp
+
+    @property 
+    def bed_temp_target(self):
+        return self._bed_temp_target
+    @bed_temp_target.setter 
+    def bed_temp_target(self, value):
+        gcode = SEND_GCODE_TEMPLATE
+        gcode["print"]["param"] = f"M140 S{value}\n"
+        self.client.publish(f"device/{self.config.serial_number}/request", json.dumps(gcode))
+
+    @property 
+    def tool_temp(self):
+        return self._tool_temp
+
+    @property 
+    def tool_temp_target(self):
+        return self._tool_temp_target
+    @tool_temp_target.setter 
+    def tool_temp_target(self, value):
+        gcode = SEND_GCODE_TEMPLATE
+        gcode["print"]["param"] = f"M104 S{value}\n"
+        self.client.publish(f"device/{self.config.serial_number}/request", json.dumps(gcode))
+
+    @property 
+    def chamber_temp(self):
+        return self._chamber_temp
+
+    @property 
+    def chamber_temp_target(self):
+        return self._chamber_temp_target
+    @chamber_temp.setter 
+    def chamber_temp_target(self, value):
+        self._chamber_temp_target = value
+
+    @property 
+    def fan_speed(self):
+        return self._fan_speed
+    @fan_speed.setter 
+    def fan_speed(self, value):
+        speed = round(value * 2.55, 0)
+        gcode = SEND_GCODE_TEMPLATE
+        gcode["print"]["param"] = f"M106 P1 S{speed}\nM106 P2 S{speed}\nM106 P3 S{speed}\n"
+        self.client.publish(f"device/{self.config.serial_number}/request", json.dumps(gcode))
+
+    @property 
+    def fan_gear(self):
+        return self._fan_gear
+
+    @property 
+    def heatbreak_fan_speed(self):
+        return self._heatbreak_fan_speed
+
+    @property 
+    def wifi_signal(self):
+        return self._wifi_signal
+
+    @property 
+    def light_state(self):
+        return self._light_state == "on"
+    @light_state.setter 
+    def light_state(self, value):
+        cmd = CHAMBER_LIGHT_TOGGLE
+        if value:
+            cmd["system"]["led_mode"] = "on"
+        else:
+            cmd["system"]["led_mode"] = "off"
+        self.client.publish(f"device/{self.config.serial_number}/request", json.dumps(cmd))
+
+    @property 
+    def speed_level(self):
+        return self._speed_level
+    @speed_level.setter 
+    def speed_level(self, value):
+        cmd = SPEED_PROFILE_TEMPLATE
+        cmd["print"]["param"] = value
+        self.client.publish(f"device/{self.config.serial_number}/request", json.dumps(cmd))
+
+    @property 
+    def gcode_state(self):
+        return self._gcode_state
+
+    @property 
+    def gcode_file(self):
+        return self._gcode_file
+    @gcode_file.setter 
+    def gcode_file(self, value):
+        self._gcode_file = value
+
+    @property 
+    def print_type(self):
+        return self._print_type
+
+    @property 
+    def percent_complete(self):
+        return self._percent_complete
+
+    @property 
+    def time_remaining(self):
+        return self._time_remaining
+
+    @property 
+    def layer_count(self):
+        return self._layer_count
+
+    @property 
+    def current_layer(self):
+        return self._current_layer
+
+    @property 
+    def current_stage(self):
+        return self._current_stage
+
+    @property 
+    def current_stage_text(self):
+        return parseStage(self._current_stage)
+
+    @property 
+    def spools(self):
+        return self._spools
+
+    @property 
+    def target_spool(self):
+        return self._target_spool
+
+    @property 
+    def active_spool(self):
+        return self._active_spool
+
+    @property 
+    def spool_state(self):
+        return self._spool_state
+
+    @property 
+    def ams_status(self):
+        return self._ams_status
+
+
+def setup_logging():
+    config_file = os.path.dirname(os.path.realpath(__file__)) + "/bambuprinterlogger.json"
+    with open(config_file) as f_in:
+        config = json.load(f_in)
+
+    logging.config.dictConfig(config)
+    queue_handler = logging.getHandlerByName("queue_handler")
+    if queue_handler is not None:
+        queue_handler.listener.start()
+        atexit.register(queue_handler.listener.stop)

bambu_printer_manager-0.0.1/src/bambu-printer-manager/bambuprinterlogger.json

@@ -0,0 +1,48 @@
+{
+    "version": 1,
+    "disable_existing_loggers": false,
+    "formatters": {
+      "simple": {
+        "format": "%(levelname)s: %(message)s",
+        "datefmt": "%Y-%m-%dT%H:%M:%S%z"
+      },
+      "json": {
+        "()": "bambulogger.BambuJSONFormatter",
+        "fmt_keys": {
+          "level": "levelname",
+          "message": "message",
+          "timestamp": "timestamp",
+          "logger": "name",
+          "module": "module",
+          "function": "funcName",
+          "line": "lineno",
+          "thread_name": "threadName"
+        }
+      }
+    },
+    "handlers": {
+      "stderr": {
+        "class": "logging.StreamHandler",
+        "level": "WARNING",
+        "formatter": "simple",
+        "stream": "ext://sys.stderr"
+      },
+      "file": {
+        "class": "logging.handlers.RotatingFileHandler",
+        "level": "DEBUG",
+        "formatter": "json",
+        "filename": "BambuPrinter.log.jsonl",
+        "maxBytes": 10000000,
+        "backupCount": 3
+      }
+    },
+    "loggers": {
+      "root": {
+        "level": "DEBUG",
+        "handlers": [
+          "stderr",
+          "file"
+        ]
+      }
+    }
+  }

bambu_printer_manager-0.0.1/src/bambu-printer-manager/bambuspool.py

@@ -0,0 +1,47 @@
+class BambuSpool:
+    def __repr__(self):
+        return str(self)
+    def __str__(self):
+        return (f"id=[{self.id}] name=[{self.name}] type=[{self.type}] sub brands=[{self.sub_brands}] color=[{self.color}]")
+    
+    def __init__(self, id, name, type, sub_brands, color):
+        self.id = id
+        self.name = name
+        self.type = type
+        self.sub_brands = sub_brands
+        self.color = color
+
+    @property 
+    def id(self):
+        return self._id
+    @id.setter 
+    def id(self, value):
+        self._id = value
+
+    @property 
+    def name(self):
+        return self._name
+    @name.setter 
+    def name(self, value):
+        self._name = value
+
+    @property 
+    def type(self):
+        return self._type
+    @type.setter 
+    def type(self, value):
+        self._type = value
+
+    @property 
+    def sub_brands(self):
+        return self._sub_brands
+    @sub_brands.setter 
+    def sub_brands(self, value):
+        self._sub_brands = value
+
+    @property 
+    def color(self):
+        return self._color
+    @color.setter 
+    def color(self, value):
+        self._color = value

bambu_printer_manager-0.0.1/src/bambu-printer-manager/bambutools.py

@@ -0,0 +1,64 @@
+from enum import Enum
+
+def parseStage(stage):
+    if type(stage) is int or stage.isnumeric():
+        stage = int(stage)
+        if stage == 0: return ""
+        elif stage == 1: return "Auto bed leveling"
+        elif stage == 2: return "Heatbed preheating"
+        elif stage == 3: return "Sweeping XY mech mode"
+        elif stage == 4: return "Changing filament"
+        elif stage == 5: return "M400 pause"
+        elif stage == 6: return "Paused due to filament runout"
+        elif stage == 7: return "Heating hotend"
+        elif stage == 8: return "Calibrating extrusion"
+        elif stage == 9: return "Scanning bed surface"
+        elif stage == 10: return "Inspecting first layer"
+        elif stage == 11: return "Identifying build plate type"
+        elif stage == 12: return "Calibrating Micro Lidar"
+        elif stage == 13: return "Homing toolhead"
+        elif stage == 14: return "Cleaning nozzle tip"
+        elif stage == 15: return "Checking extruder temperature"
+        elif stage == 16: return "Printing was paused by the user"
+        elif stage == 17: return "Pause of front cover falling"
+        elif stage == 18: return "Calibrating the micro lida"
+        elif stage == 19: return "Calibrating extrusion flow"
+        elif stage == 20: return "Paused due to nozzle temperature malfunction"
+        elif stage == 21: return "Paused due to heat bed temperature malfunction"
+        elif stage == 22: return "Filament unloading"
+        elif stage == 23: return "Skip step pause"
+        elif stage == 24: return "Filament loading"
+        elif stage == 25: return "Motor noise calibration"
+        elif stage == 26: return "Paused due to AMS lost"
+        elif stage == 27: return "Paused due to low speed of the heat break fan"
+        elif stage == 28: return "Paused due to chamber temperature control error"
+        elif stage == 29: return "Cooling chamber"
+        elif stage == 30: return "Paused by the Gcode inserted by user"
+        elif stage == 31: return "Motor noise showoff"
+        elif stage == 32: return "Nozzle filament covered detected pause"
+        elif stage == 33: return "Cutter error pause"
+        elif stage == 34: return "First layer error pause"
+        elif stage == 35: return "Nozzle clog pause"
+        return ""
+
+def parseFan(fan):
+    if type(fan) is int or fan.isnumeric():
+        fan = int(fan)
+        if fan == 1: return 10
+        elif fan == 2: return 20
+        elif fan in (3, 4): return 30
+        elif fan  in (5, 6): return 40
+        elif fan in (7, 8): return 50
+        elif fan == 9: return 60
+        elif fan in (10, 11): return 70
+        elif fan == 12: return 80
+        elif fan in (13, 14): return 90
+        elif fan == 15: return 100
+    return 0
+
+class PrinterState(Enum):
+    CONNECTED = 1,
+    DISCONNECTED = 2,
+    PAUSED = 3,
+    QUIT = 4
+