Update app.py

app.py

@@ -13,10 +13,24 @@ import json
 import threading
 import time
 import queue
+import requests
+from simple_salesforce import Salesforce
+import os
 
 # Suppress TensorFlow oneDNN warning
 os.environ['TF_ENABLE_ONEDNN_OPTS'] = '0'
 
+# Hugging Face API configuration
+HF_API_URL = "https://api-inference.huggingface.co/models/Salesforce/blip-image-captioning-base"
+HF_API_TOKEN = os.getenv("HUGGINGFACE_API_TOKEN")
+
+# Salesforce configuration
+SF_CLIENT_ID = os.getenv("SF_CLIENT_ID")
+SF_CLIENT_SECRET = os.getenv("SF_CLIENT_SECRET")
+SF_USERNAME = os.getenv("smartlabour@attendance.system")
+SF_PASSWORD = os.getenv("#Prashanth@123")
+SF_SECURITY_TOKEN = os.getenv("pasQDqmWApzD0skgbv76gVgIs")
+
 class AttendanceSystem:
     def __init__(self):
         self.known_face_embeddings = []
@@ -33,6 +47,19 @@ class AttendanceSystem:
         self.video_file_path = None
         self.video_processing = False
         
+        # Initialize Salesforce connection
+        try:
+            self.sf = Salesforce(
+                username=SF_USERNAME,
+                password=SF_PASSWORD,
+                security_token=SF_SECURITY_TOKEN,
+                client_id=SF_CLIENT_ID,
+                client_secret=SF_CLIENT_SECRET
+            )
+        except Exception as e:
+            print(f"Error connecting to Salesforce: {e}")
+            self.sf = None
+        
         # Create directories for data storage
         os.makedirs("data", exist_ok=True)
         os.makedirs("data/faces", exist_ok=True)
@@ -84,21 +111,46 @@ class AttendanceSystem:
         except Exception as e:
             print(f"Error saving data: {e}")
     
+    def get_image_caption(self, image):
+        """Generate image caption using Hugging Face API"""
+        try:
+            # Convert PIL image to bytes
+            if isinstance(image, Image.Image):
+                img_byte_arr = BytesIO()
+                image.save(img_byte_arr, format='JPEG')
+                img_data = img_byte_arr.getvalue()
+            
+            # Make API request to Hugging Face
+            headers = {"Authorization": f"Bearer {HF_API_TOKEN}"}
+            response = requests.post(HF_API_URL, headers=headers, data=img_data)
+            
+            if response.status_code == 200:
+                result = response.json()
+                if isinstance(result, list) and len(result) > 0:
+                    return result[0].get("generated_text", "No caption generated")
+                return "No caption generated"
+            else:
+                print(f"Hugging Face API error: {response.status_code} - {response.text}")
+                return "Error generating caption"
+        except Exception as e:
+            print(f"Error in Hugging Face API call: {e}")
+            return "Error generating caption"
+    
     def register_worker_manual(self, image, name):
-        """Manual worker registration"""
+        """Manual worker registration with Hugging Face and Salesforce integration"""
         if image is None or not name.strip():
             return "❌ Please provide both image and name!", self.get_registered_workers_info()
         
         # Convert PIL image to RGB array
         if isinstance(image, Image.Image):
-            image = np.array(image)
+            image_array = np.array(image)
         
         try:
             # Verify the image contains a face
-            face_analysis = DeepFace.analyze(img_path=image, actions=['emotion'], enforce_detection=True, detector_backend='opencv')
+            face_analysis = DeepFace.analyze(img_path=image_array, actions=['emotion'], enforce_detection=True, detector_backend='opencv')
             
             # Get face embedding
-            embedding = DeepFace.represent(img_path=image, model_name='Facenet')[0]['embedding']
+            embedding = DeepFace.represent(img_path=image_array, model_name='Facenet')[0]['embedding']
             
             # Check if person already exists
             name = name.strip().title()
@@ -108,6 +160,9 @@ class AttendanceSystem:
             # Generate new worker ID
             worker_id = f"W{self.next_worker_id:04d}"
             
+            # Generate image caption using Hugging Face
+            caption = self.get_image_caption(image)
+            
             # Add the face embedding, name, and ID
             self.known_face_embeddings.append(embedding)
             self.known_face_names.append(name)
@@ -115,12 +170,25 @@ class AttendanceSystem:
             self.next_worker_id += 1
             
             # Save face image
-            face_image = Image.fromarray(image)
+            face_image = Image.fromarray(image_array)
             face_image.save(f"data/faces/{worker_id}_{name.replace(' ', '_')}.jpg")
             
+            # Save to Salesforce
+            if self.sf:
+                try:
+                    self.sf.Worker__c.create({
+                        'Name': name,
+                        'Worker_ID__c': worker_id,
+                        'Face_Embedding__c': json.dumps(embedding),
+                        'Image_Caption__c': caption
+                    })
+                    print(f"✅ Worker {name} ({worker_id}) saved to Salesforce with caption: {caption}")
+                except Exception as e:
+                    print(f"Error saving to Salesforce: {e}")
+            
             self.save_data()
             
-            return f"✅ {name} has been successfully registered with ID: {worker_id}!", self.get_registered_workers_info()
+            return f"✅ {name} has been successfully registered with ID: {worker_id}! Caption: {caption}", self.get_registered_workers_info()
         
         except ValueError as e:
             if "Face could not be detected" in str(e):
@@ -139,6 +207,10 @@ class AttendanceSystem:
             # Get face embedding
             embedding = DeepFace.represent(img_path=face_image, model_name='Facenet')[0]['embedding']
             
+            # Generate image caption
+            face_pil = Image.fromarray(cv2.cvtColor(face_image, cv2.COLOR_BGR2RGB))
+            caption = self.get_image_caption(face_pil)
+            
             # Add to database
             self.known_face_embeddings.append(embedding)
             self.known_face_names.append(worker_name)
@@ -146,9 +218,21 @@ class AttendanceSystem:
             self.next_worker_id += 1
             
             # Save face image
-            face_pil = Image.fromarray(cv2.cvtColor(face_image, cv2.COLOR_BGR2RGB))
             face_pil.save(f"data/faces/{worker_id}_{worker_name}.jpg")
             
+            # Save to Salesforce
+            if self.sf:
+                try:
+                    self.sf.Worker__c.create({
+                        'Name': worker_name,
+                        'Worker_ID__c': worker_id,
+                        'Face_Embedding__c': json.dumps(embedding),
+                        'Image_Caption__c': caption
+                    })
+                    print(f"✅ Worker {worker_name} ({worker_id}) saved to Salesforce with caption: {caption}")
+                except Exception as e:
+                    print(f"Error saving to Salesforce: {e}")
+            
             self.save_data()
             
             return worker_id, worker_name
@@ -158,7 +242,7 @@ class AttendanceSystem:
             return None, None
     
     def mark_attendance(self, worker_id, worker_name):
-        """Mark attendance for a worker"""
+        """Mark attendance for a worker and save to Salesforce"""
         try:
             today = date.today().isoformat()
             current_time = datetime.now()
@@ -170,8 +254,8 @@ class AttendanceSystem:
             )
             
             if not already_marked:
-                # Mark attendance
-                self.attendance_records.append({
+                # Create attendance record
+                attendance_record = {
                     "worker_id": worker_id,
                     "name": worker_name,
                     "date": today,
@@ -179,7 +263,25 @@ class AttendanceSystem:
                     "timestamp": current_time.isoformat(),
                     "status": "Present",
                     "method": "Auto"
-                })
+                }
+                self.attendance_records.append(attendance_record)
+                
+                # Save to Salesforce
+                if self.sf:
+                    try:
+                        self.sf.Attendance__c.create({
+                            'Worker_ID__c': worker_id,
+                            'Name__c': worker_name,
+                            'Date__c': today,
+                            'Time__c': current_time.strftime("%H:%M:%S"),
+                            'Timestamp__c': current_time.isoformat(),
+                            'Status__c': "Present",
+                            'Method__c': "Auto"
+                        })
+                        print(f"✅ Attendance for {worker_name} ({worker_id}) saved to Salesforce")
+                    except Exception as e:
+                        print(f"Error saving attendance to Salesforce: {e}")
+                
                 self.save_data()
                 return True
             return False
@@ -397,7 +499,25 @@ class AttendanceSystem:
             return None
     
     def get_registered_workers_info(self):
-        """Get information about registered workers"""
+        """Get information about registered workers from Salesforce"""
+        if not self.sf:
+            return "❌ Salesforce connection not established."
+        
+        try:
+            workers = self.sf.query_all("SELECT Name, Worker_ID__c, Image_Caption__c FROM Worker__c")['records']
+            if not workers:
+                return "No workers registered yet."
+            
+            info = f"**Registered Workers ({len(workers)}):**\n\n"
+            for i, worker in enumerate(workers, 1):
+                info += f"{i}. **{worker['Name']}** (ID: {worker['Worker_ID__c']}) - Caption: {worker['Image_Caption__c'] or 'N/A'}\n"
+            return info
+        except Exception as e:
+            print(f"Error fetching workers from Salesforce: {e}")
+            return self._get_local_workers_info()
+    
+    def _get_local_workers_info(self):
+        """Fallback to local worker info if Salesforce query fails"""
         if not self.known_face_names:
             return "No workers registered yet."
         
@@ -407,7 +527,30 @@ class AttendanceSystem:
         return info
     
     def get_today_attendance(self):
-        """Get today's attendance records"""
+        """Get today's attendance records from Salesforce"""
+        if not self.sf:
+            return "❌ Salesforce connection not established."
+        
+        today = date.today().isoformat()
+        try:
+            records = self.sf.query_all(
+                f"SELECT Name__c, Worker_ID__c, Time__c, Method__c FROM Attendance__c WHERE Date__c = '{today}'"
+            )['records']
+            
+            if not records:
+                return f"**Today's Attendance ({today}):**\n\nNo attendance marked yet."
+            
+            info = f"**Today's Attendance ({today}):**\n\n"
+            for record in records:
+                method_icon = "🤖" if record['Method__c'] == "Auto" else "👤"
+                info += f"{method_icon} **{record['Name__c']}** (ID: {record['Worker_ID__c']}) - {record['Time__c']}\n"
+            return info
+        except Exception as e:
+            print(f"Error fetching attendance from Salesforce: {e}")
+            return self._get_local_today_attendance()
+    
+    def _get_local_today_attendance(self):
+        """Fallback to local attendance records if Salesforce query fails"""
         today = date.today().isoformat()
         today_records = [r for r in self.attendance_records if r["date"] == today]
         
@@ -418,11 +561,10 @@ class AttendanceSystem:
         for record in today_records:
             method_icon = "🤖" if record.get("method") == "Auto" else "👤"
             info += f"{method_icon} **{record['name']}** (ID: {record['worker_id']}) - {record['time']}\n"
-        
         return info
     
     def get_attendance_report(self, start_date, end_date):
-        """Generate attendance report for date range"""
+        """Generate attendance report for date range from Salesforce"""
         if not start_date or not end_date:
             return "Please select both start and end dates."
         
@@ -433,6 +575,50 @@ class AttendanceSystem:
         except ValueError:
             return "Invalid date format. Please use YYYY-MM-DD."
         
+        if not self.sf:
+            return "❌ Salesforce connection not established."
+        
+        try:
+            # Query Salesforce for attendance records
+            records = self.sf.query_all(
+                f"SELECT Worker_ID__c, Name__c, Date__c, Time__c, Method__c FROM Attendance__c "
+                f"WHERE Date__c >= '{start_date}' AND Date__c <= '{end_date}'"
+            )['records']
+            
+            if not records:
+                return f"No attendance records found between {start_date} and {end_date}."
+            
+            # Create DataFrame for analysis
+            df = pd.DataFrame(records)
+            
+            # Summary statistics
+            total_days = (pd.to_datetime(end_date) - pd.to_datetime(start_date)).days + 1
+            unique_workers = df['Worker_ID__c'].nunique()
+            total_attendances = len(df)
+            auto_registrations = len(df[df['Method__c'] == 'Auto'])
+            
+            report = f"**📊 Attendance Report ({start_date} to {end_date})**\n\n"
+            report += f"**Summary:**\n"
+            report += f"• Total Days: {total_days}\n"
+            report += f"• Unique Workers: {unique_workers}\n"
+            report += f"• Total Attendances: {total_attendances}\n"
+            report += f"• Auto Detections: {auto_registrations}\n\n"
+            
+            # Individual attendance counts
+            if not df.empty:
+                attendance_counts = df.groupby(['Worker_ID__c', 'Name__c']).size().reset_index(name='count')
+                report += f"**👥 Individual Attendance:**\n"
+                for _, row in attendance_counts.iterrows():
+                    percentage = (row['count'] / total_days) * 100
+                    report += f"• **{row['Name__c']}** ({row['Worker_ID__c']}): {row['count']} days ({percentage:.1f}%)\n"
+            
+            return report
+        except Exception as e:
+            print(f"Error generating report from Salesforce: {e}")
+            return self._get_local_attendance_report(start_date, end_date)
+    
+    def _get_local_attendance_report(self, start_date, end_date):
+        """Fallback to local attendance report if Salesforce query fails"""
         # Filter records by date range
         filtered_records = [
             r for r in self.attendance_records 
@@ -513,15 +699,17 @@ def create_interface():
             """
             # 🎯 Advanced Attendance System with Face Recognition
             
-            **Comprehensive facial recognition system with live camera and video file processing**
+            **Comprehensive facial recognition system with live camera and video file processing, integrated with Hugging Face and Salesforce**
             
             ## 🚀 **Key Features:**
             - **🎥 Live Camera Recognition** - Real-time face detection from camera/CCTV
             - **📹 Video File Processing** - Process pre-recorded videos for attendance
             - **🤖 Automatic Worker Registration** - Auto-register unknown faces with unique IDs
-            - **👤 Manual Registration** - Register workers manually with photos
+            - **👤 Manual Registration** - Register workers manually with photos and AI-generated captions
             - **📅 24-Hour Attendance Rule** - One attendance mark per worker per day
             - **📊 Advanced Analytics** - Detailed reports and data export
+            - **🤗 Hugging Face Integration** - AI-powered image captioning
+            - **☁️ Salesforce Integration** - Store worker and attendance data in Salesforce
             """
         )