Update app.py

app.py

@@ -1,112 +1,593 @@
-
+"""
+LabOps Log Analyzer Dashboard with CSV file upload, PDF generation, Salesforce integration, and AMC reminder email alerts
+"""
 import gradio as gr
 import pandas as pd
-import plotly.express as px
-import numpy as np
+from datetime import datetime, timedelta
 import logging
+import plotly.express as px
 from sklearn.ensemble import IsolationForest
-from simple_salesforce import Salesforce
 from transformers import pipeline
-from datetime import datetime
+import torch
+from concurrent.futures import ThreadPoolExecutor
+from simple_salesforce import Salesforce
 import os
-from reportlab.platypus import SimpleDocTemplate, Paragraph, Spacer
-from reportlab.lib.pagesizes import letter
-from reportlab.lib.styles import getSampleStyleSheet
+import json
 import smtplib
 from email.mime.text import MIMEText
 from email.mime.multipart import MIMEMultipart
 
-# Setup logging
-logging.basicConfig(level=logging.INFO)
+# Configure logging
+logging.basicConfig(level=logging.INFO, format='%(asctime)s - %(levelname)s - %(message)s')
 
-# Environment Variables
-SF_USERNAME = os.getenv("SF_USERNAME")
-SF_PASSWORD = os.getenv("SF_PASSWORD")
-SF_SECURITY_TOKEN = os.getenv("SF_SECURITY_TOKEN")
-SMTP_USERNAME = os.getenv('SMTP_USERNAME', 'harishkumarr@sathkrutha.com')
-SMTP_PASSWORD = os.getenv('SMTP_PASSWORD', 'your_app_password_here')
-EMAIL_FROM = SMTP_USERNAME
-EMAIL_TO = os.getenv('EMAIL_TO', 'sanjaybhargavneela@sathkrutha.com')
+# Salesforce configuration
+try:
+    sf = Salesforce(
+        username='multi-devicelabopsdashboard@sathkrutha.com',
+        password='Team@1234',
+        security_token=os.getenv('SF_SECURITY_TOKEN', ''),
+        domain='login'
+    )
+    logging.info("Salesforce connection established")
+except Exception as e:
+    logging.error(f"Failed to connect to Salesforce: {str(e)}")
+    sf = None
 
-# Hugging Face Pipeline
-summarizer = pipeline("summarization")
+# Email configuration
+SMTP_SERVER = 'smtp.gmail.com'
+SMTP_PORT = 587
+SMTP_USERNAME = 'harishkumarr@sathkrutha.com'
+SMTP_PASSWORD = 'Harish@048'  # Ensure this is an app-specific password
+EMAIL_FROM = "harishkumarr@sathkrutha.com"
+EMAIL_TO = "sanjaybhargavneela@sathkrutha.com"
 
-# Connect to Salesforce
-sf = Salesforce(username=SF_USERNAME, password=SF_PASSWORD, security_token=SF_SECURITY_TOKEN)
+# Try to import reportlab
+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 disabled.")
+    reportlab_available = False
 
-def detect_anomalies(df):
-    df['Usage_Hours__c'] = pd.to_numeric(df['Usage_Hours__c'], errors='coerce').fillna(0)
-    model = IsolationForest(contamination=0.1)
-    df['anomaly'] = model.fit_predict(df[['Usage_Hours__c']])
-    df['anomaly_label'] = df['anomaly'].apply(lambda x: 'Anomaly' if x == -1 else 'Normal')
-    return df
+# Preload Hugging Face model with optimization
+logging.info("Preloading Hugging Face model...")
+try:
+    device = 0 if torch.cuda.is_available() else -1
+    summarizer = pipeline(
+        "summarization",
+        model="facebook/bart-large-cnn",
+        device=device,
+        max_length=50,
+        min_length=10,
+        num_beams=4
+    )
+    logging.info(f"Hugging Face model preloaded on {'GPU' if device == 0 else 'CPU'}")
+except Exception as e:
+    logging.error(f"Failed to preload model: {str(e)}")
+    raise e
+
+# Fetch valid picklist values from Salesforce
+def get_picklist_values(field_name):
+    if sf is None:
+        return []
+    try:
+        obj_desc = sf.SmartLog__c.describe()
+        for field in obj_desc['fields']:
+            if field['name'] == field_name:
+                return [value['value'] for value in field['picklistValues'] if value['active']]
+        return []
+    except Exception as e:
+        logging.error(f"Failed to fetch picklist values for {field_name}: {str(e)}")
+        return []
+
+# Cache picklist values at startup
+status_values = get_picklist_values('Status__c') or ["Active", "Inactive", "Pending"]
+log_type_values = get_picklist_values('Log_Type__c') or ["Smart Log", "Cell Analysis", "UV Verification"]
+logging.info(f"Valid Status__c values: {status_values}")
+logging.info(f"Valid Log_Type__c values: {log_type_values}")
+
+# Map invalid picklist values to valid ones
+picklist_mapping = {
+    'Status__c': {
+        'normal': 'Active',
+        'error': 'Inactive',
+        'warning': 'Pending',
+        'ok': 'Active',
+        'failed': 'Inactive'
+    },
+    'Log_Type__c': {
+        'maint': 'Smart Log',
+        'error': 'Cell Analysis',
+        'ops': 'UV Verification',
+        'maintenance': 'Smart Log',
+        'cell': 'Cell Analysis',
+        'uv': 'UV Verification'
+    }
+}
+
+# Fetch folder ID for "LabOps Reports"
+def get_folder_id(folder_name):
+    if sf is None:
+        return None
+    try:
+        query = f"SELECT Id FROM Folder WHERE Name = '{folder_name}' AND Type = 'Report'"
+        result = sf.query(query)
+        if result['totalSize'] > 0:
+            folder_id = result['records'][0]['Id']
+            logging.info(f"Found folder ID for '{folder_name}': {folder_id}")
+            return folder_id
+        else:
+            logging.error(f"Folder '{folder_name}' not found in Salesforce.")
+            return None
+    except Exception as e:
+        logging.error(f"Failed to fetch folder ID for '{folder_name}': {str(e)}")
+        return None
+
+# Cache the folder ID at startup
+LABOPS_REPORTS_FOLDER_ID = get_folder_id('LabOps Reports')
+
+# Send AMC reminder emails
+def send_amc_reminder_emails(reminders_df):
+    if reminders_df.empty:
+        logging.info("No AMC reminders to send via email.")
+        return "No AMC reminder emails sent (no reminders found)."
+
+    try:
+        # Set up the SMTP server
+        server = smtplib.SMTP(SMTP_SERVER, SMTP_PORT)
+        server.starttls()
+        server.login(SMTP_USERNAME, SMTP_PASSWORD)
+
+        email_results = []
+        for _, row in reminders_df.iterrows():
+            device_id = row['device_id']
+            amc_date = row['amc_date'].strftime('%Y-%m-%d')
 
+            # Create the email
+            msg = MIMEMultipart()
+            msg['From'] = EMAIL_FROM
+            msg['To'] = EMAIL_TO
+            msg['Subject'] = f"AMC Reminder for Device {device_id}"
+
+            body = f"""
+Dear Sanjay Bhargav Neela,
+This is a reminder that the Annual Maintenance Contract (AMC) for the following device is due:
+- Device ID: {device_id}
+- AMC Date: {amc_date}
+Please schedule the maintenance at your earliest convenience.
+Best regards,
+Harish Kumar
+LabOps Team
+"""
+            msg.attach(MIMEText(body, 'plain'))
+
+            # Send the email
+            server.sendmail(EMAIL_FROM, EMAIL_TO, msg.as_string())
+            logging.info(f"AMC reminder email sent for Device ID {device_id} to {EMAIL_TO}")
+            email_results.append(f"Sent AMC reminder for Device ID {device_id}")
+
+        server.quit()
+        return "\n".join(email_results) if email_results else "No emails sent."
+    except Exception as e:
+        logging.error(f"Failed to send AMC reminder emails: {str(e)}")
+        return f"Failed to send AMC reminder emails: {str(e)}"
+
+# Simplified Salesforce report creation
+def create_salesforce_reports(df):
+    if sf is None:
+        return "Salesforce connection not available."
+    if not LABOPS_REPORTS_FOLDER_ID:
+        return "Cannot create reports: 'LabOps Reports' folder not found in Salesforce."
+
+    try:
+        # Simplified Usage Report
+        usage_report_metadata = {
+            "reportMetadata": {
+                "name": f"SmartLog_Usage_Report_{datetime.now().strftime('%Y%m%d_%H%M%S')}",
+                "reportType": "SmartLog__c",
+                "reportFormat": "SUMMARY",
+                "reportColumns": [
+                    {"field": "Device_Id__c"},
+                    {"field": "Usage_Hours__c", "aggregateTypes": ["Sum"]}
+                ],
+                "groupingsDown": [
+                    {"field": "Device_Id__c", "sortOrder": "Asc"}
+                ],
+                "folderId": LABOPS_REPORTS_FOLDER_ID
+            }
+        }
+        usage_result = sf.restful('analytics/reports', method='POST', json=usage_report_metadata)
+        usage_report_id = usage_result['id']
+        logging.info(f"Usage Report created: {usage_report_id}")
+
+        # Simplified AMC Reminders Report
+        amc_report_metadata = {
+            "reportMetadata": {
+                "name": f"SmartLog_AMC_Reminders_{datetime.now().strftime('%Y%m%d_%H%M%S')}",
+                "reportType": "SmartLog__c",
+                "reportFormat": "TABULAR",
+                "reportColumns": [
+                    {"field": "Device_Id__c"},
+                    {"field": "AMC_Date__c"}
+                ],
+                "folderId": LABOPS_REPORTS_FOLDER_ID
+            }
+        }
+        amc_result = sf.restful('analytics/reports', method='POST', json=amc_report_metadata)
+        amc_report_id = amc_result['id']
+        logging.info(f"AMC Reminders Report created: {amc_report_id}")
+
+        return f"Usage Report ID: {usage_report_id}, AMC Reminders Report ID: {amc_report_id}"
+    except Exception as e:
+        logging.error(f"Failed to create Salesforce reports: {str(e)}")
+        return f"Failed to create reports: {str(e)}"
+
+# Save results to Salesforce SmartLog__c with better AMC_Date__c handling
+def save_to_salesforce(df, summary, anomalies, amc_reminders, insights):
+    if sf is None:
+        return "Salesforce connection not available."
+    try:
+        records = []
+        current_date = datetime.now()
+        next_30_days = current_date + timedelta(days=30)
+        for _, row in df.head(100).iterrows():
+            # Validate and map picklist values
+            status = str(row['status'])
+            log_type = str(row['log_type'])
+            
+            # Map Status__c
+            if status not in status_values:
+                status = picklist_mapping['Status__c'].get(status.lower(), status_values[0] if status_values else None)
+                if status is None:
+                    logging.warning(f"Skipping record with invalid Status__c: {row['status']}")
+                    continue
+            
+            # Map Log_Type__c
+            if log_type not in log_type_values:
+                log_type = picklist_mapping['Log_Type__c'].get(log_type.lower(), log_type_values[0] if log_type_values else None)
+                if log_type is None:
+                    logging.warning(f"Skipping record with invalid Log_Type__c: {row['log_type']}")
+                    continue
+
+            # Handle AMC_Date__c with proper formatting
+            amc_date_str = None
+            if pd.notna(row['amc_date']):
+                try:
+                    amc_date = pd.to_datetime(row['amc_date']).strftime('%Y-%m-%d')
+                    amc_date_str = amc_date
+                    amc_date_dt = datetime.strptime(amc_date, '%Y-%m-%d')
+                    if status == "Active" and current_date.date() <= amc_date_dt.date() <= next_30_days.date():
+                        logging.info(f"Record qualifies for AMC Reminders: Device ID {row['device_id']}, AMC Date {amc_date_str}")
+                except Exception as e:
+                    logging.error(f"Failed to parse AMC Date for Device ID {row['device_id']}: {str(e)}")
+                    amc_date_str = None
+
+            record = {
+                'Device_Id__c': str(row['device_id'])[:50],
+                'Log_Type__c': log_type,
+                'Status__c': status,
+                'Timestamp__c': row['timestamp'].isoformat() if pd.notna(row['timestamp']) else None,
+                'Usage_Hours__c': float(row['usage_hours']) if pd.notna(row['usage_hours']) else 0.0,
+                'Downtime__c': float(row['downtime']) if pd.notna(row['downtime']) else 0.0,
+                'AMC_Date__c': amc_date_str
+            }
+            records.append(record)
+        
+        # Bulk insert to reduce API calls
+        if records:
+            sf.bulk.SmartLog__c.insert(records)
+            logging.info(f"Saved {len(records)} records to Salesforce")
+        return f"Saved {len(records)} records to Salesforce."
+    except Exception as e:
+        logging.error(f"Failed to save to Salesforce: {str(e)}")
+        return f"Failed to save to Salesforce: {str(e)}"
+
+# Summarize logs
 def summarize_logs(df):
-    joined_text = "\n".join([f"Device {row['Device_Id__c']} used for {row['Usage_Hours__c']} hrs with status {row['Status__c']}" for _, row in df.iterrows()])
-    summary = summarizer(joined_text, max_length=100, min_length=30, do_sample=False)[0]['summary_text']
-    return summary
-
-def save_to_salesforce(df):
-    records = []
-    for _, row in df.iterrows():
-        record = {
-            "Device_Id__c": row.get("Device_Id__c"),
-            "Usage_Hours__c": float(row.get("Usage_Hours__c", 0)),
-            "Downtime__c": float(row.get("Downtime__c", 0)),
-            "Timestamp__c": row.get("Timestamp__c"),
-            "Status__c": row.get("Status__c"),
-            "Log_Type__c": row.get("Log_Type__c"),
-            "AMC_Date__c": row.get("AMC_Date__c"),
-            "Name": row.get("Device_Id__c") + "-" + datetime.now().strftime("%Y%m%d%H%M%S")
+    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 f"Failed to generate summary: {str(e)}"
+
+# Anomaly detection
+def detect_anomalies(df):
+    try:
+        if "usage_hours" not in df.columns or "downtime" not in df.columns:
+            return "Anomaly detection requires 'usage_hours' and 'downtime' columns."
+        if len(df) > 1000:
+            df = df.sample(n=1000, random_state=42)
+        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:"]
+        for _, row in anomalies.head(5).iterrows():
+            anomaly_lines.append(
+                f"- Device ID: {row['device_id']}, Usage Hours: {row['usage_hours']}, "
+                f"Downtime: {row['downtime']}, Timestamp: {row['timestamp']}"
+            )
+        return "\n".join(anomaly_lines)
+    except Exception as e:
+        logging.error(f"Anomaly detection failed: {str(e)}")
+        return f"Anomaly detection failed: {str(e)}"
+
+# AMC reminders
+def check_amc_reminders(df, current_date):
+    try:
+        if "device_id" not in df.columns or "amc_date" not in df.columns:
+            return "AMC reminders require 'device_id' and 'amc_date' columns.", pd.DataFrame()
+        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.", reminders
+        reminder_lines = ["Upcoming AMC Reminders:"]
+        for _, row in reminders.head(5).iterrows():
+            reminder_lines.append(f"- Device ID: {row['device_id']}, AMC Date: {row['amc_date']}")
+        return "\n".join(reminder_lines), reminders
+    except Exception as e:
+        logging.error(f"AMC reminder generation failed: {str(e)}")
+        return f"AMC reminder generation failed: {str(e)}", pd.DataFrame()
+
+# Dashboard insights
+def generate_dashboard_insights(df):
+    try:
+        total_devices = df["device_id"].nunique()
+        avg_usage = df["usage_hours"].mean() if "usage_hours" in df.columns else 0
+        prompt = f"Insights: {total_devices} devices, avg usage {avg_usage:.2f} hours."
+        insights = summarizer(prompt, max_length=50, min_length=10, do_sample=False)[0]["summary_text"]
+        return insights
+    except Exception as e:
+        logging.error(f"Dashboard insights generation failed: {str(e)}")
+        return f"Dashboard insights generation failed: {str(e)}"
+
+# Create usage chart
+def create_usage_chart(df):
+    try:
+        usage_data = df.groupby("device_id")["usage_hours"].sum().reset_index()
+        if len(usage_data) > 5:
+            usage_data = usage_data.nlargest(5, "usage_hours")
+        custom_colors = ['#FF6B6B', '#4ECDC4', '#45B7D1', '#96CEB4']
+        fig = px.bar(
+            usage_data,
+            x="device_id",
+            y="usage_hours",
+            title="Usage Hours per Device",
+            labels={"device_id": "Device ID", "usage_hours": "Usage Hours"},
+            color="device_id",
+            color_discrete_sequence=custom_colors
+        )
+        fig.update_layout(
+            title_font_size=16,
+            margin=dict(l=20, r=20, t=40, b=20),
+            plot_bgcolor="white",
+            paper_bgcolor="white",
+            font=dict(size=12)
+        )
+        return fig
+    except Exception as e:
+        logging.error(f"Failed to create usage chart: {str(e)}")
+        return None
+
+# Generate PDF content
+def generate_pdf_content(summary, preview, anomalies, amc_reminders, insights, email_status):
+    if not reportlab_available:
+        return None
+    try:
+        pdf_path = f"analysis_report_{datetime.now().strftime('%Y%m%d_%H%M%S')}.pdf"
+        doc = SimpleDocTemplate(pdf_path, pagesize=letter)
+        styles = getSampleStyleSheet()
+        story = []
+
+        def safe_paragraph(text, style):
+            return Paragraph(str(text).replace('\n', '<br/>'), style) if text else Paragraph("", style)
+
+        story.append(Paragraph("LabOps Log Analysis Report", styles['Title']))
+        story.append(Paragraph(f"Generated on {datetime.now().strftime('%Y-%m-%d %H:%M:%S')}", styles['Normal']))
+        story.append(Spacer(1, 12))
+
+        story.append(Paragraph("Summary Report", styles['Heading2']))
+        story.append(safe_paragraph(summary or "No summary available.", styles['Normal']))
+        story.append(Spacer(1, 12))
+
+        story.append(Paragraph("Log Preview", styles['Heading2']))
+        story.append(safe_paragraph(preview or "No preview available.", styles['Normal']))
+        story.append(Spacer(1, 12))
+
+        story.append(Paragraph("Anomaly Detection", styles['Heading2']))
+        story.append(safe_paragraph(anomalies or "No anomalies detected.", styles['Normal']))
+        story.append(Spacer(1, 12))
+
+        story.append(Paragraph("AMC Reminders", styles['Heading2']))
+        story.append(safe_paragraph(amc_reminders or "No AMC reminders.", styles['Normal']))
+        story.append(Spacer(1, 12))
+
+        story.append(Paragraph("Email Notification Status", styles['Heading2']))
+        story.append(safe_paragraph(email_status or "No emails sent.", styles['Normal']))
+        story.append(Spacer(1, 12))
+
+        story.append(Paragraph("Dashboard Insights", styles['Heading2']))
+        story.append(safe_paragraph(insights or "No insights generated.", styles['Normal']))
+
+        doc.build(story)
+        logging.info(f"PDF generated at {pdf_path}")
+        return pdf_path
+    except Exception as e:
+        logging.error(f"Failed to generate PDF: {str(e)}")
+        return None
+
+# Main Gradio function with optimized performance
+async def process_logs(file_obj):
+    try:
+        start_time = datetime.now()
+        if not file_obj:
+            return "No file uploaded.", "No data to preview.", None, "No anomalies detected.", "No AMC reminders.", "No insights generated.", None, "No Salesforce data saved.", "No report created.", "No emails sent."
+
+        file_name = file_obj.name
+        logging.info(f"Processing file: {file_name}")
+        
+        if not file_name.endswith(".csv"):
+            return "Please upload a CSV file.", "", None, "", "", "", None, "", "", ""
+
+        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"
         }
-        records.append(record)
-    result = sf.bulk.SmartLog__c.insert(records)
-    logging.info(f"Inserted {len(result)} records into Salesforce")
-    return result
-
-def generate_pdf(summary):
-    filename = "/tmp/audit_summary.pdf"
-    doc = SimpleDocTemplate(filename, pagesize=letter)
-    styles = getSampleStyleSheet()
-    elements = [Paragraph("Smart Audit Log Summary", styles['Title']), Spacer(1, 12)]
-    elements.append(Paragraph(summary, styles['BodyText']))
-    doc.build(elements)
-    return filename
-
-def send_email_alert(subject, body):
-    msg = MIMEMultipart()
-    msg['From'] = EMAIL_FROM
-    msg['To'] = EMAIL_TO
-    msg['Subject'] = subject
-    msg.attach(MIMEText(body, 'plain'))
-
-    with smtplib.SMTP_SSL('smtp.gmail.com', 465) as server:
-        server.login(SMTP_USERNAME, SMTP_PASSWORD)
-        server.send_message(msg)
-
-def process_logs(file):
-    df = pd.read_csv(file)
-    df = detect_anomalies(df)
-    summary = summarize_logs(df)
-    pdf_path = generate_pdf(summary)
-    save_to_salesforce(df)
-
-    anomalies = df[df['anomaly_label'] == 'Anomaly']
-    if not anomalies.empty:
-        alert_msg = f"Anomalies Detected in Devices:\n" + "\n".join(anomalies['Device_Id__c'].values)
-        send_email_alert("Anomaly Alert", alert_msg)
-
-    fig = px.scatter(df, x="Device_Id__c", y="Usage_Hours__c", color="anomaly_label", title="Device Usage with Anomalies")
-    return df, summary, fig, pdf_path
-
-with gr.Blocks() as app:
-    gr.Markdown("### LabOps Log Analyzer Dashboard")
-    file_input = gr.File(label="Upload LabOps CSV", file_types=[".csv"])
-    df_output = gr.Dataframe()
-    summary_output = gr.Textbox(label="Summary")
-    graph_output = gr.Plot()
-    pdf_download = gr.File(label="Download PDF Summary")
-
-    file_input.change(fn=process_logs, inputs=file_input, outputs=[df_output, summary_output, graph_output, pdf_download])
-
-app.launch()
+        df = pd.read_csv(file_obj, dtype=dtypes)
+        missing_columns = [col for col in required_columns if col not in df.columns]
+        if missing_columns:
+            return f"Missing columns: {missing_columns}", None, None, None, None, None, None, None, None, None
+        df["timestamp"] = pd.to_datetime(df["timestamp"], errors='coerce')
+        df["amc_date"] = pd.to_datetime(df["amc_date"], errors='coerce')
+        if df.empty:
+            return "No data available.", None, None, None, None, None, None, None, None, None
+
+        # Run tasks concurrently but simplify execution
+        with ThreadPoolExecutor(max_workers=4) as executor:
+            future_summary = executor.submit(summarize_logs, df)
+            future_anomalies = executor.submit(detect_anomalies, df)
+            future_amc = executor.submit(check_amc_reminders, df, datetime.now())
+            future_insights = executor.submit(generate_dashboard_insights, df)
+            future_chart = executor.submit(create_usage_chart, df)
+            future_reports = executor.submit(create_salesforce_reports, df)
+
+            summary = f"Step 1: Summary Report\n{future_summary.result()}"
+            anomalies = f"Anomaly Detection\n{future_anomalies.result()}"
+            amc_reminders, reminders_df = future_amc.result()
+            amc_reminders = f"AMC Reminders\n{amc_reminders}"
+            insights = f"Dashboard Insights (AI)\n{future_insights.result()}"
+            chart = future_chart.result()
+            report_result = future_reports.result()
+
+        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)
+
+        salesforce_result = save_to_salesforce(df, summary, anomalies, amc_reminders, insights)
+        email_status = send_amc_reminder_emails(reminders_df)
+        pdf_file = generate_pdf_content(summary, preview, anomalies, amc_reminders, insights, email_status)
+
+        elapsed_time = (datetime.now() - start_time).total_seconds()
+        logging.info(f"Processing completed in {elapsed_time:.2f} seconds")
+        return summary, preview, chart, anomalies, amc_reminders, insights, pdf_file, salesforce_result, report_result, email_status
+    except Exception as e:
+        logging.error(f"Failed to process file: {str(e)}")
+        return f"Error: {str(e)}", None, None, None, None, None, None, None, None, None
+
+# Gradio Interface
+try:
+    logging.info("Initializing Gradio interface...")
+    with gr.Blocks(css="""
+        .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: 20px;}
+        .dashboard-section h3 {font-size: 18px; margin-bottom: 2px;}
+        .dashboard-section p {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 (Hugging Face AI)</h1>")
+        gr.Markdown("Upload a CSV file to analyze, generate Salesforce reports, and send AMC reminder emails.")
+
+        with gr.Row():
+            with gr.Column(scale=1):
+                file_input = gr.File(label="Upload Logs (CSV)", file_types=[".csv"])
+                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</div>")
+                    
+                    with gr.Group(elem_classes="dashboard-section"):
+                        gr.Markdown("### Step 1: Summary Report")
+                        summary_output = gr.Markdown()
+                    
+                    with gr.Group(elem_classes="dashboard-section"):
+                        gr.Markdown("### Step 2: Log Preview")
+                        preview_output = gr.Markdown()
+                        
+                    with gr.Group(elem_classes="dashboard-section"):
+                        gr.Markdown("### Step 3: Usage Chart")
+                        chart_output = gr.Plot()
+                        
+                    with gr.Group(elem_classes="dashboard-section"):
+                        gr.Markdown("### Step 4: Anomaly Detection")
+                        anomaly_output = gr.Markdown()
+                        
+                    with gr.Group(elem_classes="dashboard-section"):
+                        gr.Markdown("### Step 5: AMC Reminders")
+                        amc_output = gr.Markdown()
+                        
+                    with gr.Group(elem_classes="dashboard-section"):
+                        gr.Markdown("### Step 6: Insights (AI)")
+                        insights_output = gr.Markdown()
+                        
+                    with gr.Group(elem_classes="dashboard-section"):
+                        gr.Markdown("### Step 7: Email Notification Status")
+                        email_output = gr.Markdown()
+                        
+                    with gr.Group(elem_classes="dashboard-section"):
+                        gr.Markdown("### Salesforce Integration")
+                        salesforce_output = gr.Markdown()
+                        
+                    with gr.Group(elem_classes="dashboard-section"):
+                        gr.Markdown("### Salesforce Reports")
+                        report_output = gr.Markdown()
+                        
+                    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,
+                pdf_output,
+                salesforce_output,
+                report_output,
+                email_output
+            ]
+        )
+
+    logging.info("Gradio interface initialized successfully")
+except Exception as e:
+    logging.error(f"Failed to initialize Gradio interface: {str(e)}")
+    raise e
+
+if __name__ == "__main__":
+    try:
+        logging.info("Launching Gradio interface...")
+        iface.launch(server_name="0.0.0.0", server_port=7860, debug=True, share=False)
+        logging.info("Gradio interface launched successfully")
+    except Exception as e:
+        logging.error(f"Failed to launch Gradio interface: {str(e)}")
+        print(f"Error launching app: {str(e)}")
+        raise e