Update app.py

app.py

@@ -2,86 +2,153 @@ from flask import Flask, request, jsonify
 import pandas as pd
 from transformers import pipeline
 from sklearn.ensemble import IsolationForest
-from datetime import datetime, timedelta
-import json
+from datetime import datetime
 import logging
+import json
 
 app = Flask(__name__)
-logging.basicConfig(level=logging.INFO)
+logging.basicConfig(level=logging.INFO, format='%(asctime)s - %(levelname)s - %(message)s')
 
-# Initialize Hugging Face models
-summarizer = pipeline("summarization", model="facebook/bart-large-cnn")
-text_generator = pipeline("text-generation", model="gpt2")
+# 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
 
-# Sample anomaly detection model
+# 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 for analysis."""
-    df = pd.DataFrame(log_data)
-    df['timestamp'] = pd.to_datetime(df['timestamp'])
-    df['usage_hours'] = df['usage_hours'].astype(float)
-    return df
+    """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)}"
 
 def detect_anomalies(df):
-    """Detect anomalies in usage hours using IsolationForest."""
-    X = df[['usage_hours']].values
-    predictions = anomaly_detector.fit_predict(X)
-    anomalies = df[predictions == -1]
-    return [
-        {
-            "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()
-    ]
+    """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'],
+                "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."""
-    mask = (df['timestamp'] >= start_date) & (df['timestamp'] <= end_date)
-    filtered_df = df[mask]
-    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_device = filtered_df.groupby('device_id')['usage_hours'].sum().idxmax()
-    return {
-        "total_devices": total_devices,
-        "avg_uptime": f"{avg_uptime:.1f}%",
-        "downtime_events": downtime_events,
-        "most_used_device": most_used_device
-    }
+    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
+        }
+    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."""
-    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 summary
+    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 inputs
+        # 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
-        df = process_logs(logs)
-        anomalies = detect_anomalies(df)
-        usage_summary = summarize_usage(df, lab_site, start_date, end_date)
-        maintenance_report = generate_maintenance_report(anomalies, df, amc_expiry_threshold)
+        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 = {
@@ -89,10 +156,11 @@ def process_logs_endpoint():
             "usage_summary": usage_summary,
             "maintenance_report": maintenance_report
         }
+        logging.info("Successfully processed logs")
         return jsonify(response), 200
     except Exception as e:
-        logging.error(f"Error processing logs: {str(e)}")
-        return jsonify({"error": str(e)}), 500
+        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)