Update app.py

app.py

@@ -1,194 +1,195 @@
-import gradio as gr
+from flask import Flask, request, jsonify
+from simple_salesforce import Salesforce
 import pandas as pd
-from datetime import datetime
+from datetime import datetime, timedelta
 import logging
-import plotly.express as px
 from sklearn.ensemble import IsolationForest
 from transformers import pipeline
+import torch
+import os
+import time
+import requests
+from requests.exceptions import Timeout
 
-logging.basicConfig(level=logging.INFO, format='%(asctime)s - %(levelname)s - %(message)s')
+# Configure logging
+logging.basicConfig(
+    level=logging.INFO,
+    format='%(asctime)s - %(levelname)s - %(message)s',
+    handlers=[
+        logging.FileHandler('app.log'),
+        logging.StreamHandler()
+    ]
+)
 
-try:
-    logging.info("Attempting to load Hugging Face model...")
-    summarizer = pipeline("text2text-generation", model="google/flan-t5-base")
-    logging.info("Hugging Face model loaded successfully")
-except Exception as e:
-    logging.error(f"Failed to load model: {str(e)}")
-    raise e
+# Initialize Flask app
+app = Flask(__name__)
 
-def summarize_logs(df):
-    try:
-        total_devices = df["device_id"].nunique()
-        avg_uptime = "97%"
-        most_used = df.groupby("device_id")["usage_hours"].sum().idxmax() if not df.empty else "N/A"
-        downtime_events = 3
-        prompt = (f"Summarize maintenance and usage logs. There were {total_devices} devices. The most used device was {most_used}.")
-        summary = summarizer(prompt, max_length=200, do_sample=False)[0]["generated_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."
+# Salesforce credentials (use environment variables for security)
+SF_USERNAME = os.getenv('SF_USERNAME', 'your_salesforce_username')
+SF_PASSWORD = os.getenv('SF_PASSWORD', 'your_salesforce_password')
+SF_SECURITY_TOKEN = os.getenv('SF_SECURITY_TOKEN', 'your_security_token')
+SF_INSTANCE_URL = os.getenv('SF_INSTANCE_URL', 'https://login.salesforce.com')
 
-def detect_anomalies(df):
-    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."
-        features = df[["usage_hours", "downtime"]].fillna(0)
-        iso_forest = IsolationForest(contamination=0.1, random_state=42)
-        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 idx, row in anomalies.iterrows():
-            anomaly_lines.append(f"- Device ID: {row['device_id']}")
-            anomaly_lines.append(f"  Usage Hours: {row['usage_hours']}")
-            anomaly_lines.append(f"  Downtime: {row['downtime']}")
-            anomaly_lines.append(f"  Timestamp: {row['timestamp']}")
-            anomaly_lines.append("---")
-        anomaly_list = "\n".join(anomaly_lines)
-        logging.info("Anomalies detected successfully")
-        return anomaly_list
-    except Exception as e:
-        logging.error(f"Anomaly detection failed: {str(e)}")
-        return f"Anomaly detection failed: {str(e)}"
+# Global variables
+sf = None
+summarizer = None
 
-def check_amc_reminders(df, current_date):
-    try:
-        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"])
-        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:**"]
-        for idx, row in reminders.iterrows():
-            reminder_lines.append(f"- Device ID: {row['device_id']}")
-            reminder_lines.append(f"  AMC Date: {row['amc_date']}")
-            reminder_lines.append("---")
-        reminder_list = "\n".join(reminder_lines)
-        logging.info("AMC reminders generated successfully")
-        return reminder_list
-    except Exception as e:
-        logging.error(f"AMC reminder generation failed: {str(e)}")
-        return f"AMC reminder generation failed: {str(e)}"
+# Health check endpoint
+@app.route('/health', methods=['GET'])
+def health_check():
+    return jsonify({"status": "App is running"}), 200
 
-def generate_dashboard_insights(df):
+# Connect to Salesforce
+def connect_to_salesforce():
+    global sf
+    logging.info("Attempting to connect to Salesforce...")
+    start_time = time.time()
     try:
-        total_devices = df["device_id"].nunique()
-        avg_usage = df["usage_hours"].mean() if "usage_hours" in df.columns else 0
-        prompt = (f"Generate executive-level insights. There were {total_devices} devices with an average usage of {avg_usage:.2f} hours.")
-        insights = summarizer(prompt, max_length=150, do_sample=False)[0]["generated_text"]
-        logging.info("Dashboard insights generated successfully")
-        return insights
+        session = requests.Session()
+        adapter = requests.adapters.HTTPAdapter(max_retries=3)
+        session.mount('https://', adapter)
+        session.request('GET', SF_INSTANCE_URL, timeout=10)
+
+        sf = Salesforce(
+            username=SF_USERNAME,
+            password=SF_PASSWORD,
+            security_token=SF_SECURITY_TOKEN,
+            instance_url=SF_INSTANCE_URL,
+            session=session
+        )
+        logging.info(f"Connected to Salesforce in {time.time() - start_time:.2f} seconds")
+        return True
+    except Timeout:
+        logging.error("Salesforce connection timed out after 10 seconds")
+        sf = None
+        return False
     except Exception as e:
-        logging.error(f"Dashboard insights generation failed: {str(e)}")
-        return f"Dashboard insights generation failed: {str(e)}"
+        logging.error(f"Failed to connect to Salesforce: {str(e)}")
+        sf = None
+        return False
+
+# Load Hugging Face model
+def load_huggingface_model():
+    global summarizer
+    if summarizer is None:
+        logging.info("Loading Hugging Face model...")
+        start_time = time.time()
+        try:
+            device = 0 if torch.cuda.is_available() else -1
+            summarizer = pipeline("summarization", model="sshleifer/distilbart-cnn-12-6", device=device)
+            logging.info(f"Hugging Face model loaded in {time.time() - start_time:.2f} seconds on device: {'GPU' if device == 0 else 'CPU'}")
+        except Exception as e:
+            logging.error(f"Failed to load Hugging Face model: {str(e)}")
+            summarizer = None
 
-def create_usage_chart(df):
+# Fetch SmartLog records
+def fetch_smartlog_records(lab_site=None, start_date=None, end_date=None, equipment_type=None):
+    if sf is None:
+        raise Exception("Salesforce connection not established")
     try:
-        usage_data = df.groupby("device_id")["usage_hours"].sum().reset_index()
-        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="usage_hours", color_continuous_scale="Blues")
-        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
+        logging.info("Fetching SmartLog records...")
+        query = "SELECT Device_Id__c, Log_Type__c, Status__c, Timestamp__c, Usage_Hours__c, Downtime__c, AMC_Date__c FROM SmartLog__c"
+        conditions = []
+        params = {}
+        if lab_site:
+            conditions.append("Lab_Site__c = :lab_site")
+            params['lab_site'] = lab_site
+        if start_date:
+            conditions.append("Timestamp__c >= :start_date")
+            params['start_date'] = start_date
+        if end_date:
+            conditions.append("Timestamp__c <= :end_date")
+            params['end_date'] = end_date
+        if equipment_type:
+            conditions.append("Log_Type__c = :equipment_type")
+            params['equipment_type'] = equipment_type
+
+        if conditions:
+            query += " WHERE " + " AND ".join(conditions)
+
+        result = sf.query_all(query, **params)
+        records = result['records']
+        data = [{
+            'device_id': r['Device_Id__c'],
+            'log_type': r['Log_Type__c'],
+            'status': r['Status__c'],
+            'timestamp': r['Timestamp__c'],
+            'usage_hours': r['Usage_Hours__c'],
+            'downtime': r['Downtime__c'],
+            'amc_date': r['AMC_Date__c']
+        } for r in records]
+        df = pd.DataFrame(data)
+        df['timestamp'] = pd.to_datetime(df['timestamp'], errors='coerce')
+        df['amc_date'] = pd.to_datetime(df['amc_date'], errors='coerce')
+        logging.info(f"Fetched {len(df)} SmartLog records")
+        return df
     except Exception as e:
-        logging.error(f"Failed to create usage chart: {str(e)}")
-        return None
+        logging.error(f"Failed to fetch SmartLog records: {str(e)}")
+        raise
+
+# Summarize logs
+def summarize_logs(df):
+    load_huggingface_model()
+    if summarizer is None:
+        return {"error": "Hugging Face model not loaded"}
 
-def process_logs(file_obj):
     try:
-        if file_obj is None:
-            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."
-        file_name = file_obj.name if hasattr(file_obj, 'name') else file_obj
-        logging.info(f"Processing file: {file_name}")
-        if not file_name.endswith(".csv"):
-            logging.error("Unsupported file format")
-            return "Unsupported file format. Please upload a CSV file.", None, None, None, None, None
-        df = pd.read_csv(file_name)
-        logging.info(f"File loaded successfully with {len(df)} rows")
-        try:
-            df["timestamp"] = pd.to_datetime(df["timestamp"])
-        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
-        if df.empty:
-            logging.warning("No data in the file")
-            return "No data available in the file.", "No data to preview.", None, "No anomalies detected.", "No AMC reminders.", "No insights generated."
-        summary = f"**Step 1: Summary Report**\n\n{summarize_logs(df)}\n\n---\n"
-        if not df.empty:
-            preview_lines = ["**Step 2: Log Preview (First 5 Rows)**\n"]
-            for idx, row in df.head().iterrows():
-                preview_lines.append(f"**Row {idx + 1}:**")
-                preview_lines.append(f"- Device ID: {row['device_id']}")
-                preview_lines.append(f"- Timestamp: {row['timestamp']}")
-                preview_lines.append(f"- Usage Hours: {row['usage_hours']}")
-                preview_lines.append(f"- Downtime: {row['downtime']}")
-                preview_lines.append(f"- AMC Date: {row['amc_date']}")
-                preview_lines.append("---")
-            preview = "\n".join(preview_lines) + "\n---\n"
-        else:
-            preview = "**Step 2: Log Preview**\n\nNo data available.\n\n---\n"
-        chart = create_usage_chart(df)
-        anomalies = f"**Step 3: Anomaly Detection**\n\n{detect_anomalies(df)}\n\n---\n"
-        amc_reminders = f"**Step 4: AMC Reminders**\n\n{check_amc_reminders(df, datetime.now())}\n\n---\n"
-        insights = f"**Step 5: Dashboard Insights (AI)**\n\n{generate_dashboard_insights(df)}\n\n---\n"
-        return summary, preview, chart, anomalies, amc_reminders, insights
+        # Generate summary statistics
+        total_records = len(df)
+        unique_devices = df['device_id'].nunique()
+        avg_usage_hours = df['usage_hours'].mean()
+        total_downtime = df['downtime'].sum()
+        
+        # Create text for summarization
+        summary_text = (
+            f"Analyzed {total_records} SmartLog records from Salesforce. "
+            f"There are {unique_devices} unique devices. "
+            f"Average usage hours per device is {avg_usage_hours:.2f} hours. "
+            f"Total downtime recorded is {total_downtime:.2f} hours. "
+            f"Status distribution: {df['status'].value_counts().to_dict()}. "
+        )
+        
+        # Generate summary using Hugging Face model
+        summary = summarizer(summary_text, max_length=100, min_length=30, do_sample=False)[0]['summary_text']
+        
+        # Detect anomalies using Isolation Forest
+        features = df[['usage_hours', 'downtime']].fillna(0)
+        iso_forest = IsolationForest(contamination=0.1, random_state=42)
+        df['anomaly'] = iso_forest.fit_predict(features)
+        anomalies = df[df['anomaly'] == -1][['device_id', 'usage_hours', 'downtime']].to_dict('records')
+
+        return {
+            "summary": summary,
+            "statistics": {
+                "total_records": total_records,
+                "unique_devices": unique_devices,
+                "avg_usage_hours": avg_usage_hours,
+                "total_downtime": total_downtime
+            },
+            "anomalies": anomalies
+        }
     except Exception as e:
-        logging.error(f"Failed to process file: {str(e)}")
-        return f"Failed to process file: {str(e)}", None, None, None, None, None
-
-try:
-    logging.info("Initializing Gradio Blocks interface...")
-    with gr.Blocks(css=""".dashboard-container {border: 1px solid #e0e0e0; padding: 10px; border-radius: 5px; background-color: #f9f9f9;} .dashboard-title {font-size: 24px; font-weight: bold; margin-bottom: 10px;} .dashboard-section {margin-bottom: 15px;} .dashboard-section h3 {font-size: 18px; margin-bottom: 5px;}""") as iface:
-        gr.Markdown("<h1>LabOps Log Analyzer Dashboard (Hugging Face AI)</h1>")
-        gr.Markdown("Upload a CSV file containing lab equipment logs to analyze usage.")
-        with gr.Row():
-            with gr.Column(scale=1):
-                file_input = gr.File(label="Upload Logs (CSV)", file_types=[".csv"])
-                submit_button = gr.Button("Submit", 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>")
-                    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: Dashboard Insights (AI)")
-                        insights_output = gr.Markdown()
-        submit_button.click(fn=process_logs, inputs=[file_input], 
-                            outputs=[summary_output, preview_output, chart_output, anomaly_output, amc_output, insights_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__":
+        logging.error(f"Failed to summarize logs: {str(e)}")
+        return {"error": str(e)}
+
+# Main endpoint to fetch and summarize logs
+@app.route('/summarize', methods=['POST'])
+def summarize():
+    if not connect_to_salesforce():
+        return jsonify({"error": "Failed to connect to Salesforce"}), 500
+    
+    data = request.get_json()
+    lab_site = data.get('lab_site')
+    start_date = data.get('start_date')
+    end_date = data.get('end_date')
+    equipment_type = data.get('equipment_type')
+
     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")
+        df = fetch_smartlog_records(lab_site, start_date, end_date, equipment_type)
+        result = summarize_logs(df)
+        return jsonify(result), 200
     except Exception as e:
-        logging.error(f"Failed to launch Gradio interface: {str(e)}")
-        print(f"Error launching app: {str(e)}")
-        raise e
+        return jsonify({"error": str(e)}), 500
+
+if __name__ == '__main__':
+    app.run(debug=True, host='0.0.0.0', port=5000)