Update app.py

app.py

@@ -1,7 +1,7 @@
 import gradio as gr
 import pandas as pd
 import matplotlib.pyplot as plt
-from sklearn.ensemble import IsolationForest
+from sklearn.neighbors import LocalOutlierFactor
 from datetime import datetime, timedelta
 import os
 import logging
@@ -29,24 +29,69 @@ def validate_csv(df):
         return False, f"Invalid data types: {str(e)}"
     return True, ""
 
+def generate_summary(combined_df, anomaly_df, amc_df, plot_path, pdf_path):
+    """
+    Generate a detailed summary of the processing results.
+    Returns a markdown string for display in the Gradio interface.
+    """
+    summary = ["## Processing Summary\n"]
+
+    # Total records and devices
+    total_records = len(combined_df)
+    unique_devices = combined_df['equipment'].unique()
+    summary.append(f"- **Total Records Processed**: {total_records}")
+    summary.append(f"- **Unique Devices**: {len(unique_devices)} ({', '.join(unique_devices)})\n")
+
+    # Anomalies
+    if anomaly_df is not None:
+        num_anomalies = sum(anomaly_df['anomaly'] == -1)
+        summary.append(f"- **Anomalies Detected**: {num_anomalies}")
+        if num_anomalies > 0:
+            anomaly_records = anomaly_df[anomaly_df['anomaly'] == -1][['equipment', 'usage_count', 'status']]
+            summary.append("  **Anomalous Devices**:")
+            for _, row in anomaly_records.iterrows():
+                summary.append(f"  - {row['equipment']} (Usage: {row['usage_count']}, Status: {row['status']})")
+        else:
+            summary.append("  No anomalies detected.")
+    else:
+        summary.append("- **Anomalies Detected**: Failed to detect anomalies.")
+    summary.append("\n")
+
+    # AMC Expiries
+    if amc_df is not None and not amc_df.empty:
+        unique_devices_amc = amc_df['equipment'].unique()
+        summary.append(f"- **Devices with Upcoming AMC Expiries (within 7 days)**: {len(unique_devices_amc)}")
+        summary.append("  **Details**:")
+        for _, row in amc_df.iterrows():
+            summary.append(f"  - {row['equipment']}: {row['amc_expiry'].strftime('%Y-%m-%d')}")
+    else:
+        summary.append("- **Devices with Upcoming AMC Expiries**: None")
+    summary.append("\n")
+
+    # Plot and PDF
+    summary.append("- **Usage Plot**: " + ("Generated successfully." if plot_path else "Failed to generate."))
+    summary.append("- **PDF Report**: " + ("Available for download." if pdf_path else "Not generated."))
+
+    return "\n".join(summary)
+
 def process_files(uploaded_files):
     """
     Process uploaded CSV files, generate usage plots, detect anomalies, and process AMC expiries.
-    Returns a dataframe, plot path, PDF path, and AMC expiry message.
+    Returns a dataframe, plot path, PDF path, AMC expiry message, and summary.
     """
     # Log received files
     logging.info(f"Received uploaded files: {uploaded_files}")
 
     if not uploaded_files:
         logging.warning("No files uploaded.")
-        return None, None, None, "Please upload at least one valid CSV file."
+        return None, None, None, "Please upload at least one valid CSV file.", "No files uploaded."
 
     valid_files = [f for f in uploaded_files if f.name.endswith('.csv')]
     logging.info(f"Processing {len(valid_files)} valid files: {valid_files}")
 
     if not valid_files:
         logging.warning("No valid CSV files uploaded.")
-        return None, None, None, "Please upload at least one valid CSV file."
+        return None, None, None, "Please upload at least one valid CSV file.", "No valid CSV files uploaded."
 
     logging.info("Loading logs from uploaded files...")
     all_data = []
@@ -60,15 +105,15 @@ def process_files(uploaded_files):
             is_valid, error_msg = validate_csv(df)
             if not is_valid:
                 logging.error(f"Failed to load {file.name}: {error_msg}")
-                return None, None, None, f"Error loading {file.name}: {error_msg}"
+                return None, None, None, f"Error loading {file.name}: {error_msg}", f"Error: {error_msg}"
             all_data.append(df)
         except Exception as e:
             logging.error(f"Failed to load {file.name}: {str(e)}")
-            return None, None, None, f"Error loading {file.name}: {str(e)}"
+            return None, None, None, f"Error loading {file.name}: {str(e)}", f"Error: {str(e)}"
 
     if not all_data:
         logging.warning("No data loaded from uploaded files.")
-        return None, None, None, "No valid data found in uploaded files."
+        return None, None, None, "No valid data found in uploaded files.", "No data loaded."
 
     combined_df = pd.concat(all_data, ignore_index=True)
     logging.info(f"Combined {len(combined_df)} total records.")
@@ -81,15 +126,15 @@ def process_files(uploaded_files):
         logging.info("Usage plot generated successfully.")
     else:
         logging.error("Failed to generate usage plot.")
-        return combined_df, None, None, "Failed to generate usage plot."
+        return combined_df, None, None, "Failed to generate usage plot.", "Usage plot generation failed."
 
-    # Detect anomalies
-    logging.info("Detecting anomalies...")
+    # Detect anomalies using Local Outlier Factor
+    logging.info("Detecting anomalies using Local Outlier Factor...")
     anomaly_df = detect_anomalies(combined_df)
     if anomaly_df is None:
         logging.error("Failed to detect anomalies.")
     else:
-        logging.info(f"Detected {sum(anomaly_df['anomaly'] == -1)} anomalies.")
+        logging.info(f"Detected {sum(anomaly_df['anomaly'] == -1)} anomalies using Local Outlier Factor.")
 
     # Process AMC expiries
     logging.info("Processing AMC expiries...")
@@ -98,12 +143,17 @@ def process_files(uploaded_files):
     # Generate PDF report
     pdf_path = generate_pdf_report(combined_df, anomaly_df, amc_df)
 
+    # Generate summary
+    logging.info("Generating summary of results...")
+    summary = generate_summary(combined_df, anomaly_df, amc_df, plot_path, pdf_path)
+    logging.info("Summary generated successfully.")
+
     # Prepare output dataframe (combine original data with anomalies)
     output_df = combined_df.copy()
     if anomaly_df is not None:
         output_df['anomaly'] = anomaly_df['anomaly'].map({1: "Normal", -1: "Anomaly"})
 
-    return output_df, plot_path, pdf_path, amc_message
+    return output_df, plot_path, pdf_path, amc_message, summary
 
 def generate_usage_plot(df):
     """
@@ -141,11 +191,11 @@ def generate_usage_plot(df):
 
 def detect_anomalies(df):
     """
-    Detect anomalies in usage_count using Isolation Forest.
+    Detect anomalies in usage_count using Local Outlier Factor.
     Returns a dataframe with an 'anomaly' column (-1 for anomalies, 1 for normal).
     """
     try:
-        model = IsolationForest(contamination=0.1, random_state=42)
+        model = LocalOutlierFactor(n_neighbors=5, contamination=0.1)
         anomalies = model.fit_predict(df[['usage_count']].values)
         anomaly_df = df.copy()
         anomaly_df['anomaly'] = anomalies
@@ -165,7 +215,9 @@ def process_amc_expiries(df):
         df['amc_expiry'] = pd.to_datetime(df['amc_expiry'])
         upcoming_expiries = df[df['amc_expiry'] <= threshold]
         unique_devices = upcoming_expiries['equipment'].unique()
-        message = f"Found {len(unique_devices)} devices with upcoming AMC expiries: {', '.join(unique_devices)}."
+        message = f"Found {len(unique_devices)} devices with upcoming AMC expiries: {', '.join(unique_devices)}. Details: " + "; ".join(
+            [f"{row['equipment']}: {row['amc_expiry'].strftime('%Y-%m-%d')}" for _, row in upcoming_expiries.iterrows()]
+        )
         logging.info(f"Found {len(unique_devices)} devices with upcoming AMC expiries.")
         return message, upcoming_expiries
     except Exception as e:
@@ -189,38 +241,44 @@ def generate_pdf_report(original_df, anomaly_df, amc_df):
             c.setFont("Helvetica", 12)
             y = 720
 
+            # Report generated timestamp
+            current_time = datetime.now().strftime("%Y-%m-%d %H:%M:%S")
+            c.drawString(100, y, f"Generated on: {current_time}")
+            y -= 30
+
             # Summary
             c.drawString(100, y, "Summary")
             y -= 20
             c.drawString(100, y, f"Total Records: {len(original_df)}")
             y -= 20
-            c.drawString(100, y, f"Devices: {', '.join(original_df['equipment'].unique())}")
+            c.drawString(100, y, f"Unique Devices: {', '.join(original_df['equipment'].unique())}")
             y -= 40
 
             # Anomalies
-            c.drawString(100, y, "Anomaly Detection Results")
+            c.drawString(100, y, "Anomaly Detection Results (Using Local Outlier Factor)")
             y -= 20
             if anomaly_df is not None:
                 num_anomalies = sum(anomaly_df['anomaly'] == -1)
                 c.drawString(100, y, f"Anomalies Detected: {num_anomalies}")
                 y -= 20
                 if num_anomalies > 0:
-                    anomaly_records = anomaly_df[anomaly_df['anomaly'] == -1][['equipment', 'usage_count']]
+                    anomaly_records = anomaly_df[anomaly_df['anomaly'] == -1][['equipment', 'usage_count', 'status']]
                     c.drawString(100, y, "Anomalous Records:")
                     y -= 20
                     for _, row in anomaly_records.iterrows():
-                        c.drawString(100, y, f"{row['equipment']}: Usage Count = {row['usage_count']}")
+                        c.drawString(100, y, f"{row['equipment']}: Usage Count = {row['usage_count']}, Status = {row['status']}")
                         y -= 20
                         if y < 50:
                             c.showPage()
                             y = 750
+                            c.setFont("Helvetica", 12)
             else:
                 c.drawString(100, y, "Anomaly detection failed.")
                 y -= 20
             y -= 20
 
             # AMC Expiries
-            c.drawString(100, y, "AMC Expiries Within 7 Days")
+            c.drawString(100, y, "AMC Expiries Within 7 Days (as of 2025-06-05)")
             y -= 20
             if amc_df is not None and not amc_df.empty:
                 c.drawString(100, y, f"Devices with Upcoming AMC Expiries: {len(amc_df['equipment'].unique())}")
@@ -231,6 +289,7 @@ def generate_pdf_report(original_df, anomaly_df, amc_df):
                     if y < 50:
                         c.showPage()
                         y = 750
+                        c.setFont("Helvetica", 12)
             else:
                 c.drawString(100, y, "No AMC expiry data available.")
                 y -= 20
@@ -254,11 +313,13 @@ with gr.Blocks() as demo:
     with gr.Row():
         output_message = gr.Textbox(label="AMC Expiry Status")
         output_pdf = gr.File(label="Download PDF Report")
+    with gr.Row():
+        output_summary = gr.Markdown(label="Summary of Results")
 
     process_button.click(
         fn=process_files,
         inputs=[file_input],
-        outputs=[output_df, output_plot, output_pdf, output_message]
+        outputs=[output_df, output_plot, output_pdf, output_message, output_summary]
     )
 
 if __name__ == "__main__":