Update app.py

app.py

@@ -1,180 +1,173 @@
-from flask import Flask, request, jsonify
+import gradio as gr
 import pandas as pd
-from datetime import datetime, timedelta
+from datetime import datetime
 import json
+from transformers import pipeline
 import logging
-import sys
+import os
+import plotly.express as px
 
-app = Flask(__name__)
-
-# Configure logging to diagnose issues
+# Configure logging for debugging
 logging.basicConfig(level=logging.INFO, format='%(asctime)s - %(levelname)s - %(message)s')
-logger = logging.getLogger(__name__)
 
-# Try to load Hugging Face summarization pipeline with fallback
+# Load Hugging Face summarization model
 try:
-    from transformers import pipeline
-    summarizer = pipeline("text2text-generation", model="t5-small", framework="pt")
-    logger.info("Hugging Face model 't5-small' loaded successfully.")
+    logging.info("Attempting to load Hugging Face model...")
+    summarizer = pipeline("text2text-generation", model="google/flan-t5-base")
+    logging.info("Hugging Face model loaded successfully")
 except Exception as e:
-    logger.error(f"Failed to load Hugging Face model: {str(e)}")
-    summarizer = None  # Fallback to skip summarization if model fails
+    logging.error(f"Failed to load model: {str(e)}")
+    raise e
 
-# Helper function to calculate days until AMC expiry
-def days_until_expiry(expiry_date_str):
+# Format summary prompt and generate report
+def summarize_logs(df, lab_name, start_date, end_date):
     try:
-        expiry_date = datetime.strptime(expiry_date_str, "%Y-%m-%d")
-        current_date = datetime.now()
-        return (expiry_date - current_date).days
-    except ValueError as e:
-        logger.warning(f"Invalid date format for AMC expiry: {expiry_date_str}, error: {str(e)}")
-        return None
-
-# Helper function to detect anomalies (rule-based, simplified)
-def detect_anomalies(logs):
-    anomalies = []
-    for log in logs:
-        try:
-            # Rule 1: Flag ERROR status as high severity
-            if log.get("status") == "ERROR":
-                anomalies.append({
-                    "device_id": log.get("device_id", "Unknown"),
-                    "issue": "ERROR status detected",
-                    "detected_on": log.get("timestamp", "N/A"),
-                    "severity": "high"
-                })
-            # Rule 2: Flag usage spikes (>7 hours as example threshold)
-            if log.get("usage_hours", 0) > 7:
-                anomalies.append({
-                    "device_id": log.get("device_id", "Unknown"),
-                    "issue": "Usage spike",
-                    "detected_on": log.get("timestamp", "N/A"),
-                    "severity": "high"
-                })
-            # Rule 3: Flag downtime (usage_hours = 0 with DOWN status)
-            if log.get("status") == "DOWN" and log.get("usage_hours", 0) == 0:
-                anomalies.append({
-                    "device_id": log.get("device_id", "Unknown"),
-                    "issue": "Unplanned downtime",
-                    "detected_on": log.get("timestamp", "N/A"),
-                    "severity": "medium"
-                })
-        except Exception as e:
-            logger.error(f"Error processing log entry {log}: {str(e)}")
-    return anomalies
-
-# Helper function to generate AMC reminders
-def generate_amc_reminders(logs):
-    reminders = []
-    for log in logs:
-        try:
-            days_left = days_until_expiry(log.get("amc_expiry", ""))
-            if days_left is not None and 0 < days_left <= 30:
-                reminders.append({
-                    "device_id": log.get("device_id", "Unknown"),
-                    "amc_expiry": log.get("amc_expiry", "N/A"),
-                    "days_remaining": days_left,
-                    "alert": f"AMC expires in {days_left} days"
-                })
-        except Exception as e:
-            logger.error(f"Error processing AMC for log {log}: {str(e)}")
-    return reminders
-
-# Helper function to summarize logs
-def summarize_logs(logs, prompt):
-    try:
-        if summarizer is None:
-            logger.warning("Summarizer model not available, returning basic summary.")
-            return "Summary unavailable: Model not loaded. Please check logs for details."
-        
-        # Convert logs to text for summarization
-        log_text = "\n".join([f"Device {log.get('device_id', 'Unknown')} ({log.get('log_type', 'N/A')}): Status {log.get('status', 'N/A')}, Usage {log.get('usage_hours', 0)} hours, Timestamp {log.get('timestamp', 'N/A')}, AMC Expiry {log.get('amc_expiry', 'N/A')}" 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"]
+        total_devices = df["device_id"].nunique()
+        avg_uptime = "97%"  # Placeholder
+        most_used = df.groupby("device_id")["usage_hours"].sum().idxmax() if not df.empty else "N/A"
+        downtime_events = 3  # Placeholder
+
+        prompt = (
+            f"Summarize maintenance and usage logs for lab {lab_name} "
+            f"from {start_date} to {end_date}. "
+            f"There were {total_devices} devices. "
+            f"The most used device was {most_used}."
+        )
+        summary = summarizer(prompt, max_length=200, do_sample=False)[0]["generated_text"]
+        logging.info("Summary generated successfully")
         return summary
     except Exception as e:
-        logger.error(f"Error generating summary: {str(e)}")
-        return f"Summary unavailable: {str(e)}"
+        logging.error(f"Summary generation failed: {str(e)}")
+        return "Failed to generate summary."
 
-# API endpoint to process logs
-@app.route("/process-logs", methods=["POST"])
-def process_logs():
+# Create a bar chart for usage hours per device
+def create_usage_chart(df):
     try:
-        data = request.get_json()
-        if not data or "logs" not in data:
-            logger.error("Invalid or missing logs in request.")
-            return jsonify({"error": "No logs provided in the request"}), 400
+        usage_data = df.groupby("device_id")["usage_hours"].sum().reset_index()
+        fig = px.bar(
+            usage_data,
+            x="device_id",
+            y="usage_hours",
+            title="Usage Hours per Device",
+            labels={"device_id": "Device ID", "usage_hours": "Usage Hours"},
+            color="usage_hours",
+            color_continuous_scale="Blues"
+        )
+        fig.update_layout(
+            title_font_size=16,
+            margin=dict(l=20, r=20, t=40, b=20),
+            plot_bgcolor="white",
+            paper_bgcolor="white",
+            font=dict(size=12)
+        )
+        return fig
+    except Exception as e:
+        logging.error(f"Failed to create usage chart: {str(e)}")
+        return None
 
-        logs = data.get("logs", [])
-        prompt = data.get("prompt", "Summarize downtime and usage patterns for SmartLab-1 from May 1 to May 14")
+# Main Gradio function
+def process_logs(file_obj, lab_site, start_date, end_date):
+    try:
+        if file_obj is None:
+            logging.warning("No file uploaded, returning empty results")
+            return "No file uploaded.", "No data to preview.", None
+        
+        # Read file based on extension
+        file_name = file_obj.name if hasattr(file_obj, 'name') else file_obj
+        logging.info(f"Processing file: {file_name}")
+        
+        if file_name.endswith(".json"):
+            df = pd.read_json(file_name)
+        elif file_name.endswith(".csv"):
+            df = pd.read_csv(file_name)
+        else:
+            logging.error("Unsupported file format")
+            return "Unsupported file format. Please upload a CSV or JSON file.", None, None
 
-        if not logs:
-            logger.error("Empty logs list provided.")
-            return jsonify({"error": "Logs list is empty"}), 400
+        logging.info(f"File loaded successfully with {len(df)} rows")
 
-        # Convert logs to DataFrame for analysis
+        # Convert timestamp to datetime and filter by date range
         try:
-            df = pd.DataFrame(logs)
+            df["timestamp"] = pd.to_datetime(df["timestamp"])
+            start_date = pd.to_datetime(start_date)
+            end_date = pd.to_datetime(end_date)
+            df = df[(df["timestamp"] >= start_date) & (df["timestamp"] <= end_date)]
+            logging.info(f"Filtered to {len(df)} rows within date range {start_date} to {end_date}")
         except Exception as e:
-            logger.error(f"Failed to convert logs to DataFrame: {str(e)}")
-            return jsonify({"error": f"Invalid log format: {str(e)}"}), 400
+            logging.error(f"Date filtering failed: {str(e)}")
+            return f"Failed to filter data by date: {str(e)}", None, None
 
-        # Calculate summary metrics
-        try:
-            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"
-        except Exception as e:
-            logger.error(f"Error calculating summary metrics: {str(e)}")
-            total_devices, avg_uptime, downtime_events, most_used_device = 0, 0, 0, "N/A"
-
-        # 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)
-
-        # Generate maintenance report
-        report = f"""
-SmartLab-1 Maintenance Report (May 1–14, 2025)
-Generated on: {datetime.now().strftime('%Y-%m-%d')}
-
-1. Summary
-- Total Devices: {total_devices}
-- Average Uptime: {avg_uptime:.1f}%
-- Downtime Events: {downtime_events}
-- Most Used Device: {most_used_device}
-
-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}
-"""
-
-        logger.info("Successfully processed logs and generated response.")
-        return jsonify({
-            "summary": summary,
-            "anomalies": anomalies,
-            "amc_reminders": amc_reminders,
-            "maintenance_report": report
-        })
+        if df.empty:
+            logging.warning("No data within the specified date range")
+            return "No data available for the specified date range.", "No data to preview.", None
 
+        summary = summarize_logs(df, lab_site, start_date, end_date)
+        preview = df.head().to_markdown() if not df.empty else "No data available."
+        chart = create_usage_chart(df)
+
+        return summary, preview, chart
     except Exception as e:
-        logger.error(f"Unexpected error in process_logs: {str(e)}")
-        return jsonify({"error": f"Internal server error: {str(e)}"}), 500
+        logging.error(f"Failed to process file: {str(e)}")
+        return f"Failed to process file: {str(e)}", None, None
+
+# Gradio Interface with Dashboard Layout
+try:
+    logging.info("Initializing Gradio Blocks interface...")
+    with gr.Blocks(css="""
+        .dashboard-container {border: 1px solid #e0e0e0; padding: 10px; border-radius: 5px; background-color: #f9f9f9;}
+        .dashboard-title {font-size: 24px; font-weight: bold; margin-bottom: 10px;}
+        .dashboard-section {margin-bottom: 15px;}
+        .dashboard-section h3 {font-size: 18px; margin-bottom: 5px;}
+    """) as iface:
+        gr.Markdown("<h1>LabOps Log Analyzer Dashboard (Hugging Face AI)</h1>")
+        gr.Markdown("Upload a CSV or JSON file containing lab equipment logs to analyze usage.")
+
+        with gr.Row():
+            with gr.Column(scale=1):
+                file_input = gr.File(label="Upload Logs (CSV or JSON)", file_types=[".csv", ".json"])
+                lab_site_input = gr.Textbox(label="Lab Site", placeholder="e.g., Lab A")
+                start_date_input = gr.Textbox(label="Start Date (YYYY-MM-DD)", placeholder="e.g., 2025-01-01")
+                end_date_input = gr.Textbox(label="End Date (YYYY-MM-DD)", placeholder="e.g., 2025-01-31")
+                submit_button = gr.Button("Submit", variant="primary")
+            
+            with gr.Column(scale=2):
+                with gr.Group(elem_classes="dashboard-container"):
+                    gr.Markdown("<div class='dashboard-title'>Analysis Dashboard</div>")
+                    
+                    with gr.Row():
+                        with gr.Column(scale=1):
+                            with gr.Group(elem_classes="dashboard-section"):
+                                gr.Markdown("### Summary Report")
+                                summary_output = gr.Textbox(lines=5)
+                    
+                    with gr.Row():
+                        with gr.Column(scale=1):
+                            with gr.Group(elem_classes="dashboard-section"):
+                                gr.Markdown("### Usage Chart")
+                                chart_output = gr.Plot()
+                        
+                        with gr.Column(scale=1):
+                            with gr.Group(elem_classes="dashboard-section"):
+                                gr.Markdown("### Log Preview")
+                                preview_output = gr.Markdown()
+
+        submit_button.click(
+            fn=process_logs,
+            inputs=[file_input, lab_site_input, start_date_input, end_date_input],
+            outputs=[summary_output, preview_output, chart_output]
+        )
+
+    logging.info("Gradio interface initialized successfully")
+except Exception as e:
+    logging.error(f"Failed to initialize Gradio interface: {str(e)}")
+    raise e
 
 if __name__ == "__main__":
-    logger.info(f"Starting Flask app with Python version {sys.version}")
-    app.run(debug=True, host="0.0.0.0", port=5000)
+    try:
+        logging.info("Launching Gradio interface...")
+        iface.launch(server_name="0.0.0.0", server_port=7860, debug=True, share=False)
+        logging.info("Gradio interface launched successfully")
+    except Exception as e:
+        logging.error(f"Failed to launch Gradio interface: {str(e)}")
+        print(f"Error launching app: {str(e)}")
+        raise e