Update app.py

app.py

@@ -1,166 +1,70 @@
-from flask import Flask, request, jsonify
+import gradio as gr
 import pandas as pd
-from transformers import pipeline
-from sklearn.ensemble import IsolationForest
 from datetime import datetime
-import logging
 import json
+from transformers import pipeline
 
-app = Flask(__name__)
-logging.basicConfig(level=logging.INFO, format='%(asctime)s - %(levelname)s - %(message)s')
-
-# Initialize Hugging Face model for summarization
-try:
-    summarizer = pipeline("summarization", model="facebook/bart-large-cnn")
-except Exception as e:
-    logging.error(f"Failed to initialize summarizer: {str(e)}")
-    summarizer = None
-
-# Initialize anomaly detection model
-anomaly_detector = IsolationForest(contamination=0.1, random_state=42)
-
-def validate_logs(logs):
-    """Validate log data structure."""
-    required_fields = ['device_id', 'log_type', 'status', 'timestamp', 'usage_hours']
-    for log in logs:
-        if not all(field in log for field in required_fields):
-            return False, f"Missing required fields in log: {log}"
-        try:
-            pd.to_datetime(log['timestamp'])
-            float(log['usage_hours'])
-        except (ValueError, TypeError):
-            return False, f"Invalid timestamp or usage_hours in log: {log}"
-    return True, ""
-
-def process_logs(log_data):
-    """Convert JSON logs to DataFrame and preprocess."""
-    try:
-        df = pd.DataFrame(log_data)
-        df['timestamp'] = pd.to_datetime(df['timestamp'])
-        df['usage_hours'] = df['usage_hours'].astype(float)
-        return True, df
-    except Exception as e:
-        return False, f"Error processing logs: {str(e)}"
+# Load Hugging Face summarization model
+summarizer = pipeline("text2text-generation", model="google/flan-t5-base")
 
+# Sample rule-based anomaly detector
 def detect_anomalies(df):
-    """Detect anomalies in usage hours."""
-    try:
-        X = df[['usage_hours']].values
-        predictions = anomaly_detector.fit_predict(X)
-        anomalies = df[predictions == -1]
-        return True, [
-            {
-                "device_id": row['device_id'],
+    anomalies = []
+    for _, row in df.iterrows():
+        if row.get("usage_hours", 0) > 10:  # Example threshold
+            anomalies.append({
+                "device_id": row["device_id"],
                 "issue": "Usage spike",
-                "detected_on": row['timestamp'].strftime('%Y-%m-%d'),
-                "severity": "high" if row['usage_hours'] > 10 else "medium"
-            } for _, row in anomalies.iterrows()
-        ]
-    except Exception as e:
-        return False, f"Error detecting anomalies: {str(e)}"
-
-def summarize_usage(df, lab_site, start_date, end_date):
-    """Generate usage summary for a given lab site and date range."""
+                "detected_on": row["timestamp"].split("T")[0],
+                "severity": "high"
+            })
+    return anomalies
+
+# Format summary prompt and generate report
+def summarize_logs(df, lab_name, start_date, end_date):
+    # Simple aggregation
+    total_devices = df["device_id"].nunique()
+    avg_uptime = "97%"  # Placeholder
+    most_used = df.groupby("device_id")["usage_hours"].sum().idxmax()
+    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"]
+    return summary
+
+# Main Gradio function
+def process_logs(file_obj, lab_site, start_date, end_date):
     try:
-        start_date = pd.to_datetime(start_date)
-        end_date = pd.to_datetime(end_date)
-        mask = (df['timestamp'] >= start_date) & (df['timestamp'] <= end_date)
-        filtered_df = df[mask]
-        if filtered_df.empty:
-            return True, {
-                "total_devices": 0,
-                "avg_uptime": "0%",
-                "downtime_events": 0,
-                "most_used_device": "None"
-            }
-        total_devices = filtered_df['device_id'].nunique()
-        avg_uptime = 100 * (1 - filtered_df['status'].eq('DOWN').mean())
-        downtime_events = filtered_df['status'].eq('DOWN').sum()
-        most_used = filtered_df.groupby('device_id')['usage_hours'].sum()
-        most_used_device = most_used.idxmax() if not most_used.empty else "None"
-        return True, {
-            "total_devices": total_devices,
-            "avg_uptime": f"{avg_uptime:.1f}%",
-            "downtime_events": downtime_events,
-            "most_used_device": most_used_device
-        }
+        df = pd.read_json(file_obj.name) if file_obj.name.endswith(".json") else pd.read_csv(file_obj.name)
     except Exception as e:
-        return False, f"Error summarizing usage: {str(e)}"
-
-def generate_maintenance_report(anomalies, df, amc_expiry_threshold):
-    """Generate a natural language maintenance report."""
-    try:
-        if not summarizer:
-            return False, "Summarizer model not initialized"
-        if df.empty:
-            return True, "No data available for report generation"
-        prompt = f"""
-        Generate a maintenance summary for SmartLab-1 from {df['timestamp'].min().strftime('%Y-%m-%d')} to {df['timestamp'].max().strftime('%Y-%m-%d')}:
-        - {len(anomalies)} devices experienced abnormal usage patterns
-        - AMC for Device D004 expires in {amc_expiry_threshold} days
-        - UV Verifier-2 had 2.3 hrs of unplanned downtime
-        """
-        summary = summarizer(prompt, max_length=150, min_length=50, do_sample=False)[0]['summary_text']
-        return True, summary
-    except Exception as e:
-        return False, f"Error generating report: {str(e)}"
-
-@app.route('/api/process_logs', methods=['POST'])
-def process_logs_endpoint():
-    try:
-        data = request.get_json()
-        if not data or 'logs' not in data:
-            logging.error("No logs provided in request")
-            return jsonify({"error": "No logs provided"}), 400
-
-        # Extract and validate inputs
-        logs = data['logs']
-        is_valid, error_msg = validate_logs(logs)
-        if not is_valid:
-            logging.error(error_msg)
-            return jsonify({"error": error_msg}), 400
-
-        lab_site = data.get('lab_site', 'SmartLab-1')
-        start_date = data.get('start_date', '2025-05-01')
-        end_date = data.get('end_date', '2025-05-14')
-        amc_expiry_threshold = data.get('amc_expiry_threshold', 12)
-
-        # Process logs
-        success, result = process_logs(logs)
-        if not success:
-            logging.error(result)
-            return jsonify({"error": result}), 500
-        df = result
-
-        # Detect anomalies
-        success, anomalies = detect_anomalies(df)
-        if not success:
-            logging.error(anomalies)
-            return jsonify({"error": anomalies}), 500
-
-        # Summarize usage
-        success, usage_summary = summarize_usage(df, lab_site, start_date, end_date)
-        if not success:
-            logging.error(usage_summary)
-            return jsonify({"error": usage_summary}), 500
-
-        # Generate maintenance report
-        success, maintenance_report = generate_maintenance_report(anomalies, df, amc_expiry_threshold)
-        if not success:
-            logging.error(maintenance_report)
-            return jsonify({"error": maintenance_report}), 500
-
-        # Prepare response
-        response = {
-            "anomalies": anomalies,
-            "usage_summary": usage_summary,
-            "maintenance_report": maintenance_report
-        }
-        logging.info("Successfully processed logs")
-        return jsonify(response), 200
-    except Exception as e:
-        logging.error(f"Unexpected error: {str(e)}")
-        return jsonify({"error": f"Unexpected error: {str(e)}"}), 500
-
-if __name__ == '__main__':
-    app.run(debug=True, host='0.0.0.0', port=5000)
+        return f"Failed to read file: {str(e)}", None, None
+
+    anomalies = detect_anomalies(df)
+    summary = summarize_logs(df, lab_site, start_date, end_date)
+
+    return summary, anomalies, df.head().to_markdown()
+
+# Gradio Interface
+iface = gr.Interface(
+    fn=process_logs,
+    inputs=[
+        gr.File(label="Upload Logs (CSV or JSON)"),
+        gr.Textbox(label="Lab Site"),
+        gr.Textbox(label="Start Date (YYYY-MM-DD)"),
+        gr.Textbox(label="End Date (YYYY-MM-DD)")
+    ],
+    outputs=[
+        gr.Textbox(label="Summary Report"),
+        gr.JSON(label="Anomalies"),
+        gr.Markdown(label="Preview of Logs")
+    ],
+    title="LabOps Log Analyzer (Hugging Face AI)"
+)
+
+if __name__ == "__main__":
+    iface.launch()