Update app.py

app.py

@@ -18,8 +18,8 @@ import pickle
 import cv2
 import gradio as gr
 import numpy as np
-from PIL import Image
 import requests
+from PIL import Image
 from dotenv import load_dotenv
 from deepface import DeepFace
 from retrying import retry
@@ -31,7 +31,7 @@ from simple_salesforce import Salesforce
 logging.basicConfig(level=logging.INFO, format="%(asctime)s - %(levelname)s - %(message)s")
 logger = logging.getLogger(__name__)
 
-# Load environment variables from .env file
+# Load environment variables
 load_dotenv()
 
 # Hugging Face API configuration
@@ -46,32 +46,22 @@ 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)
 def connect_to_salesforce() -> Optional[Salesforce]:
-    """Establish a connection to Salesforce with retry logic."""
     try:
         sf = Salesforce(**SF_CREDENTIALS)
-        sf.describe()  # Test connection
-        logger.info("✅ Successfully connected to Salesforce.")
+        sf.describe()
+        logger.info("✅ Connected to Salesforce")
         return sf
     except Exception as e:
         logger.error(f"❌ Salesforce connection failed: {e}")
-        return None
+        raise
 
 # --- CORE LOGIC ---
 
 class AttendanceSystem:
-    """
-    Optimized face recognition attendance system with real-time performance.
-    """
     def __init__(self):
         # State Management
         self.processing_thread = None
@@ -82,16 +72,23 @@ class AttendanceSystem:
         self.final_log = None
 
         # Data Storage
-        self.known_face_embeddings: List[np.ndarray] = []
-        self.known_face_names: List[str] = []
-        self.known_face_ids: List[str] = []
-        self.next_worker_id: int = 1
+        self.known_face_embeddings = []
+        self.known_face_names = []
+        self.known_face_ids = []
+        self.next_worker_id = 1
         
         # Session Tracking
-        self.today_attendance: Dict[str, bool] = {}
-        self.last_detection_time = 0
-        self.session_log: List[str] = []
-        self.last_log_update = 0
+        self.last_recognition_time = {}
+        self.recognition_cooldown = 5
+        self.session_log = []
+        self.today_attendance = {}
+        self.last_detected_faces = {}
+
+        # Performance Optimizations
+        self.frame_skip = 1  # Process every other frame
+        self.frame_counter = 0
+        self.last_face_detection_time = 0
+        self.face_detection_interval = 0.5  # Seconds between face detections
 
         # Initialize
         self.sf = connect_to_salesforce()
@@ -102,35 +99,36 @@ class AttendanceSystem:
         os.makedirs("data/faces", exist_ok=True)
 
     def load_worker_data(self):
-        """Load worker data with timeout protection."""
-        try:
-            if self.sf:
+        logger.info("Loading worker data...")
+        if self.sf:
+            try:
                 workers = self.sf.query_all("SELECT Worker_ID__c, Name, Face_Embedding__c FROM Worker__c")['records']
-                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.")
+                if not workers:
+                    self._load_local_worker_data()
                     return
-            
-            # Fallback to local data
-            self._load_local_worker_data()
-        except Exception as e:
-            logger.error(f"Error loading worker data: {e}")
+
+                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
+                self.save_local_worker_data()
+                logger.info(f"✅ Loaded {len(self.known_face_ids)} workers")
+            except Exception as e:
+                logger.error(f"❌ Error loading from Salesforce: {e}")
+                self._load_local_worker_data()
+        else:
             self._load_local_worker_data()
 
     def _load_local_worker_data(self):
@@ -142,91 +140,52 @@ 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)
-                logger.info(f"✅ Loaded {len(self.known_face_ids)} workers from local cache.")
+                logger.info(f"✅ Loaded {len(self.known_face_ids)} workers from 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)
+                pickle.dump({
+                    "embeddings": self.known_face_embeddings,
+                    "names": self.known_face_names,
+                    "ids": self.known_face_ids,
+                    "next_id": self.next_worker_id
+                }, f)
         except Exception as e:
-            logger.error(f"Error saving local worker data: {e}")
+            logger.error(f"❌ Error saving local 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)
-            
-            # 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']
-
+            embedding = DeepFace.represent(img_path=image_array, model_name='Facenet', enforce_detection=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 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)
             return f"✅ {name} registered with ID: {worker_id}!", self.get_registered_workers_info()
+        except ValueError:
+            return "❌ No face detected!", 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:
-            # 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
-
-            # Full processing if quality is good
-            embedding = DeepFace.represent(
-                img_path=face_image,
-                model_name='Facenet',
-                enforce_detection=False,
-                align=True
-            )[0]['embedding']
-
+            embedding = DeepFace.represent(img_path=face_image, model_name='Facenet', enforce_detection=False)[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)
-            
-            log_msg = f"🆕 Auto-registered: {worker_name} ({worker_id})"
-            self._add_to_session_log(log_msg)
+            log_msg = f"🆕 [{datetime.now().strftime('%H:%M:%S')}] Auto-registered: {worker_name} ({worker_id})"
+            self.session_log.append(log_msg)
             return worker_id, worker_name
         except Exception as e:
             logger.error(f"Auto-registration error: {e}")
@@ -242,240 +201,185 @@ class AttendanceSystem:
         face_pil = Image.fromarray(cv2.cvtColor(image_array, cv2.COLOR_BGR2RGB))
         face_pil.save(f"data/faces/{worker_id}.jpg")
         
-        # 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}")
+        # Sync with Salesforce if available
+        if self.sf:
+            try:
+                caption = self._get_image_caption(face_pil)
+                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})
+            except Exception as e:
+                logger.error(f"Salesforce sync error: {e}")
 
     def _is_duplicate_face(self, embedding: List[float], threshold: float = 10.0) -> bool:
         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]
+        distances = [np.linalg.norm(np.array(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()
+        current_time = time.time()
         
-        # Already marked today?
+        # Check if already marked today
         if worker_id in self.today_attendance:
             return False
             
-        self.today_attendance[worker_id] = True
-        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()
+        # Check cooldown period
+        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"Salesforce error: {e}")
         
-        log_msg = f"✅ [{current_time.strftime('%H:%M:%S')}] Present: {worker_name} ({worker_id})"
-        self._add_to_session_log(log_msg)
+        self.today_attendance[worker_id] = True
+        self.last_recognition_time[worker_id] = current_time
+        log_msg = f"✅ [{current_time_dt.strftime('%H:%M:%S')}] Present: {worker_name} ({worker_id})"
+        self.session_log.append(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 frame with face detection and recognition."""
         try:
-            now = time.time()
+            current_time = time.time()
             
-            # Throttle face detection
-            if now - self.last_detection_time < FACE_DETECTION_INTERVAL:
+            # Skip frames if processing too frequently
+            if current_time - self.last_face_detection_time < self.face_detection_interval:
                 return frame
                 
-            self.last_detection_time = now
+            self.last_face_detection_time = current_time
             
             # Resize for faster processing
-            height, width = frame.shape[:2]
-            scale = PROCESSING_WIDTH / width
-            small_frame = cv2.resize(frame, (PROCESSING_WIDTH, int(height * scale)))
+            small_frame = cv2.resize(frame, (0, 0), fx=0.5, fy=0.5)
             
-            # Detect faces with fast backend
+            # Face detection with optimized parameters
             face_objs = DeepFace.extract_faces(
                 img_path=small_frame,
-                detector_backend='opencv',  # Fastest backend
+                detector_backend='opencv',
                 enforce_detection=False,
-                align=False  # Skip alignment for detection
+                align=False  # Alignment takes extra time
             )
 
             for face_obj in face_objs:
-                if face_obj['confidence'] < MIN_FACE_CONFIDENCE:
+                if face_obj['confidence'] < 0.9:  # Lower confidence threshold for speed
                     continue
-                    
-                # Get face coordinates and scale back to original
+
                 facial_area = face_obj['facial_area']
-                x = int(facial_area['x'] / scale)
-                y = int(facial_area['y'] / scale)
-                w = int(facial_area['w'] / scale)
-                h = int(facial_area['h'] / scale)
+                x, y, w, h = facial_area['x'], facial_area['y'], facial_area['w'], facial_area['h']
                 
-                # Extract face region
+                # Scale coordinates back to original frame
+                x, y, w, h = x*2, y*2, w*2, h*2
                 face_image = frame[y:y+h, x:x+w]
+                
                 if face_image.size == 0:
                     continue
+
+                # Skip if we recently processed this face position
+                face_key = f"{x}_{y}"
+                if face_key in self.last_detected_faces and (current_time - self.last_detected_faces[face_key] < 2.0):
+                    continue
+                self.last_detected_faces[face_key] = current_time
+
+                # Face recognition
+                embedding = DeepFace.represent(
+                    img_path=face_image,
+                    model_name='Facenet',
+                    enforce_detection=False,
+                    align=False  # Skip alignment for speed
+                )[0]['embedding']
                 
-                # Recognize or register
-                worker_id, worker_name, color = self._process_face(face_image)
+                if not self.known_face_embeddings:
+                    continue
+
+                # Find closest match
+                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 = (0, 0, 255)  # Default red for unknown
+                label = "Unknown"
                 
-                # Draw results
-                label = f"{worker_name}" + (f" ({worker_id})" if worker_id else "")
+                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
+                    label = f"{worker_name} ({worker_id})"
+                    self.mark_attendance(worker_id, worker_name)
+                else:
+                    # Only auto-register if face is clear
+                    color = (0, 165, 255)  # Orange for new
+                    new_worker = self._register_worker_auto(face_image)
+                    if new_worker:
+                        worker_id, worker_name = new_worker
+                        label = f"{worker_name} ({worker_id})"
+                        self.mark_attendance(worker_id, worker_name)
+
+                # Draw rectangle and label
                 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"Frame processing error: {e}")
+            logger.error(f"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']
+    def _processing_loop(self, source):
+        cap = cv2.VideoCapture(source)
+        if not cap.isOpened():
+            self.error_message = "❌ Could not open video source"
+            self.is_processing.clear()
+            return
 
-            # 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
+        # Set higher FPS if possible
+        if isinstance(source, int):
+            cap.set(cv2.CAP_PROP_FPS, 30)
 
-            return None, "Unknown", (0, 0, 255)  # Red
-        except Exception as e:
-            logger.error(f"Face processing error: {e}")
-            return None, "Error", (0, 0, 255)
+        while self.is_processing.is_set():
+            ret, frame = cap.read()
+            if not ret:
+                break
 
-    def _processing_loop(self, source):
-        """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()
+            processed_frame = self.process_frame(frame)
+            
+            # Only update queue if not full to prevent lag
+            if self.frame_queue.qsize() < 3:
+                self.frame_queue.put(processed_frame)
+                
+            self.last_processed_frame = processed_frame
+
+        cap.release()
+        self.final_log = self.session_log.copy()
+        self.is_processing.clear()
 
     def start_processing(self, source) -> str:
-        """Start processing with clean state."""
         if self.is_processing.is_set():
-            return "⚠️ Processing is already active."
-            
+            return "⚠️ Already processing"
+
+        # Reset session state
         self.session_log.clear()
         self.today_attendance.clear()
+        self.last_detected_faces.clear()
         self.error_message = None
         self.last_processed_frame = None
         self.final_log = None
-        self.last_detection_time = 0
-        
+
         self.is_processing.set()
         self.processing_thread = threading.Thread(
             target=self._processing_loop,
@@ -483,39 +387,29 @@ class AttendanceSystem:
             daemon=True
         )
         self.processing_thread.start()
-        return "✅ Started processing..."
+        return "✅ Processing started"
 
     def stop_processing(self) -> str:
-        """Stop processing gracefully."""
         self.is_processing.clear()
-        return "✅ Processing stopped."
+        return "✅ Processing stopped"
 
     # --- Helper Methods ---
     def _get_image_caption(self, image: Image.Image) -> str:
-        """Get image caption from Hugging Face (with timeout)."""
         if not HF_API_TOKEN:
-            return ""
-            
+            return "No API token"
         try:
             buffered = BytesIO()
             image.save(buffered, format="JPEG")
-            response = requests.post(
-                HF_API_URL,
-                headers={"Authorization": f"Bearer {HF_API_TOKEN}"},
-                data=buffered.getvalue(),
-                timeout=5  # Short timeout
-            )
-            response.raise_for_status()
-            return response.json()[0].get("generated_text", "")
+            headers = {"Authorization": f"Bearer {HF_API_TOKEN}"}
+            response = requests.post(HF_API_URL, headers=headers, data=buffered.getvalue())
+            return response.json()[0].get("generated_text", "No caption")
         except Exception as e:
             logger.error(f"Caption error: {e}")
-            return ""
+            return "Caption failed"
 
     def _upload_image_to_salesforce(self, image: Image.Image, record_id: str, worker_id: str) -> Optional[str]:
-        """Upload image to Salesforce with timeout."""
         if not self.sf:
             return None
-            
         try:
             buffered = BytesIO()
             image.save(buffered, format="JPEG")
@@ -524,129 +418,146 @@ class AttendanceSystem:
                 'PathOnClient': f'{worker_id}.jpg',
                 'VersionData': base64.b64encode(buffered.getvalue()).decode('utf-8'),
                 'FirstPublishLocationId': record_id
-            }, timeout=5)  # Short timeout
+            })
             return f"/{cv['id']}"
         except Exception as e:
-            logger.error(f"Image upload error: {e}")
+            logger.error(f"Upload error: {e}")
             return None
 
     def get_registered_workers_info(self) -> str:
-        """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)
-        )
+        if not self.sf:
+            return "❌ Not connected to Salesforce"
+        try:
+            workers = self.sf.query_all("SELECT Name, Worker_ID__c FROM Worker__c ORDER BY Name")['records']
+            if not workers:
+                return "No workers registered"
+            return "**👥 Registered Workers**\n" + "\n".join(
+                f"- {w['Name']} ({w['Worker_ID__c']})" for w in workers
+            )
+        except Exception as e:
+            return f"Error: {e}"
 
 # --- GRADIO UI ---
 attendance_system = AttendanceSystem()
 
 def create_interface():
     with gr.Blocks(theme=gr.themes.Soft(), title="Attendance System") as demo:
-        gr.Markdown("# 🚀 Fast Face Recognition Attendance")
+        gr.Markdown("# 🎯 Face Recognition Attendance System")
         
         with gr.Tabs():
-            with gr.Tab("🎥 Live Recognition"):
+            with gr.Tab("⚙️ Controls"):
                 with gr.Row():
-                    with gr.Column(scale=2):
-                        video_output = gr.Image(label="Live Feed", streaming=True)
-                    with gr.Column(scale=1):
-                        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.Column():
+                        video_source = gr.Radio(
+                            ["Camera", "Video File"],
+                            label="Input Source",
+                            value="Camera"
+                        )
+                        camera_device = gr.Number(
+                            label="Camera Device",
+                            value=0,
+                            visible=True,
+                            precision=0
+                        )
+                        video_file = gr.Video(
+                            label="Upload Video",
+                            visible=False
                         )
+                    with gr.Column():
+                        start_btn = gr.Button("▶️ Start", variant="primary")
+                        stop_btn = gr.Button("⏹️ Stop", variant="stop")
+                        status = gr.Textbox(label="Status", value="Ready")
                 
-            with gr.Tab("👤 Worker Management"):
+                gr.Markdown("**Color Legend:** <span style='color:green'>Green</span> = Known | <span style='color:orange'>Orange</span> = New | <span style='color:red'>Red</span> = Unknown")
+
+            with gr.Tab("📊 Output"):
                 with gr.Row():
+                    video_output = gr.Image(label="Live View", interactive=False)
                     with gr.Column():
-                        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)
+                        session_log = gr.Markdown("### Session Log")
+                        refresh_log = gr.Button("🔄 Refresh Log")
+
+            with gr.Tab("👤 Management"):
+                with gr.Row():
                     with gr.Column():
-                        gr.Markdown("### Registered Workers")
-                        workers_info = gr.Markdown(attendance_system.get_registered_workers_info())
-                        refresh_btn = gr.Button("🔄 Refresh")
-        
+                        reg_image = gr.Image(label="Worker Photo", type="pil")
+                        reg_name = gr.Textbox(label="Full Name")
+                        reg_btn = gr.Button("Register", variant="primary")
+                        reg_status = gr.Textbox(label="Status")
+                    with gr.Column():
+                        workers_list = gr.Markdown(attendance_system.get_registered_workers_info())
+                        refresh_workers = gr.Button("🔄 Refresh List")
+
         # Event handlers
-        source_select.change(
-            lambda x: gr.update(visible=x == "Webcam"),
-            inputs=source_select,
-            outputs=video_output
+        video_source.change(
+            lambda x: (gr.update(visible=x == "Camera"), gr.update(visible=x == "Video File")),
+            inputs=video_source,
+            outputs=[camera_device, video_file]
         )
-        
+
+        def start_processing(source, cam_device, video_path):
+            src = cam_device if source == "Camera" else video_path
+            return attendance_system.start_processing(src)
+            
         start_btn.click(
-            lambda: attendance_system.start_processing(0 if source_select.value == "Webcam" else video_file.value),
-            outputs=status_box
+            start_processing,
+            inputs=[video_source, camera_device, video_file],
+            outputs=status
         )
-        
+
         stop_btn.click(
             attendance_system.stop_processing,
-            outputs=status_box
+            inputs=None,
+            outputs=status
         )
-        
-        register_btn.click(
+
+        reg_btn.click(
             attendance_system.register_worker_manual,
-            inputs=[register_image, register_name],
-            outputs=[register_output, workers_info]
+            inputs=[reg_image, reg_name],
+            outputs=[reg_status, workers_list]
         )
-        
-        refresh_btn.click(
-            lambda: attendance_system.get_registered_workers_info(),
-            outputs=workers_info
+
+        refresh_workers.click(
+            attendance_system.get_registered_workers_info,
+            outputs=workers_list
         )
-        
+
+        refresh_log.click(
+            lambda: "\n".join(reversed(attendance_system.session_log[-20:])) or "No entries",
+            outputs=session_log
+        )
+
         def update_ui():
             while True:
-                # 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.error_message:
+                    yield None, attendance_system.error_message
+                    time.sleep(2)
+                    attendance_system.error_message = None
+                    continue
+                    
                 if attendance_system.is_processing.is_set():
-                    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]
-        )
-    
+                    frame = None
+                    try:
+                        frame = attendance_system.frame_queue.get_nowait()
+                        frame = cv2.cvtColor(frame, cv2.COLOR_BGR2RGB) if frame is not None else None
+                    except queue.Empty:
+                        pass
+                    
+                    log = "\n".join(reversed(attendance_system.session_log[-20:])) or "Processing..."
+                    yield frame, log
+                else:
+                    if attendance_system.last_processed_frame is not None:
+                        frame = cv2.cvtColor(attendance_system.last_processed_frame, cv2.COLOR_BGR2RGB)
+                        log = "\n".join(reversed(attendance_system.final_log[-20:])) or "Processing complete"
+                        yield frame, log
+                    else:
+                        yield None, "System ready"
+                time.sleep(0.03)  # Faster UI updates
+
+        demo.load(update_ui, outputs=[video_output, 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
-    )
+    app.launch(server_name="0.0.0.0", server_port=7860)