bambu-mqtt 0.1.0__py3-none-any.whl

bambu_mqtt/__main__.py

@@ -0,0 +1,208 @@
+"""
+Entry point for Bambu MQTT middle layer.
+
+Connects to a local Bambu printer over MQTT using TLS, subscribes to telemetry
+topics, parses incoming JSON messages, and logs or processes them for further use
+(e.g., Grafana / InfluxDB pipelines).
+
+Usage:
+    python -m bambu_mqtt --host 192.168.0.123 --device-id ABC123 --access-code 123456
+"""
+
+import argparse
+import logging
+import signal
+from importlib.metadata import version, PackageNotFoundError
+import os
+from typing import Any
+from paho.mqtt.client import Client, MQTTMessage
+from bambu_mqtt.telemetry import Telemetry
+from bambu_mqtt.utils import connect_local_mqtt, extract_device_id_from_cert
+from bambu_mqtt.parser import Parser
+from bambu_mqtt.logger import configure_logging
+from bambu_mqtt.writers.influxdb import InfluxDBWriter
+
+logger = logging.getLogger("bambu_mqtt")
+
+TOPIC_TEMPLATE: str = "device/{device_id}/{suffix}"
+
+
+try:
+    __version__ = version("bambu-mqtt")
+except PackageNotFoundError:
+    __version__ = "unknown"
+    logger.warning(
+        "Package not found. Version information may be unavailable. "
+        "Ensure that the package is installed in the current environment."
+    )
+
+
+parser = argparse.ArgumentParser(
+    prog="bambu_mqtt",
+    description=(
+        "Bambu MQTT listener - connect to a local Bambu printer over TLS, "
+        "subscribe to telemetry topics, and parse the incoming messages for "
+        "logging or further processing (e.g., Grafana / InfluxDB)."
+    ),
+    epilog=(
+        "Note: The device ID is derived from the TLS certificate, so you do not need to "
+        "provide it explicitly. The access code is required for MQTT authentication.\n\n"
+        "Example usage:\n"
+        "  python -m bambu_mqtt --host 192.0.2.10 "
+        "--access-code YOUR_PRINTER_ACCESS_CODE --cert ./blcert.pem\n"
+        "  python -m bambu_mqtt --host 192.0.2.10 "
+        "--access-code YOUR_PRINTER_ACCESS_CODE --cert ./blcert.pem --log-level DEBUG\n\n"
+    ),
+    formatter_class=argparse.RawTextHelpFormatter,
+)
+
+parser.add_argument(
+    "-H", "--host", required=True, help="LAN IP or hostname of the printer."
+)
+parser.add_argument("--access-code", required=True, help="Printer MQTT access code.")
+parser.add_argument(
+    "-c",
+    "--cert",
+    required=True,
+    help="Path to the TLS certificate (used to derive device ID for MQTT).",
+)
+parser.add_argument(
+    "-l",
+    "--log-level",
+    default="INFO",
+    choices=["DEBUG", "INFO", "WARNING", "ERROR", "CRITICAL"],
+    help="Set the logging level (default: INFO).",
+)
+
+parser.add_argument(
+    "-v",
+    "--version",
+    action="version",
+    version=f"%(prog)s {__version__}",
+    help="Show the version of the Bambu MQTT listener and exit.",
+)
+
+parser.add_argument(
+    "--influx-url",
+    default="http://localhost:8086",
+    help="InfluxDB server URL.",
+)
+parser.add_argument(
+    "--influx-token",
+    default=os.getenv("INFLUXDB_TOKEN"),
+    required=os.getenv("INFLUXDB_TOKEN") is None,
+    help="InfluxDB authentication token (or set INFLUXDB_TOKEN).",
+)
+parser.add_argument("--influx-org", required=True, help="InfluxDB organization.")
+parser.add_argument("--influx-bucket", required=True, help="InfluxDB bucket.")
+
+args = parser.parse_args()
+configure_logging(args.log_level)
+
+writer = InfluxDBWriter(
+    url=args.influx_url,
+    token=args.influx_token,
+    org=args.influx_org,
+    bucket=args.influx_bucket,
+)
+
+# Connect to printer via MQTT
+try:
+    device_id = extract_device_id_from_cert(args.cert)
+except (ValueError, FileNotFoundError) as exc:
+    logger.error("%s", exc)
+    raise SystemExit(2) from exc
+
+client = connect_local_mqtt(args.host, device_id, args.access_code, args.cert)
+TOPIC_REPORT = TOPIC_TEMPLATE.format(device_id=device_id, suffix="report")
+
+
+# Define callback for incoming MQTT messages
+def on_message(_client: Client, _userdata: Any, msg: MQTTMessage):
+    """On message handler for the MQTT client
+
+    Args:
+        _client (_type_): MQTT client session
+        _userdata (_type_): MQTT userdata
+        msg (_type_): Received message
+    """
+    logger.info("Received MQTT message on topic %s: parsing now", msg.topic)
+    try:
+        payload = msg.payload.decode("utf-8")
+        data = Parser(payload).data
+        telemetry = Telemetry.from_dict(
+            data
+        )  # TODO use telemetry object for further processing (e.g., logging, Grafana, InfluxDB)
+        logger.debug("Received telemetry: %s", data)
+        with writer:
+            writer.write(telemetry)
+        logger.info("Telemetry written to InfluxDB successfully.")
+        logger.debug("Telemetry object: %s", telemetry)
+    except UnicodeDecodeError as exc:
+        logger.warning("Failed to decode MQTT payload: %s", exc)
+    except ValueError as exc:
+        logger.warning("Failed to parse MQTT payload: %s", exc)
+    except Exception:
+        logger.exception("Failed to process or store telemetry")
+
+
+def on_connect(_client: Client, _userdata: Any, _flags: dict, rc: int):
+    """On connect handler for the MQTT client
+
+    Args:
+        _client (Client): MQTT client session
+        _userdata (Any): MQTT userdata
+        _flags (dict): MQTT flags
+        rc (int): Connection result code
+    """
+    if rc == 0:
+        logger.info("Connected to printer %s at %s", device_id, args.host)
+        client.subscribe(TOPIC_REPORT)
+        logger.debug("Subscribed to topic %s", TOPIC_REPORT)
+    else:
+        logger.error("Failed to connect to printer: %s", rc)
+
+
+def on_disconnect(_client: Client, _userdata: Any, rc: int):
+    """On disconnect handler for the MQTT client
+
+    Args:
+        _client (_type_): MQTT client session
+        _userdata (_type_): MQTT userdata
+        rc (_type_): Disconnection result code
+    """
+    if rc != 0:
+        logger.warning("Unexpected disconnection from printer: %s", rc)
+    else:
+        logger.info("Disconnected from printer %s at %s", device_id, args.host)
+
+
+def handle_sigterm(_signum: int, _frame: Any):
+    """Handle SIGTERM signal for graceful shutdown.
+
+    Args:
+        _signum (int): Signal number
+        _frame (frame object): Current stack frame
+    """
+    logger.info("Received SIGTERM signal. Disconnecting from printer...")
+    client.disconnect()
+    logger.info("Disconnected. Exiting.")
+    raise SystemExit(0)
+
+
+client.on_message = on_message
+client.on_connect = on_connect
+client.on_disconnect = on_disconnect
+
+client.subscribe(TOPIC_REPORT)
+
+# Start MQTT network loop
+signal.signal(signal.SIGTERM, handle_sigterm)
+try:
+    client.loop_forever()
+except KeyboardInterrupt:
+    logger.info("Shutdown requested by user (Ctrl+C)")
+finally:
+    logger.info("Disconnecting from printer")
+    client.disconnect()
+    logger.info("Bambu MQTT listener stopped")

bambu_mqtt/logger.py

@@ -0,0 +1,44 @@
+"""Configure application-wide colored logging."""
+
+import logging
+import sys
+
+
+class ColoredFormatter(logging.Formatter):
+    """Format log records with colors based on severity."""
+
+    RESET = "\033[0m"
+    COLORS = {
+        logging.DEBUG: "\033[36m",  # Cyan
+        logging.INFO: "\033[32m",  # Green
+        logging.WARNING: "\033[33m",  # Yellow
+        logging.ERROR: "\033[31m",  # Red
+        logging.CRITICAL: "\033[1;31m",  # Bold red
+    }
+
+    def format(self, record: logging.LogRecord) -> str:
+        """Format a log record with a colored level name."""
+        original_levelname = record.levelname
+        color = self.COLORS.get(record.levelno, self.RESET)
+
+        record.levelname = f"{color}{original_levelname}{self.RESET}"
+        try:
+            return super().format(record)
+        finally:
+            record.levelname = original_levelname
+
+
+def configure_logging(level: int = logging.INFO) -> None:
+    """Configure colored console logging."""
+    handler = logging.StreamHandler(sys.stdout)
+    handler.setFormatter(
+        ColoredFormatter(
+            "%(asctime)s | %(levelname)-8s | %(name)s | %(message)s",
+            datefmt="%Y-%m-%d %H:%M:%S",
+        )
+    )
+
+    root_logger = logging.getLogger()
+    root_logger.setLevel(level)
+    root_logger.handlers.clear()
+    root_logger.addHandler(handler)

bambu_mqtt/mqtt_client.py

@@ -0,0 +1,33 @@
+"""
+MQTT client with TLS support to connect to an MQTT broker.
+
+Project: Bambu MQTT
+Author: dvanhecke
+"""
+
+import ssl
+import paho.mqtt.client as mqtt
+
+
+class MQTTSClient(mqtt.Client):
+    """
+    MQTT client that supports custom Server Name Indication (SNI) for TLS certificates.
+
+    This is useful when the broker's certificate hostname does not match the connection hostname.
+    See: https://github.com/eclipse-paho/paho.mqtt.python/issues/734#issuecomment-2256633060
+    """
+
+    def __init__(self, *args, server_name=None, **kwargs):
+        super().__init__(*args, **kwargs)
+        self._server_name = server_name
+
+    def _ssl_wrap_socket(self, tcp_sock) -> ssl.SSLSocket:
+        """
+        Wrap the TCP socket with SSL, overriding the host for custom SNI if specified.
+        """
+        orig_host = self._host
+        if self._server_name:
+            self._host = self._server_name
+        res = super()._ssl_wrap_socket(tcp_sock)
+        self._host = orig_host
+        return res

bambu_mqtt/parser.py

@@ -0,0 +1,41 @@
+"""Parse and normalize Bambu Lab printer telemetry.
+
+This module extracts useful printer and AMS metrics from MQTT status
+payloads and converts them into a structured dictionary suitable for
+logging, monitoring, and time-series storage.
+"""
+
+import json
+from typing import Any, Dict
+
+
+class Parser:
+    """Parse and normalize Bambu Lab printer telemetry."""
+
+    def __init__(self, payload: str) -> None:
+        self._payload: str = payload
+        self._data: Dict[str, Any] = self.parse_data()
+
+    def parse_data(self) -> Dict[str, Any]:
+        """Parse the MQTT payload and return a structured dictionary."""
+        try:
+            parsed = json.loads(self._payload)
+            # Normalize keys and values as needed
+            normalized_data = {k.lower(): v for k, v in parsed.items()}
+            return normalized_data
+        except json.JSONDecodeError as e:
+            raise ValueError("Invalid JSON payload") from e
+
+    @property
+    def data(self) -> Dict[str, Any]:
+        """Return the parsed and normalized data."""
+        return self._data
+
+    @property
+    def payload(self) -> str:
+        """Return the original payload."""
+        return self._payload
+
+    def __str__(self) -> str:
+        """Return a string representation of the parsed data."""
+        return json.dumps(self._data, indent=2)

bambu_mqtt/telemetry.py

@@ -0,0 +1,194 @@
+
+"""Parse and normalize Bambu Lab H2S printer telemetry."""
+
+from dataclasses import dataclass, field
+from typing import Any
+
+
+def _as_float(value: Any) -> float | None:
+    """Convert a value to float."""
+    try:
+        return float(value) if value is not None else None
+    except (TypeError, ValueError):
+        return None
+
+
+def _as_int(value: Any) -> int | None:
+    """Convert a value to int."""
+    try:
+        return int(value) if value is not None else None
+    except (TypeError, ValueError):
+        return None
+
+
+def _as_str(value: Any) -> str | None:
+    """Convert a value to string, if valid."""
+    return value if isinstance(value, str) else None
+
+
+@dataclass
+class PrinterStatus:
+    """Printer and print-job information."""
+
+    state: str | None = None
+    progress: float | None = None
+    current_layer: int | None = None
+    total_layers: int | None = None
+    remaining_minutes: int | None = None
+    job_name: str | None = None
+
+    @classmethod
+    def from_dict(cls, data: dict[str, Any]) -> "PrinterStatus":
+        return cls(
+            state=_as_str(data.get("gcode_state")),
+            progress=_as_float(data.get("mc_percent")),
+            current_layer=_as_int(data.get("layer_num")),
+            total_layers=_as_int(data.get("total_layer_num")),
+            remaining_minutes=_as_int(data.get("mc_remaining_time")),
+            job_name=_as_str(data.get("subtask_name")),
+        )
+
+
+
+@dataclass
+class Temperature:
+    """Printer temperature readings."""
+
+    nozzle: float | None = None
+    nozzle_target: float | None = None
+    bed: float | None = None
+    bed_target: float | None = None
+    chamber: float | None = None
+    chamber_target: float | None = None
+
+    @classmethod
+    def from_dict(cls, data: dict[str, Any]) -> "Temperature":
+        """Create temperature readings from Bambu MQTT data."""
+
+        device = data.get("device", {})
+        ctc = device.get("ctc", {}) if isinstance(device, dict) else {}
+        ctc_info = ctc.get("info", {}) if isinstance(ctc, dict) else {}
+
+        return cls(
+            nozzle=_as_float(data.get("nozzle_temper")),
+            nozzle_target=_as_float(data.get("nozzle_target_temper")),
+            bed=_as_float(data.get("bed_temper")),
+            bed_target=_as_float(data.get("bed_target_temper")),
+            chamber=(
+                _as_float(ctc_info.get("temp"))
+                if isinstance(ctc_info, dict)
+                else None
+            ),
+            chamber_target=None,
+        )
+
+@dataclass
+class Connectivity:
+    """Printer network connectivity."""
+
+    wifi_signal: str | None = None
+
+    @classmethod
+    def from_dict(cls, data: dict[str, Any]) -> "Connectivity":
+        return cls(
+            wifi_signal=_as_str(data.get("wifi_signal")),
+        )
+
+
+@dataclass
+class AMSTray:
+    """Individual filament tray."""
+
+    id: int | None = None
+    filament_type: str | None = None
+    color: str | None = None
+    remaining: int | None = None
+    nozzle_temp_min: float | None = None
+    nozzle_temp_max: float | None = None
+    tray_diameter: float | None = None
+    tray_weight: float | None = None
+
+    @classmethod
+    def from_dict(cls, data: dict[str, Any]) -> "AMSTray":
+        remaining = _as_int(data.get("remain"))
+
+        return cls(
+            id=_as_int(data.get("id")),
+            filament_type=_as_str(data.get("tray_type")),
+            color=_as_str(data.get("tray_color")),
+            remaining=(
+                remaining if remaining is not None and remaining >= 0 else None
+            ),
+            nozzle_temp_min=_as_float(data.get("nozzle_temp_min")),
+            nozzle_temp_max=_as_float(data.get("nozzle_temp_max")),
+            tray_diameter=_as_float(data.get("tray_diameter")),
+            tray_weight=_as_float(data.get("tray_weight")),
+        )
+
+
+@dataclass
+class AMSStatus:
+    """One AMS unit and its filament trays."""
+
+    id: str | None = None
+    temperature: float | None = None
+    humidity: float | None = None
+    humidity_raw: float | None = None
+    trays: list[AMSTray] = field(default_factory=list)
+
+    @classmethod
+    def from_dict(cls, data: dict[str, Any]) -> "AMSStatus":
+        tray_data = data.get("tray", [])
+
+        trays = [
+            AMSTray.from_dict(tray)
+            for tray in tray_data
+            if isinstance(tray, dict)
+        ] if isinstance(tray_data, list) else []
+
+        return cls(
+            id=_as_str(data.get("id")),
+            temperature=_as_float(data.get("temp")),
+            humidity=_as_float(data.get("humidity")),
+            humidity_raw=_as_float(data.get("humidity_raw")),
+            trays=trays,
+        )
+
+
+@dataclass
+class Telemetry:
+    """Normalized Bambu Lab printer telemetry."""
+
+    printer: PrinterStatus = field(default_factory=PrinterStatus)
+    temperatures: Temperature = field(default_factory=Temperature)
+    connectivity: Connectivity = field(default_factory=Connectivity)
+    ams: list[AMSStatus] = field(default_factory=list)
+
+    @classmethod
+    def from_dict(cls, payload: dict[str, Any]) -> "Telemetry":
+        """Parse a complete Bambu MQTT status payload."""
+
+        print_data = payload.get("print", payload)
+
+        if not isinstance(print_data, dict):
+            raise ValueError("Invalid MQTT payload: missing print dictionary")
+
+        ams_container = print_data.get("ams", {})
+        ams_units = (
+            ams_container.get("ams", [])
+            if isinstance(ams_container, dict)
+            else []
+        )
+
+        ams = [
+            AMSStatus.from_dict(unit)
+            for unit in ams_units
+            if isinstance(unit, dict)
+        ] if isinstance(ams_units, list) else []
+
+        return cls(
+            printer=PrinterStatus.from_dict(print_data),
+            temperatures=Temperature.from_dict(print_data),
+            connectivity=Connectivity.from_dict(print_data),
+            ams=ams,
+        )

bambu_mqtt/utils.py

@@ -0,0 +1,96 @@
+"""
+Utility functions for Bambu MQTT connections and TLS setup.
+
+This module provides helpers to:
+
+- Create a TLS/SSL context for secure connections to local Bambu printers,
+  automatically referencing the package-local certificate.
+- Connect to a local printer over MQTT using TLS, handling authentication
+  and server name indication (SNI).
+
+All functions are designed for LAN-only printer setups with developer mode
+enabled and can be integrated with Telegraf / InfluxDB pipelines.
+
+Project: Bambu MQTT
+Author: dvanhecke
+"""
+
+import ssl
+from pathlib import Path
+from cryptography import x509
+from cryptography.hazmat.backends import default_backend
+
+from bambu_mqtt.mqtt_client import MQTTSClient
+
+
+def extract_device_id_from_cert(cert_path: str | Path) -> str:
+    """
+    Extracts the Bambu printer device ID from the provided PEM certificate.
+
+    Args:
+        cert_path (str | Path): Path to the PEM certificate file.
+
+    Returns:
+        str: The device ID embedded in the certificate CN.
+
+    Raises:
+        FileNotFoundError: If the certificate file does not exist.
+        ValueError: If the device ID cannot be found in the certificate.
+    """
+    cert_path = Path(cert_path)
+    if not cert_path.exists():
+        raise FileNotFoundError(f"Certificate file not found: {cert_path}")
+
+    with cert_path.open("rb") as f:
+        cert_data = f.read()
+
+    cert = x509.load_pem_x509_certificate(cert_data, default_backend())
+    subject = cert.subject
+
+    # The device ID is usually in the Common Name (CN)
+    cn = subject.get_attributes_for_oid(x509.NameOID.COMMON_NAME)
+    if not cn:
+        raise ValueError("Device ID not found in certificate CN")
+
+    return cn[0].value
+
+
+def create_local_ssl_context(ca_cert_path: str) -> ssl.SSLContext:
+    """
+    Create an SSL context for TLS connections to local Bambu printers.
+
+    This context validates the printer's certificate located in the package's
+    `certs/` folder, relaxing strict X.509 verification for LAN-only printer
+    certificates. When using the context, you must call:
+        context.wrap_socket(sock, servername=printer_serial_number)
+    to correctly set the Server Name Indication (SNI) for the printer.
+
+    Returns:
+        ssl.SSLContext: Configured SSL context for local printer connections.
+    """
+    # Locate the certificate in the bambu_mqtt package
+
+    context = ssl.create_default_context(cafile=ca_cert_path)
+    context.verify_flags &= ~ssl.VERIFY_X509_STRICT
+    return context
+
+
+def connect_local_mqtt(
+    hostname: str, device_id: str, access_code: str, certfile: str
+) -> MQTTSClient:
+    """
+    Connect to a local Bambu printer over MQTT using TLS.
+
+    Args:
+        hostname (str): The LAN IP or hostname of the printer.
+        device_id (str): The printer's device ID, used for SNI in TLS.
+        access_code (str): Printer-specific password for MQTT authentication.
+
+    Returns:
+        MQTTSClient: A connected MQTT client instance ready to subscribe or publish.
+    """
+    client = MQTTSClient(server_name=device_id)
+    client.tls_set_context(create_local_ssl_context(certfile))
+    client.username_pw_set("bblp", access_code)
+    client.connect(hostname, port=8883, keepalive=60)
+    return client

bambu_mqtt/writers/base.py

@@ -0,0 +1,65 @@
+"""Define the abstract interface for telemetry writers."""
+
+from abc import ABC, abstractmethod
+from types import TracebackType
+from typing import Self
+
+from bambu_mqtt.telemetry import Telemetry
+
+
+class BaseWriter(ABC):
+    """Abstract base class for telemetry output backends."""
+
+    @abstractmethod
+    def write(self, telemetry: Telemetry) -> None:
+        """Write a telemetry snapshot to the configured backend.
+
+        Args:
+            telemetry (Telemetry): Telemetry to write.
+
+        Raises:
+            NotImplementedError: Not yet implemented.
+        """
+        raise NotImplementedError
+
+    @abstractmethod
+    def connect(self) -> None:
+        """Establish a connection.
+
+        Raises:
+            NotImplementedError: Not yet implemented.
+        """
+        raise NotImplementedError
+
+    @abstractmethod
+    def disconnect(self) -> None:
+        """Close the connection.
+
+        Raises:
+            NotImplementedError: Not yet implemented.
+        """
+        raise NotImplementedError
+
+    def __enter__(self) -> Self:
+        """Connect to the backend and enter the runtime context.
+
+        Returns:
+            Self: Writer object.
+        """
+        self.connect()
+        return self
+
+    def __exit__(
+        self,
+        exc_type: type[BaseException] | None,
+        exc_value: BaseException | None,
+        traceback: TracebackType | None,
+    ) -> None:
+        """Disconnect from the backend when leaving the runtime context.
+
+        Args:
+            exc_type (type[BaseException] | None): exit type.
+            exc_value (BaseException | None): exit value.
+            traceback (TracebackType | None): traceback.
+        """
+        self.disconnect()

bambu_mqtt/writers/influxdb.py

@@ -0,0 +1,235 @@
+"""Write Bambu Lab printer telemetry to InfluxDB.
+
+This module provides an InfluxDB-backed implementation of the
+:class:`BaseWriter` interface for storing printer and AMS telemetry
+as time-series data.
+"""
+
+import logging
+from influxdb_client import InfluxDBClient, Point
+from influxdb_client.client.write_api import SYNCHRONOUS, WriteApi
+
+from bambu_mqtt.telemetry import Telemetry
+from bambu_mqtt.writers.base import BaseWriter
+
+logger = logging.getLogger(__name__)
+
+
+class InfluxDBWriter(BaseWriter):
+    """Write Bambu Lab printer telemetry to InfluxDB.
+
+    This class implements the :class:`BaseWriter` interface for storing
+    printer and AMS telemetry as time-series data in an InfluxDB backend.
+    """
+
+    def __init__(
+        self,
+        url: str,
+        token: str,
+        org: str,
+        bucket: str,
+    ) -> None:
+        """Initialize the InfluxDBWriter.
+
+        Args:
+            url (str): InfluxDB server URL.
+            token (str): InfluxDB authentication token.
+            org (str): InfluxDB organization name.
+            bucket (str): InfluxDB bucket name.
+        """
+        self._url = url
+        self._token = token
+        self._org = org
+        self._bucket = bucket
+        self._client: InfluxDBClient | None = None
+        self._write_api: WriteApi | None = None
+
+    def write(self, telemetry: Telemetry) -> None:
+        """Write printer, AMS, and filament tray telemetry."""
+
+        if self._write_api is None:
+            raise RuntimeError("InfluxDB writer is not connected")
+
+        points: list[Point] = []
+
+        # --------------------------------------------------
+        # Printer measurement
+        # --------------------------------------------------
+
+        printer = telemetry.printer
+        temperatures = telemetry.temperatures
+        connectivity = telemetry.connectivity
+
+        printer_fields = {
+            "state": printer.state,
+            "progress": printer.progress,
+            "current_layer": printer.current_layer,
+            "total_layers": printer.total_layers,
+            "remaining_minutes": printer.remaining_minutes,
+            "job_name": printer.job_name,
+            "nozzle_temperature": temperatures.nozzle,
+            "nozzle_target_temperature": temperatures.nozzle_target,
+            "bed_temperature": temperatures.bed,
+            "bed_target_temperature": temperatures.bed_target,
+            "chamber_temperature": temperatures.chamber,
+            "chamber_target_temperature": temperatures.chamber_target,
+            "wifi_signal": connectivity.wifi_signal,
+        }
+
+        printer_point = Point("printer")
+
+        for name, value in printer_fields.items():
+            if value is not None:
+                printer_point = printer_point.field(name, value)
+
+        if any(value is not None for value in printer_fields.values()):
+            points.append(printer_point)
+
+        # --------------------------------------------------
+        # AMS measurements
+        # --------------------------------------------------
+
+        for ams in telemetry.ams:
+
+            # AMS unit measurement
+            ams_fields = {
+                "temperature": ams.temperature,
+                "humidity": ams.humidity,
+                "humidity_raw": ams.humidity_raw,
+            }
+
+            ams_point = Point("ams")
+
+            if ams.id is not None:
+                ams_point = ams_point.tag("ams_id", ams.id)
+
+            for name, value in ams_fields.items():
+                if value is not None:
+                    ams_point = ams_point.field(name, value)
+
+            if any(value is not None for value in ams_fields.values()):
+                points.append(ams_point)
+
+            # --------------------------------------------------
+            # Individual filament tray measurements
+            # --------------------------------------------------
+
+            for tray in ams.trays:
+                tray_fields = {
+                    "filament_type": tray.filament_type,
+                    "color": tray.color,
+                    "remaining": tray.remaining,
+                    "nozzle_temp_min": tray.nozzle_temp_min,
+                    "nozzle_temp_max": tray.nozzle_temp_max,
+                    "tray_diameter": tray.tray_diameter,
+                    "tray_weight": tray.tray_weight,
+                }
+
+                tray_point = Point("ams_tray")
+
+                if ams.id is not None:
+                    tray_point = tray_point.tag("ams_id", ams.id)
+
+                if tray.id is not None:
+                    tray_point = tray_point.tag(
+                        "tray_id",
+                        str(tray.id),
+                    )
+
+                for name, value in tray_fields.items():
+                    if value is not None:
+                        tray_point = tray_point.field(name, value)
+
+                if any(value is not None for value in tray_fields.values()):
+                    points.append(tray_point)
+
+        # --------------------------------------------------
+        # Write measurements
+        # --------------------------------------------------
+
+        if not points:
+            logger.debug("No telemetry data available to write")
+            return
+
+        try:
+            self._write_api.write(
+                bucket=self._bucket,
+                org=self._org,
+                record=points,
+            )
+        except Exception:
+            logger.exception("Failed to write telemetry to InfluxDB")
+            raise
+
+        logger.debug(
+            "Successfully wrote %d telemetry points to InfluxDB",
+            len(points),
+        )
+
+    def connect(self) -> None:
+        """Establish an InfluxDB connection."""
+        if self._client is not None:
+            logger.warning("InfluxDB writer is already connected")
+            raise RuntimeError("InfluxDB writer is already connected")
+
+        logger.info("Connecting to InfluxDB at %s", self._url)
+
+        client = InfluxDBClient(
+            url=self._url,
+            token=self._token,
+            org=self._org,
+        )
+
+        try:
+            write_api = client.write_api(write_options=SYNCHRONOUS)
+        except Exception:
+            logger.exception("Failed to initialise InfluxDB write API")
+
+            try:
+                client.close()
+            except Exception:
+                logger.exception(
+                    "Failed to close InfluxDB client after initialisation failure"
+                )
+
+            raise
+
+        self._client = client
+        self._write_api = write_api
+
+        logger.info("Successfully connected to InfluxDB")
+
+    def disconnect(self) -> None:
+        """Close the InfluxDB connection."""
+        logger.info("Disconnecting from InfluxDB")
+
+        write_api = self._write_api
+        client = self._client
+
+        # Reset state before attempting cleanup.
+        self._write_api = None
+        self._client = None
+
+        cleanup_error = None
+
+        if write_api is not None:
+            try:
+                write_api.close()
+                logger.debug("InfluxDB write API closed")
+            except Exception as exc:
+                logger.exception("Failed to close InfluxDB write API")
+                cleanup_error = exc
+
+        if client is not None:
+            try:
+                client.close()
+                logger.debug("InfluxDB client closed")
+            except Exception as exc:
+                logger.exception("Failed to close InfluxDB client")
+                if cleanup_error is None:
+                    cleanup_error = exc
+
+        if cleanup_error is not None:
+            raise cleanup_error
+
+        logger.info("Successfully disconnected from InfluxDB")

bambu_mqtt-0.1.0.dist-info/METADATA

@@ -0,0 +1,257 @@
+Metadata-Version: 2.4
+Name: bambu-mqtt
+Version: 0.1.0
+Summary: Bambu Lab MQTT telemetry collector with InfluxDB integration
+Author: NullVanta
+License-Expression: MIT
+Project-URL: Homepage, https://github.com/NullVanta/bambu-mqtt
+Project-URL: Repository, https://github.com/NullVanta/bambu-mqtt
+Project-URL: Issues, https://github.com/NullVanta/bambu-mqtt/issues
+Requires-Python: >=3.14
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Requires-Dist: paho-mqtt
+Requires-Dist: cryptography
+Requires-Dist: influxdb-client
+Dynamic: license-file
+
+# bambu-mqtt
+
+**A Python-based MQTT telemetry collector for Bambu Lab 3D printers.**
+
+`bambu-mqtt` connects to a Bambu Lab printer over its local MQTT interface using TLS, parses printer and AMS telemetry into structured Python dataclasses, and exports the collected data to InfluxDB for monitoring and visualization.
+
+Designed for self-hosted monitoring setups using InfluxDB and Grafana.
+
+## Features
+
+- Connects to Bambu Lab printers through local MQTT.
+- Uses TLS certificate authentication.
+- Parses MQTT status messages into structured telemetry objects.
+- Tracks printer status, print progress and layer information.
+- Collects nozzle, bed and chamber temperature readings.
+- Monitors Wi-Fi signal strength.
+- Supports multiple AMS units and their individual filament trays.
+- Exports telemetry to InfluxDB.
+- Uses Python logging for configurable runtime diagnostics.
+
+## Architecture
+
+```mermaid
+       flowchart TD
+    A["Bambu Lab Printer"] -->|MQTT over TLS| B["MQTT Client"]
+    B --> C["Telemetry Parser"]
+    C --> D["Python Dataclasses"]
+    D --> E["InfluxDB Writer"]
+    E --> F[("InfluxDB")]
+    F --> G["Grafana"]
+
+    subgraph Collector["bambu-mqtt"]
+        B
+        C
+        D
+        E
+    end
+```
+
+## Requirements
+
+- A compatible Bambu Lab printer with local MQTT access.
+- Developer mode enabled on the printer, where required.
+- Python.
+- An MQTT TLS certificate.
+- An InfluxDB 2.x instance.
+- An InfluxDB API token with write permissions.
+
+## Installation
+
+Clone the repository:
+
+```bash
+git clone https://github.com/NullVanta/bambu-mqtt.git
+cd bambu-mqtt
+```
+
+Install the project dependencies using Pipenv:
+
+```bash
+pipenv install
+```
+
+For development dependencies:
+
+```bash
+pipenv install --dev
+```
+
+## Configuration
+
+Before starting the collector, obtain the required printer connection information:
+
+| Parameter | Description |
+|---|---|
+| Host | Printer's local IP address |
+| Access code | Printer's LAN access code |
+| Certificate | TLS certificate used for authentication |
+| InfluxDB URL | InfluxDB server address |
+| InfluxDB token | API token with bucket write access |
+| InfluxDB organization | Target InfluxDB organization |
+| InfluxDB bucket | Target bucket for telemetry |
+
+The printer device ID is derived from the certificate's Common Name (CN).
+
+Set your InfluxDB token as an environment variable:
+
+```bash
+export INFLUXDB_TOKEN="your-influxdb-token"
+```
+
+## Usage
+
+Start the collector:
+
+```bash
+pipenv run python -m bambu_mqtt \
+    --host 192.168.0.240 \
+    --cert ./blcert.pem \
+    --access-code YOUR_ACCESS_CODE \
+    --influx-url http://localhost:8086 \
+    --influx-org YOUR_ORG \
+    --influx-bucket bambulab
+```
+
+### Command-line arguments
+
+| Argument | Description |
+|---|---|
+| `-H`, `--host` | Printer IP address |
+| `--access-code` | Printer LAN access code |
+| `-c`, `--cert` | Path to the TLS certificate |
+| `-l`, `--log-level` | Logging verbosity |
+| `-v`, `--version` | Display application version |
+| `--influx-url` | InfluxDB server URL |
+| `--influx-token` | InfluxDB API token |
+| `--influx-org` | InfluxDB organization |
+| `--influx-bucket` | InfluxDB destination bucket |
+
+Supported log levels:
+
+`DEBUG`, `INFO`, `WARNING`, `ERROR`, `CRITICAL`
+
+The default logging level is `INFO`.
+
+## Telemetry
+
+Telemetry is normalized into structured Python dataclasses before being passed to the configured writer.
+
+### Printer
+
+- Printer state
+- Print progress
+- Current layer
+- Total layers
+- Remaining print time
+- Job name
+
+### Temperatures
+
+- Nozzle temperature
+- Nozzle target temperature
+- Bed temperature
+- Bed target temperature
+- Chamber temperature
+- Chamber target temperature, when available
+
+### Connectivity
+
+- Wi-Fi signal strength
+
+### AMS
+
+- AMS identifier
+- AMS temperature
+- Humidity
+- Raw humidity
+- Individual filament tray information
+
+### Filament trays
+
+- Tray identifier
+- Filament type
+- Filament colour
+- Remaining filament percentage
+- Minimum and maximum nozzle temperatures
+- Filament diameter
+- Filament spool weight
+
+Unavailable telemetry fields are represented as `None`.
+
+## InfluxDB measurements
+
+The InfluxDB writer currently exports three measurements:
+
+| Measurement | Contents |
+|---|---|
+| `printer` | Printer status, temperatures and connectivity |
+| `ams` | AMS temperature and humidity |
+| `ams_tray` | Individual filament tray information |
+
+These measurements can be queried in Grafana using Flux.
+
+## Logging
+
+The application uses Python's standard logging framework.
+
+Example output:
+
+```text
+INFO | Connected to printer
+DEBUG | Subscribed to MQTT topic
+INFO | Received MQTT message, parsing now
+INFO | Connecting to InfluxDB
+INFO | Successfully connected to InfluxDB
+DEBUG | Successfully wrote 6 telemetry points
+INFO | Telemetry written to InfluxDB successfully
+```
+
+Logging verbosity can be adjusted using `--log-level`.
+
+## Development
+
+The project uses Pipenv for dependency management.
+
+Install development dependencies:
+
+```bash
+pipenv install --dev
+```
+
+Run the application:
+
+```bash
+pipenv run python -m bambu_mqtt
+```
+
+### Code quality
+
+The project uses:
+
+- Black for code formatting.
+- Pylint for static code analysis.
+
+Run the checks:
+
+```bash
+pipenv run black --check bambu_mqtt
+pipenv run pylint bambu_mqtt
+```
+
+## Project status
+
+`bambu-mqtt` is under active development.
+
+The initial release focuses on local MQTT connectivity, telemetry parsing and InfluxDB integration.
+
+## License
+
+See [LICENSE](LICENSE) for licensing information.

bambu_mqtt-0.1.0.dist-info/RECORD

@@ -0,0 +1,15 @@
+bambu_mqtt/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+bambu_mqtt/__main__.py,sha256=sH2FEwMRoUTevdijltRWBZlZMMo8wRE833B-nSUxF5k,6707
+bambu_mqtt/logger.py,sha256=4YgPxMDLsnckgIddZAIClhzHJTY0rOmZN4iNmziIF8Y,1342
+bambu_mqtt/mqtt_client.py,sha256=YqFub3gofCgu9oKVkpogRFgjjCRrcQz9FgH9L43meQo,996
+bambu_mqtt/parser.py,sha256=34ogrDDVT8aT2FhYyRnEdqvNriV16uBJUHvNpfcyAoE,1327
+bambu_mqtt/telemetry.py,sha256=rtJXnmK5aXSbYC53HYmsyF8bSZnRwcZ3cGmrrD1uGgk,5894
+bambu_mqtt/utils.py,sha256=h2ZTV__daTGIKLCHimGRjj26KCIF6JTQTHM2E1SqT7M,3219
+bambu_mqtt/writers/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+bambu_mqtt/writers/base.py,sha256=DAMnpKzdhSAk9mm1M91F6VvcFyg4kL7-eQDM2pR9wIQ,1699
+bambu_mqtt/writers/influxdb.py,sha256=jyJhZKNkk7ohBad5tEJhF9Xl5zPjT-IjLmRRkbl44BQ,7697
+bambu_mqtt-0.1.0.dist-info/licenses/LICENSE,sha256=OXw8z_ZCkmzMLj-0ydLyMyFJrWEVFu_oVICreZ8Fq6c,1065
+bambu_mqtt-0.1.0.dist-info/METADATA,sha256=PiGYH2vUX9pVr-c8nLa7t21a9KXk4gxJc4zCEQkJFlQ,6013
+bambu_mqtt-0.1.0.dist-info/WHEEL,sha256=mOdXR9C3wMVov7cSY8PY-XCzo3SmmWCHvGQr5csJoao,91
+bambu_mqtt-0.1.0.dist-info/top_level.txt,sha256=yRTcJp-gT6B2HWNcm7LR9hVAdN-hI6wk2pJwFJk2bm0,11
+bambu_mqtt-0.1.0.dist-info/RECORD,,

bambu_mqtt-0.1.0.dist-info/WHEEL

@@ -0,0 +1,5 @@
+Wheel-Version: 1.0
+Generator: setuptools (84.2.1)
+Root-Is-Purelib: true
+Tag: py3-none-any
+

bambu_mqtt-0.1.0.dist-info/licenses/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2025 YourName
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in
+all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+THE SOFTWARE.

bambu_mqtt-0.1.0.dist-info/top_level.txt

@@ -0,0 +1 @@
+bambu_mqtt