Update app.py

app.py

@@ -1,447 +1,113 @@
 import gradio as gr
 import pandas as pd
-import plotly.express as px
-from sklearn.ensemble import IsolationForest
-from reportlab.lib.pagesizes import letter
-from reportlab.pdfgen import canvas
-from transformers import pipeline
-import datetime
-import os
-import logging
-import re
-import numpy as np
-import torch
-import tempfile
-
-# Configure logging to track application events and errors
-logging.basicConfig(level=logging.INFO, format='%(asctime)s - %(levelname)s - %(message)s')
-logger = logging.getLogger(__name__)
-
-# Log versions of key dependencies for debugging
-logger.info(f"NumPy version: {np.__version__}")
-logger.info(f"Pandas version: {pd.__version__}")
-logger.info(f"PyTorch version: {torch.__version__}")
-logger.info(f"Gradio version: {gr.__version__}")
-
-# Initialize list to store log messages for UI display
-log_messages = []
-
-# Custom logging handler to capture logs for Gradio UI
-class UILogHandler(logging.Handler):
-    def emit(self, record):
-        log_entry = self.format(record)
-        log_messages.append(log_entry)
-
-ui_handler = UILogHandler()
-ui_handler.setFormatter(logging.Formatter('%(asctime)s - %(levelname)s - %(message)s'))
-logger.addHandler(ui_handler)
-
-# Initialize Hugging Face summarization model (BART) for generating summaries
-try:
-    summarizer = pipeline(
-        "summarization",
-        model="facebook/bart-large-cnn",
-        device=0 if torch.cuda.is_available() else -1,  # Use GPU if available
-        framework="pt"
-    )
-    logger.info("Hugging Face summarization pipeline initialized")
-except Exception as e:
-    logger.error(f"Failed to initialize Hugging Face pipeline: {e}")
-    summarizer = None
-
-# Global DataFrame to store logs data
-logs = pd.DataFrame()
-
-# Load and validate logs from uploaded CSV file
-def load_logs(logs_file):
-    global logs
-    try:
-        if logs_file is None:
-            logger.error("No logs CSV file uploaded")
-            return pd.DataFrame()
-        # Write uploaded file to a temporary CSV
-        with tempfile.NamedTemporaryFile(delete=False, suffix='.csv') as tmp:
-            tmp.write(logs_file.read())
-            tmp_path = tmp.name
-        logs = pd.read_csv(tmp_path)
-        os.unlink(tmp_path)  # Remove temporary file
-        # Define required columns; 'comments' is optional
-        required_columns = ['device_id', 'lab_id', 'timestamp', 'status', 'usage_count', 'type']
-        if not all(col in logs.columns for col in required_columns):
-            logger.error(f"Missing required columns in logs: {required_columns}")
-            return pd.DataFrame()
-        # Add 'comments' column if missing, filling with 'No comment'
-        if 'comments' not in logs.columns:
-            logs['comments'] = 'No comment'
-            logger.info("Added missing 'comments' column with default value 'No comment'")
-        # Convert timestamp to datetime and check for invalid entries
-        logs['timestamp'] = pd.to_datetime(logs['timestamp'], errors='coerce')
-        if logs['timestamp'].isna().any():
-            logger.error("Invalid timestamps detected in logs")
-            return pd.DataFrame()
-        logger.info("Logs loaded successfully from uploaded CSV")
-        return logs
-    except Exception as e:
-        logger.error(f"Error loading logs: {e}")
-        return pd.DataFrame()
-
-# Update dropdown menus based on uploaded CSV data
-def update_dropdowns(logs_file):
-    global logs
-    logs = load_logs(logs_file)
-    if logs.empty:
-        return (
-            gr.Dropdown(choices=[], value=None, label="Select Lab"),
-            gr.Dropdown(choices=[], value=None, label="Select Equipment Type"),
-            "<p style='color: red;'>Please upload a valid logs CSV file to proceed.</p>",
-            False  # Disable Generate Dashboard button
-        )
-    # Extract unique labs and equipment types, sorted for better UX
-    lab_choices = sorted(logs['lab_id'].unique().tolist())
-    equipment_choices = sorted(logs['type'].unique().tolist())
-    upload_status = "<p style='color: green;'>Logs loaded successfully.</p>"
-    return (
-        gr.Dropdown(choices=lab_choices, value=lab_choices[0] if lab_choices else None, label="Select Lab"),
-        gr.Dropdown(choices=equipment_choices, value=equipment_choices[0] if equipment_choices else None, label="Select Equipment Type"),
-        upload_status,
-        True  # Enable Generate Dashboard button
-    )
-
-# Detect anomalies using Isolation Forest
-def detect_anomalies(logs):
-    try:
-        if logs.empty:
-            logger.warning("No logs available for anomaly detection")
-            return logs
-        model = IsolationForest(contamination=0.1, random_state=42)
-        usage_data = logs[['usage_count']].copy()
-        logs['anomaly'] = model.fit_predict(usage_data)
-        logger.info("Anomaly detection completed")
-        return logs
-    except Exception as e:
-        logger.error(f"Error in anomaly detection: {e}")
-        return logs
-
-# Generate text summary including comments
-def generate_text_summary(logs):
-    if summarizer is None or logs.empty:
-        return "No summary available due to missing data or model initialization."
-    try:
-        log_text = "\n".join(
-            f"Device {row['device_id']} in lab {row['lab_id']} on {row['timestamp'].strftime('%Y-%m-%d %H:%M:%S')} "
-            f"was {row['status']} with usage count {row['usage_count']} (Type: {row['type']}). "
-            f"Comment: {row['comments']}"
-            for _, row in logs.iterrows()
-        )
-        summary = summarizer(log_text, max_length=150, min_length=40, do_sample=False)[0]['summary_text']
-        logger.info("Text summary generated successfully")
-        return summary
-    except Exception as e:
-        logger.error(f"Error generating text summary: {e}")
-        return f"Error generating summary: {str(e)}"
-
-# Generate executive insights including comments
-def generate_executive_insights(logs, anomalies):
-    if summarizer is None or logs.empty:
-        return "No executive insights available due to missing data or model initialization."
-    try:
-        log_text = "\n".join(
-            f"Device {row['device_id']} in lab {row['lab_id']} on {row['timestamp'].strftime('%Y-%m-%d %H:%M:%S')} "
-            f"was {row['status']} with usage count {row['usage_count']} (Type: {row['type']}). "
-            f"Comment: {row['comments']}"
-            for _, row in logs.iterrows()
-        )
-        anomaly_text = "\n".join(
-            f"Device {row['device_id']} showed anomalous usage count {row['usage_count']} on "
-            f"{row['timestamp'].strftime('%Y-%m-%d %H:%M:%S')}. Comment: {row['comments']}"
-            for _, row in anomalies.iterrows()
-        ) if not anomalies.empty else "No anomalies detected."
-        prompt = (
-            f"Summarize the following lab operations data into concise executive insights:\n\n"
-            f"Logs:\n{log_text}\n\n"
-            f"Anomalies:\n{anomaly_text}\n\n"
-            f"Provide high-level insights for lab managers, focusing on operational status, issues, and comments."
-        )
-        insights = summarizer(prompt, max_length=200, min_length=50, do_sample=False)[0]['summary_text']
-        logger.info("Executive insights generated successfully")
-        return insights
-    except Exception as e:
-        logger.error(f"Error generating executive insights: {e}")
-        return f"Error generating insights: {str(e)}"
-
-# Generate PDF report with summary, insights, and comments
-def generate_pdf(lab, equipment_type, filtered_logs, summary, insights):
-    try:
-        pdf_file = f"labops_report_{lab}_{equipment_type}_{datetime.datetime.now().strftime('%Y%m%d_%H%M%S')}.pdf"
-        c = canvas.Canvas(pdf_file, pagesize=letter)
-        c.setFont("Helvetica-Bold", 16)
-        c.drawString(100, 750, "LabOps Dashboard Report")
-        c.setFont("Helvetica", 12)
-        c.drawString(100, 730, f"Lab: {lab}, Equipment Type: {equipment_type}")
-        
-        # Add summary
-        c.setFont("Helvetica-Bold", 14)
-        c.drawString(100, 700, "Summary")
-        c.setFont("Helvetica", 12)
-        y = 680
-        for line in summary.split('\n'):
-            c.drawString(100, y, line[:80])
-            y -= 20
-            if y < 100:
-                c.showPage()
-                y = 750
-        
-        # Add executive insights
-        c.setFont("Helvetica-Bold", 14)
-        c.drawString(100, y, "Executive Insights")
-        c.setFont("Helvetica", 12)
-        y -= 20
-        for line in insights.split('\n'):
-            c.drawString(100, y, line[:80])
-            y -= 20
-            if y < 100:
-                c.showPage()
-                y = 750
-        
-        # Add device status with comments
-        c.setFont("Helvetica-Bold", 14)
-        c.drawString(100, y, "Device Status Summary")
-        c.setFont("Helvetica", 12)
-        y -= 20
-        for _, row in filtered_logs.iterrows():
-            c.drawString(100, y, f"Device: {row['device_id']}, Status: {row['status']}, "
-                                f"Usage: {row['usage_count']}, Comment: {row['comments'][:30]}")
-            y -= 20
-            if y < 100:
-                c.showPage()
-                y = 750
-        
-        c.save()
-        if not os.path.exists(pdf_file):
-            logger.error("PDF file was not created.")
-            return None
-        logger.info(f"PDF report generated: {pdf_file}")
-        return pdf_file
-    except Exception as e:
-        logger.error(f"Error generating PDF: {e}")
-        return None
-
-# Validate date format (YYYY-MM-DD)
-def validate_date(date_str):
-    pattern = r'^\d{4}-\d{2}-\d{2}$'
-    if not isinstance(date_str, str) or not re.match(pattern, date_str):
-        return False
-    try:
-        pd.to_datetime(date_str, format='%Y-%m-%d')
-        return True
-    except ValueError:
-        return False
-
-# Render the dashboard with filtered data
-def render_dashboard(lab, equipment_type, start_date, end_date):
-    try:
-        logger.info(f"Rendering dashboard with filters: lab={lab}, equipment_type={equipment_type}, "
-                    f"start_date={start_date}, end_date={end_date}")
-        # Validate inputs
-        if not lab or not equipment_type:
-            return (
-                "<p style='color: red;'>Please select both Lab and Equipment Type.</p>",
-                None, None, "<p style='color: red;'>Invalid input</p>",
-                None, "No summary available.", "No insights available.",
-                "\n".join(log_messages[-10:]) or "No logs available."
-            )
-        # Validate and adjust dates
-        if not validate_date(start_date):
-            logger.warning(f"Invalid start_date format: {start_date}. Using default 2025-05-01.")
-            start_date = "2025-05-01"
-        if not validate_date(end_date):
-            logger.warning(f"Invalid end_date format: {end_date}. Using default 2025-05-30.")
-            end_date = "2025-05-30"
-        start_dt = pd.to_datetime(start_date, format='%Y-%m-%d')
-        end_dt = pd.to_datetime(end_date, format='%Y-%m-%d')
-        if start_dt > end_dt:
-            logger.warning("start_date is after end_date. Swapping dates.")
-            start_dt, end_dt = end_dt, start_dt
-        # Filter logs by lab, equipment type, and date range
-        filtered_logs = logs[(logs['lab_id'] == lab) & (logs['type'] == equipment_type)]
-        filtered_logs = filtered_logs[
-            (filtered_logs['timestamp'] >= start_dt) &
-            (filtered_logs['timestamp'] <= end_dt)
-        ]
-        if filtered_logs.empty:
-            logger.warning("No data available for the selected filters")
-            return (
-                "<p style='color: orange;'>No devices found for the selected filters.</p>",
-                None, None, "<p>No anomalies detected.</p>",
-                None, "No summary available.", "No insights available.",
-                "\n".join(log_messages[-10:]) or "No logs available."
-            )
-        # Apply anomaly detection
-        filtered_logs = detect_anomalies(filtered_logs)
-        # Generate device cards for display
-        device_cards = "<div style='display: flex; flex-wrap: wrap; gap: 20px;'>"
-        for _, row in filtered_logs.iterrows():
-            status_color = "green" if row['status'] == "active" else "red"
-            device_cards += f"""
-                <div style='border: 1px solid #ccc; padding: 15px; margin: 10px; border-radius: 8px; width: 250px; background-color: #f9f9f9;'>
-                    <h3 style='margin: 0; font-size: 18px;'>Device: {row['device_id']}</h3>
-                    <p style='color: {status_color};'>Status: {row['status'].capitalize()}</p>
-                    <p>Usage Count: {row['usage_count']}</p>
-                    <p>Comment: {row['comments'][:30]}</p>
-                    <p>Last Log: {row['timestamp'].strftime('%Y-%m-%d %H:%M:%S')}</p>
-                </div>
-            """
-        device_cards += "</div>"
-        # Generate usage trend chart
-        fig_usage = px.line(
-            filtered_logs,
-            x='timestamp',
-            y='usage_count',
-            color='device_id',
-            title="Daily Usage Trends",
-            template="plotly_white"
-        ).update_layout(
-            xaxis_title="Timestamp",
-            yaxis_title="Usage Count",
-            margin=dict(l=20, r=20, t=40, b=20)
-        )
-        # Generate uptime chart
-        uptime = filtered_logs.groupby('device_id')['status'].apply(lambda x: (x == 'active').mean() * 100)
-        fig_uptime = px.bar(
-            uptime,
-            x=uptime.index,
-            y=uptime,
-            title="Weekly Uptime %",
-            template="plotly_white"
-        ).update_layout(
-            xaxis_title="Device ID",
-            yaxis_title="Uptime %",
-            margin=dict(l=20, r=20, t=40, b=20)
-        )
-        # Generate anomaly table
-        anomalies = filtered_logs[filtered_logs['anomaly'] == -1] if 'anomaly' in filtered_logs.columns else pd.DataFrame()
-        anomaly_table = anomalies[['device_id', 'timestamp', 'usage_count', 'comments']].to_html(
-            index=False,
-            classes="table table-striped",
-            border=0
-        ) if not anomalies.empty else "<p>No anomalies detected.</p>"
-        # Generate summary and insights
-        summary = generate_text_summary(filtered_logs)
-        insights = generate_executive_insights(filtered_logs, anomalies)
-        # Generate PDF report
-        pdf_data = generate_pdf(lab, equipment_type, filtered_logs, summary, insights)
-        # Display recent logs
-        logs_output = "\n".join(log_messages[-10:]) or "No logs available."
-        logger.info("Dashboard rendered successfully")
-        return (
-            device_cards,
-            fig_usage,
-            fig_uptime,
-            anomaly_table,
-            pdf_data,
-            summary,
-            insights,
-            logs_output
-        )
-    except Exception as e:
-        logger.error(f"Error rendering dashboard: {e}")
-        logs_output = "\n".join(log_messages[-10:]) or "No logs available."
-        return (
-            f"<p style='color: red;'>Error rendering dashboard: {str(e)}</p>",
-            None,
-            None,
-            "<p style='color: red;'>Error</p>",
-            None,
-            "Error generating summary.",
-            "Error generating insights.",
-            logs_output
-        )
-
-# Define Gradio interface
-with gr.Blocks(
-    css="""
-        .gradio-container {max-width: 1200px; margin: auto; padding: 20px;}
-        .table {width: 100%; border-collapse: collapse;}
-        .table th, .table td {padding: 8px; text-align: left;}
-        .table-striped tbody tr:nth-of-type(odd) {background-color: #f9f9f9;}
-        h1 {color: #2c3e50; text-align: center;}
-        .submit-btn {margin-top: 10px;}
-    """
-) as demo:
-    gr.Markdown("## LabOps Central Dashboard")
-    
-    # File Upload Section
-    with gr.Group():
-        gr.Markdown("### Upload Data File")
-        gr.Markdown("**Note**: Please upload a logs.csv file to proceed.")
-        logs_file = gr.File(label="Upload Logs CSV (Required)", file_types=[".csv"])
-        upload_btn = gr.Button("Load Data", variant="primary", elem_classes="submit-btn")
-        upload_status = gr.HTML(label="Upload Status")
-
-    # Filter Options
-    with gr.Group():
-        gr.Markdown("### Filter Options")
-        with gr.Row():
-            lab = gr.Dropdown(
-                choices=[],
-                label="Select Lab",
-                value=None,
-                interactive=True
-            )
-            equipment_type = gr.Dropdown(
-                choices=[],
-                label="Select Equipment Type",
-                value=None,
-                interactive=True
-            )
-        with gr.Row():
-            start_date = gr.Textbox(
-                label="Start Date (YYYY-MM-DD)",
-                value="2025-05-01",
-                placeholder="YYYY-MM-DD",
-                info="Enter date in YYYY-MM-DD format (e.g., 2025-05-01)"
-            )
-            end_date = gr.Textbox(
-                label="End Date (YYYY-MM-DD)",
-                value="2025-05-30",
-                placeholder="YYYY-MM-DD",
-                info="Enter date in YYYY-MM-DD format (e.g., 2025-05-30)"
-            )
-        submit_btn = gr.Button("Generate Dashboard", variant="primary", elem_classes="submit-btn", interactive=False)
-
-    # Output Section
-    with gr.Group():
-        gr.Markdown("### Dashboard Results")
-        with gr.Tabs():
-            with gr.Tab("Device Status"):
-                device_cards = gr.HTML(label="Device Status")
-            with gr.Tab("Usage Trends"):
-                usage_chart = gr.Plot(label="Usage Trends")
-            with gr.Tab("Uptime"):
-                uptime_chart = gr.Plot(label="Weekly Uptime %")
-            with gr.Tab("Anomaly Alerts"):
-                anomaly_table = gr.HTML(label="Anomaly Alerts")
-            with gr.Tab("Summary"):
-                summary_output = gr.Textbox(label="Log Summary", lines=5, interactive=False)
-            with gr.Tab("Executive Insights"):
-                insights_output = gr.Textbox(label="Executive Insights", lines=5, interactive=False)
-        pdf_download = gr.File(label="Download PDF Report")
-        log_display = gr.Textbox(label="Debug Logs", lines=10, interactive=False)
-    
-    # Connect upload button to dropdown update function
-    upload_btn.click(
-        fn=update_dropdowns,
-        inputs=[logs_file],
-        outputs=[lab, equipment_type, upload_status, submit_btn]
-    )
-    # Connect submit button to dashboard rendering
-    inputs = [lab, equipment_type, start_date, end_date]
-    outputs = [device_cards, usage_chart, uptime_chart, anomaly_table, pdf_download, summary_output, insights_output, log_display]
-    submit_btn.click(render_dashboard, inputs=inputs, outputs=outputs)
-
-# Launch Gradio app
-if __name__ == "__main__":
-    try:
-        demo.launch(server_name="0.0.0.0", server_port=7860, share=False)
-    except Exception as e:
-        logger.error(f"Failed to launch Gradio app: {e}")
+import matplotlib.pyplot as plt
+import io
+from datetime import datetime
+from fpdf import FPDF
+
+# ----------------------------
+# Function: Load Logs from Uploaded File or Default
+# ----------------------------
+def load_logs(file_obj):
+    if file_obj is not None:
+        df = pd.read_csv(file_obj.name, parse_dates=['Timestamp'])
+    else:
+        # Sample fallback data
+        sample_data = {
+            'DeviceID': ['D001', 'D002', 'D003'],
+            'Lab': ['Lab A', 'Lab B', 'Lab A'],
+            'Type': ['UV', 'Weight', 'Cell'],
+            'Timestamp': [pd.Timestamp('2025-06-01 09:00:00'),
+                          pd.Timestamp('2025-06-01 10:00:00'),
+                          pd.Timestamp('2025-06-01 11:00:00')],
+            'Status': ['OK', 'DOWN', 'OK'],
+            'UsageCount': [120, 85, 100]
+        }
+        df = pd.DataFrame(sample_data)
+    return df
+
+# ----------------------------
+# Function: Summarize Log Data
+# ----------------------------
+def summarize_logs(df):
+    summary = df.groupby(['Lab', 'Type'])['Status'].value_counts().unstack().fillna(0)
+    return summary
+
+# ----------------------------
+# Function: Generate Chart from Summary
+# ----------------------------
+def generate_chart(df):
+    summary = summarize_logs(df)
+    fig, ax = plt.subplots(figsize=(8, 4))
+    summary.plot(kind='bar', stacked=True, ax=ax)
+    ax.set_title("Device Uptime/Downtime Summary")
+    ax.set_ylabel("Count")
+    ax.set_xlabel("Lab + Device Type")
+    ax.legend(title="Status")
+    fig.tight_layout()
+    return fig
+
+# ----------------------------
+# Function: Export Summary to PDF
+# ----------------------------
+def export_pdf(df):
+    summary = summarize_logs(df)
+    pdf = FPDF()
+    pdf.add_page()
+    pdf.set_font("Arial", size=12)
+
+    pdf.cell(200, 10, txt="LabOps Dashboard Summary Report", ln=True, align='C')
+    pdf.cell(200, 10, txt=f"Generated on {datetime.now().strftime('%Y-%m-%d %H:%M:%S')}", ln=True, align='C')
+    pdf.ln(10)
+
+    # Table header
+    headers = ["Lab", "Device", "OK", "DOWN"]
+    col_widths = [40, 40, 30, 30]
+    for header, width in zip(headers, col_widths):
+        pdf.cell(width, 10, header, border=1)
+    pdf.ln()
+
+    # Table rows
+    for (lab, dev_type), row in summary.iterrows():
+        ok = int(row.get('OK', 0))
+        down = int(row.get('DOWN', 0))
+        pdf.cell(40, 10, lab, border=1)
+        pdf.cell(40, 10, dev_type, border=1)
+        pdf.cell(30, 10, str(ok), border=1)
+        pdf.cell(30, 10, str(down), border=1)
+        pdf.ln()
+
+    # Return PDF bytes
+    output = io.BytesIO()
+    pdf.output(output)
+    output.seek(0)
+    return output
+
+# ----------------------------
+# Gradio UI
+# ----------------------------
+def dashboard(file_obj):
+    df = load_logs(file_obj)
+    fig = generate_chart(df)
+    return fig
+
+def generate_pdf_button(file_obj):
+    df = load_logs(file_obj)
+    pdf_bytes = export_pdf(df)
+    return gr.File.update(value=pdf_bytes, visible=True)
+
+with gr.Blocks() as demo:
+    gr.Markdown("## 🧪 LabOps Dashboard")
+    gr.Markdown("Monitor and analyze device logs across SmartLabs.")
+
+    with gr.Row():
+        file_input = gr.File(label="Upload Log CSV (Optional)", file_types=[".csv"])
+        download_button = gr.Button("Download PDF Summary")
+        download_file = gr.File(label="Download PDF", visible=False)
+
+    plot_output = gr.Plot()
+
+    file_input.change(fn=dashboard, inputs=file_input, outputs=plot_output)
+    download_button.click(fn=generate_pdf_button, inputs=file_input, outputs=download_file)
+
+demo.launch()