Update app.py

app.py

@@ -45,7 +45,6 @@ except ImportError:
 logging.info("Preloading Hugging Face model...")
 try:
     device = 0 if torch.cuda.is_available() else -1
-    # Use a smaller model for faster inference
     summarizer = pipeline(
         "summarization",
         model="t5-small",
@@ -159,6 +158,7 @@ def create_salesforce_reports(df):
 # Save to Salesforce
 def save_to_salesforce(df, reminders_df):
     if sf is None:
+        logging.error("Salesforce connection not established, cannot save records.")
         return
     try:
         current_date = datetime.now()
@@ -167,40 +167,61 @@ def save_to_salesforce(df, reminders_df):
         reminder_device_ids = set(reminders_df['device_id']) if not reminders_df.empty else set()
 
         for _, row in df.iterrows():
-            status = str(row['status'])
-            log_type = str(row['log_type'])
-            status = picklist_mapping['Status__c'].get(status.lower(), status_values[0] if status_values else None)
-            log_type = picklist_mapping['Log_Type__c'].get(log_type.lower(), log_type_values[0] if log_type_values else None)
-            if status is None or log_type is None:
-                continue
+            status = str(row['status']).strip().lower()
+            log_type = str(row['log_type']).strip().lower()
 
+            # Map status and log_type to valid picklist values
+            status_mapped = picklist_mapping['Status__c'].get(status, None)
+            if status_mapped is None:
+                status_mapped = status_values[0] if status_values else 'Active'
+                logging.warning(f"Invalid status '{status}' for device {row['device_id']}, defaulting to {status_mapped}")
+
+            log_type_mapped = picklist_mapping['Log_Type__c'].get(log_type, None)
+            if log_type_mapped is None:
+                log_type_mapped = log_type_values[0] if log_type_values else 'Smart Log'
+                logging.warning(f"Invalid log_type '{log_type}' for device {row['device_id']}, defaulting to {log_type_mapped}")
+
+            # Handle AMC date
             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_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"AMC Reminder for Device ID {row['device_id']}")
-                except:
+                    amc_date_dt = pd.to_datetime(row['amc_date'])
+                    amc_date_str = amc_date_dt.strftime('%Y-%m-%d')
+                    if status_mapped == "Active" and current_date.date() <= amc_date_dt.date() <= next_30_days.date():
+                        logging.info(f"AMC Reminder for Device ID {row['device_id']} on {amc_date_str}")
+                except Exception as e:
+                    logging.warning(f"Invalid AMC date for device {row['device_id']}: {str(e)}")
                     amc_date_str = None
 
+            # Prepare record
             record = {
                 'Device_Id__c': str(row['device_id'])[:50],
-                'Log_Type__c': log_type,
-                'Status__c': status,
+                'Log_Type__c': log_type_mapped,
+                'Status__c': status_mapped,
                 '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
             }
+
+            # Skip records already in reminders to avoid duplicates
             if row['device_id'] not in reminder_device_ids:
                 records.append(record)
 
         if records:
-            sf.bulk.SmartLog__c.insert(records)
-            logging.info(f"Saved {len(records)} records to Salesforce")
+            # Perform bulk insert and handle results
+            result = sf.bulk.SmartLog__c.insert(records)
+            success_count = sum(1 for r in result if r['success'])
+            error_count = len(result) - success_count
+            logging.info(f"Saved {success_count} records to Salesforce, {error_count} failed")
+            for r in result:
+                if not r['success']:
+                    logging.error(f"Failed to save record: {r['errors']}")
+        else:
+            logging.info("No records to save to Salesforce")
     except Exception as e:
         logging.error(f"Failed to save to Salesforce: {str(e)}")
+        raise
 
 # Summarize logs
 def summarize_logs(df):
@@ -564,7 +585,6 @@ async def process_logs(file_obj, lab_site_filter, equipment_type_filter, date_ra
             future_downtime_chart = executor.submit(create_downtime_chart, filtered_df)
             future_daily_log_chart = executor.submit(create_daily_log_trends_chart, filtered_df)
             future_weekly_uptime_chart = executor.submit(create_weekly_uptime_chart, filtered_df)
-            future_anomaly_alerts_chart = executor.submit(create_anomaly_alerts_chart, pd.DataFrame())
             future_device_cards = executor.submit(generate_device_cards, filtered_df)
             future_reports = executor.submit(create_salesforce_reports, filtered_df)
 
@@ -578,7 +598,7 @@ async def process_logs(file_obj, lab_site_filter, equipment_type_filter, date_ra
             downtime_chart = future_downtime_chart.result()
             daily_log_chart = future_daily_log_chart.result()
             weekly_uptime_chart = future_weekly_uptime_chart.result()
-            anomaly_alerts_chart = future_anomaly_alerts_chart.result()
+            anomaly_alerts_chart = create_anomaly_alerts_chart(anomalies_df)  # Use anomalies_df directly
             device_cards = future_device_cards.result()
 
         save_to_salesforce(filtered_df, reminders_df)