Update app.py

app.py

@@ -1,4 +1,5 @@
 from flask import Flask, request, jsonify
+from simple_salesforce import Salesforce
 import pandas as pd
 from datetime import datetime
 import logging
@@ -8,17 +9,19 @@ import torch
 import os
 import time
 import sys
+import requests
+from requests.exceptions import Timeout
 
-# Configure logging to console first (force output even if file logging fails)
+# Configure logging to console first
 logging.basicConfig(
     level=logging.INFO,
     format='%(asctime)s - %(levelname)s - %(message)s',
     handlers=[
-        logging.StreamHandler(sys.stdout)  # Force console output
+        logging.StreamHandler(sys.stdout)
     ]
 )
 
-# Add file handler for logging (if possible)
+# Add file handler for logging
 try:
     file_handler = logging.FileHandler('app.log')
     file_handler.setFormatter(logging.Formatter('%(asctime)s - %(levelname)s - %(message)s'))
@@ -31,18 +34,48 @@ except Exception as e:
 app = Flask(__name__)
 logging.info("Flask app initialized")
 
+# Salesforce credentials
+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')
+
+# Global variable for Salesforce connection
+sf = None
+
 # Global variable for Hugging Face model (lazy initialization)
 summarizer = None
 logging.info("Hugging Face model set to lazy initialization")
 
-# Health check endpoint to confirm the app is running
+# Health check endpoint
 @app.route('/health', methods=['GET'])
 def health_check():
     return jsonify({"status": "App is running"}), 200
 
-# Dummy Salesforce connection placeholder (disabled for now)
-sf = None
-logging.info("Salesforce connection disabled for troubleshooting")
+# Connect to Salesforce with a timeout
+def connect_to_salesforce():
+    global sf
+    logging.info("Attempting to connect to Salesforce...")
+    start_time = time.time()
+    try:
+        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 successfully in {time.time() - start_time:.2f} seconds")
+    except Timeout:
+        logging.error("Salesforce connection timed out after 10 seconds")
+        sf = None
+    except Exception as e:
+        logging.error(f"Failed to connect to Salesforce: {str(e)}")
+        sf = None
 
 # Lazy load the Hugging Face model
 def load_huggingface_model():
@@ -52,32 +85,61 @@ def load_huggingface_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)
+            summarizer = pipeline("summarization", model="t5-small", device=device)  # Use a smaller model
             logging.info(f"Hugging Face model loaded successfully 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
 
-# Dummy fetch function (since Salesforce is disabled)
+# Fetch SmartLog records from Salesforce
 def fetch_smartlog_records(lab_site, start_date, end_date, equipment_type):
-    logging.info("Salesforce connection is disabled. Returning dummy data for testing.")
-    # Return a small dummy DataFrame to test processing
-    data = [
-        {
-            'device_id': 'D001',
-            'log_type': 'SmartLog',
-            'status': 'OK',
-            'timestamp': '2025-05-14T10:15:00Z',
-            'usage_hours': 5.0,
-            'downtime': 0.0,
-            'amc_date': '2025-06-15'
-        }
-    ]
-    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"Returning dummy DataFrame with {len(df)} records")
-    return df
+    if sf is None:
+        raise Exception("Salesforce connection not established")
+    try:
+        logging.info("Fetching SmartLog records from Salesforce...")
+        query = "SELECT Device_Id__c, Log_Type__c, Status__c, Timestamp__c, Usage_Hours__c, Downtime__c, AMC_Date__c FROM SmartLog__c WHERE "
+        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 not conditions:
+            query = query.replace(" WHERE ", "")
+        else:
+            query += " AND ".join(conditions)
+
+        result = sf.query_all(query, **params)
+        records = result['records']
+
+        data = []
+        for record in records:
+            data.append({
+                'device_id': record['Device_Id__c'],
+                'log_type': record['Log_Type__c'],
+                'status': record['Status__c'],
+                'timestamp': record['Timestamp__c'],
+                'usage_hours': record['Usage_Hours__c'],
+                'downtime': record['Downtime__c'],
+                'amc_date': record['AMC_Date__c']
+            })
+        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 e
 
 # Format summary prompt and generate report
 def summarize_logs(df):
@@ -179,6 +241,9 @@ def create_usage_chart_data(df):
 @app.route('/process_logs', methods=['POST'])
 def process_logs():
     try:
+        if sf is None:
+            return jsonify({"error": "Salesforce connection not established. Check server logs for details."}), 500
+
         data = request.get_json()
         lab_site = data.get('lab_site')
         start_date = data.get('start_date')
@@ -186,15 +251,53 @@ def process_logs():
         equipment_type = data.get('equipment_type')
         amc_threshold = data.get('amc_threshold', 30)
 
-        # Fetch SmartLog records (using dummy data for now)
         df = fetch_smartlog_records(lab_site, start_date, end_date, equipment_type)
         if df.empty:
-            return jsonify({"error": "No data available."}), 400
+            return jsonify({"error": "No data available in SmartLog__c."}), 400
 
-        # Step 1: Summary Report
         summary = summarize_logs(df)
 
-        # Step 2: Log Preview (First 5 Rows)
         preview_lines = []
         for idx, row in df.head().iterrows():
-            preview
+            preview_lines.append({
+                "row": idx + 1,
+                "device_id": row['device_id'],
+                "timestamp": row['timestamp'].isoformat() if pd.notnull(row['timestamp']) else None,
+                "usage_hours": float(row['usage_hours']) if pd.notnull(row['usage_hours']) else 0,
+                "downtime": float(row['downtime']) if pd.notnull(row['downtime']) else 0,
+                "amc_date": row['amc_date'].isoformat() if pd.notnull(row['amc_date']) else None
+            })
+
+        chart_data = create_usage_chart_data(df)
+
+        anomaly_lines, anomaly_error = detect_anomalies(df)
+        if anomaly_error:
+            anomaly_lines = [{"error": anomaly_error}]
+
+        reminder_lines, reminder_error = check_amc_reminders(df, datetime.now())
+        if reminder_error:
+            reminder_lines = [{"error": reminder_error}]
+
+        insights = generate_dashboard_insights(df)
+
+        response = {
+            "summary": summary,
+            "log_preview": preview_lines,
+            "usage_chart": chart_data,
+            "anomalies": anomaly_lines,
+            "amc_reminders": reminder_lines,
+            "insights": insights
+        }
+
+        return jsonify(response), 200
+
+    except Exception as e:
+        logging.error(f"Failed to process logs: {str(e)}")
+        return jsonify({"error": str(e)}), 500
+
+if __name__ == "__main__":
+    logging.info("Starting Flask application...")
+    start_time = time.time()
+    connect_to_salesforce()
+    logging.info(f"Flask application startup completed in {time.time() - start_time:.2f} seconds")
+    app.run(host="0.0.0.0", port=5000, debug=True)