Update app.py

app.py

@@ -18,7 +18,6 @@ import pickle
 import cv2
 import gradio as gr
 import numpy as np
-import pandas as pd
 from PIL import Image
 import requests
 from dotenv import load_dotenv
@@ -47,6 +46,12 @@ SF_CREDENTIALS = {
     "domain": os.getenv("SF_DOMAIN", "login")
 }
 
+# Performance settings
+PROCESSING_WIDTH = 640  # Width for resizing frames
+FACE_DETECTION_INTERVAL = 0.1  # Seconds between face detections
+MIN_FACE_CONFIDENCE = 0.90  # Minimum confidence for face detection
+RECOGNITION_COOLDOWN = 5  # Seconds between recognizing same person
+
 # --- SALESFORCE CONNECTION ---
 
 @retry(stop_max_attempt_number=3, wait_fixed=2000)
@@ -59,22 +64,22 @@ def connect_to_salesforce() -> Optional[Salesforce]:
         return sf
     except Exception as e:
         logger.error(f"❌ Salesforce connection failed: {e}")
-        raise
+        return None
 
 # --- CORE LOGIC ---
 
 class AttendanceSystem:
     """
-    Manages all backend logic for the face recognition attendance system.
+    Optimized face recognition attendance system with real-time performance.
     """
     def __init__(self):
         # State Management
         self.processing_thread = None
         self.is_processing = threading.Event()
-        self.frame_queue = queue.Queue(maxsize=10)
-        self.error_message = None 
-        self.last_processed_frame = None # Holds the final frame after processing
-        self.final_log = None # Holds the final log after processing
+        self.frame_queue = queue.Queue(maxsize=5)  # Smaller queue for faster updates
+        self.error_message = None
+        self.last_processed_frame = None
+        self.final_log = None
 
         # Data Storage
         self.known_face_embeddings: List[np.ndarray] = []
@@ -83,15 +88,10 @@ class AttendanceSystem:
         self.next_worker_id: int = 1
         
         # Session Tracking
-        self.last_recognition_time: Dict[str, float] = {}
-        self.recognition_cooldown = 5  # seconds
+        self.today_attendance: Dict[str, bool] = {}
+        self.last_detection_time = 0
         self.session_log: List[str] = []
-        self.today_attendance: Dict[str, bool] = {}  # Track attendance for today
-        self.last_detected_faces: Dict[str, float] = {}  # Track last detection time per worker
-
-        # Performance optimization
-        self.frame_skip = 2  # Process every 3rd frame for faster processing
-        self.frame_counter = 0
+        self.last_log_update = 0
 
         # Initialize
         self.sf = connect_to_salesforce()
@@ -102,106 +102,134 @@ class AttendanceSystem:
         os.makedirs("data/faces", exist_ok=True)
 
     def load_worker_data(self):
-        logger.info("Loading worker data...")
-        if self.sf:
-            try:
+        """Load worker data with timeout protection."""
+        try:
+            if self.sf:
                 workers = self.sf.query_all("SELECT Worker_ID__c, Name, Face_Embedding__c FROM Worker__c")['records']
-                if not workers:
-                    self._load_local_worker_data()
+                if workers:
+                    temp_embeddings, temp_names, temp_ids = [], [], []
+                    max_id = 0
+                    for worker in workers:
+                        if worker.get('Face_Embedding__c'):
+                            temp_embeddings.append(np.array(json.loads(worker['Face_Embedding__c'])))
+                            temp_names.append(worker['Name'])
+                            temp_ids.append(worker['Worker_ID__c'])
+                            try:
+                                worker_num = int(worker['Worker_ID__c'][1:])
+                                max_id = max(max_id, worker_num)
+                            except (ValueError, TypeError):
+                                continue
+                    
+                    self.known_face_embeddings = temp_embeddings
+                    self.known_face_names = temp_names
+                    self.known_face_ids = temp_ids
+                    self.next_worker_id = max_id + 1
+                    logger.info(f"✅ Loaded {len(self.known_face_ids)} workers from Salesforce.")
                     return
-
-                temp_embeddings, temp_names, temp_ids, max_id = [], [], [], 0
-                for worker in workers:
-                    if worker.get('Face_Embedding__c'):
-                        temp_embeddings.append(np.array(json.loads(worker['Face_Embedding__c'])))
-                        temp_names.append(worker['Name'])
-                        temp_ids.append(worker['Worker_ID__c'])
-                        try:
-                            worker_num = int(worker['Worker_ID__c'][1:])
-                            if worker_num > max_id:
-                                max_id = worker_num
-                        except (ValueError, TypeError):
-                            continue
-                
-                self.known_face_embeddings = temp_embeddings
-                self.known_face_names = temp_names
-                self.known_face_ids = temp_ids
-                self.next_worker_id = max_id + 1
-                self.save_local_worker_data()
-                logger.info(f"✅ Loaded {len(self.known_face_ids)} workers from Salesforce.")
-            except Exception as e:
-                logger.error(f"❌ Error loading from Salesforce: {e}. Attempting local load.")
-                self._load_local_worker_data()
-        else:
-            logger.warning("Salesforce not connected. Loading from local cache.")
+            
+            # Fallback to local data
+            self._load_local_worker_data()
+        except Exception as e:
+            logger.error(f"Error loading worker data: {e}")
             self._load_local_worker_data()
 
     def _load_local_worker_data(self):
         try:
             if os.path.exists("data/workers.pkl"):
-                with open("data/workers.pkl", "rb") as f: data = pickle.load(f)
+                with open("data/workers.pkl", "rb") as f:
+                    data = pickle.load(f)
                 self.known_face_embeddings = data.get("embeddings", [])
                 self.known_face_names = data.get("names", [])
                 self.known_face_ids = data.get("ids", [])
                 self.next_worker_id = data.get("next_id", 1)
                 logger.info(f"✅ Loaded {len(self.known_face_ids)} workers from local cache.")
         except Exception as e:
-            logger.error(f"❌ Error loading local data: {e}")
+            logger.error(f"Error loading local data: {e}")
 
     def save_local_worker_data(self):
         try:
-            worker_data = {"embeddings": self.known_face_embeddings, "names": self.known_face_names, "ids": self.known_face_ids, "next_id": self.next_worker_id}
-            with open("data/workers.pkl", "wb") as f: pickle.dump(worker_data, f)
+            worker_data = {
+                "embeddings": self.known_face_embeddings,
+                "names": self.known_face_names,
+                "ids": self.known_face_ids,
+                "next_id": self.next_worker_id
+            }
+            with open("data/workers.pkl", "wb") as f:
+                pickle.dump(worker_data, f)
         except Exception as e:
-            logger.error(f"❌ Error saving local worker data: {e}")
+            logger.error(f"Error saving local worker data: {e}")
     
     # --- Registration and Attendance ---
     def register_worker_manual(self, image: Image.Image, name: str) -> Tuple[str, str]:
         if image is None or not name.strip():
             return "❌ Please provide both image and name!", self.get_registered_workers_info()
+        
         try:
             image_array = np.array(image)
-            # Analyze face quality before registration
-            analysis = DeepFace.analyze(img_path=image_array, actions=['emotion'], enforce_detection=True)
-            if analysis[0]['face_confidence'] < 0.95:
-                return "❌ Face not clear enough for registration!", self.get_registered_workers_info()
             
-            embedding = DeepFace.represent(img_path=image_array, model_name='Facenet')[0]['embedding']
+            # Quick face detection check
+            try:
+                face_objs = DeepFace.extract_faces(
+                    img_path=image_array,
+                    detector_backend='opencv',
+                    enforce_detection=True,
+                    align=False  # Skip alignment for faster check
+                )
+                if not face_objs or face_objs[0]['confidence'] < MIN_FACE_CONFIDENCE:
+                    return "❌ No clear face detected in the image!", self.get_registered_workers_info()
+            except:
+                return "❌ No face detected in the image!", self.get_registered_workers_info()
+
+            # Full processing with alignment
+            embedding = DeepFace.represent(
+                img_path=image_array,
+                model_name='Facenet',
+                enforce_detection=True,
+                align=True
+            )[0]['embedding']
+
             if self._is_duplicate_face(embedding):
-                 return f"❌ Face matches an existing worker!", self.get_registered_workers_info()
+                return f"❌ Face matches an existing worker!", self.get_registered_workers_info()
 
             worker_id = f"W{self.next_worker_id:04d}"
             name = name.strip().title()
             self._add_worker_to_system(worker_id, name, embedding, image_array)
-            self.save_local_worker_data()
-            self.load_worker_data()
             return f"✅ {name} registered with ID: {worker_id}!", self.get_registered_workers_info()
-        except ValueError:
-            return "❌ No face detected in the image!", self.get_registered_workers_info()
         except Exception as e:
             return f"❌ Registration error: {e}", self.get_registered_workers_info()
 
     def _register_worker_auto(self, face_image: np.ndarray) -> Optional[Tuple[str, str]]:
         try:
-            # Check face quality before auto-registration
-            analysis = DeepFace.analyze(img_path=face_image, actions=['emotion'], enforce_detection=False)
-            if analysis[0]['face_confidence'] < 0.95:
+            # Quick quality check first
+            face_objs = DeepFace.extract_faces(
+                img_path=face_image,
+                detector_backend='opencv',
+                enforce_detection=False,
+                align=False
+            )
+            if not face_objs or face_objs[0]['confidence'] < MIN_FACE_CONFIDENCE:
                 return None
-                
-            embedding = DeepFace.represent(img_path=face_image, model_name='Facenet', enforce_detection=False)[0]['embedding']
-            if self._is_duplicate_face(embedding): 
+
+            # Full processing if quality is good
+            embedding = DeepFace.represent(
+                img_path=face_image,
+                model_name='Facenet',
+                enforce_detection=False,
+                align=True
+            )[0]['embedding']
+
+            if self._is_duplicate_face(embedding):
                 return None
-                
+
             worker_id = f"W{self.next_worker_id:04d}"
             worker_name = f"Worker {self.next_worker_id}"
             self._add_worker_to_system(worker_id, worker_name, embedding, face_image)
-            self.save_local_worker_data()
-            log_msg = f"🆕 [{datetime.now().strftime('%H:%M:%S')}] Auto-registered: {worker_name} ({worker_id})"
-            self.session_log.append(log_msg)
-            logger.info(log_msg)
+            
+            log_msg = f"🆕 Auto-registered: {worker_name} ({worker_id})"
+            self._add_to_session_log(log_msg)
             return worker_id, worker_name
         except Exception as e:
-            logger.error(f"❌ Auto-registration error: {e}")
+            logger.error(f"Auto-registration error: {e}")
             return None
 
     def _add_worker_to_system(self, worker_id: str, name: str, embedding: List[float], image_array: np.ndarray):
@@ -209,358 +237,416 @@ class AttendanceSystem:
         self.known_face_names.append(name)
         self.known_face_ids.append(worker_id)
         self.next_worker_id += 1
+        
+        # Save face image
         face_pil = Image.fromarray(cv2.cvtColor(image_array, cv2.COLOR_BGR2RGB))
         face_pil.save(f"data/faces/{worker_id}.jpg")
-        caption = self._get_image_caption(face_pil)
-        if self.sf:
-            try:
-                worker_record = self.sf.Worker__c.create({'Name': name, 'Worker_ID__c': worker_id, 'Face_Embedding__c': json.dumps(embedding), 'Image_Caption__c': caption})
-                image_url = self._upload_image_to_salesforce(face_pil, worker_record['id'], worker_id)
-                if image_url: self.sf.Worker__c.update(worker_record['id'], {'Image_URL__c': image_url})
-                logger.info(f"✅ Worker {worker_id} synced to Salesforce.")
-            except Exception as e:
-                logger.error(f"❌ Salesforce sync error for {worker_id}: {e}")
+        
+        # Async Salesforce sync
+        threading.Thread(
+            target=self._sync_worker_to_salesforce,
+            args=(worker_id, name, embedding, face_pil),
+            daemon=True
+        ).start()
+
+    def _sync_worker_to_salesforce(self, worker_id: str, name: str, embedding: List[float], image: Image.Image):
+        if not self.sf:
+            return
+            
+        try:
+            # Generate caption (async)
+            caption = self._get_image_caption(image)
+            
+            # Create worker record
+            worker_record = self.sf.Worker__c.create({
+                'Name': name,
+                'Worker_ID__c': worker_id,
+                'Face_Embedding__c': json.dumps(embedding),
+                'Image_Caption__c': caption
+            })
+            
+            # Upload image
+            image_url = self._upload_image_to_salesforce(image, worker_record['id'], worker_id)
+            if image_url:
+                self.sf.Worker__c.update(worker_record['id'], {'Image_URL__c': image_url})
+            
+            logger.info(f"Worker {worker_id} synced to Salesforce.")
+            self.save_local_worker_data()
+        except Exception as e:
+            logger.error(f"Salesforce sync error for {worker_id}: {e}")
 
     def _is_duplicate_face(self, embedding: List[float], threshold: float = 10.0) -> bool:
-        if not self.known_face_embeddings: return False
-        distances = [np.linalg.norm(np.array(embedding) - known_embedding) for known_embedding in self.known_face_embeddings]
+        if not self.known_face_embeddings:
+            return False
+            
+        # Convert to numpy array once
+        new_embedding = np.array(embedding)
+        
+        # Calculate distances efficiently
+        distances = [np.linalg.norm(new_embedding - known) for known in self.known_face_embeddings]
         return min(distances) < threshold
 
     def mark_attendance(self, worker_id: str, worker_name: str) -> bool:
         today_str = date.today().isoformat()
         
-        # Check if already marked today
+        # Already marked today?
         if worker_id in self.today_attendance:
             return False
             
-        # Check cooldown period
-        current_time = time.time()
-        if worker_id in self.last_recognition_time and (current_time - self.last_recognition_time[worker_id] < self.recognition_cooldown):
-            return False
-            
-        # Mark attendance
-        current_time_dt = datetime.now()
-        if self.sf:
-            try:
-                self.sf.Attendance__c.create({
-                    'Worker_ID__c': worker_id, 
-                    'Name__c': worker_name, 
-                    'Date__c': today_str, 
-                    'Timestamp__c': current_time_dt.isoformat(), 
-                    'Status__c': "Present"
-                })
-            except Exception as e:
-                logger.error(f"❌ Error saving attendance to Salesforce: {e}")
-        
         self.today_attendance[worker_id] = True
-        self.last_recognition_time[worker_id] = current_time
-        log_msg = f"✅ [{current_time_dt.strftime('%H:%M:%S')}] Marked Present: {worker_name} ({worker_id})"
-        self.session_log.append(log_msg)
+        current_time = datetime.now()
+        
+        # Async Salesforce sync
+        threading.Thread(
+            target=self._sync_attendance_to_salesforce,
+            args=(worker_id, worker_name, today_str, current_time),
+            daemon=True
+        ).start()
+        
+        log_msg = f"✅ [{current_time.strftime('%H:%M:%S')}] Present: {worker_name} ({worker_id})"
+        self._add_to_session_log(log_msg)
         return True
 
+    def _sync_attendance_to_salesforce(self, worker_id: str, worker_name: str, date_str: str, timestamp: datetime):
+        if not self.sf:
+            return
+            
+        try:
+            self.sf.Attendance__c.create({
+                'Worker_ID__c': worker_id,
+                'Name__c': worker_name,
+                'Date__c': date_str,
+                'Timestamp__c': timestamp.isoformat(),
+                'Status__c': "Present"
+            })
+        except Exception as e:
+            logger.error(f"Error saving attendance to Salesforce: {e}")
+
+    def _add_to_session_log(self, message: str):
+        """Add message to session log with rate limiting."""
+        now = time.time()
+        if now - self.last_log_update > 0.5:  # Throttle log updates
+            self.session_log.append(message)
+            self.last_log_update = now
+            if len(self.session_log) > 20:  # Keep log manageable
+                self.session_log.pop(0)
+
     # --- Video Processing ---
     def process_frame(self, frame: np.ndarray) -> np.ndarray:
-        """
-        Process a single video frame with optimizations for speed and accuracy.
-        """
+        """Process a frame with face detection and recognition."""
         try:
-            # Skip frames for faster processing
-            self.frame_counter += 1
-            if self.frame_counter % (self.frame_skip + 1) != 0:
+            now = time.time()
+            
+            # Throttle face detection
+            if now - self.last_detection_time < FACE_DETECTION_INTERVAL:
                 return frame
-
-            # Resize frame for faster processing (keeping aspect ratio)
+                
+            self.last_detection_time = now
+            
+            # Resize for faster processing
             height, width = frame.shape[:2]
-            new_width = 640
-            new_height = int((new_width / width) * height)
-            small_frame = cv2.resize(frame, (new_width, new_height))
-
+            scale = PROCESSING_WIDTH / width
+            small_frame = cv2.resize(frame, (PROCESSING_WIDTH, int(height * scale)))
+            
+            # Detect faces with fast backend
             face_objs = DeepFace.extract_faces(
-                img_path=small_frame, 
-                detector_backend='opencv', 
+                img_path=small_frame,
+                detector_backend='opencv',  # Fastest backend
                 enforce_detection=False,
-                align=True
+                align=False  # Skip alignment for detection
             )
 
             for face_obj in face_objs:
-                confidence = face_obj['confidence']
-                if confidence < 0.95:  # Higher confidence threshold
+                if face_obj['confidence'] < MIN_FACE_CONFIDENCE:
                     continue
-
+                    
+                # Get face coordinates and scale back to original
                 facial_area = face_obj['facial_area']
-                x, y, w, h = facial_area['x'], facial_area['y'], facial_area['w'], facial_area['h']
-                
-                # Scale coordinates back to original frame size
-                x = int(x * width / new_width)
-                y = int(y * height / new_height)
-                w = int(w * width / new_width)
-                h = int(h * height / new_height)
+                x = int(facial_area['x'] / scale)
+                y = int(facial_area['y'] / scale)
+                w = int(facial_area['w'] / scale)
+                h = int(facial_area['h'] / scale)
                 
+                # Extract face region
                 face_image = frame[y:y+h, x:x+w]
-                if face_image.size == 0: 
-                    continue
-
-                # Only process faces that haven't been detected recently
-                current_time = time.time()
-                face_key = f"{x}_{y}_{w}_{h}"
-                if face_key in self.last_detected_faces and (current_time - self.last_detected_faces[face_key] < 2.0):
+                if face_image.size == 0:
                     continue
-                self.last_detected_faces[face_key] = current_time
-
-                embedding = DeepFace.represent(
-                    img_path=face_image, 
-                    model_name='Facenet', 
-                    enforce_detection=False,
-                    align=True
-                )[0]['embedding']
                 
-                if not self.known_face_embeddings:
-                    continue
-
-                distances = [np.linalg.norm(np.array(embedding) - known) for known in self.known_face_embeddings]
-                min_dist = min(distances) if distances else float('inf')
-                match_index = distances.index(min_dist) if min_dist < 10.0 else -1
-
-                color, worker_id, worker_name = (0, 0, 255), None, "Unknown"
-                
-                if match_index != -1:
-                    worker_id = self.known_face_ids[match_index]
-                    worker_name = self.known_face_names[match_index]
-                    color = (0, 255, 0)  # Green for known workers
-                    self.mark_attendance(worker_id, worker_name)
-                else:
-                    # Only attempt auto-registration for high-quality faces
-                    analysis = DeepFace.analyze(img_path=face_image, actions=['emotion'], enforce_detection=False)
-                    if analysis[0]['face_confidence'] >= 0.95:
-                        color = (0, 165, 255)  # Orange for potential new worker
-                        new_worker = self._register_worker_auto(face_image)
-                        if new_worker:
-                            worker_id, worker_name = new_worker[0], new_worker[1]
-                            self.mark_attendance(worker_id, worker_name)
+                # Recognize or register
+                worker_id, worker_name, color = self._process_face(face_image)
                 
-                # Draw rectangle and label
+                # Draw results
                 label = f"{worker_name}" + (f" ({worker_id})" if worker_id else "")
                 cv2.rectangle(frame, (x, y), (x+w, y+h), color, 2)
                 cv2.putText(frame, label, (x, y-10), cv2.FONT_HERSHEY_SIMPLEX, 0.7, color, 2)
 
             return frame
         except Exception as e:
-            logger.error(f"ERROR in process_frame: {e}")
+            logger.error(f"Frame processing error: {e}")
             return frame
 
+    def _process_face(self, face_image: np.ndarray) -> Tuple[Optional[str], str, Tuple[int, int, int]]:
+        """Process a single face image and return (id, name, color)."""
+        try:
+            # Get embedding with alignment
+            embedding = DeepFace.represent(
+                img_path=face_image,
+                model_name='Facenet',
+                enforce_detection=False,
+                align=True
+            )[0]['embedding']
+
+            # Find closest match
+            if self.known_face_embeddings:
+                distances = [np.linalg.norm(np.array(embedding) - known) for known in self.known_face_embeddings]
+                min_dist = min(distances)
+                match_index = distances.index(min_dist) if min_dist < 10.0 else -1
+            else:
+                match_index = -1
+
+            # Known worker
+            if match_index != -1:
+                worker_id = self.known_face_ids[match_index]
+                worker_name = self.known_face_names[match_index]
+                self.mark_attendance(worker_id, worker_name)
+                return worker_id, worker_name, (0, 255, 0)  # Green
+            
+            # New worker - check quality before registering
+            face_objs = DeepFace.extract_faces(
+                img_path=face_image,
+                detector_backend='opencv',
+                enforce_detection=False,
+                align=False
+            )
+            if face_objs and face_objs[0]['confidence'] >= MIN_FACE_CONFIDENCE:
+                new_worker = self._register_worker_auto(face_image)
+                if new_worker:
+                    worker_id, worker_name = new_worker
+                    self.mark_attendance(worker_id, worker_name)
+                    return worker_id, worker_name, (0, 165, 255)  # Orange
+
+            return None, "Unknown", (0, 0, 255)  # Red
+        except Exception as e:
+            logger.error(f"Face processing error: {e}")
+            return None, "Error", (0, 0, 255)
+
     def _processing_loop(self, source):
-        video_capture = cv2.VideoCapture(source)
-        if not video_capture.isOpened():
-            err_msg = f"❌ **Error:** Could not open video source. The file may be corrupt or in an unsupported format. Please try converting it to a standard MP4."
-            self.error_message = err_msg
+        """Main processing loop optimized for performance."""
+        try:
+            video_capture = cv2.VideoCapture(source)
+            if not video_capture.isOpened():
+                self.error_message = "❌ Could not open video source."
+                self.is_processing.clear()
+                return
+
+            # Set higher FPS if possible
+            if isinstance(source, int):  # Camera
+                video_capture.set(cv2.CAP_PROP_FPS, 30)
+                video_capture.set(cv2.CAP_PROP_BUFFERSIZE, 1)  # Reduce latency
+
+            while self.is_processing.is_set():
+                ret, frame = video_capture.read()
+                if not ret:
+                    break
+
+                # Process frame and add to queue
+                processed_frame = self.process_frame(frame)
+                if not self.frame_queue.full():
+                    self.frame_queue.put(processed_frame)
+                self.last_processed_frame = processed_frame
+
+            self.final_log = self.session_log.copy()
+        except Exception as e:
+            logger.error(f"Processing loop error: {e}")
+            self.error_message = f"❌ Processing error: {str(e)}"
+        finally:
+            if 'video_capture' in locals():
+                video_capture.release()
             self.is_processing.clear()
-            return
-            
-        # Set higher FPS if possible (for live camera)
-        if isinstance(source, int):
-            video_capture.set(cv2.CAP_PROP_FPS, 30)
-            
-        while self.is_processing.is_set():
-            ret, frame = video_capture.read()
-            if not ret: 
-                break
-                
-            processed_frame = self.process_frame(frame)
-            
-            if not self.frame_queue.full(): 
-                self.frame_queue.put(processed_frame)
-                
-            self.last_processed_frame = processed_frame
-            time.sleep(0.02)  # Reduced sleep for faster processing
-            
-        self.final_log = self.session_log.copy()
-        video_capture.release()
-        self.is_processing.clear()
 
     def start_processing(self, source) -> str:
-        if self.is_processing.is_set(): 
+        """Start processing with clean state."""
+        if self.is_processing.is_set():
             return "⚠️ Processing is already active."
             
-        # Reset states for new session
         self.session_log.clear()
-        self.last_recognition_time.clear()
         self.today_attendance.clear()
-        self.last_detected_faces.clear()
         self.error_message = None
         self.last_processed_frame = None
         self.final_log = None
-        self.frame_counter = 0
+        self.last_detection_time = 0
         
         self.is_processing.set()
         self.processing_thread = threading.Thread(
-            target=self._processing_loop, 
+            target=self._processing_loop,
             args=(source,),
             daemon=True
         )
         self.processing_thread.start()
-        return f"✅ Started processing..."
+        return "✅ Started processing..."
 
     def stop_processing(self) -> str:
+        """Stop processing gracefully."""
         self.is_processing.clear()
-        self.error_message = None
-        self.last_processed_frame = None
-        self.final_log = None
-        return "✅ Processing stopped by user."
+        return "✅ Processing stopped."
 
-    # --- Helper & Reporting ---
+    # --- Helper Methods ---
     def _get_image_caption(self, image: Image.Image) -> str:
-        if not HF_API_TOKEN: 
-            return "Hugging Face API token not configured."
+        """Get image caption from Hugging Face (with timeout)."""
+        if not HF_API_TOKEN:
+            return ""
+            
         try:
             buffered = BytesIO()
             image.save(buffered, format="JPEG")
-            img_data = buffered.getvalue()
-            headers = {"Authorization": f"Bearer {HF_API_TOKEN}"}
-            response = requests.post(HF_API_URL, headers=headers, data=img_data)
+            response = requests.post(
+                HF_API_URL,
+                headers={"Authorization": f"Bearer {HF_API_TOKEN}"},
+                data=buffered.getvalue(),
+                timeout=5  # Short timeout
+            )
             response.raise_for_status()
-            result = response.json()
-            return result[0].get("generated_text", "No caption found.")
+            return response.json()[0].get("generated_text", "")
         except Exception as e:
-            logger.error(f"Hugging Face API error: {e}")
-            return "Caption generation failed."
+            logger.error(f"Caption error: {e}")
+            return ""
 
     def _upload_image_to_salesforce(self, image: Image.Image, record_id: str, worker_id: str) -> Optional[str]:
-        if not self.sf: 
+        """Upload image to Salesforce with timeout."""
+        if not self.sf:
             return None
+            
         try:
             buffered = BytesIO()
             image.save(buffered, format="JPEG")
-            encoded_image = base64.b64encode(buffered.getvalue()).decode('utf-8')
             cv = self.sf.ContentVersion.create({
                 'Title': f'Image_{worker_id}',
                 'PathOnClient': f'{worker_id}.jpg',
-                'VersionData': encoded_image,
+                'VersionData': base64.b64encode(buffered.getvalue()).decode('utf-8'),
                 'FirstPublishLocationId': record_id
-            })
-            return f"/{cv['id']}"  # Relative URL
+            }, timeout=5)  # Short timeout
+            return f"/{cv['id']}"
         except Exception as e:
-            logger.error(f"Salesforce image upload error: {e}")
+            logger.error(f"Image upload error: {e}")
             return None
 
     def get_registered_workers_info(self) -> str:
-        if not self.sf: 
-            return "❌ Salesforce not connected."
-        try:
-            records = self.sf.query_all("SELECT Name, Worker_ID__c FROM Worker__c ORDER BY Name")['records']
-            if not records: 
-                return "No workers registered."
-            return f"**👥 Registered Workers ({len(records)})**\n" + "\n".join(
-                [f"- **{w['Name']}** (ID: {w['Worker_ID__c']})" for w in records]
-            )
-        except Exception as e: 
-            return f"Error: {e}"
-        
+        """Get formatted worker list."""
+        if not self.known_face_ids:
+            return "No workers registered."
+        return "**👥 Registered Workers**\n" + "\n".join(
+            f"- {name} (ID: {id})" for name, id in zip(self.known_face_names, self.known_face_ids)
+        )
+
 # --- GRADIO UI ---
 attendance_system = AttendanceSystem()
 
 def create_interface():
     with gr.Blocks(theme=gr.themes.Soft(), title="Attendance System") as demo:
-        gr.Markdown("# 🎯 Advanced Face Recognition Attendance System")
+        gr.Markdown("# 🚀 Fast Face Recognition Attendance")
+        
         with gr.Tabs():
-            with gr.Tab("⚙️ Controls & Status"):
-                gr.Markdown("### 1. Choose Input Source & Start Processing")
-                with gr.Row():
-                    with gr.Column(scale=1):
-                        selected_tab_index = gr.Number(value=0, visible=False)
-                        with gr.Tabs() as video_tabs:
-                            with gr.Tab("Live Camera", id=0):
-                                camera_source = gr.Number(label="Camera Source", value=0, precision=0)
-                            with gr.Tab("Upload Video", id=1):
-                                video_file = gr.Video(label="Upload Video File", sources=["upload"])
-                    with gr.Column(scale=1):
-                        start_btn = gr.Button("▶️ Start Processing", variant="primary")
-                        stop_btn = gr.Button("⏹️ Stop Processing", variant="stop")
-                        status_box = gr.Textbox(label="Status", interactive=False, value="System Ready.")
-                gr.Markdown("### 2. View Results in the 'Output & Log' Tab")
-                gr.Markdown("**🎨 Color Coding:** <font color='green'>Green</font> = Known, <font color='orange'>Orange</font> = New, <font color='red'>Red</font> = Unknown")
-            
-            with gr.Tab("📊 Output & Log"):
+            with gr.Tab("🎥 Live Recognition"):
                 with gr.Row():
                     with gr.Column(scale=2):
-                        video_output = gr.Image(label="Recognition Output", interactive=False)
+                        video_output = gr.Image(label="Live Feed", streaming=True)
                     with gr.Column(scale=1):
-                        session_log_display = gr.Markdown(label="📋 Session Log", value="System is ready.")
-
+                        with gr.Row():
+                            source_select = gr.Radio(
+                                ["Webcam", "Video File"],
+                                label="Source",
+                                value="Webcam"
+                            )
+                        with gr.Row():
+                            start_btn = gr.Button("▶️ Start", variant="primary")
+                            stop_btn = gr.Button("⏹️ Stop")
+                        status_box = gr.Textbox(label="Status", value="Ready")
+                        session_log = gr.Textbox(
+                            label="Session Log",
+                            lines=10,
+                            max_lines=20,
+                            interactive=False
+                        )
+                
             with gr.Tab("👤 Worker Management"):
                 with gr.Row():
                     with gr.Column():
-                        register_image = gr.Image(label="Upload Worker's Photo", type="pil")
-                        register_name = gr.Textbox(label="Worker's Full Name")
-                        register_btn = gr.Button("Register Worker", variant="primary")
-                        register_output = gr.Textbox(label="Registration Status", interactive=False)
+                        gr.Markdown("### Register New Worker")
+                        register_image = gr.Image(
+                            label="Worker Photo",
+                            type="pil",
+                            sources=["webcam", "upload"]
+                        )
+                        register_name = gr.Textbox(label="Full Name")
+                        register_btn = gr.Button("Register", variant="primary")
+                        register_output = gr.Textbox(label="Status", interactive=False)
                     with gr.Column():
-                        registered_workers_info = gr.Markdown(value=attendance_system.get_registered_workers_info())
-                        refresh_workers_btn = gr.Button("🔄 Refresh List")
-
-        # --- Event Handlers ---
-        def on_tab_select(evt: gr.SelectData): 
-            return evt.index
-            
-        video_tabs.select(fn=on_tab_select, inputs=None, outputs=[selected_tab_index])
+                        gr.Markdown("### Registered Workers")
+                        workers_info = gr.Markdown(attendance_system.get_registered_workers_info())
+                        refresh_btn = gr.Button("🔄 Refresh")
+        
+        # Event handlers
+        source_select.change(
+            lambda x: gr.update(visible=x == "Webcam"),
+            inputs=source_select,
+            outputs=video_output
+        )
         
-        def start_wrapper(tab_index, cam_src, vid_path):
-            source = cam_src if tab_index == 0 else vid_path
-            return "Please provide an input source." if source is None else attendance_system.start_processing(source)
-            
         start_btn.click(
-            fn=start_wrapper, 
-            inputs=[selected_tab_index, camera_source, video_file], 
-            outputs=[status_box]
+            lambda: attendance_system.start_processing(0 if source_select.value == "Webcam" else video_file.value),
+            outputs=status_box
         )
         
         stop_btn.click(
-            fn=attendance_system.stop_processing, 
-            inputs=None, 
-            outputs=[status_box]
+            attendance_system.stop_processing,
+            outputs=status_box
         )
         
         register_btn.click(
-            fn=attendance_system.register_worker_manual, 
-            inputs=[register_image, register_name], 
-            outputs=[register_output, registered_workers_info]
+            attendance_system.register_worker_manual,
+            inputs=[register_image, register_name],
+            outputs=[register_output, workers_info]
         )
         
-        refresh_workers_btn.click(
-            fn=attendance_system.get_registered_workers_info, 
-            outputs=[registered_workers_info]
+        refresh_btn.click(
+            lambda: attendance_system.get_registered_workers_info(),
+            outputs=workers_info
         )
         
-        def update_ui_generator():
+        def update_ui():
             while True:
-                if attendance_system.error_message:
-                    yield None, attendance_system.error_message
-                    time.sleep(2)
-                    attendance_system.error_message = None
-                    continue
-                    
+                # Get latest frame
+                frame = None
+                if not attendance_system.frame_queue.empty():
+                    frame = attendance_system.frame_queue.get_nowait()
+                    if frame is not None:
+                        frame = cv2.cvtColor(frame, cv2.COLOR_BGR2RGB)
+                
+                # Get latest status
+                status = "Ready"
                 if attendance_system.is_processing.is_set():
-                    frame, log_md = None, "\n".join(reversed(attendance_system.session_log[-20:])) or "Processing..."
-                    try:
-                        if not attendance_system.frame_queue.empty():
-                            frame = attendance_system.frame_queue.get_nowait()
-                            if frame is not None: 
-                                frame = cv2.cvtColor(frame, cv2.COLOR_BGR2RGB)
-                    except queue.Empty: 
-                        pass
-                    yield frame, log_md
-                else:
-                    if attendance_system.last_processed_frame is not None:
-                        final_frame = cv2.cvtColor(attendance_system.last_processed_frame, cv2.COLOR_BGR2RGB)
-                        final_log_md = "\n".join(reversed(attendance_system.final_log[-20:])) or "Processing complete. No log entries."
-                        yield final_frame, final_log_md
-                    else:
-                        yield None, "System stopped. Go to 'Controls & Status' to start."
-                time.sleep(0.05)  # Faster UI updates
-
-        demo.load(fn=update_ui_generator, outputs=[video_output, session_log_display])
+                    status = "Processing..."
+                elif attendance_system.error_message:
+                    status = attendance_system.error_message
+                
+                # Get latest log
+                log_text = "\n".join(reversed(attendance_system.session_log[-10:])) or "No activity yet"
+                
+                yield frame, status, log_text
+                time.sleep(0.033)  # ~30 FPS update rate
+
+        demo.load(
+            update_ui,
+            outputs=[video_output, status_box, session_log]
+        )
+    
     return demo
 
 if __name__ == "__main__":
     app = create_interface()
     app.queue()
-    app.launch(server_name="0.0.0.0", server_port=7860, show_error=True, debug=True)
+    app.launch(
+        server_name="0.0.0.0",
+        server_port=7860,
+        show_error=True
+    )