Update app.py

app.py

@@ -1,154 +1,70 @@
+"""
+LabOps Log Analyzer Dashboard with CSV file upload and optional PDF generation
+"""
 import gradio as gr
 import pandas as pd
 from datetime import datetime
 import logging
 import plotly.express as px
-from sklearn.ensemble import IsolationForest  # For anomaly detection
+from sklearn.ensemble import IsolationForest
 from transformers import pipeline
-import torch  # For GPU availability check
-from simple_salesforce import Salesforce  # For Salesforce connection
+import torch
+
+# Try to import reportlab for PDF generation
+try:
+    from reportlab.lib.pagesizes import letter
+    from reportlab.platypus import SimpleDocTemplate, Paragraph, Spacer
+    from reportlab.lib.styles import getSampleStyleSheet
+    reportlab_available = True
+    logging.info("reportlab module successfully imported")
+except ImportError:
+    logging.warning("reportlab module not found. PDF generation will be disabled. Install with: pip install reportlab")
+    reportlab_available = False
 
 # Configure logging for debugging
 logging.basicConfig(level=logging.INFO, format='%(asctime)s - %(levelname)s - %(message)s')
 
-# Salesforce credentials (replace with your actual credentials or use environment variables)
-SALESFORCE_USERNAME = "your_username"
-SALESFORCE_PASSWORD = "your_password"
-SALESFORCE_SECURITY_TOKEN = "your_security_token"
-SALESFORCE_DOMAIN = "login"  # Use "test" for sandbox, "login" for production
-
 # Preload Hugging Face summarization model at startup
 logging.info("Preloading Hugging Face model...")
 try:
     device = 0 if torch.cuda.is_available() else -1
-    summarizer = pipeline("summarization", model="sshleifer/distilbart-cnn-12-6", device=device)  # Lighter model
+    summarizer = pipeline("summarization", model="sshleifer/distilbart-cnn-12-6", device=device)
     logging.info(f"Hugging Face model preloaded successfully on device: {'GPU' if device == 0 else 'CPU'}")
 except Exception as e:
     logging.error(f"Failed to preload model: {str(e)}")
     raise e
 
-# Connect to Salesforce
-def connect_to_salesforce():
-    try:
-        sf = Salesforce(
-            username=SALESFORCE_USERNAME,
-            password=SALESFORCE_PASSWORD,
-            security_token=SALESFORCE_SECURITY_TOKEN,
-            domain=SALESFORCE_DOMAIN
-        )
-        logging.info("Successfully connected to Salesforce")
-        return sf
-    except Exception as e:
-        logging.error(f"Failed to connect to Salesforce: {str(e)}")
-        raise e
-
-# Fetch data from Salesforce
-def fetch_salesforce_data(sf, row_limit=10000, progress=gr.Progress()):
-    progress(0.05, "Fetching data from Salesforce...")
-    try:
-        # Query Salesforce for LabEquipmentLog__c object
-        query = """
-            SELECT Device_ID__c, Log_Type__c, Status__c, Timestamp__c, 
-                   Usage_Hours__c, Downtime__c, AMC_Date__c 
-            FROM LabEquipmentLog__c
-            LIMIT {}
-        """.format(row_limit)
-        result = sf.query_all(query)
-        records = result["records"]
-        
-        # Convert to DataFrame
-        df = pd.DataFrame(records)
-        df = df.rename(columns={
-            "Device_ID__c": "device_id",
-            "Log_Type__c": "log_type",
-            "Status__c": "status",
-            "Timestamp__c": "timestamp",
-            "Usage_Hours__c": "usage_hours",
-            "Downtime__c": "downtime",
-            "AMC_Date__c": "amc_date"
-        })
-        
-        # Ensure proper data types
-        df["timestamp"] = pd.to_datetime(df["timestamp"], errors='coerce')
-        df["amc_date"] = pd.to_datetime(df["amc_date"], errors='coerce')
-        df["usage_hours"] = df["usage_hours"].astype("float32", errors='ignore')
-        df["downtime"] = df["downtime"].astype("float32", errors='ignore')
-        df["device_id"] = df["device_id"].astype("string")
-        
-        logging.info(f"Fetched {len(df)} records from Salesforce")
-        return df
-    except Exception as e:
-        logging.error(f"Failed to fetch Salesforce data: {str(e)}")
-        raise e
-
-# Load data from CSV file
-def load_csv_data(file_obj, row_limit=10000, progress=gr.Progress()):
-    progress(0.05, "Loading CSV file...")
-    try:
-        file_name = file_obj.name if hasattr(file_obj, 'name') else file_obj
-        logging.info(f"Processing CSV file: {file_name}")
-        
-        if not file_name.endswith(".csv"):
-            logging.error("Unsupported file format")
-            raise ValueError("Unsupported file format. Please upload a CSV file.")
-
-        usecols = ["device_id", "log_type", "status", "timestamp", "usage_hours", "downtime", "amc_date"]
-        dtypes = {
-            "device_id": "string",
-            "log_type": "string",
-            "status": "string",
-            "usage_hours": "float32",
-            "downtime": "float32",
-            "amc_date": "string"
-        }
-        df = pd.read_csv(file_name, usecols=usecols, dtype=dtypes, nrows=row_limit)
-        
-        # Convert timestamps
-        df["timestamp"] = pd.to_datetime(df["timestamp"], errors='coerce')
-        df["amc_date"] = pd.to_datetime(df["amc_date"], errors='coerce')
-        
-        logging.info(f"File loaded successfully with {len(df)} rows (limited to {row_limit} rows)")
-        return df
-    except Exception as e:
-        logging.error(f"Failed to load CSV: {str(e)}")
-        raise e
-
 # Format summary prompt and generate report
 def summarize_logs(df, progress=gr.Progress()):
     progress(0.1, "Generating summary report...")
     try:
         total_devices = df["device_id"].nunique()
         most_used = df.groupby("device_id")["usage_hours"].sum().idxmax() if not df.empty else "N/A"
-
         prompt = f"Maintenance logs: {total_devices} devices. Most used: {most_used}."
         summary = summarizer(prompt, max_length=50, min_length=10, do_sample=False)[0]["summary_text"]
         logging.info("Summary generated successfully")
         return summary
     except Exception as e:
         logging.error(f"Summary generation failed: {str(e)}")
-        return "Failed to generate summary."
+        return f"Failed to generate summary: {str(e)}"
 
-# Anomaly Detection using Isolation Forest with sampling for large datasets
+# Anomaly Detection using Isolation Forest
 def detect_anomalies(df, progress=gr.Progress()):
     progress(0.4, "Detecting anomalies...")
     try:
         if "usage_hours" not in df.columns or "downtime" not in df.columns:
             logging.warning("Required columns for anomaly detection not found")
             return "Anomaly detection requires 'usage_hours' and 'downtime' columns."
-
         if len(df) > 5000:
             df = df.sample(n=5000, random_state=42)
             logging.info("Sampled data for anomaly detection to 5,000 rows")
-
         features = df[["usage_hours", "downtime"]].fillna(0)
         iso_forest = IsolationForest(contamination=0.1, random_state=42, n_jobs=-1)
         df["anomaly"] = iso_forest.fit_predict(features)
-       
         anomalies = df[df["anomaly"] == -1][["device_id", "usage_hours", "downtime", "timestamp"]]
         if anomalies.empty:
             return "No anomalies detected."
-       
-        anomaly_lines = ["**Detected Anomalies:**"]
+        anomaly_lines = ["Detected Anomalies:"]
         for idx, row in anomalies.head(5).iterrows():
             anomaly_lines.append(f"- Device ID: {row['device_id']}, Usage Hours: {row['usage_hours']}, Downtime: {row['downtime']}, Timestamp: {row['timestamp']}")
         anomaly_list = "\n".join(anomaly_lines)
@@ -165,17 +81,13 @@ def check_amc_reminders(df, current_date, progress=gr.Progress()):
         if "device_id" not in df.columns or "amc_date" not in df.columns:
             logging.warning("Required columns for AMC reminders not found")
             return "AMC reminders require 'device_id' and 'amc_date' columns."
-
         df["amc_date"] = pd.to_datetime(df["amc_date"], errors='coerce')
         current_date = pd.to_datetime(current_date)
-       
         df["days_to_amc"] = (df["amc_date"] - current_date).dt.days
         reminders = df[(df["days_to_amc"] >= 0) & (df["days_to_amc"] <= 30)][["device_id", "amc_date"]]
-       
         if reminders.empty:
             return "No AMC reminders due within the next 30 days."
-       
-        reminder_lines = ["**Upcoming AMC Reminders:**"]
+        reminder_lines = ["Upcoming AMC Reminders:"]
         for idx, row in reminders.head(5).iterrows():
             reminder_lines.append(f"- Device ID: {row['device_id']}, AMC Date: {row['amc_date']}")
         reminder_list = "\n".join(reminder_lines)
@@ -185,7 +97,7 @@ def check_amc_reminders(df, current_date, progress=gr.Progress()):
         logging.error(f"AMC reminder generation failed: {str(e)}")
         return f"AMC reminder generation failed: {str(e)}"
 
-# Dashboard Insights (AI-generated executive-level insights)
+# Dashboard Insights (AI-generated)
 def generate_dashboard_insights(df, progress=gr.Progress()):
     progress(0.8, "Generating dashboard insights...")
     try:
@@ -207,7 +119,6 @@ def create_usage_chart(df, progress=gr.Progress()):
         if len(usage_data) > 5:
             usage_data = usage_data.nlargest(5, "usage_hours")
             logging.info("Limited chart data to top 5 devices")
-
         custom_colors = ['#FF6B6B', '#4ECDC4', '#45B7D1', '#96CEB4']
         fig = px.bar(
             usage_data,
@@ -230,113 +141,216 @@ def create_usage_chart(df, progress=gr.Progress()):
         logging.error(f"Failed to create usage chart: {str(e)}")
         return None
 
+# Generate PDF content using reportlab if available
+def generate_pdf_content(summary, preview, anomalies, amc_reminders, insights):
+    if not reportlab_available:
+        logging.warning("Skipping PDF generation: reportlab not installed")
+        return None
+    try:
+        pdf_path = "analysis_report.pdf"
+        doc = SimpleDocTemplate(pdf_path, pagesize=letter)
+        styles = getSampleStyleSheet()
+        story = []
+
+        # Title
+        story.append(Paragraph("LabOps Log Analysis Report", styles['Title']))
+        story.append(Paragraph(f"Generated on {datetime.now().strftime('%Y-%m-%d')}", styles['Normal']))
+        story.append(Spacer(1, 12))
+
+        # Summary Report
+        story.append(Paragraph("Summary Report", styles['Heading2']))
+        for line in summary.split('\n'):
+            story.append(Paragraph(line, styles['Normal']))
+        story.append(Spacer(1, 12))
+
+        # Log Preview
+        story.append(Paragraph("Log Preview", styles['Heading2']))
+        for line in preview.split('\n'):
+            story.append(Paragraph(line, styles['Normal']))
+        story.append(Spacer(1, 12))
+
+        # Anomaly Detection
+        story.append(Paragraph("Anomaly Detection", styles['Heading2']))
+        for line in anomalies.split('\n'):
+            story.append(Paragraph(line, styles['Normal']))
+        story.append(Spacer(1, 12))
+
+        # AMC Reminders
+        story.append(Paragraph("AMC Reminders", styles['Heading2']))
+        for line in amc_reminders.split('\n'):
+            story.append(Paragraph(line, styles['Normal']))
+        story.append(Spacer(1, 12))
+
+        # Dashboard Insights
+        story.append(Paragraph("Dashboard Insights", styles['Heading2']))
+        for line in insights.split('\n'):
+            story.append(Paragraph(line, styles['Normal']))
+
+        # Build PDF
+        doc.build(story)
+        logging.info(f"PDF generated successfully at {pdf_path}")
+        return pdf_path
+    except Exception as e:
+        logging.error(f"Failed to generate PDF: {str(e)}")
+        return None
+
 # Main Gradio function
-async def process_logs(file_obj=None, progress=gr.Progress()):
+async def process_logs(file_obj, progress=gr.Progress()):
     try:
-        progress(0, "Starting data processing...")
+        progress(0, "Starting file processing...")
+        if not file_obj:
+            logging.warning("No file uploaded, returning empty results")
+            return "No file uploaded.", "No data to preview.", None, "No anomalies detected.", "No AMC reminders.", "No insights generated.", None
+
+        file_name = file_obj.name
+        logging.info(f"Processing file: {file_name}")
         
-        # Load data: prioritize CSV if uploaded, otherwise fetch from Salesforce
-        if file_obj:
-            df = load_csv_data(file_obj, row_limit=10000, progress=progress)
-        else:
-            progress(0.05, "No CSV uploaded, fetching from Salesforce...")
-            sf = connect_to_salesforce()
-            df = fetch_salesforce_data(sf, row_limit=10000, progress=progress)
+        if not file_name.endswith(".csv"):
+            logging.error("Unsupported file format")
+            return "Unsupported file format. Please upload a CSV file.", "", None, "", "", "", None
+
+        try:
+            required_columns = ["device_id", "log_type", "status", "timestamp", "usage_hours", "downtime", "amc_date"]
+            dtypes = {
+                "device_id": "string",
+                "log_type": "string",
+                "status": "string",
+                "usage_hours": "float32",
+                "downtime": "float32",
+                "amc_date": "string"
+            }
+            df = pd.read_csv(file_obj, dtype=dtypes)
+            # Check for required columns
+            missing_columns = [col for col in required_columns if col not in df.columns]
+            if missing_columns:
+                logging.error(f"Missing columns: {missing_columns}")
+                return f"Missing required columns: {missing_columns}", None, None, None, None, None, None
+            logging.info(f"File loaded successfully with {len(df)} rows")
+        except Exception as e:
+            logging.error(f"Failed to load CSV: {str(e)}")
+            return f"Failed to load CSV: {str(e)}", None, None, None, None, None, None
+
+        try:
+            df["timestamp"] = pd.to_datetime(df["timestamp"], errors='coerce')
+        except Exception as e:
+            logging.error(f"Date conversion failed: {str(e)}")
+            return f"Failed to convert timestamp to datetime: {str(e)}", None, None, None, None, None, None
 
         if df.empty:
-            logging.warning("No data available")
-            return "No data available.", "No data to preview.", None, "No anomalies detected.", "No AMC reminders.", "No insights generated."
+            logging.warning("No data provided in the file")
+            return "No data available in provided.", None, None, None, None, None, None
 
-        # Step 1: Summary Report
-        progress(0.2, "Generating summary...")
-        summary = f"**Step 1: Summary Report**  \n{summarize_logs(df, progress)}"
+        # Step 1: Summary
+        progress(0.2, "Summary...")
+        summary = f"Step 1: Summary Report\n{summarize_logs(df)}"
 
         # Step 2: Log Preview
-        progress(0.3, "Previewing logs...")
+        progress(0.3, "Previewing...")
         if not df.empty:
-            preview_lines = ["**Step 2: Log Preview (First 5 Rows)**"]
-            for idx, row in df.head().iterrows():
-                preview_lines.append(f"**Row {idx + 1}:** Device ID: {row['device_id']}, Timestamp: {row['timestamp']}, Usage Hours: {row['usage_hours']}, Downtime: {row['downtime']}, AMC Date: {row['amc_date']}, Log Type: {row['log_type']}, Status: {row['status']}")
+            preview_lines = ["Step 2: Log Preview (First 5 Rows)"]
+            for idx, row in df.head(5).iterrows():
+                preview_lines.append(
+                    f"Row {idx + 1}: Device ID: {row['device_id']}, "
+                    f"Log Type: {row['log_type']}, Status: {row['status']}, "
+                    f"Timestamp: {row['timestamp']}, Usage Hours: {row['usage_hours']}, "
+                    f"Downtime: {row['downtime']}, AMC Date: {row['amc_date']}"
+                )
             preview = "\n".join(preview_lines)
         else:
-            preview = "**Step 2: Log Preview**  \nNo data available."
+            preview = "Step 2: Log Preview\nNo data available."
 
         # Step 3: Usage Chart
-        chart = create_usage_chart(df, progress)
+        progress(0.5, "Chart...")
+        chart = create_usage_chart(df)
 
         # Step 4: Anomaly Detection
-        anomalies = f"**Step 3: Anomaly Detection**  \n{detect_anomalies(df, progress)}"
+        progress(0.7, "Anomalies...")
+        anomalies = f"Anomaly Detection\n{detect_anomalies(df)}"
 
         # Step 5: AMC Reminders
-        amc_reminders = f"**Step 4: AMC Reminders**  \n{check_amc_reminders(df, datetime.now(), progress)}"
+        progress(0.8, "AMC...")
+        amc_reminders = f"AMC Reminders\n{check_amc_reminders(df, datetime.now())}"
+
+        # Step 6: Insights
+        progress(0.9, "Insights...")
+        insights = f"Dashboard Insights (AI)\n{generate_dashboard_insights(df)}"
 
-        # Step 6: Dashboard Insights
-        insights = f"**Step 5: Dashboard Insights (AI)**  \n{generate_dashboard_insights(df, progress)}"
+        # Generate PDF if available
+        progress(0.95, "PDF...")
+        pdf_file = generate_pdf_content(summary, preview, anomalies, amc_reminders, insights) if reportlab_available else None
+        if pdf_file is None and reportlab_available:
+            logging.warning("PDF generation failed")
+        elif pdf_file is None:
+            logging.info("PDF skipped: no reportlab")
 
-        progress(1.0, "Processing complete!")
-        return summary, preview, chart, anomalies, amc_reminders, insights
+        progress(1.0, "Done!")
+        return summary, preview, chart, anomalies, amc_reminders, insights, pdf_file
     except Exception as e:
-        logging.error(f"Failed to process data: {str(e)}")
-        return f"Failed to process data: {str(e)}", None, None, None, None, None
+        logging.error(f"Failed to process file: {str(e)}")
+        return f"Error processing file: {str(e)}", None, None, None, None, None, None
 
-# Gradio Interface with Step-by-Step Layout
+# Gradio Interface
 try:
-    logging.info("Initializing Gradio Blocks interface...")
+    logging.info("Initializing Gradio interface...")
     with gr.Blocks(css="""
-        .dashboard-container {border: 1px solid #e0e0e0; padding: 10px; border-radius: 5px; background-color: #f9f9f9;}
+        .dashboard-container {border: 1px solid #e0e0e0; padding: 10px; border-radius: 5px;}
         .dashboard-title {font-size: 24px; font-weight: bold; margin-bottom: 5px;}
-        .dashboard-section {margin-bottom: 5px;}
+        .dashboard-section {margin-bottom: 20px;}
         .dashboard-section h3 {font-size: 18px; margin-bottom: 2px;}
         .dashboard-section p {margin: 1px 0; line-height: 1.2;}
-        .dashboard-section li {margin: 1px 0; line-height: 1.2;}
         .dashboard-section ul {margin: 2px 0; padding-left: 20px;}
     """) as iface:
-        gr.Markdown("<h1>LabOps Log Analyzer Dashboard (Salesforce + Hugging Face AI)</h1>")
-        gr.Markdown("Upload a CSV file or fetch lab equipment logs from Salesforce to analyze usage.")
+        gr.Markdown("<h1>LabOps Log Analyzer Dashboard (Hugging Face AI)</h1>")
+        gr.Markdown("Upload a CSV file containing lab equipment logs to analyze.")
 
         with gr.Row():
             with gr.Column(scale=1):
                 file_input = gr.File(label="Upload Logs (CSV)", file_types=[".csv"])
-                submit_button = gr.Button("Analyze Data", variant="primary")
-           
+                submit_button = gr.Button("Analyze", variant="primary")
+
             with gr.Column(scale=2):
                 with gr.Group(elem_classes="dashboard-container"):
                     gr.Markdown("<div class='dashboard-title'>Analysis Results (Step-by-Step)</div>")
-                   
+                    
                     # Step 1: Summary Report
                     with gr.Group(elem_classes="dashboard-section"):
                         gr.Markdown("### Step 1: Summary Report")
                         summary_output = gr.Markdown()
-                   
+                    
                     # Step 2: Log Preview
                     with gr.Group(elem_classes="dashboard-section"):
                         gr.Markdown("### Step 2: Log Preview")
                         preview_output = gr.Markdown()
-                   
+                        
                     # Step 3: Usage Chart
                     with gr.Group(elem_classes="dashboard-section"):
                         gr.Markdown("### Step 3: Usage Chart")
                         chart_output = gr.Plot()
-                   
+                        
                     # Step 4: Anomaly Detection
                     with gr.Group(elem_classes="dashboard-section"):
                         gr.Markdown("### Step 4: Anomaly Detection")
                         anomaly_output = gr.Markdown()
-                   
+                        
                     # Step 5: AMC Reminders
                     with gr.Group(elem_classes="dashboard-section"):
                         gr.Markdown("### Step 5: AMC Reminders")
                         amc_output = gr.Markdown()
-                   
+                        
                     # Step 6: Dashboard Insights
                     with gr.Group(elem_classes="dashboard-section"):
-                        gr.Markdown("### Step 6: Dashboard Insights (AI)")
+                        gr.Markdown("### Step 6: Insights (AI)")
                         insights_output = gr.Markdown()
+                        
+                    # PDF Download
+                    with gr.Group(elem_classes="dashboard-section"):
+                        gr.Markdown("### Download Report")
+                        pdf_output = gr.File(label="Download Analysis Report as PDF")
 
         submit_button.click(
             fn=process_logs,
             inputs=[file_input],
-            outputs=[summary_output, preview_output, chart_output, anomaly_output, amc_output, insights_output]
+            outputs=[summary_output, preview_output, chart_output, anomaly_output, amc_output, insights_output, pdf_output]
         )
 
     logging.info("Gradio interface initialized successfully")
@@ -352,4 +366,4 @@ if __name__ == "__main__":
     except Exception as e:
         logging.error(f"Failed to launch Gradio interface: {str(e)}")
         print(f"Error launching app: {str(e)}")
-        raise e
+        raise e