Update app.py

app.py

@@ -1,413 +1,138 @@
-import gradio as gr
+from flask import Flask, request, jsonify
+from transformers import pipeline
 import pandas as pd
-import matplotlib.pyplot as plt
-import numpy as np
-import io
 from datetime import datetime, timedelta
-import sys
-import traceback
+import json
 
-# Try to import fpdf2, but allow the app to run without it
-try:
-    from fpdf2 import FPDF
-    FPDF_AVAILABLE = True
-    print("FPDF2 successfully loaded.")  # Debug log to confirm fpdf2 installation
-except ImportError:
-    FPDF_AVAILABLE = False
-    FPDF = None
-    print("FPDF2 not installed. PDF download feature will be disabled.")
+app = Flask(__name__)
 
-# Check library versions for debugging
-debug_msg = "Library Versions:\n"
-try:
-    debug_msg += f"Python: {sys.version}\n"
-    debug_msg += f"Gradio: {gr.__version__}\n"
-    debug_msg += f"Pandas: {pd.__version__}\n"
-    debug_msg += f"Matplotlib: {matplotlib.__version__}\n"
-    debug_msg += f"NumPy: {np.__version__}\n"
-    if FPDF_AVAILABLE:
-        debug_msg += f"FPDF2: {FPDF.__version__}\n"
-    else:
-        debug_msg += "FPDF2: Not installed (PDF download feature disabled)\n"
-except Exception as e:
-    debug_msg += f"Error checking library versions: {str(e)}\n"
+# Initialize Hugging Face summarization pipeline
+summarizer = pipeline("text2text-generation", model="t5-small")
 
-# Global DataFrame to store the CSV data
-df = pd.DataFrame()
-
-def upload_csv(file):
-    global df
-    debug_msg_local = debug_msg + "\nStarting CSV upload process...\n"
+# Helper function to calculate days until AMC expiry
+def days_until_expiry(expiry_date_str):
     try:
-        if file is None:
-            debug_msg_local += "No file uploaded. Please upload a CSV file.\n"
-            print(debug_msg_local)  # Log to console for debugging
-            return ["All"], ["All"], ["All"], debug_msg_local, "All", "All", "All", None, None, None, None
-        
-        # Read the CSV file with encoding handling
-        debug_msg_local += "Reading CSV file...\n"
-        try:
-            df = pd.read_csv(file, encoding='utf-8')
-        except UnicodeDecodeError:
-            debug_msg_local += "Error: CSV file encoding is not UTF-8. Trying latin1 encoding...\n"
-            df = pd.read_csv(file, encoding='latin1')
-        except Exception as e:
-            debug_msg_local += f"Error reading CSV file: {str(e)}\n{traceback.format_exc()}\n"
-            print(debug_msg_local)
-            return ["All"], ["All"], ["All"], debug_msg_local, "All", "All", "All", None, None, None, None
-        
-        if df.empty:
-            debug_msg_local += "The uploaded CSV file is empty.\n"
-            print(debug_msg_local)
-            return ["All"], ["All"], ["All"], debug_msg_local, "All", "All", "All", None, None, None, None
-        
-        # Debug: Show the CSV column names (limit verbosity)
-        debug_msg_local += f"CSV Columns: {', '.join(df.columns)}\n"
-        
-        # Define required columns
-        required_columns = {'DeviceID', 'Lab', 'Type', 'Timestamp', 'Status', 'UsageCount'}
-        if not required_columns.issubset(df.columns):
-            missing_cols = required_columns - set(df.columns)
-            debug_msg_local += f"Error: CSV is missing required columns: {', '.join(missing_cols)}\n"
-            print(debug_msg_local)
-            return ["All"], ["All"], ["All"], debug_msg_local, "All", "All", "All", None, None, None, None
-        
-        # Debug: Check data types and sample values (limit to 5 rows)
-        debug_msg_local += f"Data Types:\n{df.dtypes.to_string()}\n"
-        debug_msg_local += f"Sample Values (first 5 rows):\n{df.head(5).to_string()}\n"
-        
-        # Check for empty or all-NaN columns
-        if df['Lab'].dropna().empty:
-            debug_msg_local += "Error: Lab column is empty or contains only NaN values.\n"
-        if df['Type'].dropna().empty:
-            debug_msg_local += "Error: Type column is empty or contains only NaN values.\n"
-        if df['Lab'].dropna().empty or df['Type'].dropna().empty:
-            print(debug_msg_local)
-            return ["All"], ["All"], ["All"], debug_msg_local, "All", "All", "All", None, None, None, None
-        
-        # Convert Timestamp to datetime with a specific format and fallback
-        debug_msg_local += "Converting Timestamp column...\n"
-        try:
-            # Try parsing with a common format first
-            df['Timestamp'] = pd.to_datetime(df['Timestamp'], format='%Y-%m-%d %H:%M:%S', errors='coerce')
-            # If parsing fails for some rows, try without a specific format
-            if df['Timestamp'].isna().any():
-                debug_msg_local += "Some timestamps failed to parse with format '%Y-%m-%d %H:%M:%S'. Falling back to generic parsing...\n"
-                df['Timestamp'] = pd.to_datetime(df['Timestamp'], errors='coerce')
-            timestamps_invalid = df['Timestamp'].isna().all()
-            if timestamps_invalid:
-                debug_msg_local += "Warning: All Timestamp values are invalid or unparseable. Date range filtering will be disabled.\n"
-        except Exception as e:
-            debug_msg_local += f"Error parsing Timestamp column: {str(e)}\n{traceback.format_exc()}\n"
-            print(debug_msg_local)
-            return ["All"], ["All"], ["All"], debug_msg_local, "All", "All", "All", None, None, None, None
-        
-        # Extract unique values for dropdowns
-        debug_msg_local += "Extracting unique values for dropdowns...\n"
-        labs = ['All'] + sorted([str(lab) for lab in df['Lab'].dropna().unique()])
-        types = ['All'] + sorted([str(v) for v in df['Type'].dropna().unique()])
-        debug_msg_local += f"Lab options: {', '.join(labs)}\nType options: {', '.join(types)}\n"
-        
-        # Extract date range for filter
-        if timestamps_invalid:
-            date_ranges = ['All']
-            debug_msg_local += "Date range dropdown disabled due to invalid timestamps.\n"
-        else:
-            min_date = df['Timestamp'].min()
-            max_date = df['Timestamp'].max()
-            if pd.isna(min_date) or pd.isna(max_date):
-                date_ranges = ['All']
-                debug_msg_local += "Warning: Could not determine date range due to invalid timestamps.\n"
-            else:
-                min_date_str = min_date.strftime('%Y-%m-%d')
-                max_date_str = max_date.strftime('%Y-%m-%d')
-                date_ranges = ['All', f"{min_date_str} to {max_date_str}"]
-                debug_msg_local += f"Date Range: {min_date_str} to {max_date_str}\n"
-        
-        # Automatically trigger filter_and_visualize after upload with default filters
-        debug_msg_local += "Triggering initial visualization with default filters...\n"
-        try:
-            device_cards, plot_daily, plot_uptime, anomaly_text, filter_msg = filter_and_visualize("All", "All", "All")
-            debug_msg_local += f"Initial Filter Result: {filter_msg}\n"
-        except Exception as e:
-            debug_msg_local += f"Initial Filter Error: {str(e)}\n{traceback.format_exc()}\n"
-            device_cards, plot_daily, plot_uptime, anomaly_text = None, None, None, None
-        
-        # Truncate debug message to prevent Gradio rendering issues
-        debug_msg_local = debug_msg_local[:5000]  # Limit to 5000 characters
-        print(debug_msg_local)
-        return labs, types, date_ranges, debug_msg_local, "All", "All", "All", device_cards, plot_daily, plot_uptime, anomaly_text
-    except Exception as e:
-        debug_msg_local += f"Failed to process CSV: {str(e)}\n{traceback.format_exc()}\n"
-        debug_msg_local = debug_msg_local[:5000]  # Limit to 5000 characters
-        print(debug_msg_local)
-        return ["All"], ["All"], ["All"], debug_msg_local, "All", "All", "All", None, None, None, None
+        expiry_date = datetime.strptime(expiry_date_str, "%Y-%m-%d")
+        current_date = datetime.now()
+        return (expiry_date - current_date).days
+    except ValueError:
+        return None
 
-def filter_and_visualize(selected_lab, selected_type, selected_date_range):
-    global df
-    error_msg = "Starting filter and visualize process...\n"
-    try:
-        if df.empty:
-            error_msg += "No data available.\n"
-            print(error_msg)
-            return None, None, None, None, error_msg
-        
-        # Debug: Log the filter parameters
-        error_msg += f"Applying filters: Lab={selected_lab}, Type={selected_type}, Date Range={selected_date_range}\n"
-        
-        # Filter the DataFrame
-        filtered_df = df.copy()
-        error_msg += f"Initial DataFrame: {len(filtered_df)} rows\n"
-        
-        if selected_lab != "All":
-            filtered_df = filtered_df[filtered_df["Lab"] == selected_lab]
-            error_msg += f"After Lab filter ({selected_lab}): {len(filtered_df)} rows\n"
-        if selected_type != "All":
-            filtered_df = filtered_df[filtered_df["Type"] == selected_type]
-            error_msg += f"After Type filter ({selected_type}): {len(filtered_df)} rows\n"
-        if selected_date_range != "All" and selected_date_range != "No data available." and not df['Timestamp'].isna().all():
-            try:
-                start_date, end_date = selected_date_range.split(" to ")
-                start_date = pd.to_datetime(start_date)
-                end_date = pd.to_datetime(end_date) + timedelta(days=1)  # Include end date
-                filtered_df = filtered_df[(filtered_df["Timestamp"] >= start_date) & (filtered_df["Timestamp"] < end_date)]
-                error_msg += f"After Date Range filter ({start_date} to {end_date}): {len(filtered_df)} rows\n"
-            except Exception as e:
-                error_msg += f"Error parsing date range: {str(e)}\n{traceback.format_exc()}\n"
-        
-        if filtered_df.empty:
-            error_msg += "No data matches the selected filters.\n"
-            print(error_msg)
-            return None, None, None, None, error_msg
-        
-        # Debug: Log the filtered DataFrame (limit verbosity)
-        error_msg += f"Filtered DataFrame (first 5 rows):\n{filtered_df.head(5).to_string()}\n"
-        
-        # Device Cards (as a table)
-        device_cards = filtered_df[['DeviceID', 'Lab', 'Type', 'UsageCount', 'Timestamp']].sort_values(by='Timestamp', ascending=False)
-        
-        # Daily Log Trends (Line Chart)
-        try:
-            if df['Timestamp'].isna().all():
-                error_msg += "Warning: All timestamps are invalid. Skipping Daily Log Trends.\n"
-                plt.figure(figsize=(8, 4))
-                plt.title("Daily Log Trends - No Data (Invalid Timestamps)")
-                plt.xlabel("Date")
-                plt.ylabel("Number of Logs")
-                plot_daily = io.BytesIO()
-                plt.savefig(plot_daily, format="png", bbox_inches="tight")
-                plt.close()
-                plot_daily.seek(0)
-            else:
-                daily_logs = filtered_df.groupby(filtered_df['Timestamp'].dt.date).size()
-                if daily_logs.empty:
-                    error_msg += "Warning: No data for Daily Log Trends.\n"
-                    plt.figure(figsize=(8, 4))
-                    plt.title("Daily Log Trends - No Data")
-                    plt.xlabel("Date")
-                    plt.ylabel("Number of Logs")
-                    plot_daily = io.BytesIO()
-                    plt.savefig(plot_daily, format="png", bbox_inches="tight")
-                    plt.close()
-                    plot_daily.seek(0)
-                else:
-                    plt.figure(figsize=(8, 4))
-                    daily_logs.plot(kind='line', marker='o', color='blue')
-                    plt.title("Daily Log Trends")
-                    plt.xlabel("Date")
-                    plt.ylabel("Number of Logs")
-                    plt.xticks(rotation=45)
-                    plot_daily = io.BytesIO()
-                    plt.savefig(plot_daily, format="png", bbox RACinches="tight")
-                    plt.close()
-                    plot_daily.seek(0)
-        except Exception as e:
-            error_msg += f"Error generating Daily Log Trends: {str(e)}\n{traceback.format_exc()}\n"
-            plt.figure(figsize=(8, 4))
-            plt.title("Daily Log Trends - Error")
-            plt.xlabel("Date")
-            plt.ylabel("Number of Logs")
-            plot_daily = io.BytesIO()
-            plt.savefig(plot_daily, format="png", bbox_inches="tight")
-            plt.close()
-            plot_daily.seek(0)
-        
-        # Weekly Uptime % (Bar Chart)
-        try:
-            if df['Timestamp'].isna().all():
-                error_msg += "Warning: All timestamps are invalid. Skipping Weekly Uptime.\n"
-                plt.figure(figsize=(8, 4))
-                plt.title("Weekly Uptime % - No Data (Invalid Timestamps)")
-                plt.xlabel("Date")
-                plt.ylabel("Uptime %")
-                plot_uptime = io.BytesIO()
-                plt.savefig(plot_uptime, format="png", bbox_inches="tight")
-                plt.close()
-                plot_uptime.seek(0)
-            else:
-                end_date = filtered_df['Timestamp'].max()
-                start_date = end_date - timedelta(days=7)
-                weekly_df = filtered_df[(filtered_df['Timestamp'] >= start_date) & (filtered_df['Timestamp'] <= end_date)]
-                if weekly_df.empty:
-                    error_msg += "Warning: No data for Weekly Uptime % (date range too narrow).\n"
-                    plt.figure(figsize=(8, 4))
-                    plt.title("Weekly Uptime % - No Data")
-                    plt.xlabel("Date")
-                    plt.ylabel("Uptime %")
-                    plot_uptime = io.BytesIO()
-                    plt.savefig(plot_uptime, format="png", bbox_inches="tight")
-                    plt.close()
-                    plot_uptime.seek(0)
-                else:
-                    uptime = weekly_df.groupby(weekly_df['Timestamp'].dt.date)['Status'].apply(lambda x: (x == 'Up').mean() * 100)
-                    plt.figure(figsize=(8, 4))
-                    uptime.plot(kind='bar', color='green')
-                    plt.title("Weekly Uptime %")
-                    plt.xlabel("Date")
-                    plt.ylabel("Uptime %")
-                    plt.xticks(rotation=45)
-                    plot_uptime = io.BytesIO()
-                    plt.savefig(plot_uptime, format="png", bbox_inches="tight")
-                    plt.close()
-                    plot_uptime.seek(0)
-        except Exception as e:
-            error_msg += f"Error generating Weekly Uptime %: {str(e)}\n{traceback.format_exc()}\n"
-            plt.figure(figsize=(8, 4))
-            plt.title("Weekly Uptime % - Error")
-            plt.xlabel("Date")
-            plt.ylabel("Uptime %")
-            plot_uptime = io.BytesIO()
-            plt.savefig(plot_uptime, format="png", bbox_inches="tight")
-            plt.close()
-            plot_uptime.seek(0)
-        
-        # Anomaly Alerts (Text)
-        try:
-            anomalies = filtered_df[(filtered_df['UsageCount'] > 80) | (filtered_df['Status'] == 'Down')]
-            if anomalies.empty:
-                anomaly_text = "No anomalies detected."
-            else:
-                anomaly_text = "Anomalies Detected:\n" + anomalies[['DeviceID', 'Lab', 'Type', 'Status', 'UsageCount']].to_string(index=False)
-        except Exception as e:
-            error_msg += f"Error generating Anomaly Alerts: {str(e)}\n{traceback.format_exc()}\n"
-            anomaly_text = "Error generating anomaly alerts."
-        
-        error_msg = error_msg[:5000]  # Limit to 5000 characters
-        print(error_msg)
-        return device_cards, plot_daily, plot_uptime, anomaly_text, f"{error_msg}Filters applied successfully."
-    except Exception as e:
-        error_msg += f"Unexpected error in filter_and_visualize: {str(e)}\n{traceback.format_exc()}\n"
-        plt.figure(figsize=(8, 4))
-        plt.title("Daily Log Trends - Error")
-        plt.xlabel("Date")
-        plt.ylabel("Number of Logs")
-        plot_daily = io.BytesIO()
-        plt.savefig(plot_daily, format="png", bbox_inches="tight")
-        plt.close()
-        plot_daily.seek(0)
-        
-        plt.figure(figsize=(8, 4))
-        plt.title("Weekly Uptime % - Error")
-        plt.xlabel("Date")
-        plt.ylabel("Uptime %")
-        plot_uptime = io.BytesIO()
-        plt.savefig(plot_uptime, format="png", bbox_inches="tight")
-        plt.close()
-        plot_uptime.seek(0)
-        
-        error_msg = error_msg[:5000]  # Limit to 5000 characters
-        print(error_msg)
-        return None, plot_daily, plot_uptime, "Error generating anomaly alerts.", error_msg
+# Helper function to detect anomalies (rule-based)
+def detect_anomalies(logs):
+    anomalies = []
+    for log in logs:
+        # Rule 1: Flag ERROR status as high severity
+        if log["status"] == "ERROR":
+            anomalies.append({
+                "device_id": log["device_id"],
+                "issue": "ERROR status detected",
+                "detected_on": log["timestamp"],
+                "severity": "high"
+            })
+        # Rule 2: Flag usage spikes (>7 hours as example threshold)
+        if log["usage_hours"] > 7:
+            anomalies.append({
+                "device_id": log["device_id"],
+                "issue": "Usage spike",
+                "detected_on": log["timestamp"],
+                "severity": "high"
+            })
+        # Rule 3: Flag downtime (usage_hours = 0 with DOWN status)
+        if log["status"] == "DOWN" and log["usage_hours"] == 0:
+            anomalies.append({
+                "device_id": log["device_id"],
+                "issue": "Unplanned downtime",
+                "detected_on": log["timestamp"],
+                "severity": "medium"
+            })
+    return anomalies
+
+# Helper function to generate AMC reminders
+def generate_amc_reminders(logs):
+    reminders = []
+    for log in logs:
+        days_left = days_until_expiry(log["amc_expiry"])
+        if days_left is not None and 0 < days_left <= 30:
+            reminders.append({
+                "device_id": log["device_id"],
+                "amc_expiry": log["amc_expiry"],
+                "days_remaining": days_left,
+                "alert": f"AMC expires in {days_left} days"
+            })
+    return reminders
+
+# Helper function to summarize logs
+def summarize_logs(logs, prompt):
+    # Convert logs to text for summarization
+    log_text = "\n".join([f"Device {log['device_id']} ({log['log_type']}): Status {log['status']}, Usage {log['usage_hours']} hours, Timestamp {log['timestamp']}, AMC Expiry {log['amc_expiry']}" for log in logs])
+    input_text = f"{prompt}\n\nLogs:\n{log_text}"
+    
+    # Use Hugging Face summarizer
+    summary = summarizer(input_text, max_length=150, min_length=50, do_sample=False)[0]["generated_text"]
+    return summary
 
-def download_pdf(selected_lab, selected_type, selected_date_range):
-    global df
+# API endpoint to process logs
+@app.route("/process-logs", methods=["POST"])
+def process_logs():
     try:
-        if not FPDF_AVAILABLE:
-            print("PDF download feature disabled: fpdf2 module not installed.")
-            return None
-        
-        if df.empty:
-            return None
-        
-        filtered_df = df.copy()
-        if selected_lab != "All":
-            filtered_df = filtered_df[filtered_df["Lab"] == selected_lab]
-        if selected_type != "All":
-            filtered_df = filtered_df[filtered_df["Type"] == selected_type]
-        if selected_date_range != "All" and selected_date_range != "No data available." and not df['Timestamp'].isna().all():
-            start_date, end_date = selected_date_range.split(" to ")
-            start_date = pd.to_datetime(start_date)
-            end_date = pd.to_datetime(end_date) + timedelta(days=1)
-            filtered_df = filtered_df[(filtered_df["Timestamp"] >= start_date) & (filtered_df["Timestamp"] < end_date)]
-        
-        if filtered_df.empty:
-            return None
-        
-        pdf = FPDF()
-        pdf.add_page()
-        pdf.set_font("Arial", size=12)
-        pdf.cell(200, 10, txt="LabOps Dashboard Report", ln=True, align='C')
-        pdf.ln(10)
-        
-        for index, row in filtered_df.iterrows():
-            line = f"{row['Timestamp']} | {row['DeviceID']} | {row['Lab']} | {row['Type']} | {row['Status']} | {row['UsageCount']}"
-            pdf.multi_cell(0, 10, txt=line)
-        
-        output = io.BytesIO()
-        pdf.output(output)
-        output.seek(0)
-        return output
-    except Exception as e:
-        print(f"Error in download_pdf: {str(e)}\n{traceback.format_exc()}")
-        return None
+        data = request.get_json()
+        logs = data.get("logs", [])
+        prompt = data.get("prompt", "Summarize downtime and usage patterns for SmartLab-1 from May 1 to May 14")
 
-# Build the Gradio interface
-try:
-    with gr.Blocks() as demo:
-        gr.Markdown("🧪 **Multi-Device LabOps Dashboard**\nMonitor smart lab devices, visualize logs, and generate PDF reports.")
+        if not logs:
+            return jsonify({"error": "No logs provided"}), 400
 
-        with gr.Row():
-            csv_input = gr.File(label="Upload Device Logs CSV", file_types=[".csv"])
-        
-        with gr.Row():
-            lab_dropdown = gr.Dropdown(label="Filter by Lab", choices=["All"], value="All")
-            type_dropdown = gr.Dropdown(label="Filter by Equipment Type", choices=["All"], value="All")
-            date_dropdown = gr.Dropdown(label="Filter by Date Range", choices=["All"], value="All")
+        # Convert logs to DataFrame for analysis
+        df = pd.DataFrame(logs)
+        
+        # Calculate summary metrics
+        total_devices = len(df["device_id"].unique())
+        avg_uptime = len(df[df["status"] == "OK"]) / len(df) * 100 if len(df) > 0 else 0
+        downtime_events = len(df[df["status"] == "DOWN"])
+        most_used_device = df.groupby("device_id")["usage_hours"].sum().idxmax() if not df.empty else "N/A"
 
-        with gr.Row():
-            submit_btn = gr.Button("Submit Filters")
+        # Generate outputs
+        summary = {
+            "total_devices": total_devices,
+            "avg_uptime": f"{avg_uptime:.1f}%",
+            "downtime_events": downtime_events,
+            "most_used_device": most_used_device
+        }
+        anomalies = detect_anomalies(logs)
+        amc_reminders = generate_amc_reminders(logs)
+        text_summary = summarize_logs(logs, prompt)
 
-        with gr.Row():
-            device_cards = gr.DataFrame(label="Device Cards (Usage, Last Log)")
-            plot_daily = gr.Image(label="Daily Log Trends")
-            plot_uptime = gr.Image(label="Weekly Uptime %")
+        # Generate maintenance report
+        report = f"""
+SmartLab-1 Maintenance Report (May 1–14, 2025)
+Generated on: {datetime.now().strftime('%Y-%m-%d')}
 
-        anomaly_output = gr.Textbox(label="Anomaly Alerts")
-        
-        with gr.Row():
-            download_btn = gr.Button("Download PDF Report", visible=True)  # Always visible since fpdf2 should be installed
-        
-        error_box = gr.Textbox(label="Status/Error Message", visible=True, interactive=False)
+1. Summary
+Total Devices: {total_devices}
+Average Uptime: {avg_uptime:.1f}%
+Downtime Events: {downtime_events}
+Most Used Device: {most_used_device}
 
-        # Connect the components
-        csv_input.change(
-            fn=upload_csv,
-            inputs=csv_input,
-            outputs=[lab_dropdown, type_dropdown, date_dropdown, error_box, lab_dropdown, type_dropdown, date_dropdown, device_cards, plot_daily, plot_uptime, anomaly_output]
-        )
-        
-        submit_btn.click(
-            fn=filter_and_visualize,
-            inputs=[lab_dropdown, type_dropdown, date_dropdown],
-            outputs=[device_cards, plot_daily, plot_uptime, anomaly_output, error_box]
-        )
-        
-        download_btn.click(
-            fn=download_pdf,
-            inputs=[lab_dropdown, type_dropdown, date_dropdown],
-            outputs=gr.File(label="Download PDF")
-        )
+2. Anomalies Detected
+{chr(10).join([f"- {a['device_id']}: {a['issue']} on {a['detected_on']} ({a['severity']} severity)" for a in anomalies]) or "No anomalies detected"}
+
+3. AMC Alerts
+{chr(10).join([f"- {r['device_id']}: AMC expires on {r['amc_expiry']} ({r['days_remaining']} days remaining)" for r in amc_reminders]) or "No AMC expirations within 30 days"}
+
+4. AI-Generated Summary
+{text_summary}
+"""
+
+        return jsonify({
+            "summary": summary,
+            "anomalies": anomalies,
+            "amc_reminders": amc_reminders,
+            "maintenance_report": report
+        })
+
+    except Exception as e:
+        return jsonify({"error": str(e)}), 500
 
-    demo.launch()
-except Exception as e:
-    print(f"Error launching Gradio interface: {str(e)}\n{traceback.format_exc()}")
+if __name__ == "__main__":
+    app.run(debug=True, host="0.0.0.0", port=5000)