Update app.py

app.py

@@ -1,72 +1,48 @@
 from flask import Flask, request, jsonify
-from simple_salesforce import Salesforce
 import pandas as pd
-from datetime import datetime, timedelta
+from datetime import datetime
 import logging
 from sklearn.ensemble import IsolationForest
 from transformers import pipeline
 import torch
 import os
 import time
-import requests
-from requests.exceptions import Timeout
+import sys
 
-# Configure logging to a file and console for better debugging
+# Configure logging to console first (force output even if file logging fails)
 logging.basicConfig(
     level=logging.INFO,
     format='%(asctime)s - %(levelname)s - %(message)s',
     handlers=[
-        logging.FileHandler('app.log'),  # Log to a file for persistence
-        logging.StreamHandler()          # Log to console for real-time visibility
+        logging.StreamHandler(sys.stdout)  # Force console output
     ]
 )
 
+# Add file handler for logging (if possible)
+try:
+    file_handler = logging.FileHandler('app.log')
+    file_handler.setFormatter(logging.Formatter('%(asctime)s - %(levelname)s - %(message)s'))
+    logging.getLogger().addHandler(file_handler)
+    logging.info("File logging enabled successfully")
+except Exception as e:
+    logging.warning(f"Failed to enable file logging: {str(e)}. Continuing with console logging only.")
+
 # 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')
-SF_INSTANCE_URL = os.getenv('SF_INSTANCE_URL', 'https://login.salesforce.com')
-
-# Global variable for Salesforce connection
-sf = None
+logging.info("Flask app initialized")
 
 # 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
 @app.route('/health', methods=['GET'])
 def health_check():
     return jsonify({"status": "App is running"}), 200
 
-# Connect to Salesforce with a timeout
-def connect_to_salesforce():
-    global sf
-    logging.info("Attempting to connect to Salesforce...")
-    start_time = time.time()
-    try:
-        # Use a timeout to prevent hanging
-        session = requests.Session()
-        adapter = requests.adapters.HTTPAdapter(max_retries=3)
-        session.mount('https://', adapter)
-        session.request('GET', SF_INSTANCE_URL, timeout=10)  # Test connectivity
-
-        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
+# Dummy Salesforce connection placeholder (disabled for now)
+sf = None
+logging.info("Salesforce connection disabled for troubleshooting")
 
 # Lazy load the Hugging Face model
 def load_huggingface_model():
@@ -82,57 +58,26 @@ def load_huggingface_model():
             logging.error(f"Failed to load Hugging Face model: {str(e)}")
             summarizer = None
 
-# Fetch SmartLog records from Salesforce
+# Dummy fetch function (since Salesforce is disabled)
 def fetch_smartlog_records(lab_site, start_date, end_date, equipment_type):
-    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)
-
-        # Execute SOQL query
-        result = sf.query_all(query, **params)
-        records = result['records']
-
-        # Convert records to a DataFrame
-        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
+    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
 
 # Format summary prompt and generate report
 def summarize_logs(df):
@@ -234,9 +179,6 @@ 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')
@@ -244,10 +186,10 @@ def process_logs():
         equipment_type = data.get('equipment_type')
         amc_threshold = data.get('amc_threshold', 30)
 
-        # Fetch SmartLog records from Salesforce
+        # 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 in SmartLog__c."}), 400
+            return jsonify({"error": "No data available."}), 400
 
         # Step 1: Summary Report
         summary = summarize_logs(df)
@@ -255,50 +197,4 @@ def process_logs():
         # Step 2: Log Preview (First 5 Rows)
         preview_lines = []
         for idx, row in df.head().iterrows():
-            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
-            })
-
-        # Step 3: Usage Chart (Textual Data)
-        chart_data = create_usage_chart_data(df)
-
-        # Step 4: Anomaly Detection
-        anomaly_lines, anomaly_error = detect_anomalies(df)
-        if anomaly_error:
-            anomaly_lines = [{"error": anomaly_error}]
-
-        # Step 5: AMC Reminders
-        reminder_lines, reminder_error = check_amc_reminders(df, datetime.now())
-        if reminder_error:
-            reminder_lines = [{"error": reminder_error}]
-
-        # Step 6: Dashboard Insights
-        insights = generate_dashboard_insights(df)
-
-        # Prepare the response
-        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()  # Attempt to connect to Salesforce at startup
-    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)
+            preview