refactor app.py https://chatgpt.com/share/67d33ee7-7ef4-8006-a2f2-dd8055c61552

app.py

@@ -2,27 +2,16 @@ import gradio as gr
 import paho.mqtt.client as mqtt
 import json
 import time
-import threading
 import os
-import base64
+import requests
+import traceback
 from PIL import Image
 import io
-import numpy as np
-import logging
-import sys
-import random
-import cv2
-from PIL import ImageDraw
-import requests
-
+import threading
 
-logging.basicConfig(
-    level=logging.INFO,
-    format="%(asctime)s - %(name)s - %(levelname)s - %(message)s",
-    handlers=[logging.StreamHandler(sys.stdout), logging.FileHandler("app.log")],
-)
-logger = logging.getLogger("bambu-analysis")
+print("Starting MQTT Print Control...")
 
+# Environment variables
 BAMBU_HOST = os.environ.get("BAMBU_HOST", "default_host")
 BAMBU_PORT = int(os.environ.get("BAMBU_PORT", 1883))
 BAMBU_USERNAME = os.environ.get("BAMBU_USERNAME", "default_user")
@@ -34,615 +23,121 @@ RPI_PORT = int(os.environ.get("RPI_PORT", 1883))
 RPI_USERNAME = os.environ.get("RPI_USERNAME", "default_user")
 RPI_PASSWORD = os.environ.get("RPI_PASSWORD", "default_pass")
 
-logger.info(
-    f"BAMBU MQTT Configuration: HOST={BAMBU_HOST}, PORT={BAMBU_PORT}, USERNAME={BAMBU_USERNAME}, PWD={'*'*len(BAMBU_PASSWORD)}"
-)
-logger.info(
-    f"RPI MQTT Configuration: HOST={RPI_HOST}, PORT={RPI_PORT}, USERNAME={RPI_USERNAME}, PWD={'*'*len(RPI_PASSWORD)}"
-)
+latest_data = {}
 
-latest_data = {
-    "bed_temperature": "N/A",
-    "nozzle_temperature": "N/A",
-    "status": "N/A",
-    "update_time": "Waiting for data...",
-    "image_url": "N/A",
-    "progress": 0,
-    "message": "",
-}
 
-bambu_client = None
-rpi_client = None
-response_topic = None  # Will be set dynamically
-
-# add a global variable to track if the application just started
-is_first_load = True
-
-
-def create_client(client_type):
-    global bambu_client, rpi_client
-    if client_type == "bambu":
-        bambu_client = mqtt.Client()
-        bambu_client.username_pw_set(BAMBU_USERNAME, BAMBU_PASSWORD)
-        bambu_client.tls_set(tls_version=mqtt.ssl.PROTOCOL_TLS)
-        bambu_client.on_connect = on_connect
-        bambu_client.on_message = bambu_on_message
-        bambu_client.connect(BAMBU_HOST, BAMBU_PORT)
-        bambu_client.loop_start()
-    elif client_type == "rpi":
-        rpi_client = mqtt.Client()
-        rpi_client.username_pw_set(RPI_USERNAME, RPI_PASSWORD)
-        rpi_client.tls_set(tls_version=mqtt.ssl.PROTOCOL_TLS)
-        rpi_client.on_connect = on_connect
-        rpi_client.on_message = rpi_on_message
-        rpi_client.connect(RPI_HOST, RPI_PORT)
-        rpi_client.loop_start()
-
-
-def on_connect(client, userdata, flags, rc):
-    logger.info(f"Connected with result code {rc}")
+# Centralized MQTT client setup
+def setup_mqtt_client(host, port, username, password, on_message):
+    client = mqtt.Client()
+    client.username_pw_set(username, password)
+    client.on_message = on_message
+    client.connect(host, port)
+    client.loop_start()
+    return client
 
 
+# Single callback responsibility
 def bambu_on_message(client, userdata, message):
     global latest_data
-    logger.info("Received message")
-    try:
-        data = json.loads(message.payload)
-        latest_data["bed_temperature"] = data.get("bed_temperature", "N/A")
-        latest_data["nozzle_temperature"] = data.get("nozzle_temperature", "N/A")
-        latest_data["status"] = data.get("status", "N/A")
-        latest_data["update_time"] = time.strftime(
-            "%Y-%m-%d %H:%M:%S", time.localtime()
-        )
-        latest_data["image_url"] = data.get("image_url", "N/A")
-    except Exception as e:
-        logger.error(f"Error parsing MQTT message: {e}")
+    latest_data.update(json.loads(message.payload))
+    latest_data["update_time"] = time.strftime("%Y-%m-%d %H:%M:%S", time.localtime())
 
 
-def rpi_on_message(client, userdata, msg):
+def rpi_on_message(client, userdata, message):
     global latest_data
+    latest_data.update(json.loads(message.payload))
+    latest_data["update_time"] = time.strftime("%Y-%m-%d %H:%M:%S", time.localtime())
 
-    try:
-        payload = msg.payload.decode("utf-8")
-        logger.info(f"Received message from RPI: {payload}")
-
-        data = json.loads(payload)
-        status = data.get("status", "Unknown")
 
-        latest_data["status"] = status
-        latest_data["update_time"] = data.get(
-            "update_time", time.strftime("%Y-%m-%d %H:%M:%S", time.localtime())
+# Centralized error handling
+def main_logic():
+    global bambu_client, rpi_client
+    try:
+        bambu_client = setup_mqtt_client(
+            BAMBU_HOST, BAMBU_PORT, BAMBU_USERNAME, BAMBU_PASSWORD, bambu_on_message
         )
-
-        if "nozzle_temperature" in data:
-            latest_data["nozzle_temperature"] = data["nozzle_temperature"]
-
-        if "bed_temperature" in data:
-            latest_data["bed_temperature"] = data["bed_temperature"]
-
-        if "error" in data:
-            logger.error(f"Error from RPI: {data['error']}")
-
-        if status == "Ready":
-            latest_data["progress"] = 0
-            latest_data["message"] = "Printer ready"
-        elif status == "Processing":
-            latest_data["progress"] = 25
-            latest_data["message"] = "Processing G-code..."
-
-    except Exception as e:
-        logger.error(f"Error processing message from RPI: {e}")
-
-        try:
-            result = json.loads(payload)
-
-            if "status" in result:
-                status = result["status"]
-                latest_data["status"] = status
-
-            if (
-                "command" in result
-                and result["command"] == "capture_image"
-                and result.get("auto_triggered", False)
-            ):
-                logger.info("receive capture command")
-                threading.Thread(
-                    target=handle_auto_capture, args=(result,), daemon=True
-                ).start()
-
-        except json.JSONDecodeError:
-            logger.error(f"Invalid JSON in message: {payload}")
-
-
-def get_data(serial=DEFAULT_SERIAL):
-    global bambu_client, response_topic
-
-    if bambu_client is None:
-        create_client("bambu")
-
-    request_topic = f"bambu_a1_mini/request/{serial}"
-    response_topic = f"bambu_a1_mini/response/{serial}"
-
-    logger.info(f"Subscribing to {response_topic}")
-    bambu_client.subscribe(response_topic)
-
-    logger.info(f"Publishing request to {request_topic}")
-    bambu_client.publish(request_topic, json.dumps("HI"))
-
-    global latest_data
-    latest_data["bed_temperature"] = "N/A"
-    timeout = 10
-    while latest_data["bed_temperature"] == "N/A" and timeout > 0:
-        time.sleep(1)
-        timeout -= 1
-
-    return (
-        latest_data["status"],
-        latest_data["bed_temperature"],
-        latest_data["nozzle_temperature"],
-        latest_data["update_time"],
-    )
+        rpi_client = setup_mqtt_client(
+            RPI_HOST, RPI_PORT, RPI_USERNAME, RPI_PASSWORD, rpi_on_message
+        )
+        bambu_client.subscribe(f"bambu_a1_mini/response/{DEFAULT_SERIAL}")
+        rpi_client.subscribe(f"bambu_a1_mini/response/{DEFAULT_SERIAL}")
+    except Exception:
+        print("MQTT setup failed:")
+        traceback.print_exc()
 
 
+# Sending print parameters functionality
 def send_print_parameters(nozzle_temp, bed_temp, print_speed, fan_speed):
-    global rpi_client
-
-    serial = DEFAULT_SERIAL
-
-    logger.info(
-        f"Sending parameters to RPi for G-code generation: nozzle={nozzle_temp}, bed={bed_temp}, "
-        f"speed={print_speed}, fan={fan_speed}"
-    )
-
     try:
         params = {
             "nozzle_temp": nozzle_temp,
             "bed_temp": bed_temp,
             "print_speed": print_speed,
             "fan_speed": fan_speed,
+            "command": "generate_gcode",
         }
+        topic = f"bambu_a1_mini/request/{DEFAULT_SERIAL}"
+        rpi_client.publish(topic, json.dumps(params))
+        return "Parameters sent successfully."
+    except Exception:
+        print("Failed to send parameters:")
+        traceback.print_exc()
+        return "Failed to send parameters."
 
-        request_topic = f"bambu_a1_mini/request/{serial}"
-
-        if rpi_client:
-            rpi_client.publish(
-                request_topic,
-                json.dumps({"command": "generate_gcode", "parameters": params}),
-            )
-            logger.info("Parameters sent successfully to RPi for G-code generation")
-
-            global latest_data
-            latest_data["status"] = "Sent"
-            latest_data["update_time"] = time.strftime(
-                "%Y-%m-%d %H:%M:%S", time.localtime()
-            )
-
-            return "Parameters sent successfully to RPi. Status: Sent"
-        else:
-            logger.warning("MQTT not connected, parameters not sent")
-            return "MQTT not connected, parameters not sent"
-    except Exception as e:
-        logger.error(f"Error sending parameters: {e}")
-        return f"Error sending parameters: {e}"
-
-    latest_data["status"] = "Sending"
-    latest_data["progress"] = 10
-    latest_data["message"] = "Sending parameters to printer..."
-
-
-def get_image_base64(image):
-    if image is None:
-        logger.warning("No image to encode")
-        return None
-
-    try:
-        if isinstance(image, np.ndarray):
-            image = Image.fromarray(image)
-
-        buffer = io.BytesIO()
-        image.save(buffer, format="PNG")
-        img_str = base64.b64encode(buffer.getvalue()).decode("utf-8")
-        logger.info(f"Image encoded to base64 (length: {len(img_str)})")
-        return img_str
-    except Exception as e:
-        logger.error(f"Error encoding image: {e}")
-        return None
-
-
-def handle_auto_capture(message):
-    try:
-        logger.info(f"receive capture command: {message}")
-
-        print_job = message.get("print_job", "unknown_job")
-        timestamp = message.get("timestamp", time.strftime("%Y-%m-%d %H:%M:%S"))
 
-        latest_data["auto_capture_requested"] = True
-        latest_data["last_capture_job"] = print_job
-        latest_data["last_capture_time"] = timestamp
-
-        return capture_image()
-    except Exception as e:
-        logger.error(f"error: {e}")
-        return None, f"capture failed: {str(e)}"
-
-
-def capture_image(url=None):
-    global rpi_client, latest_data
-
-    if rpi_client is None:
-        create_client("rpi")
-
-    serial = DEFAULT_SERIAL
-    request_topic = f"bambu_a1_mini/request/{serial}"
-    response_topic = f"bambu_a1_mini/response/{serial}"
-
-    logger.info(f"Subscribing to {response_topic}")
-    rpi_client.subscribe(response_topic)
-
-    rpi_client.publish(
-        request_topic,
-        json.dumps(
-            {
-                "command": "capture_image",
-            }
-        ),
+# Simple Gradio interface
+def get_status():
+    return (
+        latest_data.get("status", "N/A"),
+        latest_data.get("bed_temperature", "N/A"),
+        latest_data.get("nozzle_temperature", "N/A"),
+        latest_data.get("update_time", "Waiting for data..."),
     )
 
-    latest_data["image_url"] = "N/A"
-    timeout = 45
-    while latest_data["image_url"] == "N/A" and timeout > 0:
-        # print("timeout", timeout)
-        time.sleep(1)
-        timeout -= 1
 
-    url = latest_data["image_url"]
-
-    if url != "N/A":
-        try:
-            logger.info(f"Capturing image from URL: {url}")
-            response = requests.get(url, timeout=10)
+# Image capture functionality
+def capture_image():
+    try:
+        img_url = latest_data.get("image_url", None)
+        if img_url and img_url != "N/A":
+            response = requests.get(img_url, timeout=10)
             if response.status_code == 200:
                 return Image.open(io.BytesIO(response.content))
-            else:
-                logger.error(f"Failed to get image from URL: {response.status_code}")
-        except Exception as e:
-            logger.error(f"Error capturing image from URL: {e}")
-    else:
-        raise Exception("url is 'N/A'")
-
-
-def update_print_status():
-    global latest_data
-    return (
-        latest_data["status"],
-        latest_data["nozzle_temperature"],
-        latest_data["bed_temperature"],
-        latest_data["update_time"],
-        latest_data.get("progress", 0),
-        latest_data.get("message", ""),
-    )
-
-
-def health_check():
-    status = {
-        "app": "running",
-        "time": time.strftime("%Y-%m-%d %H:%M:%S"),
-        "bambu_mqtt_connected": bambu_client is not None,
-        "rpi_mqtt_connected": rpi_client is not None,
-        "latest_update": latest_data["update_time"],
-    }
-    logger.info(f"Health check: {status}")
-    return status
-
-
-demo = gr.Blocks(title="Bambu A1 Mini Print Control")
-
-with demo:
-    gr.Markdown("# Bambu A1 Mini Print Control")
-
-    with gr.Row():
-        refresh_btn = gr.Button("Refresh Status")
-
-    with gr.Row():
-        current_status = gr.Textbox(
-            label="Printer Status", value="N/A", interactive=False
-        )
-        current_bed_temp = gr.Textbox(
-            label="Current Bed Temperature", value="N/A", interactive=False
-        )
-        current_nozzle_temp = gr.Textbox(
-            label="Current Nozzle Temperature", value="N/A", interactive=False
-        )
-        last_update = gr.Textbox(label="Last Update", value="N/A", interactive=False)
-
-    with gr.Row():
-        # Left column for image and capture button
-        with gr.Column(scale=2):
-            captured_image = gr.Image(label="Current Print Image", type="pil")
-            capture_btn = gr.Button("Capture Image")
-
-        # Right column for queue status and livestream
-        with gr.Column(scale=1):
-            gr.Markdown("### YouTube Livestream")
-            iframe_html = """
-            <div style="position: relative; width: 100%; padding-top: 56.25%;">
-                <iframe 
-                    style="position: absolute; top: 0; left: 0; width: 100%; height: 100%;" 
-                    src="https://www.youtube.com/embed/ZzYOO6y6cJU" 
-                    title="Bambu A1mini Livestream" 
-                    frameborder="0" 
-                    allow="accelerometer; autoplay; clipboard-write; encrypted-media; gyroscope; picture-in-picture; web-share" 
-                    referrerpolicy="strict-origin-when-cross-origin" 
-                    allowfullscreen>
-                </iframe>
-            </div>
-            """
-            gr.HTML(iframe_html)
+        return None
+    except Exception:
+        print("Image capture failed:")
+        traceback.print_exc()
+        return None
 
-    with gr.Row():
-        with gr.Column():
-            nozzle_temp = gr.Slider(
-                minimum=180,
-                maximum=250,
-                step=1,
-                value=200,
-                label="Nozzle Temperature (°C)",
-            )
-            bed_temp = gr.Slider(
-                minimum=40, maximum=100, step=1, value=60, label="Bed Temperature (°C)"
-            )
-            print_speed = gr.Slider(
-                minimum=20, maximum=150, step=1, value=60, label="Print Speed (mm/s)"
-            )
-            fan_speed = gr.Slider(
-                minimum=0, maximum=100, step=1, value=100, label="Fan Speed (%)"
-            )
 
-            send_params_btn = gr.Button("Send Print Parameters")
+with gr.Blocks(title="Simplified Printer Control") as demo:
+    status = gr.Textbox(label="Status")
+    bed_temp = gr.Textbox(label="Bed Temperature")
+    nozzle_temp = gr.Textbox(label="Nozzle Temperature")
+    update_time = gr.Textbox(label="Last Update")
+    image_display = gr.Image(label="Captured Image", type="pil")
 
-    refresh_btn.click(
-        fn=get_data,
-        outputs=[current_status, current_bed_temp, current_nozzle_temp, last_update],
+    nozzle_input = gr.Slider(
+        label="Nozzle Temperature", minimum=180, maximum=250, value=200
     )
+    bed_input = gr.Slider(label="Bed Temperature", minimum=40, maximum=100, value=60)
+    speed_input = gr.Slider(label="Print Speed", minimum=20, maximum=150, value=60)
+    fan_input = gr.Slider(label="Fan Speed", minimum=0, maximum=100, value=100)
 
-    capture_btn.click(
-        fn=lambda: gr.update(interactive=False), outputs=capture_btn
-    ).then(fn=capture_image, outputs=[captured_image]).then(
-        fn=lambda: gr.update(interactive=True), outputs=capture_btn
-    )
+    refresh = gr.Button("Refresh")
+    refresh.click(fn=get_status, outputs=[status, bed_temp, nozzle_temp, update_time])
 
-    def api_send_print_parameters(
-        nozzle_temp=200, bed_temp=60, print_speed=60, fan_speed=100
-    ):
-        """API endpoint to send print parameters to the Bambu printer via RPI MQTT"""
-        global is_first_load
-    
-        # if the application just started, skip the actual operation
-        if is_first_load:
-            logger.info("First load detected, skipping automatic parameter sending")
-            is_first_load = False
-            return "Ready to send parameters. Click 'Submit' to send."
-        
-        # the original function, only execute when the user explicitly requests it
-        return send_print_parameters(nozzle_temp, bed_temp, print_speed, fan_speed)
+    capture_btn = gr.Button("Capture Image")
+    capture_btn.click(fn=capture_image, outputs=image_display)
 
+    send_params_btn = gr.Button("Send Parameters")
     send_params_btn.click(
-        fn=api_send_print_parameters,
-        inputs=[nozzle_temp, bed_temp, print_speed, fan_speed],
-        outputs=[current_status],
-    )
-
-    def api_get_data():
-        logger.info("API call: get_data")
-        return get_data()
-
-    def api_capture_frame(url=None):
-        logger.info(f"API call: capture_frame with URL: {url}")
-
-        try:
-            img = capture_image(url)
-            if img:
-                if img.mode == "RGBA":
-                    img = img.convert("RGB")
-
-                buffered = io.BytesIO()
-                img.save(buffered, format="JPEG")
-                img_str = base64.b64encode(buffered.getvalue()).decode()
-
-                return {"success": True, "image": img_str}
-            else:
-                return {"success": False, "error": "Failed to capture image"}
-        except Exception as e:
-            logger.error(f"Error in capture_frame: {e}")
-            return {"success": False, "error": str(e)}
-
-    def api_lambda(
-        img_data=None,
-        param_1=200,
-        param_2=60,
-        param_3=60,
-        param_4=100,
-    ):
-        logger.info(
-            f"API call: lambda with params: {param_1}, {param_2}, {param_3}, {param_4}"
-        )
-        try:
-            img = None
-
-            if (
-                img_data
-                and isinstance(img_data, str)
-                and (img_data.startswith("http://") or img_data.startswith("https://"))
-            ):
-                logger.info(f"Lambda received image URL: {img_data}")
-                img = capture_image(img_data)
-
-            elif img_data and isinstance(img_data, str):
-                try:
-                    logger.info("Lambda received base64 image data")
-                    img_bytes = base64.b64decode(img_data)
-                    img = Image.open(io.BytesIO(img_bytes))
-                except Exception as e:
-                    logger.error(f"Failed to decode base64 image: {e}")
-
-            if img:
-                img_array = np.array(img)
-
-                quality_level = "low"
-                if 190 <= param_1 <= 210 and param_3 <= 50 and param_4 >= 80:
-                    quality_level = "high"
-                elif 185 <= param_1 <= 215 and param_3 <= 70 and param_4 >= 60:
-                    quality_level = "medium"
-
-                if quality_level == "high":
-                    missing_rate = 0.02
-                    excess_rate = 0.01
-                    stringing_rate = 0.01
-                elif quality_level == "medium":
-                    missing_rate = 0.05
-                    excess_rate = 0.03
-                    stringing_rate = 0.02
-                else:  # low
-                    missing_rate = 0.10
-                    excess_rate = 0.07
-                    stringing_rate = 0.05
-
-                uniformity_score = 1.0 - (missing_rate + excess_rate + stringing_rate)
-
-                print_quality_score = 1.0 - (
-                    missing_rate * 2.0 + excess_rate * 1.5 + stringing_rate * 1.0
-                )
-                print_quality_score = max(0, min(1, print_quality_score))
-
-                print_speed_score = param_3 / 150.0
-                print_speed_score = max(0, min(1, print_speed_score))
-
-                material_efficiency_score = 1.0 - excess_rate * 3.0
-                material_efficiency_score = max(0, min(1, material_efficiency_score))
-
-                total_performance_score = (
-                    0.5 * print_quality_score
-                    + 0.3 * print_speed_score
-                    + 0.2 * material_efficiency_score
-                )
-
-                img_draw = img.copy()
-                draw = ImageDraw.Draw(img_draw)
-                draw.text(
-                    (10, 10), f"Quality: {quality_level.upper()}", fill=(255, 0, 0)
-                )
-                draw.text((10, 30), f"Missing: {missing_rate:.2f}", fill=(255, 0, 0))
-                draw.text((10, 50), f"Excess: {excess_rate:.2f}", fill=(255, 0, 0))
-                draw.text(
-                    (10, 70), f"Stringing: {stringing_rate:.2f}", fill=(255, 0, 0)
-                )
-
-                result = {
-                    "success": True,
-                    "missing_rate": missing_rate,
-                    "excess_rate": excess_rate,
-                    "stringing_rate": stringing_rate,
-                    "uniformity_score": uniformity_score,
-                    "print_quality_score": print_quality_score,
-                    "print_speed_score": print_speed_score,
-                    "material_efficiency_score": material_efficiency_score,
-                    "total_performance_score": total_performance_score,
-                }
-
-                if img_draw.mode == "RGBA":
-                    img_draw = img_draw.convert("RGB")
-
-                buffered = io.BytesIO()
-                img_draw.save(buffered, format="JPEG")
-                img_str = base64.b64encode(buffered.getvalue()).decode()
-                result["image"] = img_str
-
-                return result
-            else:
-                return {"success": False, "error": "Failed to get image"}
-        except Exception as e:
-            logger.error(f"Error in lambda: {e}")
-            return {"error": str(e)}
-
-
-    api_json_output = gr.JSON()
-    api_text_output = gr.Textbox()
-
-    capture_frame_api = demo.load(
-        fn=api_capture_frame,
-        inputs=[gr.Text(label="Camera URL (Optional)")],
-        outputs=[gr.Image(label="Captured Frame"), gr.JSON()],
-        api_name="capture_frame"
-    )
-
-    lambda_api = demo.load(
-        fn=api_lambda,
-        inputs=[
-            gr.Image(label="Image Data"),
-            gr.Number(label="Nozzle Temperature", value=200),
-            gr.Number(label="Bed Temperature", value=60),
-            gr.Number(label="Print Speed", value=60),
-            gr.Number(label="Fan Speed", value=100),
-        ],
-        outputs=[gr.Image(label="Visualization"), gr.JSON()],
-        api_name="lambda"
-    )
-
-    get_data_api = demo.load(
-        fn=api_get_data,
-        inputs=[],
-        outputs=gr.JSON(),
-        api_name="get_data"
-    )
-
-    send_params_api = demo.load(
-        fn=api_send_print_parameters,
-        inputs=[
-            gr.Number(label="Nozzle Temperature", value=200),
-            gr.Number(label="Bed Temperature", value=60),
-            gr.Number(label="Print Speed", value=60),
-            gr.Number(label="Fan Speed", value=100),
-        ],
-        outputs=api_text_output,
-        api_name="send_print_parameters"
-    )
-
-    get_status_api = demo.load(
-        fn=update_print_status,
-        inputs=[],
-        outputs=[
-            gr.Textbox(label="Status"),
-            gr.Textbox(label="Nozzle Temperature"),
-            gr.Textbox(label="Bed Temperature"),
-            gr.Textbox(label="Update Time"),
-            gr.Number(label="Progress"),
-            gr.Textbox(label="Message"),
-        ],
-        api_name="get_status"
-    )
-
-    health_check_api = demo.load(
-        fn=health_check,
-        inputs=[],
-        outputs=gr.JSON(),
-        api_name="health_check"
+        fn=send_print_parameters,
+        inputs=[nozzle_input, bed_input, speed_input, fan_input],
+        outputs=status,
     )
 
 if __name__ == "__main__":
-    logger.info("Starting Bambu A1 Mini Print Control application")
-
-    try:
-        logger.info("Initializing Bambu MQTT client")
-        create_client("bambu")
-    except Exception as e:
-        logger.error(f"Failed to initialize Bambu MQTT: {e}")
-
-    try:
-        logger.info("Initializing RPI MQTT client")
-        create_client("rpi")
-    except Exception as e:
-        logger.error(f"Failed to initialize RPI MQTT: {e}")
-
-    demo.queue().launch(
-        show_error=True, share=False, server_name="0.0.0.0", server_port=7860
-    )
+    print("App initializing...")
+    threading.Thread(target=main_logic, daemon=True).start()
+    demo.launch()