Update app.py

app.py

@@ -19,140 +19,39 @@ import queue
 import requests
 from simple_salesforce import Salesforce
 from dotenv import load_dotenv
-import logging
 from retrying import retry
-from reportlab.lib.pagesizes import letter
-from reportlab.pdfgen import canvas
-from reportlab.lib.units import inch
-import tempfile
-import shutil
-
-# Load environment variables from .env file
-load_dotenv()
+import logging
 
 # Setup logging
 logging.basicConfig(level=logging.INFO, format="%(asctime)s - %(levelname)s - %(message)s")
 logger = logging.getLogger(__name__)
 
-# Enhanced Configuration
-CONFIG = {
-    "SF_CREDENTIALS": {
-        "username": os.getenv("SF_USERNAME", "smartlabour@attendance.system"),
-        "password": os.getenv("SF_PASSWORD", "#Prashanth@123"),
-        "security_token": os.getenv("SF_SECURITY_TOKEN", "pasQDqmWApzD0skgbv76gVgIs"),
-        "domain": "login"
-    },
-    "PUBLIC_URL_BASE": "https://your-domain.com/static/output/",
-    "RETRY_ATTEMPTS": 3,
-    "RETRY_DELAY": 2000,
-    "RECOGNITION_COOLDOWN": 5,  # seconds between recognitions for same person
-    "FACE_RECOGNITION_THRESHOLD": 10,  # threshold for face recognition
-    "FACE_CONFIDENCE_THRESHOLD": 0.9  # minimum confidence for face detection
-}
+# Load environment variables from .env file
+load_dotenv()
 
 # 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")
 
-@retry(stop_max_attempt_number=CONFIG["RETRY_ATTEMPTS"], wait_fixed=CONFIG["RETRY_DELAY"])
+# Salesforce configuration
+SF_CREDENTIALS = {
+    "username": os.getenv("SF_USERNAME", "smartlabour@attendance.system"),
+    "password": os.getenv("SF_PASSWORD", "#Prashanth@123"),
+    "security_token": os.getenv("SF_SECURITY_TOKEN", "pasQDqmWApzD0skgbv76gVgIs"),
+    "domain": "login"
+}
+
+@retry(stop_max_attempt_number=3, wait_fixed=2000)
 def connect_to_salesforce():
-    """Enhanced Salesforce connection with retry mechanism"""
     try:
-        sf = Salesforce(**CONFIG["SF_CREDENTIALS"])
-        logger.info("Connected to Salesforce successfully")
-        # Test connection
+        sf = Salesforce(**SF_CREDENTIALS)
+        logger.info("Connected to Salesforce")
         sf.describe()
         return sf
     except Exception as e:
         logger.error(f"Salesforce connection failed: {e}")
         raise
 
-def generate_attendance_pdf(attendance_records, workers_info, output_dir):
-    """Generate PDF report for attendance records"""
-    try:
-        pdf_filename = f"attendance_report_{int(time.time())}.pdf"
-        pdf_path = os.path.join(output_dir, pdf_filename)
-        pdf_file = BytesIO()
-        c = canvas.Canvas(pdf_file, pagesize=letter)
-        
-        # Header
-        c.setFont("Helvetica-Bold", 16)
-        c.drawString(1 * inch, 10 * inch, "Attendance System Report")
-        
-        c.setFont("Helvetica", 12)
-        c.drawString(1 * inch, 9.5 * inch, f"Date: {time.strftime('%Y-%m-%d')}")
-        c.drawString(1 * inch, 9.2 * inch, f"Time: {time.strftime('%H:%M:%S')}")
-        
-        # Summary
-        y_position = 8.7 * inch
-        c.setFont("Helvetica-Bold", 14)
-        c.drawString(1 * inch, y_position, f"Total Workers: {len(workers_info)}")
-        y_position -= 0.3 * inch
-        c.drawString(1 * inch, y_position, f"Total Attendance Records: {len(attendance_records)}")
-        y_position -= 0.5 * inch
-        
-        c.setFont("Helvetica-Bold", 12)
-        c.drawString(1 * inch, y_position, "Attendance Records:")
-        y_position -= 0.3 * inch
-        
-        c.setFont("Helvetica", 10)
-        for record in attendance_records:
-            if isinstance(record, dict):
-                record_text = f"• {record.get('name', 'Unknown')} ({record.get('worker_id', 'N/A')}) - {record.get('date', 'N/A')} {record.get('time', 'N/A')}"
-            else:
-                # Handle Salesforce record format
-                record_text = f"• {getattr(record, 'Name__c', 'Unknown')} ({getattr(record, 'Worker_ID__c', 'N/A')}) - {getattr(record, 'Date__c', 'N/A')} {getattr(record, 'Time__c', 'N/A')}"
-            
-            c.drawString(1 * inch, y_position, record_text)
-            y_position -= 0.2 * inch
-            
-            if y_position < 1 * inch:
-                c.showPage()
-                c.setFont("Helvetica", 10)
-                y_position = 10 * inch
-        
-        c.save()
-        pdf_file.seek(0)
-        
-        # Save to file
-        with open(pdf_path, "wb") as f:
-            f.write(pdf_file.getvalue())
-        
-        public_url = f"{CONFIG['PUBLIC_URL_BASE']}{pdf_filename}"
-        logger.info(f"PDF generated: {public_url}")
-        return pdf_path, public_url, pdf_file
-    except Exception as e:
-        logger.error(f"Error generating PDF: {e}")
-        return "", "", None
-
-def upload_pdf_to_salesforce(sf, pdf_file, report_id):
-    """Upload PDF file to Salesforce"""
-    try:
-        if not pdf_file:
-            logger.error("No PDF file provided for upload")
-            return ""
-        
-        encoded_pdf = base64.b64encode(pdf_file.getvalue()).decode('utf-8')
-        content_version_data = {
-            "Title": f"Attendance_Report_{int(time.time())}",
-            "PathOnClient": f"attendance_report_{int(time.time())}.pdf",
-            "VersionData": encoded_pdf,
-            "FirstPublishLocationId": report_id
-        }
-        content_version = sf.ContentVersion.create(content_version_data)
-        result = sf.query(f"SELECT Id, ContentDocumentId FROM ContentVersion WHERE Id = '{content_version['id']}'")
-        
-        if not result['records']:
-            logger.error("Failed to retrieve ContentVersion")
-            return ""
-        
-        file_url = f"https://{sf.sf_instance}/sfc/servlet.shepherd/version/download/{content_version['id']}"
-        logger.info(f"PDF uploaded to Salesforce: {file_url}")
-        return file_url
-    except Exception as e:
-        logger.error(f"Error uploading PDF to Salesforce: {e}")
-        return ""
-
 class AttendanceSystem:
     def __init__(self):
         self.known_face_embeddings = []
@@ -165,27 +64,25 @@ class AttendanceSystem:
         self.frame_queue = queue.Queue(maxsize=2)
         self.recognition_thread = None
         self.last_recognition_time = {}
-        self.recognition_cooldown = CONFIG["RECOGNITION_COOLDOWN"]
+        self.recognition_cooldown = 5  # seconds between recognitions for same person
         self.video_file_path = None
         self.video_processing = False
-        
-        # Enhanced Salesforce connection with retry
+
+        # Initialize Salesforce connection
         try:
             self.sf = connect_to_salesforce()
-            logger.info("Salesforce connection established successfully")
         except Exception as e:
-            logger.error(f"Failed to establish Salesforce connection: {e}")
+            logger.error(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)
-        os.makedirs("data/reports", exist_ok=True)
-        
-        self.load_data()
     
+        self.load_data()
+
     def load_data(self):
-        """Load all stored data with enhanced error handling"""
+        """Load all stored data"""
         try:
             # Load face embeddings and worker data
             if os.path.exists("data/workers.pkl"):
@@ -195,16 +92,12 @@ class AttendanceSystem:
                     self.known_face_names = data.get("names", [])
                     self.known_face_ids = data.get("ids", [])
                     self.next_worker_id = data.get("next_id", 1)
-            
+        
             # Load attendance records
             if os.path.exists("data/attendance.json"):
                 with open("data/attendance.json", "r") as f:
                     self.attendance_records = json.load(f)
-            
-            # Sync with Salesforce if connected
-            if self.sf:
-                self.sync_with_salesforce()
-                    
+                
         except Exception as e:
             logger.error(f"Error loading data: {e}")
             self.known_face_embeddings = []
@@ -212,33 +105,9 @@ class AttendanceSystem:
             self.known_face_ids = []
             self.attendance_records = []
             self.next_worker_id = 1
-    
-    def sync_with_salesforce(self):
-        """Sync local data with Salesforce"""
-        try:
-            if not self.sf:
-                return
-            
-            # Sync workers from Salesforce
-            workers = self.sf.query_all("SELECT Name, Worker_ID__c, Face_Embedding__c FROM Worker__c")['records']
-            for worker in workers:
-                worker_id = worker['Worker_ID__c']
-                if worker_id not in self.known_face_ids:
-                    self.known_face_ids.append(worker_id)
-                    self.known_face_names.append(worker['Name'])
-                    if worker['Face_Embedding__c']:
-                        embedding = json.loads(worker['Face_Embedding__c'])
-                        self.known_face_embeddings.append(embedding)
-                    else:
-                        self.known_face_embeddings.append([])
-            
-            logger.info(f"Synced {len(workers)} workers from Salesforce")
-            
-        except Exception as e:
-            logger.error(f"Error syncing with Salesforce: {e}")
-    
+
     def save_data(self):
-        """Save all data to files with enhanced error handling"""
+        """Save all data to files"""
         try:
             # Save worker data
             worker_data = {
@@ -249,205 +118,162 @@ class AttendanceSystem:
             }
             with open("data/workers.pkl", "wb") as f:
                 pickle.dump(worker_data, f)
-            
+        
             # Save attendance records
             with open("data/attendance.json", "w") as f:
                 json.dump(self.attendance_records, f, indent=2)
-                
+            
         except Exception as e:
             logger.error(f"Error saving data: {e}")
-    
+
     def get_image_caption(self, image):
-        """Generate image caption using Hugging Face API with enhanced error handling"""
+        """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, timeout=30)
-            
+            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", "Professional worker photo")
-                return "Professional worker photo"
+                    return result[0].get("generated_text", "No caption generated")
+                return "No caption generated"
             else:
-                logger.warning(f"Hugging Face API error: {response.status_code} - {response.text}")
-                return "Professional worker photo"
+                logger.error(f"Hugging Face API error: {response.status_code} - {response.text}")
+                return "Error generating caption"
         except Exception as e:
             logger.error(f"Error in Hugging Face API call: {e}")
-            return "Professional worker photo"
-    
-    def save_worker_to_salesforce(self, worker_data):
-        """Save worker data to Salesforce with enhanced error handling"""
-        if not self.sf:
-            logger.warning("Salesforce not connected, skipping save")
-            return False
-        
-        try:
-            result = self.sf.Worker__c.create({
-                'Name': worker_data['name'],
-                'Worker_ID__c': worker_data['worker_id'],
-                'Face_Embedding__c': json.dumps(worker_data['embedding']),
-                'Image_Caption__c': worker_data.get('caption', ''),
-                'Registration_Date__c': worker_data.get('registration_date', date.today().isoformat()),
-                'Status__c': 'Active'
-            })
-            logger.info(f"Worker saved to Salesforce: {result['id']}")
-            return True
-        except Exception as e:
-            logger.error(f"Error saving worker to Salesforce: {e}")
-            return False
-    
-    def save_attendance_to_salesforce(self, attendance_data):
-        """Save attendance data to Salesforce with enhanced error handling"""
-        if not self.sf:
-            logger.warning("Salesforce not connected, skipping save")
-            return False
-        
-        try:
-            result = self.sf.Attendance__c.create({
-                'Worker_ID__c': attendance_data['worker_id'],
-                'Name__c': attendance_data['worker_name'],
-                'Date__c': attendance_data['date'],
-                'Time__c': attendance_data['time'],
-                'Timestamp__c': attendance_data['timestamp'],
-                'Status__c': attendance_data['status'],
-                'Method__c': attendance_data['method'],
-                'Confidence__c': attendance_data.get('confidence', 0.0)
-            })
-            logger.info(f"Attendance saved to Salesforce: {result['id']}")
-            return True
-        except Exception as e:
-            logger.error(f"Error saving attendance to Salesforce: {e}")
-            return False
-    
+            return "Error generating caption"
+
     def register_worker_manual(self, image, name):
-        """Manual worker registration with enhanced Salesforce integration"""
+        """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_array = np.array(image)
-        
+    
         try:
             # Verify the image contains a face
             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_array, model_name='Facenet')[0]['embedding']
-            
+        
             # Check if person already exists
             name = name.strip().title()
             if name in self.known_face_names:
                 return f"❌ {name} is already registered!", self.get_registered_workers_info()
-            
+        
             # 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)
             self.known_face_ids.append(worker_id)
             self.next_worker_id += 1
-            
-            # Save face image
+        
+            # Save face image locally
             face_image = Image.fromarray(image_array)
-            face_image.save(f"data/faces/{worker_id}_{name.replace(' ', '_')}.jpg")
-            
-            # Prepare worker data for Salesforce
-            worker_data = {
-                'name': name,
-                'worker_id': worker_id,
-                'embedding': embedding,
-                'caption': caption,
-                'registration_date': date.today().isoformat()
-            }
-            
+            image_path = f"data/faces/{worker_id}_{name.replace(' ', '_')}.jpg"
+            face_image.save(image_path)
+        
             # Save to Salesforce
-            salesforce_success = self.save_worker_to_salesforce(worker_data)
-            
+            if self.sf:
+                try:
+                    # Create Worker__c record with image path
+                    self.sf.Worker__c.create({
+                        'Name': name,
+                        'Worker_ID__c': worker_id,
+                        'Face_Embedding__c': json.dumps(embedding),
+                        'Image_Caption__c': caption,
+                        'Image_Path__c': image_path
+                    })
+                    logger.info(f"Worker {name} ({worker_id}) saved to Salesforce with image path: {image_path}")
+                except Exception as e:
+                    logger.error(f"Error saving to Salesforce: {e}")
+        
             self.save_data()
-            
-            status_message = f"✅ {name} has been successfully registered with ID: {worker_id}! Caption: {caption}"
-            if salesforce_success:
-                status_message += " (Synced with Salesforce)"
-            else:
-                status_message += " (Local only - Salesforce sync failed)"
-            
-            return status_message, self.get_registered_workers_info()
         
+            return f"✅ {name} has been successfully registered with ID: {worker_id}! Caption: {caption}\nImage Path: {image_path}", self.get_registered_workers_info()
+    
         except ValueError as e:
             if "Face could not be detected" in str(e):
                 return "❌ No face detected in the image! Please try again with a clear face image.", self.get_registered_workers_info()
             return f"❌ Error processing image: {str(e)}", self.get_registered_workers_info()
         except Exception as e:
-            logger.error(f"Error during registration: {e}")
             return f"❌ Error during registration: {str(e)}", self.get_registered_workers_info()
-    
+
     def register_worker_auto(self, face_image):
-        """Automatic worker registration for unrecognized faces with enhanced Salesforce integration"""
+        """Automatic worker registration for unrecognized faces"""
         try:
             # Generate new worker ID and name
             worker_id = f"W{self.next_worker_id:04d}"
             worker_name = f"Unknown_Worker_{self.next_worker_id}"
-            
+        
             # 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)
             self.known_face_ids.append(worker_id)
             self.next_worker_id += 1
-            
-            # Save face image
-            face_pil.save(f"data/faces/{worker_id}_{worker_name}.jpg")
-            
-            # Prepare worker data for Salesforce
-            worker_data = {
-                'name': worker_name,
-                'worker_id': worker_id,
-                'embedding': embedding,
-                'caption': caption,
-                'registration_date': date.today().isoformat()
-            }
-            
+        
+            # Save face image locally
+            image_path = f"data/faces/{worker_id}_{worker_name}.jpg"
+            face_pil.save(image_path)
+        
             # Save to Salesforce
-            self.save_worker_to_salesforce(worker_data)
-            
+            if self.sf:
+                try:
+                    # Create Worker__c record with image path
+                    self.sf.Worker__c.create({
+                        'Name': worker_name,
+                        'Worker_ID__c': worker_id,
+                        'Face_Embedding__c': json.dumps(embedding),
+                        'Image_Caption__c': caption,
+                        'Image_Path__c': image_path
+                    })
+                    logger.info(f"Worker {worker_name} ({worker_id}) saved to Salesforce with image path: {image_path}")
+                except Exception as e:
+                    logger.error(f"Error saving to Salesforce: {e}")
+        
             self.save_data()
-            
+        
             return worker_id, worker_name
-            
+        
         except Exception as e:
             logger.error(f"Error in auto registration: {e}")
             return None, None
-    
-    def mark_attendance(self, worker_id, worker_name, confidence=0.0):
-        """Mark attendance for a worker with enhanced Salesforce integration"""
+
+    def mark_attendance(self, worker_id, worker_name):
+        """Mark attendance for a worker and save to Salesforce"""
         try:
             today = date.today().isoformat()
             current_time = datetime.now()
-            
+        
             # Check if already marked today
             already_marked = any(
                 record["worker_id"] == worker_id and record["date"] == today 
                 for record in self.attendance_records
             )
-            
+        
             if not already_marked:
                 # Create attendance record
                 attendance_record = {
@@ -457,66 +283,60 @@ class AttendanceSystem:
                     "time": current_time.strftime("%H:%M:%S"),
                     "timestamp": current_time.isoformat(),
                     "status": "Present",
-                    "method": "Auto",
-                    "confidence": confidence
+                    "method": "Auto"
                 }
                 self.attendance_records.append(attendance_record)
-                
-                # Prepare attendance data for Salesforce
-                attendance_data = {
-                    'worker_id': worker_id,
-                    'worker_name': worker_name,
-                    'date': today,
-                    'time': current_time.strftime("%H:%M:%S"),
-                    'timestamp': current_time.isoformat(),
-                    'status': "Present",
-                    'method': "Auto",
-                    'confidence': confidence
-                }
-                
+            
                 # Save to Salesforce
-                self.save_attendance_to_salesforce(attendance_data)
-                
+                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"
+                        })
+                        logger.info(f"Attendance for {worker_name} ({worker_id}) saved to Salesforce")
+                    except Exception as e:
+                        logger.error(f"Error saving attendance to Salesforce: {e}")
+            
                 self.save_data()
                 return True
             return False
-            
+        
         except Exception as e:
             logger.error(f"Error marking attendance: {e}")
             return False
-    
+
     def process_video_frame(self, frame):
-        """Process a single video frame for face recognition with enhanced accuracy"""
+        """Process a single video frame for face recognition"""
         try:
             rgb_frame = cv2.cvtColor(frame, cv2.COLOR_BGR2RGB)
-            
+        
             # Find faces in the frame
-            face_objs = DeepFace.extract_faces(
-                img_path=rgb_frame, 
-                target_size=(160, 160), 
-                enforce_detection=False, 
-                detector_backend='opencv'
-            )
-            
+            face_objs = DeepFace.extract_faces(img_path=rgb_frame, target_size=(160, 160), enforce_detection=False, detector_backend='opencv')
+        
             current_time = time.time()
-            
+        
             for face_obj in face_objs:
-                if face_obj['confidence'] > CONFIG["FACE_CONFIDENCE_THRESHOLD"]:
+                if face_obj['confidence'] > 0.9:  # Only consider confident detections
                     face_area = face_obj['facial_area']
                     x, y, w, h = face_area['x'], face_area['y'], face_area['w'], face_area['h']
-                    
+                
                     # Extract face image
                     face_image = frame[y:y+h, x:x+w]
-                    
+                
                     try:
                         # Get face embedding
                         embedding = DeepFace.represent(img_path=face_image, model_name='Facenet')[0]['embedding']
-                        
+                    
                         worker_id = None
                         worker_name = "Unknown"
                         color = (0, 0, 255)  # Red for unknown
-                        confidence = 0.0
-                        
+                    
                         # Compare with known faces
                         if len(self.known_face_embeddings) > 0:
                             # Calculate distances to known faces
@@ -524,24 +344,23 @@ class AttendanceSystem:
                             for known_embedding in self.known_face_embeddings:
                                 distance = np.linalg.norm(np.array(embedding) - np.array(known_embedding))
                                 distances.append(distance)
-                            
+                        
                             min_distance = min(distances)
                             best_match_index = distances.index(min_distance)
-                            confidence = max(0, 100 - min_distance * 10)  # Convert distance to confidence percentage
-                            
-                            if min_distance < CONFIG["FACE_RECOGNITION_THRESHOLD"]:
+                        
+                            if min_distance < 10:  # Threshold for recognition
                                 worker_id = self.known_face_ids[best_match_index]
                                 worker_name = self.known_face_names[best_match_index]
                                 color = (0, 255, 0)  # Green for known
-                                
+                            
                                 # Check cooldown period
                                 if worker_id not in self.last_recognition_time or \
                                    current_time - self.last_recognition_time[worker_id] > self.recognition_cooldown:
-                                    
+                                
                                     # Mark attendance
-                                    if self.mark_attendance(worker_id, worker_name, confidence):
-                                        logger.info(f"✅ Attendance marked for {worker_name} ({worker_id}) with confidence {confidence:.1f}%")
-                                    
+                                    if self.mark_attendance(worker_id, worker_name):
+                                        logger.info(f"Attendance marked for {worker_name} ({worker_id})")
+                                
                                     self.last_recognition_time[worker_id] = current_time
                             else:
                                 # Unknown face - auto register
@@ -551,150 +370,145 @@ class AttendanceSystem:
                                         worker_id = new_id
                                         worker_name = new_name
                                         color = (255, 165, 0)  # Orange for newly registered
-                                        logger.info(f"🆕 New worker registered: {new_name} ({new_id})")
-                                        
+                                        logger.info(f"New worker registered: {new_name} ({new_id})")
+                                    
                                         # Mark attendance for new worker
-                                        self.mark_attendance(worker_id, worker_name, confidence)
-                        
+                                        self.mark_attendance(worker_id, worker_name)
+                    
                         # Draw rectangle and label
                         cv2.rectangle(frame, (x, y), (x+w, y+h), color, 2)
                         cv2.rectangle(frame, (x, y+h - 35), (x+w, y+h), color, cv2.FILLED)
-                        
+                    
                         label = f"{worker_name}"
                         if worker_id:
                             label += f" ({worker_id})"
-                        if confidence > 0:
-                            label += f" {confidence:.1f}%"
-                        
+                    
                         cv2.putText(frame, label, (x + 6, y+h - 6), 
                                   cv2.FONT_HERSHEY_DUPLEX, 0.6, (255, 255, 255), 1)
-                    
+                
                     except Exception as e:
                         logger.error(f"Error processing face: {e}")
                         continue
-            
+        
             return frame
-            
+        
         except Exception as e:
             logger.error(f"Error processing frame: {e}")
             return frame
-    
+
     def start_video_stream(self, camera_source=0):
-        """Start video streaming and recognition with enhanced error handling"""
+        """Start video streaming and recognition"""
         try:
             if self.is_streaming:
                 return "⚠️ Video stream is already running!"
-            
+        
             # Clear previous video file if switching from file to camera
             self.video_file_path = None
-            
+        
             self.video_capture = cv2.VideoCapture(camera_source)
             if not self.video_capture.isOpened():
                 return "❌ Could not open camera/video source!"
-            
+        
             self.is_streaming = True
-            
+        
             def video_loop():
                 while self.is_streaming:
                     ret, frame = self.video_capture.read()
                     if not ret:
                         break
-                    
+                
                     # Process frame for face recognition
                     processed_frame = self.process_video_frame(frame)
-                    
+                
                     # Add to queue for display
                     if not self.frame_queue.full():
                         try:
                             self.frame_queue.put_nowait(processed_frame)
                         except queue.Full:
                             pass
-                    
+                
                     time.sleep(0.1)  # Limit processing rate
-            
+        
             self.recognition_thread = threading.Thread(target=video_loop)
             self.recognition_thread.daemon = True
             self.recognition_thread.start()
-            
+        
             return "✅ Live camera stream started successfully!"
-            
+        
         except Exception as e:
-            logger.error(f"Error starting video stream: {e}")
             return f"❌ Error starting video stream: {e}"
-    
+
     def process_uploaded_video(self, video_path):
-        """Process an uploaded video file for face recognition with enhanced error handling"""
+        """Process an uploaded video file for face recognition"""
         try:
             if self.is_streaming:
                 return "⚠️ Please stop current stream before processing a video file!"
-            
+        
             if not os.path.exists(video_path):
                 return "❌ Video file not found!"
-            
+        
             self.video_file_path = video_path
             self.video_processing = True
-            
+        
             def video_processing_loop():
                 cap = cv2.VideoCapture(video_path)
                 fps = cap.get(cv2.CAP_PROP_FPS)
                 frame_delay = 1.0 / fps if fps > 0 else 0.03
-                
+            
                 while self.video_processing and cap.isOpened():
                     ret, frame = cap.read()
                     if not ret:
                         break
-                    
+                
                     # Process frame for face recognition
                     processed_frame = self.process_video_frame(frame)
-                    
+                
                     # Add to queue for display
                     if not self.frame_queue.full():
                         try:
                             self.frame_queue.put_nowait(processed_frame)
                         except queue.Full:
                             pass
-                    
-                    time.sleep(frame_delay)
                 
+                    time.sleep(frame_delay)
+            
                 cap.release()
                 self.video_processing = False
-            
+        
             self.recognition_thread = threading.Thread(target=video_processing_loop)
             self.recognition_thread.daemon = True
             self.recognition_thread.start()
-            
+        
             return f"✅ Video processing started successfully! ({os.path.basename(video_path)})"
-            
+        
         except Exception as e:
-            logger.error(f"Error processing video: {e}")
             return f"❌ Error processing video: {e}"
-    
+
     def stop_video_stream(self):
-        """Stop video streaming or processing with enhanced cleanup"""
+        """Stop video streaming or processing"""
         try:
             self.is_streaming = False
             self.video_processing = False
-            
+        
             if self.video_capture:
                 self.video_capture.release()
                 self.video_capture = None
-            
+        
             if self.recognition_thread:
                 self.recognition_thread.join(timeout=2)
-            
+        
             # Clear frame queue
             while not self.frame_queue.empty():
                 try:
                     self.frame_queue.get_nowait()
                 except queue.Empty:
                     break
-            
+        
             return "✅ Video stream/processing stopped successfully!"
-            
+        
         except Exception as e:
-            logger.error(f"Error stopping video: {e}")
             return f"❌ Error stopping video: {e}"
-    
+
     def get_current_frame(self):
         """Get current frame for display"""
         try:
@@ -704,260 +518,186 @@ class AttendanceSystem:
             return None
         except queue.Empty:
             return None
-    
+
     def get_registered_workers_info(self):
-        """Get information about registered workers with enhanced Salesforce integration"""
-        if self.sf:
-            try:
-                workers = self.sf.query_all("SELECT Name, Worker_ID__c, Image_Caption__c, Registration_Date__c FROM Worker__c ORDER BY Registration_Date__c DESC")['records']
-                if not workers:
-                    return "No workers registered yet."
-                
-                info = f"**Registered Workers ({len(workers)}) - Synced with Salesforce:**\n\n"
-                for i, worker in enumerate(workers, 1):
-                    reg_date = worker.get('Registration_Date__c', 'N/A')
-                    caption = worker.get('Image_Caption__c', 'N/A')
-                    info += f"{i}. **{worker['Name']}** (ID: {worker['Worker_ID__c']}) - Registered: {reg_date}\n"
-                    info += f"   Caption: {caption}\n\n"
-                return info
-            except Exception as e:
-                logger.error(f"Error fetching workers from Salesforce: {e}")
-                return self._get_local_workers_info()
-        else:
-            return self._get_local_workers_info()
+        """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, Image_Path__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"
+                info += f"   Image Path: {worker['Image_Path__c'] or 'N/A'}\n"
+            return info
+        except Exception as e:
+            logger.error(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."
-        
-        info = f"**Registered Workers ({len(self.known_face_names)}) - Local Database:**\n\n"
+    
+        info = f"**Registered Workers ({len(self.known_face_names)}):**\n\n"
         for i, (worker_id, name) in enumerate(zip(self.known_face_ids, self.known_face_names), 1):
             info += f"{i}. **{name}** (ID: {worker_id})\n"
         return info
-    
+
     def get_today_attendance(self):
-        """Get today's attendance records with enhanced Salesforce integration"""
+        """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 self.sf:
-            try:
-                records = self.sf.query_all(
-                    f"SELECT Name__c, Worker_ID__c, Time__c, Method__c, Confidence__c FROM Attendance__c WHERE Date__c = '{today}' ORDER BY Time__c DESC"
-                )['records']
-                
-                if not records:
-                    return f"**Today's Attendance ({today}) - Synced with Salesforce:**\n\nNo attendance marked yet."
-                
-                info = f"**Today's Attendance ({today}) - Synced with Salesforce:**\n\n"
-                for record in records:
-                    method_icon = "🤖" if record['Method__c'] == "Auto" else "👤"
-                    confidence = record.get('Confidence__c', 0)
-                    confidence_text = f" ({confidence:.1f}%)" if confidence > 0 else ""
-                    info += f"{method_icon} **{record['Name__c']}** (ID: {record['Worker_ID__c']}) - {record['Time__c']}{confidence_text}\n"
-                return info
-            except Exception as e:
-                logger.error(f"Error fetching attendance from Salesforce: {e}")
-                return self._get_local_today_attendance()
-        else:
+            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:
+            logger.error(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]
-        
+    
         if not today_records:
-            return f"**Today's Attendance ({today}) - Local Database:**\n\nNo attendance marked yet."
-        
-        info = f"**Today's Attendance ({today}) - Local Database:**\n\n"
+            return f"**Today's Attendance ({today}):**\n\nNo attendance marked yet."
+    
+        info = f"**Today's Attendance ({today}):**\n\n"
         for record in today_records:
             method_icon = "🤖" if record.get("method") == "Auto" else "👤"
-            confidence = record.get("confidence", 0)
-            confidence_text = f" ({confidence:.1f}%)" if confidence > 0 else ""
-            info += f"{method_icon} **{record['name']}** (ID: {record['worker_id']}) - {record['time']}{confidence_text}\n"
+            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 comprehensive attendance report with enhanced Salesforce integration and PDF generation"""
+        """Generate attendance report for date range from Salesforce"""
         if not start_date or not end_date:
             return "Please select both start and end dates."
-        
+    
         try:
             # Validate date format
             datetime.strptime(start_date, '%Y-%m-%d')
             datetime.strptime(end_date, '%Y-%m-%d')
         except ValueError:
             return "Invalid date format. Please use YYYY-MM-DD."
-        
+    
+        if not self.sf:
+            return "❌ Salesforce connection not established."
+    
         try:
-            if self.sf:
-                # Query Salesforce for attendance records
-                records = self.sf.query_all(
-                    f"SELECT Worker_ID__c, Name__c, Date__c, Time__c, Method__c, Confidence__c FROM Attendance__c "
-                    f"WHERE Date__c >= '{start_date}' AND Date__c <= '{end_date}' ORDER BY Date__c DESC, Time__c DESC"
-                )['records']
-                
-                # Get worker info
-                workers = self.sf.query_all("SELECT Name, Worker_ID__c FROM Worker__c")['records']
-                
-                data_source = "Salesforce"
-            else:
-                # Use local data
-                records = [r for r in self.attendance_records if start_date <= r["date"] <= end_date]
-                workers = [{'Name': name, 'Worker_ID__c': wid} for name, wid in zip(self.known_face_names, self.known_face_ids)]
-                data_source = "Local Database"
-            
+            # 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}."
-            
-            # Generate PDF report
-            output_dir = "data/reports"
-            pdf_path, pdf_url = self.generate_comprehensive_report(start_date, end_date, records, workers)
-            
+        
             # Create DataFrame for analysis
-            if self.sf:
-                df_data = []
-                for record in records:
-                    df_data.append({
-                        'Worker_ID': record['Worker_ID__c'],
-                        'Name': record['Name__c'],
-                        'Date': record['Date__c'],
-                        'Time': record['Time__c'],
-                        'Method': record['Method__c'],
-                        'Confidence': record.get('Confidence__c', 0)
-                    })
-                df = pd.DataFrame(df_data)
-            else:
-                df = pd.DataFrame(records)
-                df = df.rename(columns={'worker_id': 'Worker_ID', 'name': 'Name', 'date': 'Date', 'time': 'Time', 'method': 'Method', 'confidence': 'Confidence'})
-            
+            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'].nunique()
+            unique_workers = df['Worker_ID__c'].nunique()
             total_attendances = len(df)
-            auto_registrations = len(df[df['Method'] == 'Auto'])
-            avg_confidence = df['Confidence'].mean() if 'Confidence' in df.columns else 0
-            
-            report = f"**📊 Comprehensive Attendance Report ({start_date} to {end_date})**\n"
-            report += f"**Data Source:** {data_source}\n\n"
+            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"
-            report += f"• Average Confidence: {avg_confidence:.1f}%\n\n"
-            
+            report += f"• Auto Detections: {auto_registrations}\n\n"
+        
             # Individual attendance counts
             if not df.empty:
-                attendance_counts = df.groupby(['Worker_ID', 'Name']).size().reset_index(name='count')
+                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']}** ({row['Worker_ID']}): {row['count']} days ({percentage:.1f}%)\n"
-            
-            if pdf_path:
-                report += f"\n**📄 PDF Report Generated:** {os.path.basename(pdf_path)}\n"
-            
+                    report += f"• **{row['Name__c']}** ({row['Worker_ID__c']}): {row['count']} days ({percentage:.1f}%)\n"
+        
             return report
         except Exception as e:
-            logger.error(f"Error generating report: {e}")
-            return f"❌ Error generating report: {e}"
+            logger.error(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 
+            if start_date <= r["date"] <= end_date
+        ]
     
-    def generate_comprehensive_report(self, start_date, end_date, records, workers):
-        """Generate comprehensive PDF report with enhanced features"""
-        try:
-            output_dir = "data/reports"
-            pdf_path, pdf_url, pdf_file = generate_attendance_pdf(records, workers, output_dir)
-            
-            # Upload to Salesforce if connected
-            if self.sf and pdf_file:
-                try:
-                    # Create report record in Salesforce
-                    report_record = self.sf.Attendance_Report__c.create({
-                        'Start_Date__c': start_date,
-                        'End_Date__c': end_date,
-                        'Total_Workers__c': len(workers),
-                        'Total_Attendance__c': len(records),
-                        'PDF_URL__c': pdf_url,
-                        'Generated_Date__c': date.today().isoformat()
-                    })
-                    logger.info(f"Report record created in Salesforce: {report_record['id']}")
-                    
-                    # Upload PDF to Salesforce
-                    uploaded_url = upload_pdf_to_salesforce(self.sf, pdf_file, report_record['id'])
-                    if uploaded_url:
-                        # Update record with uploaded PDF URL
-                        self.sf.Attendance_Report__c.update(report_record['id'], {'PDF_URL__c': uploaded_url})
-                        pdf_url = uploaded_url
-                        
-                except Exception as e:
-                    logger.error(f"Error creating report record in Salesforce: {e}")
-            
-            return pdf_path, pdf_url
-        except Exception as e:
-            logger.error(f"Error generating comprehensive report: {e}")
-            return "", ""
+        if not filtered_records:
+            return f"No attendance records found between {start_date} and {end_date}."
+    
+        # Create DataFrame for analysis
+        df = pd.DataFrame(filtered_records)
+    
+        # Summary statistics
+        total_days = (pd.to_datetime(end_date) - pd.to_datetime(start_date)).days + 1
+        unique_workers = df['worker_id'].nunique()
+        total_attendances = len(df)
+        auto_registrations = len(df[df['method'] == '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', 'name']).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']}** ({row['worker_id']}): {row['count']} days ({percentage:.1f}%)\n"
+    
+        return report
+
     def export_attendance_csv(self):
-        """Export attendance records to CSV with enhanced features"""
+        """Export attendance records to CSV"""
         try:
-            if self.sf:
-                # Export from Salesforce
-                records = self.sf.query_all("SELECT Worker_ID__c, Name__c, Date__c, Time__c, Method__c, Confidence__c FROM Attendance__c ORDER BY Date__c DESC, Time__c DESC")['records']
-                if not records:
-                    return None, "No attendance records to export from Salesforce."
-                
-                # Convert to DataFrame
-                df_data = []
-                for record in records:
-                    df_data.append({
-                        'Worker_ID': record['Worker_ID__c'],
-                        'Name': record['Name__c'],
-                        'Date': record['Date__c'],
-                        'Time': record['Time__c'],
-                        'Method': record['Method__c'],
-                        'Confidence': record.get('Confidence__c', 0)
-                    })
-                df = pd.DataFrame(df_data)
-                source = "Salesforce"
-            else:
-                # Export from local data
-                if not self.attendance_records:
-                    return None, "No attendance records to export from local database."
-                
-                df = pd.DataFrame(self.attendance_records)
-                source = "Local"
-            
+            if not self.attendance_records:
+                return None, "No attendance records to export."
+        
+            df = pd.DataFrame(self.attendance_records)
             timestamp = datetime.now().strftime('%Y%m%d_%H%M%S')
-            csv_file = f"data/reports/attendance_report_{source}_{timestamp}.csv"
+            csv_file = f"attendance_report_{timestamp}.csv"
             df.to_csv(csv_file, index=False)
-            
-            return csv_file, f"✅ Attendance exported to {os.path.basename(csv_file)} (Source: {source})"
-            
+        
+            return csv_file, f"✅ Attendance exported to {csv_file}"
+        
         except Exception as e:
-            logger.error(f"Error exporting data: {e}")
             return None, f"❌ Error exporting data: {e}"
-    
-    def get_salesforce_status(self):
-        """Get current Salesforce connection status"""
-        if self.sf:
-            try:
-                # Test connection
-                self.sf.describe()
-                return "✅ Connected to Salesforce - Data syncing enabled"
-            except Exception as e:
-                logger.error(f"Salesforce connection test failed: {e}")
-                return "❌ Salesforce connection lost - Using local data only"
-        else:
-            return "❌ Not connected to Salesforce - Using local data only"
 
 # Initialize the attendance system
 attendance_system = AttendanceSystem()
 
 def create_interface():
     with gr.Blocks(
-        title="🎯 Enhanced Attendance System with Improved Salesforce Integration",
+        title="🎯 Advanced Attendance System with Video Recognition",
         theme=gr.themes.Soft(),
         css="""
         .gradio-container {
@@ -974,47 +714,31 @@ def create_interface():
         .video-option-tabs {
             margin-bottom: 15px;
         }
-        .salesforce-status {
-            background: linear-gradient(90deg, #f0f9ff, #e0f2fe);
-            border: 1px solid #0ea5e9;
-            border-radius: 8px;
-            padding: 10px;
-            margin: 10px 0;
-        }
         """
     ) as demo:
-        
         gr.Markdown(
             """
-            # 🎯 Enhanced Attendance System with Improved Salesforce Integration
-            
-            **Comprehensive facial recognition system with live camera and video file processing, integrated with Hugging Face AI and Salesforce cloud storage**
-            
-            ## 🚀 **Enhanced Features:**
-            - **🎥 Live Camera Recognition** - Real-time face detection with confidence scoring
-            - **📹 Video File Processing** - Process pre-recorded videos for batch attendance
-            - **🤖 Automatic Worker Registration** - Auto-register unknown faces with AI-generated captions
-            - **👤 Manual Registration** - Register workers manually with Hugging Face image captioning
-            - **📅 Smart Attendance Rules** - One attendance mark per worker per day with cooldown periods
-            - **📊 Advanced Analytics** - Detailed reports with PDF generation and CSV export
-            - **🤗 Hugging Face Integration** - AI-powered image captioning for worker profiles
-            - **☁️ Enhanced Salesforce Integration** - Robust data sync with retry mechanisms and error handling
-            - **📄 PDF Report Generation** - Comprehensive reports with automatic Salesforce upload
-            - **🔄 Real-time Sync** - Automatic data synchronization between local and cloud storage
+            # 🎯 Advanced Attendance System with Face Recognition
+            
+            **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 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
             """
         )
-        
-        # Salesforce Status Display
-        salesforce_status = gr.Markdown(
-            value=attendance_system.get_salesforce_status(),
-            elem_classes="salesforce-status"
-        )
-        
+    
         with gr.Tabs():
             # Video Recognition Tab
             with gr.Tab("🎥 Video Recognition", elem_classes="tab-nav"):
-                gr.Markdown("### Enhanced Face Recognition from Live Camera or Video File")
-                
+                gr.Markdown("### Face Recognition from Live Camera or Video File")
+            
                 with gr.Row():
                     with gr.Column(scale=1):
                         with gr.Tabs(selected="live", elem_classes="video-option-tabs") as video_tabs:
@@ -1024,82 +748,80 @@ def create_interface():
                                     value=0,
                                     precision=0
                                 )
-                                
+                            
                                 with gr.Row():
                                     start_stream_btn = gr.Button(
                                         "🎥 Start Live Recognition",
                                         variant="primary",
                                         size="lg"
                                     )
-                            
+                        
                             with gr.Tab("Upload Video", id="upload"):
                                 video_file = gr.Video(
                                     label="Upload Video File",
                                     sources=["upload"],
                                     format="mp4"
                                 )
-                                
+                            
                                 with gr.Row():
                                     process_video_btn = gr.Button(
                                         "📹 Process Video File",
                                         variant="primary",
                                         size="lg"
                                     )
-                        
+                    
                         stop_stream_btn = gr.Button(
                             "⏹️ Stop Processing",
                             variant="stop",
                             size="lg"
                         )
-                        
+                    
                         stream_status = gr.Textbox(
                             label="Processing Status",
                             value="Ready to start...",
                             interactive=False,
                             lines=2
                         )
-                        
+                    
                         gr.Markdown(
                             """
-                            **📋 Enhanced Instructions:**
+                            **📋 Instructions:**
                             - **Live Camera:** Select camera source and click "Start Live Recognition"
                             - **Video File:** Upload a video file and click "Process Video File"
-                            - **Confidence Scoring:** System shows recognition confidence percentages
-                            - **Auto-Registration:** Unknown faces are automatically registered with unique IDs
-                            - **Cooldown Period:** 5-second cooldown between recognitions for same person
+                            - Click "Stop Processing" to stop current session
                             
-                            **🎨 Enhanced Color Coding:**
-                            - 🟢 **Green:** Known worker (attendance marked with confidence score)
-                            - 🟠 **Orange:** New worker (auto-registered with AI caption)
-                            - 🔴 **Red:** Face detected but processing/low confidence
+                            **🎨 Color Coding:**
+                            - 🟢 **Green:** Known worker (attendance marked)
+                            - 🟠 **Orange:** New worker (auto-registered)
+                            - 🔴 **Red:** Face detected but processing
                             """
                         )
-                    
+                
                     with gr.Column(scale=1):
                         video_output = gr.Image(
-                            label="Enhanced Recognition Output",
+                            label="Recognition Output",
                             streaming=True,
                             interactive=False
                         )
-                        
+                    
                         live_attendance_display = gr.Markdown(
                             value=attendance_system.get_today_attendance(),
-                            label="Live Attendance Updates (Synced with Salesforce)"
+                            label="Live Attendance Updates"
                         )
-                        
+                    
                         refresh_attendance_btn = gr.Button(
                             "🔄 Refresh Attendance",
                             variant="secondary"
                         )
-            
+        
             # Manual Registration Tab
-            with gr.Tab("👤 Enhanced Registration", elem_classes="tab-nav"):
-                gr.Markdown("### Register Workers Manually with AI-Powered Captions")
-                
+            with gr.Tab("👤 Manual Registration", elem_classes="tab-nav"):
+                gr.Markdown("### Register Workers Manually")
+            
                 with gr.Row():
                     with gr.Column(scale=1):
                         register_image = gr.Image(
-                            label="Upload Worker's Photo (High Quality Recommended)",
+                            label="Upload Worker's Photo",
                             type="pil",
                             height=300
                         )
@@ -1109,22 +831,11 @@ def create_interface():
                             lines=1
                         )
                         register_btn = gr.Button(
-                            "👤 Register Worker with AI Caption",
+                            "👤 Register Worker",
                             variant="primary",
                             size="lg"
                         )
-                        
-                        gr.Markdown(
-                            """
-                            **✨ Enhanced Features:**
-                            - **AI-Powered Captions:** Automatic image description using Hugging Face
-                            - **Face Validation:** Ensures clear face detection before registration
-                            - **Duplicate Prevention:** Checks for existing registrations
-                            - **Salesforce Sync:** Automatic cloud backup with retry mechanisms
-                            - **High-Quality Storage:** Optimized face embeddings for better recognition
-                            """
-                        )
-                    
+                
                     with gr.Column(scale=1):
                         register_output = gr.Textbox(
                             label="Registration Status",
@@ -1133,16 +844,16 @@ def create_interface():
                         )
                         registered_workers_info = gr.Markdown(
                             value=attendance_system.get_registered_workers_info(),
-                            label="Enhanced Workers Database (Synced with Salesforce)"
+                            label="Registered Workers Database"
                         )
-            
+        
             # Reports & Analytics Tab
-            with gr.Tab("📊 Advanced Reports & Analytics", elem_classes="tab-nav"):
-                gr.Markdown("### Comprehensive Attendance Reports with PDF Generation and Salesforce Integration")
-                
+            with gr.Tab("📊 Reports & Analytics", elem_classes="tab-nav"):
+                gr.Markdown("### Attendance Reports and Data Export")
+            
                 with gr.Row():
                     with gr.Column():
-                        gr.Markdown("#### 📅 Generate Comprehensive Report")
+                        gr.Markdown("#### 📅 Generate Report")
                         start_date = gr.Textbox(
                             label="Start Date (YYYY-MM-DD)",
                             value=date.today().replace(day=1).strftime('%Y-%m-%d')
@@ -1152,13 +863,13 @@ def create_interface():
                             value=date.today().strftime('%Y-%m-%d')
                         )
                         generate_report_btn = gr.Button(
-                            "📊 Generate Enhanced Report with PDF",
+                            "📊 Generate Report",
                             variant="primary"
                         )
-                        
-                        gr.Markdown("#### 💾 Export Enhanced Data")
+                    
+                        gr.Markdown("#### 💾 Export Data")
                         export_btn = gr.Button(
-                            "📥 Export to CSV (Salesforce + Local)",
+                            "📥 Export to CSV",
                             variant="secondary"
                         )
                         export_status = gr.Textbox(
@@ -1170,105 +881,83 @@ def create_interface():
                             label="Download File",
                             visible=False
                         )
-                        
-                        gr.Markdown(
-                            """
-                            **🚀 Enhanced Analytics Features:**
-                            - **PDF Report Generation:** Professional reports with charts and statistics
-                            - **Salesforce Integration:** Real-time data from cloud storage
-                            - **Confidence Analytics:** Average recognition confidence scores
-                            - **Attendance Patterns:** Daily, weekly, and monthly trends
-                            - **Worker Performance:** Individual attendance percentages
-                            - **Auto-Upload:** PDF reports automatically uploaded to Salesforce
-                            """
-                        )
-                    
+                
                     with gr.Column():
                         report_output = gr.Markdown(
-                            value="Select date range and click 'Generate Enhanced Report' to view comprehensive attendance analytics with PDF generation.",
-                            label="Enhanced Attendance Report"
+                            value="Select date range and click 'Generate Report' to view attendance analytics.",
+                            label="Attendance Report"
                         )
-        
-        # Enhanced Event handlers
+    
+        # Event handlers
         start_stream_btn.click(
             fn=attendance_system.start_video_stream,
             inputs=[camera_source],
             outputs=[stream_status]
         )
-        
+    
         process_video_btn.click(
             fn=attendance_system.process_uploaded_video,
             inputs=[video_file],
             outputs=[stream_status]
         )
-        
+    
         stop_stream_btn.click(
             fn=attendance_system.stop_video_stream,
             outputs=[stream_status]
         )
-        
-        def refresh_all_data():
-            attendance = attendance_system.get_today_attendance()
-            sf_status = attendance_system.get_salesforce_status()
-            return attendance, sf_status
-        
+    
         refresh_attendance_btn.click(
-            fn=refresh_all_data,
-            outputs=[live_attendance_display, salesforce_status]
+            fn=attendance_system.get_today_attendance,
+            outputs=[live_attendance_display]
         )
-        
+    
         register_btn.click(
             fn=attendance_system.register_worker_manual,
             inputs=[register_image, register_name],
             outputs=[register_output, registered_workers_info]
         )
-        
+    
         generate_report_btn.click(
             fn=attendance_system.get_attendance_report,
             inputs=[start_date, end_date],
             outputs=[report_output]
         )
-        
+    
         def export_and_show():
             file_path, status = attendance_system.export_attendance_csv()
             if file_path:
                 return status, gr.update(visible=True, value=file_path)
             else:
                 return status, gr.update(visible=False)
-        
+    
         export_btn.click(
             fn=export_and_show,
             outputs=[export_status, export_file]
         )
-        
-        # Enhanced video frame update with error handling
+    
+        # Video frame update
         def update_video_frame():
             start_time = time.time()
             while True:
-                try:
-                    current_time = time.time()
-                    if current_time - start_time >= 0.03:  # Update every 0.03 seconds
-                        frame = attendance_system.get_current_frame()
-                        if frame is not None:
-                            # Convert BGR to RGB
-                            frame = cv2.cvtColor(frame, cv2.COLOR_BGR2RGB)
-                            return frame
-                        start_time = current_time
-                    time.sleep(0.01)  # Small sleep to prevent busy-waiting
-                except Exception as e:
-                    logger.error(f"Error in video frame update: {e}")
-                    time.sleep(0.1)
-        
+                current_time = time.time()
+                if current_time - start_time >= 0.03:  # Update every 0.03 seconds
+                    frame = attendance_system.get_current_frame()
+                    if frame is not None:
+                        # Convert BGR to RGB
+                        frame = cv2.cvtColor(frame, cv2.COLOR_BGR2RGB)
+                        return frame
+                    start_time = current_time
+                time.sleep(0.01)  # Small sleep to prevent busy-waiting
+    
         # Start the video frame update as a background thread
         video_thread = threading.Thread(target=lambda: demo.queue()(update_video_frame)())
         video_thread.daemon = True
         video_thread.start()
-    
+
     return demo
 
-# Create and launch the enhanced interface
+# Create and launch the interface
 if __name__ == "__main__":
-    logger.info("Launching Enhanced Attendance System with Improved Salesforce Integration...")
     demo = create_interface()
     demo.launch(
         server_name="0.0.0.0",