Update app.py

app.py

@@ -1,14 +1,17 @@
 from flask import Flask, request, jsonify
+from simple_salesforce import Salesforce
 import pandas as pd
 from datetime import datetime
 import logging
-from simple_salesforce import Salesforce
+from sklearn.ensemble import IsolationForest
+from transformers import pipeline
+import torch
 import os
+import time
 import requests
 from requests.exceptions import Timeout
-import time
 
-# Configure logging for debugging
+# Configure logging
 logging.basicConfig(
     level=logging.INFO,
     format='%(asctime)s - %(levelname)s - %(message)s',
@@ -21,25 +24,22 @@ logging.basicConfig(
 # Initialize Flask app
 app = Flask(__name__)
 
-# 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')
+# Salesforce credentials
+SF_USERNAME = os.getenv('SF_USERNAME', 'your_username')
+SF_PASSWORD = os.getenv('SF_PASSWORD', 'your_password')
+SF_SECURITY_TOKEN = os.getenv('SF_SECURITY_TOKEN', 'your_token')
 SF_INSTANCE_URL = os.getenv('SF_INSTANCE_URL', 'https://login.salesforce.com')
 
-# Global Salesforce connection
 sf = None
+summarizer = None
 
-# Health check endpoint
 @app.route('/health', methods=['GET'])
 def health_check():
-    return jsonify({"status": "App is running", "timestamp": datetime.now().isoformat()}), 200
+    return jsonify({"status": "App is running"}), 200
 
-# Connect to Salesforce
 def connect_to_salesforce():
     global sf
-    logging.info("Attempting to connect to Salesforce...")
-    start_time = time.time()
+    logging.info("Connecting to Salesforce...")
     try:
         session = requests.Session()
         adapter = requests.adapters.HTTPAdapter(max_retries=3)
@@ -53,122 +53,111 @@ def connect_to_salesforce():
             instance_url=SF_INSTANCE_URL,
             session=session
         )
-        logging.info(f"Connected to Salesforce in {time.time() - start_time:.2f} seconds")
-        return True
+        logging.info("Connected to Salesforce successfully.")
     except Timeout:
-        logging.error("Salesforce connection timed out after 10 seconds")
+        logging.error("Salesforce connection timed out.")
         sf = None
-        return False
     except Exception as e:
-        logging.error(f"Failed to connect to Salesforce: {str(e)}")
+        logging.error(f"Salesforce connection error: {e}")
         sf = None
-        return False
 
-# Fetch SmartLog records
+def load_huggingface_model():
+    global summarizer
+    if summarizer is None:
+        logging.info("Loading Hugging Face model...")
+        try:
+            device = 0 if torch.cuda.is_available() else -1
+            summarizer = pipeline("summarization", model="sshleifer/distilbart-cnn-12-6", device=device)
+            logging.info("Model loaded.")
+        except Exception as e:
+            logging.error(f"Model load error: {e}")
+            summarizer = None
+
 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")
+        raise Exception("Salesforce connection not established.")
+
     try:
         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"
+        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
+            conditions.append(f"Lab_Site__c = '{lab_site}'")
         if start_date:
-            conditions.append("Timestamp__c >= :start_date")
-            params['start_date'] = start_date
+            conditions.append(f"Timestamp__c >= {start_date}")
         if end_date:
-            conditions.append("Timestamp__c <= :end_date")
-            params['end_date'] = end_date
+            conditions.append(f"Timestamp__c <= {end_date}")
         if equipment_type:
-            conditions.append("Log_Type__c = :equipment_type")
-            params['equipment_type'] = equipment_type
+            conditions.append(f"Log_Type__c = '{equipment_type}'")
 
         if conditions:
             query += " WHERE " + " AND ".join(conditions)
 
-        result = sf.query_all(query, **params)
+        result = sf.query_all(query)
         records = result['records']
-        if not records:
-            logging.info("No records found matching the criteria")
-            return pd.DataFrame()
-
         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'] or 0,
-            'downtime': r['Downtime__c'] or 0,
+            '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 fetch SmartLog records: {str(e)}")
-        raise
+        logging.error(f"Error fetching records: {e}")
+        raise e
 
-# Summarize logs (simplified without Hugging Face)
 def summarize_logs(df):
-    try:
-        if df.empty:
-            return {
-                "summary": "No records found for the given criteria.",
-                "statistics": {}
-            }
-
-        total_records = len(df)
-        unique_devices = df['device_id'].nunique()
-        avg_usage_hours = df['usage_hours'].mean() if 'usage_hours' in df else 0
-        total_downtime = df['downtime'].sum() if 'downtime' in df else 0
-        status_counts = df['status'].value_counts().to_dict()
-
-        summary_text = (
-            f"Analyzed {total_records} SmartLog records. "
-            f"Found {unique_devices} unique devices. "
-            f"Average usage hours: {avg_usage_hours:.2f} hours. "
-            f"Total downtime: {total_downtime:.2f} hours. "
-            f"Status distribution: {status_counts}"
-        )
+    load_huggingface_model()
+    if summarizer is None:
+        return "Model not available"
+
+    text = ""
+    for _, row in df.iterrows():
+        text += f"Device {row['device_id']} had status {row['status']} on {row['timestamp'].strftime('%Y-%m-%d')}.\n"
+
+    if len(text) < 20:
+        return "Not enough log data for summarization."
 
-        return {
-            "summary": summary_text,
-            "statistics": {
-                "total_records": total_records,
-                "unique_devices": unique_devices,
-                "avg_usage_hours": float(avg_usage_hours),
-                "total_downtime": float(total_downtime),
-                "status_counts": status_counts
-            }
-        }
+    try:
+        summary = summarizer(text[:1024], max_length=100, min_length=30, do_sample=False)[0]['summary_text']
+        return summary
     except Exception as e:
-        logging.error(f"Failed to summarize logs: {str(e)}")
-        return {"error": str(e)}
+        logging.error(f"Summarization failed: {e}")
+        return "Error summarizing logs"
 
-# 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
-
+def summarize_endpoint():
     try:
-        data = request.get_json() or {}
-        lab_site = data.get('lab_site')
-        start_date = data.get('start_date')
-        end_date = data.get('end_date')
-        equipment_type = data.get('equipment_type')
+        data = request.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")
 
         df = fetch_smartlog_records(lab_site, start_date, end_date, equipment_type)
-        result = summarize_logs(df)
-        return jsonify(result), 200
+        summary = summarize_logs(df)
+
+        return jsonify({
+            "summary": summary,
+            "records_fetched": len(df)
+        })
+
     except Exception as e:
-        logging.error(f"Error in summarize endpoint: {str(e)}")
+        logging.error(f"API error: {e}")
         return jsonify({"error": str(e)}), 500
 
 if __name__ == '__main__':
-    app.run(debug=True, host='0.0.0.0', port=5000)
+    connect_to_salesforce()
+    app.run(host='0.0.0.0', port=5000)