Update app.py

app.py

@@ -1,144 +1,203 @@
 import gradio as gr
 import pandas as pd
-from utils.load_data import load_logs
-from utils.visualize import plot_usage
-from utils.report import generate_pdf
-from models.anomaly import detect_anomalies
-from utils.amc import upcoming_amc_devices
-import logging
+import matplotlib.pyplot as plt
+from sklearn.ensemble import IsolationForest
+from datetime import datetime, timedelta
 import os
+import logging
+from reportlab.lib.pagesizes import letter
+from reportlab.pdfgen import canvas
+import tempfile
 
 # Configure logging
-logging.basicConfig(level=logging.INFO, format="%(asctime)s - %(levelname)s - %(message)s")
-logger = logging.getLogger(__name__)
+logging.basicConfig(level=logging.INFO, format='%(asctime)s - %(levelname)s - %(message)s')
 
 def process_files(uploaded_files):
-    """Process uploaded CSV files and generate dashboard outputs."""
-    logger.info(f"Received uploaded files: {uploaded_files}")
-    # Handle Gradio's File component output: may be a tuple/list of lists
+    """
+    Process uploaded CSV files, generate usage plots, detect anomalies, and process AMC expiries.
+    Returns a dataframe, plot, PDF path, and status message.
+    """
     if not uploaded_files:
-        logger.warning("No files uploaded.")
-        return "Please upload at least one valid CSV file.", None, None, None, None
-
-    # Flatten the structure: uploaded_files might be (['path'],) or ['path']
-    if isinstance(uploaded_files, (tuple, list)) and len(uploaded_files) > 0:
-        if isinstance(uploaded_files[0], list):
-            valid_files = uploaded_files[0]  # Extract the inner list
-        else:
-            valid_files = uploaded_files
-    else:
-        valid_files = []
+        logging.warning("No files uploaded.")
+        return None, None, None, "Please upload at least one valid CSV file."
 
-    # Filter out None values and ensure we have valid files
-    valid_files = [f for f in valid_files if f is not None]
+    valid_files = [f for f in uploaded_files if f.name.endswith('.csv')]
     if not valid_files:
-        logger.warning("No valid files after filtering.")
-        return "Please upload at least one valid CSV file.", None, None, None, None
-
-    logger.info(f"Processing {len(valid_files)} valid files: {valid_files}")
-    try:
-        # Load data
-        df = load_logs(valid_files)
-        logger.info(f"Loaded {len(df)} log records from uploaded files.")
+        logging.warning("No valid CSV files uploaded.")
+        return None, None, None, "Please upload at least one valid CSV file."
 
-        # Log table
-        log_table = df.head().to_dict(orient="records")
+    logging.info(f"Processing {len(valid_files)} valid files: {[f.name for f in valid_files]}")
+    all_data = []
 
-        # Usage chart
-        logger.info("Generating usage plot...")
-        fig = plot_usage(df)
-        logger.info("Usage plot generated successfully.")
-
-        # Anomalies
-        anomaly_table = "Anomaly detection failed."
+    # Load and combine CSV files
+    for file in valid_files:
         try:
-            anomalies = detect_anomalies(df)
-            anomaly_table = anomalies.to_dict(orient="records") if not anomalies.empty else "No anomalies detected."
+            logging.info(f"Loading logs from {file.name}")
+            df = pd.read_csv(file.name)
+            logging.info(f"Loaded {len(df)} records from {file.name}")
+            all_data.append(df)
         except Exception as e:
-            logger.error(f"Anomaly detection failed: {e}")
+            logging.error(f"Failed to load {file.name}: {str(e)}")
+            return None, None, None, f"Error loading {file.name}: {str(e)}"
 
-        # AMC expiries
-        amc_table = None
-        try:
-            if "amc_expiry" in df.columns:
-                logger.info("Processing AMC expiries...")
-                amc_df = upcoming_amc_devices(df)
-                amc_table = amc_df.to_dict(orient="records") if not amc_df.empty else "No upcoming AMC expiries."
-            else:
-                amc_table = "Column `amc_expiry` not found in uploaded data."
-                logger.warning("Missing `amc_expiry` column in data.")
-        except Exception as e:
-            logger.error(f"AMC processing failed: {e}")
-            amc_table = f"Error processing AMC expiries: {e}"
+    if not all_data:
+        logging.warning("No data loaded from uploaded files.")
+        return None, None, None, "No valid data found in uploaded files."
+
+    combined_df = pd.concat(all_data, ignore_index=True)
+    logging.info(f"Combined {len(combined_df)} total records.")
+    logging.info(f"CSV columns: {combined_df.columns.tolist()}")
 
-        return log_table, fig, anomaly_table, amc_table, df
+    # Generate usage plot
+    plot_path = generate_usage_plot(combined_df)
+    
+    # Detect anomalies
+    anomaly_df = detect_anomalies(combined_df)
+    
+    # Process AMC expiries
+    amc_message, amc_df = process_amc_expiries(combined_df)
+    
+    # Generate PDF report
+    pdf_path = generate_pdf_report(combined_df, anomaly_df, amc_df)
+    
+    # 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']
+    
+    return output_df, plot_path, pdf_path, amc_message
+
+def generate_usage_plot(df):
+    """
+    Generate a bar plot of usage_count by equipment and status.
+    Returns the path to the saved plot.
+    """
+    logging.info("Generating usage plot...")
+    try:
+        plt.figure(figsize=(10, 6))
+        for status in df['status'].unique():
+            subset = df[df['status'] == status]
+            plt.bar(subset['equipment'] + f" ({status})", subset['usage_count'], label=status)
+        plt.xlabel("Equipment (Status)")
+        plt.ylabel("Usage Count")
+        plt.title("Usage Count by Equipment and Status")
+        plt.legend()
+        plt.xticks(rotation=45)
+        plt.tight_layout()
+        
+        # Save plot to temporary file
+        with tempfile.NamedTemporaryFile(delete=False, suffix='.png') as tmp:
+            plt.savefig(tmp.name, format='png')
+            plot_path = tmp.name
+        plt.close()
+        logging.info("Usage plot generated successfully.")
+        return plot_path
     except Exception as e:
-        logger.error(f"Error processing files: {e}")
-        return f"Error: {e}", None, None, None, None
+        logging.error(f"Failed to generate usage plot: {str(e)}")
+        return None
 
-def generate_pdf_report(df):
-    """Generate and return path to PDF report, with error message if applicable."""
-    if df is None:
-        logger.warning("No data available for PDF generation.")
-        return None, "Please upload CSV files first."
-    logger.info("Generating PDF report...")
+def detect_anomalies(df):
+    """
+    Detect anomalies in usage_count using Isolation Forest.
+    Returns a dataframe with an 'anomaly' column (-1 for anomalies, 1 for normal).
+    """
+    logging.info("Detecting anomalies...")
     try:
-        pdf_path = generate_pdf(df)
-        return pdf_path, "PDF generated successfully."
+        model = IsolationForest(contamination=0.1, random_state=42)
+        anomalies = model.fit_predict(df[['usage_count']].values)
+        anomaly_df = df.copy()
+        anomaly_df['anomaly'] = anomalies
+        logging.info(f"Detected {sum(anomalies == -1)} anomalies.")
+        return anomaly_df
     except Exception as e:
-        logger.error(f"Failed to generate PDF: {e}")
-        return None, f"Error generating PDF: {e}"
+        logging.error(f"Failed to detect anomalies: {str(e)}")
+        return None
 
-with gr.Blocks(title="Multi-Device LabOps Dashboard") as demo:
-    gr.Markdown("# 📊 Multi-Device LabOps Dashboard")
-    
-    with gr.Row():
-        file_input = gr.File(file_count="multiple", file_types=[".csv"], label="Upload Device Logs (CSV)")
-    
-    with gr.Row():
-        submit_btn = gr.Button("Process Files")
-    
+def process_amc_expiries(df):
+    """
+    Identify devices with AMC expiries within 7 days from 2025-06-05.
+    Returns a message and a dataframe of devices with upcoming expiries.
+    """
+    logging.info("Processing AMC expiries...")
+    try:
+        current_date = datetime(2025, 6, 5)
+        threshold = current_date + timedelta(days=7)
+        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)}"
+        logging.info(message)
+        return message, upcoming_expiries
+    except Exception as e:
+        logging.error(f"Failed to process AMC expiries: {str(e)}")
+        return f"Error processing AMC expiries: {str(e)}", None
+
+def generate_pdf_report(original_df, anomaly_df, amc_df):
+    """
+    Generate a PDF report with data summary, anomalies, and AMC expiries.
+    Returns the path to the saved PDF.
+    """
+    logging.info("Generating PDF report...")
+    try:
+        with tempfile.NamedTemporaryFile(delete=False, suffix='.pdf') as tmp:
+            c = canvas.Canvas(tmp.name, pagesize=letter)
+            c.drawString(100, 750, "Equipment Log Analysis Report")
+            y = 700
+            
+            # Summary
+            c.drawString(100, y, f"Total Records: {len(original_df)}")
+            c.drawString(100, y-20, f"Devices: {', '.join(original_df['equipment'].unique())}")
+            y -= 40
+            
+            # Anomalies
+            if anomaly_df is not None:
+                num_anomalies = sum(anomaly_df['anomaly'] == -1)
+                c.drawString(100, y, f"Anomalies Detected: {num_anomalies}")
+                if num_anomalies > 0:
+                    anomaly_equipment = anomaly_df[anomaly_df['anomaly'] == -1]['equipment'].unique()
+                    c.drawString(100, y-20, f"Anomalous Devices: {', '.join(anomaly_equipment)}")
+                y -= 40
+            else:
+                c.drawString(100, y, "Anomaly detection failed.")
+                y -= 20
+            
+            # AMC Expiries
+            if amc_df is not None:
+                c.drawString(100, y, f"Devices with Upcoming AMC Expiries: {len(amc_df['equipment'].unique())}")
+                for _, row in amc_df.iterrows():
+                    c.drawString(100, y-20, f"{row['equipment']}: {row['amc_expiry'].strftime('%Y-%m-%d')}")
+                    y -= 20
+            else:
+                c.drawString(100, y, "No AMC expiry data available.")
+                y -= 20
+            
+            c.showPage()
+            c.save()
+            pdf_path = tmp.name
+        logging.info("PDF report generated successfully.")
+        return pdf_path
+    except Exception as e:
+        logging.error(f"Failed to generate PDF report: {str(e)}")
+        return None
+
+# Gradio interface
+with gr.Blocks() as demo:
+    gr.Markdown("# Equipment Log Analysis")
     with gr.Row():
-        with gr.Column():
-            gr.Markdown("## 📋 Uploaded Logs")
-            log_output = gr.Dataframe()
-        with gr.Column():
-            gr.Markdown("## 📈 Daily Usage Chart")
-            chart_output = gr.Plot()
-    
+        file_input = gr.File(file_count="multiple", label="Upload CSV Files")
+        process_button = gr.Button("Process Files")
     with gr.Row():
-        with gr.Column():
-            gr.Markdown("## 🚨 Detected Anomalies")
-            anomaly_output = gr.Dataframe()
-        with gr.Column():
-            gr.Markdown("## 🛠 Upcoming AMC Devices")
-            amc_output = gr.Dataframe()
-    
+        output_df = gr.Dataframe(label="Processed Data")
+        output_plot = gr.Image(label="Usage Plot")
     with gr.Row():
-        pdf_btn = gr.Button("📄 Generate PDF Report")
-        pdf_output = gr.File(label="Download PDF Report")
-        pdf_message = gr.Textbox(label="PDF Generation Status")
+        output_message = gr.Textbox(label="AMC Expiry Status")
+        output_pdf = gr.File(label="Download PDF Report")
     
-    # State to store dataframe
-    df_state = gr.State()
-
-    # Connect inputs to outputs
-    submit_btn.click(
+    process_button.click(
         fn=process_files,
         inputs=[file_input],
-        outputs=[log_output, chart_output, anomaly_output, amc_output, df_state]
-    )
-    
-    pdf_btn.click(
-        fn=generate_pdf_report,
-        inputs=[df_state],
-        outputs=[pdf_output, pdf_message]
+        outputs=[output_df, output_plot, output_pdf, output_message]
     )
 
 if __name__ == "__main__":
-    try:
-        logger.info("Application starting...")
-        demo.launch(server_name="0.0.0.0", server_port=7860)
-    except Exception as e:
-        logger.error(f"Application failed to start: {e}")
-        raise
+    demo.launch(server_name="0.0.0.0", server_port=7860)