Update app.py

app.py

@@ -11,7 +11,7 @@ import threading
 import time
 from datetime import datetime, date
 from io import BytesIO
-from typing import Tuple, Optional, List, Dict
+from typing import Tuple, Optional, List
 import pickle
 
 # Third-Party Imports
@@ -47,6 +47,16 @@ SF_CREDENTIALS = {
     "domain": os.getenv("SF_DOMAIN", "login")
 }
 
+# --- MODIFICATION: Added configuration for performance and accuracy ---
+# Defines how many frames to skip between face analysis. Higher value = faster but less frequent detection.
+FRAME_PROCESS_RATE = 3 
+# Stricter distance threshold for Facenet. Faces with distance > this are considered different people.
+# Default DeepFace threshold is ~10, which is too loose. A value between 0.4 and 0.7 is recommended for Facenet.
+FACE_MATCH_THRESHOLD = 0.6 
+# Minimum confidence score from the face detector to consider a face for auto-registration.
+AUTO_REGISTER_CONFIDENCE = 0.99 
+# --- END MODIFICATION ---
+
 # --- SALESFORCE CONNECTION ---
 
 @retry(stop_max_attempt_number=3, wait_fixed=2000)
@@ -83,15 +93,12 @@ class AttendanceSystem:
         self.next_worker_id: int = 1
         
         # Session Tracking
-        self.last_recognition_time: Dict[str, float] = {}
-        self.recognition_cooldown = 5  # seconds
+        self.last_recognition_time = {}
+        self.recognition_cooldown = 5
         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
+        # --- MODIFICATION: Set to track workers already marked present in the current session for unique UI logs ---
+        self.session_attended_ids = set()
+        # --- END MODIFICATION ---
 
         # Initialize
         self.sf = connect_to_salesforce()
@@ -117,7 +124,8 @@ class AttendanceSystem:
                         temp_names.append(worker['Name'])
                         temp_ids.append(worker['Worker_ID__c'])
                         try:
-                            worker_num = int(worker['Worker_ID__c'][1:])
+                            # Robustly extract number from Worker ID like "W0042"
+                            worker_num = int(''.join(filter(str.isdigit, worker['Worker_ID__c'])))
                             if worker_num > max_id:
                                 max_id = worker_num
                         except (ValueError, TypeError):
@@ -128,7 +136,7 @@ class AttendanceSystem:
                 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.")
+                logger.info(f"✅ Loaded {len(self.known_face_ids)} workers from Salesforce. Next ID: {self.next_worker_id}")
             except Exception as e:
                 logger.error(f"❌ Error loading from Salesforce: {e}. Attempting local load.")
                 self._load_local_worker_data()
@@ -144,7 +152,7 @@ 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 local cache. Next ID: {self.next_worker_id}")
         except Exception as e:
             logger.error(f"❌ Error loading local data: {e}")
 
@@ -161,41 +169,37 @@ class AttendanceSystem:
             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()
+            # Ensure a face exists before proceeding
+            DeepFace.analyze(img_path=image_array, actions=['emotion'], enforce_detection=True)
+            embedding = DeepFace.represent(img_path=image_array, model_name='Facenet', enforce_detection=False)[0]['embedding']
             
-            embedding = DeepFace.represent(img_path=image_array, model_name='Facenet')[0]['embedding']
             if self._is_duplicate_face(embedding):
                  return f"❌ Face matches an existing worker!", self.get_registered_workers_info()
 
+            # --- MODIFICATION: Ensure unique ID assignment is robust ---
             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()
+            # self.load_worker_data() # Not strictly necessary, can rely on local update
             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:
+            logger.error(f"Manual registration error: {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:
-                return None
-                
             embedding = DeepFace.represent(img_path=face_image, model_name='Facenet', enforce_detection=False)[0]['embedding']
-            if self._is_duplicate_face(embedding): 
-                return None
-                
+            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}"
+            worker_name = f"Unknown 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)
@@ -205,13 +209,16 @@ class AttendanceSystem:
             return None
 
     def _add_worker_to_system(self, worker_id: str, name: str, embedding: List[float], image_array: np.ndarray):
+        """Adds worker to local lists, increments ID, saves image, and syncs to Salesforce."""
         self.known_face_embeddings.append(np.array(embedding))
         self.known_face_names.append(name)
         self.known_face_ids.append(worker_id)
-        self.next_worker_id += 1
+        self.next_worker_id += 1 # This ensures the next ID is always unique
+
         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})
@@ -221,209 +228,196 @@ class AttendanceSystem:
             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:
+    def _is_duplicate_face(self, embedding: List[float]) -> bool:
+        """Checks if a new face embedding is too close to any known embeddings."""
         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]
-        return min(distances) < threshold
+        new_embedding = np.array(embedding)
+        # --- MODIFICATION: Using stricter threshold for duplicate check ---
+        distances = [np.linalg.norm(new_embedding - known_embedding) for known_embedding in self.known_face_embeddings]
+        return min(distances) < FACE_MATCH_THRESHOLD
+        # --- END MODIFICATION ---
 
     def mark_attendance(self, worker_id: str, worker_name: str) -> bool:
+        """Marks attendance if not already marked in this session. Returns True if newly marked."""
+        # --- MODIFICATION: Check session log first for immediate UI uniqueness ---
+        if worker_id in self.session_attended_ids:
+            return False # Already logged in this session
+        # --- END MODIFICATION ---
+
         today_str = date.today().isoformat()
-        
-        # Check if 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):
+        if self._has_attended_today_in_sf(worker_id, today_str): 
+            self.session_attended_ids.add(worker_id) # Add to session log to prevent re-logging
             return False
-            
-        # Mark attendance
-        current_time_dt = datetime.now()
+
+        current_time = 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"
-                })
+                self.sf.Attendance__c.create({'Worker_ID__c': worker_id, 'Name__c': worker_name, 'Date__c': today_str, 'Timestamp__c': current_time.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})"
+
+        log_msg = f"✅ [{current_time.strftime('%H:%M:%S')}] Marked Present: {worker_name} ({worker_id})"
         self.session_log.append(log_msg)
-        logger.info(log_msg)
+        self.session_attended_ids.add(worker_id) # Mark as attended for this session
         return True
 
+    def _has_attended_today_in_sf(self, worker_id: str, today_str: str) -> bool:
+        """Checks Salesforce to see if an attendance record for today already exists."""
+        if self.sf:
+            try:
+                query = f"SELECT Id FROM Attendance__c WHERE Worker_ID__c = '{worker_id}' AND Date__c = {today_str}"
+                if self.sf.query(query)['totalSize'] > 0:
+                    logger.info(f"Worker {worker_id} already marked present today in Salesforce.")
+                    return True
+            except Exception as e:
+                logger.error(f"Error checking SF for attendance: {e}")
+        return False
+
     # --- Video Processing ---
     def process_frame(self, frame: np.ndarray) -> np.ndarray:
-        """
-        Process a single video frame with optimizations for speed and accuracy.
-        """
+        """Main function to process a single video frame."""
         try:
-            # Skip frames for faster processing
-            self.frame_counter += 1
-            if self.frame_counter % (self.frame_skip + 1) != 0:
-                return frame
-
-            # Resize frame for faster processing (keeping aspect ratio)
-            height, width = frame.shape[:2]
-            new_width = 360  # Reduced resolution for speed
-            new_height = int((new_width / width) * height)
-            small_frame = cv2.resize(frame, (new_width, new_height))
-
-            # Use OpenCV detector with relaxed settings
-            face_objs = DeepFace.extract_faces(
-                img_path=small_frame,
-                detector_backend='opencv',
-                enforce_detection=False,
-                align=True
-            )
-
-            if not face_objs:
-                logger.warning(f"No faces detected in frame at {datetime.now().strftime('%H:%M:%S')}")
-                return frame
+            # Using 'opencv' backend which is generally fastest
+            face_objs = DeepFace.extract_faces(img_path=frame, detector_backend='opencv', enforce_detection=False)
 
+            # Iterate through each face found in the frame
             for face_obj in face_objs:
-                confidence = face_obj.get('confidence', 0.0)
-                if confidence < 0.85:  # Further lowered threshold to catch more faces
+                confidence = face_obj['confidence']
+                
+                # Only process faces with a reasonable confidence score
+                if confidence < 0.95: 
                     continue
 
                 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)
-                
                 face_image = frame[y:y+h, x:x+w]
-                if face_image.size == 0:
-                    continue
+                
+                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):
-                    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']
+                # Get the embedding for the detected face
+                embedding = DeepFace.represent(img_path=face_image, model_name='Facenet', enforce_detection=False)[0]['embedding']
                 
                 if not self.known_face_embeddings:
-                    logger.info("No known face embeddings loaded.")
+                    # If no workers are registered yet, attempt to register this one
+                    if confidence > AUTO_REGISTER_CONFIDENCE:
+                        self._register_worker_auto(face_image)
                     continue
 
+                # Compare the face to all known faces
                 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
+                min_dist = min(distances)
+                # --- MODIFICATION: Using the stricter threshold for matching ---
+                match_index = distances.index(min_dist) if min_dist < FACE_MATCH_THRESHOLD else -1
+                # --- END MODIFICATION ---
+
+                worker_id, worker_name = None, "Unknown"
+                color = (0, 0, 255) # Red for Unknown
 
-                color, worker_id, worker_name = (0, 0, 255), None, "Unknown"
-                
                 if match_index != -1:
+                    # --- KNOWN FACE FOUND ---
                     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)
+                    color = (0, 255, 0) # Green for Known/Present
+                    if self.mark_attendance(worker_id, worker_name):
+                        self.last_recognition_time[worker_id] = time.time()
                 else:
-                    # Attempt auto-registration for high-quality faces
-                    analysis = DeepFace.analyze(img_path=face_image, actions=['emotion'], enforce_detection=False)
-                    if analysis[0].get('face_confidence', 0.0) >= 0.85:  # Lowered threshold
-                        color = (0, 165, 255)  # Orange for potential new worker
+                    # --- UNKNOWN FACE ---
+                    color = (0, 165, 255) # Orange for newly registered
+                    # --- MODIFICATION: Only auto-register very clear faces ---
+                    if confidence > AUTO_REGISTER_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)
-                
-                # Draw rectangle and label
+                            if self.mark_attendance(worker_id, worker_name):
+                                self.last_recognition_time[worker_id] = time.time()
+                    # --- END MODIFICATION ---
+
+                # Draw bounding box and label on the frame
                 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:
+            # Log error but don't crash the loop
             logger.error(f"ERROR in process_frame: {e}")
             return frame
 
     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."
+            err_msg = f"❌ **Error:** Could not open video source. Please check the file path or camera index."
             self.error_message = err_msg
             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)
-            
+        
+        # --- MODIFICATION: Frame skipping for performance ---
+        frame_count = 0
+        last_annotated_frame = None
+        # --- END MODIFICATION ---
+
         while self.is_processing.is_set():
             ret, frame = video_capture.read()
-            if not ret:
-                break
-                
-            processed_frame = self.process_frame(frame)
-            
-            if processed_frame is not None and not self.frame_queue.full():
+            if not ret: break
+
+            # --- MODIFICATION: Implement frame skipping ---
+            frame_count += 1
+            if frame_count % FRAME_PROCESS_RATE == 0:
+                # Process this frame fully
+                processed_frame = self.process_frame(frame)
+                last_annotated_frame = processed_frame.copy() # Save the annotated frame
+            else:
+                # For skipped frames, just use the last annotated frame to keep the UI responsive
+                processed_frame = last_annotated_frame if last_annotated_frame is not None else frame
+            # --- END MODIFICATION ---
+
+            if not self.frame_queue.full(): 
                 self.frame_queue.put(processed_frame)
-                
-            self.last_processed_frame = processed_frame
-            time.sleep(0.01)  # Reduced sleep for faster processing
             
+            # Continuously update last frame to show at the end
+            self.last_processed_frame = processed_frame 
+            time.sleep(0.01) # Small sleep to yield CPU
+
         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():
-            return "⚠️ Processing is already active."
-            
-        # Reset states for new session
+        if self.is_processing.is_set(): return "⚠️ Processing is already active."
+        # Reset states for the 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
-        
+        # --- MODIFICATION: Clear the session attendance tracker ---
+        self.session_attended_ids.clear()
+        # --- END MODIFICATION ---
+
         self.is_processing.set()
-        self.processing_thread = threading.Thread(
-            target=self._processing_loop,
-            args=(source,),
-            daemon=True
-        )
+        self.processing_thread = threading.Thread(target=self._processing_loop, args=(source,))
+        self.processing_thread.daemon = True
         self.processing_thread.start()
         return f"✅ Started processing..."
 
     def stop_processing(self) -> str:
+        if not self.is_processing.is_set():
+            return "⚠️ Processing is not currently active."
         self.is_processing.clear()
-        self.error_message = None
-        self.last_processed_frame = None
-        self.final_log = None
+        # Give the thread a moment to finish
+        if self.processing_thread:
+            self.processing_thread.join(timeout=2)
         return "✅ Processing stopped by user."
 
     # --- Helper & Reporting ---
     def _get_image_caption(self, image: Image.Image) -> str:
-        if not HF_API_TOKEN:
-            return "Hugging Face API token not configured."
+        if not HF_API_TOKEN: return "Hugging Face API token not configured."
         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=headers, data=img_data, timeout=10)
             response.raise_for_status()
             result = response.json()
             return result[0].get("generated_text", "No caption found.")
@@ -432,35 +426,34 @@ class AttendanceSystem:
             return "Caption generation failed."
 
     def _upload_image_to_salesforce(self, image: Image.Image, record_id: str, worker_id: str) -> Optional[str]:
-        if not self.sf:
-            return None
+        if not self.sf: return None
         try:
             buffered = BytesIO()
             image.save(buffered, format="JPEG")
             encoded_image = base64.b64encode(buffered.getvalue()).decode('utf-8')
+            # Create a ContentVersion (File)
             cv = self.sf.ContentVersion.create({
                 'Title': f'Image_{worker_id}',
                 'PathOnClient': f'{worker_id}.jpg',
                 'VersionData': encoded_image,
-                'FirstPublishLocationId': record_id
+                'FirstPublishLocationId': record_id # Link to the Worker__c record
             })
-            return f"/{cv['id']}"  # Relative URL
+            # To get a usable URL, you query the ContentDocumentLink
+            content_doc_link = self.sf.query(f"SELECT ContentDocumentId FROM ContentDocumentLink WHERE LinkedEntityId = '{record_id}'")['records'][0]
+            content_doc_id = content_doc_link['ContentDocumentId']
+            # This relative URL can be used within Salesforce
+            return f"/sfc/servlet.shepherd/document/download/{content_doc_id}"
         except Exception as e:
             logger.error(f"Salesforce 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}"
+        # Refresh local data from Salesforce before displaying
+        self.load_worker_data() 
+        if not self.known_face_ids: return "No workers registered."
+        
+        info_list = [f"- **{name}** (ID: {id})" for name, id in sorted(zip(self.known_face_names, self.known_face_ids))]
+        return f"**👥 Registered Workers ({len(info_list)})**\n" + "\n".join(info_list)
         
 # --- GRADIO UI ---
 attendance_system = AttendanceSystem()
@@ -476,7 +469,7 @@ def create_interface():
                         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)
+                                camera_source = gr.Number(label="Camera Source Index", 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):
@@ -484,88 +477,104 @@ def create_interface():
                         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")
+                gr.Markdown("**🎨 Color Coding:** <font color='green'>Green</font> = Known/Present, <font color='orange'>Orange</font> = New/Registered, <font color='red'>Red</font> = Unknown")
             
             with gr.Tab("📊 Output & Log"):
                 with gr.Row():
                     with gr.Column(scale=2):
-                        video_output = gr.Image(label="Recognition Output", interactive=False)
+                        video_output = gr.Image(label="Recognition Output", interactive=False, type="pil")
                     with gr.Column(scale=1):
                         session_log_display = gr.Markdown(label="📋 Session Log", value="System is ready.")
 
             with gr.Tab("👤 Worker Management"):
                 with gr.Row():
                     with gr.Column():
-                        register_image = gr.Image(label="Upload Worker's Photo", type="pil")
+                        gr.Markdown("### Register New Worker")
+                        register_image = gr.Image(label="Upload Worker's Photo", type="pil", sources=["upload"])
                         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)
                     with gr.Column():
+                        gr.Markdown("### Current Worker Roster")
                         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
-            
+        def on_tab_select(evt: gr.SelectData): return evt.index
         video_tabs.select(fn=on_tab_select, inputs=None, outputs=[selected_tab_index])
-        
+
         def start_wrapper(tab_index, cam_src, vid_path):
-            source = cam_src if tab_index == 0 else vid_path
+            source = int(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]
-        )
         
-        stop_btn.click(
-            fn=attendance_system.stop_processing,
-            inputs=None,
-            outputs=[status_box]
-        )
+        start_btn.click(fn=start_wrapper, inputs=[selected_tab_index, camera_source, video_file], outputs=[status_box])
+        stop_btn.click(fn=attendance_system.stop_processing, inputs=None, outputs=[status_box])
         
         register_btn.click(
-            fn=attendance_system.register_worker_manual,
-            inputs=[register_image, register_name],
+            fn=attendance_system.register_worker_manual, 
+            inputs=[register_image, register_name], 
             outputs=[register_output, registered_workers_info]
         )
-        
         refresh_workers_btn.click(
-            fn=attendance_system.get_registered_workers_info,
+            fn=attendance_system.get_registered_workers_info, 
             outputs=[registered_workers_info]
         )
         
         def update_ui_generator():
             while True:
+                # Handle error messages first
                 if attendance_system.error_message:
-                    yield None, attendance_system.error_message
+                    error = attendance_system.error_message
+                    attendance_system.error_message = None # Clear after sending
+                    yield None, error, f"Status: {error}"
                     time.sleep(2)
-                    attendance_system.error_message = None
                     continue
-                    
+
+                log_md = "\n".join(reversed(attendance_system.session_log)) or "Processing..."
+                frame = None
+
                 if attendance_system.is_processing.is_set():
-                    frame = None
                     try:
+                        # Non-blocking get from the queue
                         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)
+                            frame_bgr = attendance_system.frame_queue.get_nowait()
+                            if frame_bgr is not None:
+                                frame = cv2.cvtColor(frame_bgr, cv2.COLOR_BGR2RGB)
                     except queue.Empty:
-                        pass
-                    log_md = "\n".join(reversed(attendance_system.session_log[-20:])) or "Processing..."
-                    yield frame, log_md
+                        pass # No new frame, just update log
+                    yield frame, log_md, "Status: Processing..."
                 else:
+                    # Processing has stopped
+                    final_frame = None
                     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."
-                        yield final_frame, final_log_md
+                    
+                    final_log_md = "Processing complete. Here is the final log:"
+                    if attendance_system.final_log:
+                        final_log_md = "\n".join(reversed(attendance_system.final_log))
                     else:
-                        yield None, "System stopped. Go to 'Controls & Status' to start."
-                time.sleep(0.03)  # Faster UI updates
+                        final_log_md = "Processing stopped or finished with no new attendance."
+                    
+                    yield final_frame, final_log_md, "Status: Stopped. Go to 'Controls & Status' to start."
+                
+                time.sleep(0.1) # UI update frequency
+
+        # Use a separate generator for status to avoid conflicts
+        def update_status_generator():
+             while True:
+                if attendance_system.is_processing.is_set():
+                    yield "Status: Processing..."
+                else:
+                    yield "Status: Stopped. Go to 'Controls & Status' to start."
+                time.sleep(1)
+
+        # Bind the generator to update the UI components
+        demo.load(
+            fn=update_ui_generator, 
+            outputs=[video_output, session_log_display, status_box],
+            every=0.1
+        )
 
-        demo.load(fn=update_ui_generator, outputs=[video_output, session_log_display])
     return demo
 
 if __name__ == "__main__":