Update app.py

app.py

@@ -72,14 +72,10 @@ class AttendanceSystem:
         self.processing_thread = None
         self.is_processing = threading.Event()
         self.frame_queue = queue.Queue(maxsize=10)
-        self.error_message = None
+        self.error_message = None 
         self.last_processed_frame = None
         self.final_log = None
 
-        # Recognition Parameters
-        self.RECOGNITION_THRESHOLD = 1.1 # Strict threshold for a confident match.
-        self.DUPLICATE_THRESHOLD = 1.4   # More lenient threshold to prevent re-registering known faces.
-
         # Data Storage
         self.known_face_embeddings: List[np.ndarray] = []
         self.known_face_names: List[str] = []
@@ -87,8 +83,11 @@ class AttendanceSystem:
         self.next_worker_id: int = 1
         
         # Session Tracking
+        self.last_recognition_time = {}
+        self.recognition_cooldown = 5
         self.session_log: List[str] = []
-        self.session_logged_ids = set()
+        self.today_attendance = set()
+        self.today_str = date.today().isoformat()
 
         # Initialize
         self.sf = connect_to_salesforce()
@@ -99,7 +98,6 @@ class AttendanceSystem:
         os.makedirs("data/faces", exist_ok=True)
 
     def load_worker_data(self):
-        """Loads worker data from Salesforce or a local file at startup."""
         logger.info("Loading worker data...")
         if self.sf:
             try:
@@ -125,7 +123,7 @@ class AttendanceSystem:
                 self.known_face_names = temp_names
                 self.known_face_ids = temp_ids
                 self.next_worker_id = max_id + 1
-                self.save_local_worker_data() # Create a local backup
+                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.")
@@ -137,7 +135,8 @@ class AttendanceSystem:
     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", [])
@@ -147,12 +146,11 @@ class AttendanceSystem:
             logger.error(f"❌ Error loading local data: {e}")
 
     def save_local_worker_data(self):
-        """Saves the current in-memory worker database to a local pickle file."""
         try:
             worker_data = {
-                "embeddings": self.known_face_embeddings, 
-                "names": self.known_face_names, 
-                "ids": self.known_face_ids, 
+                "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: 
@@ -166,181 +164,230 @@ class AttendanceSystem:
             return "❌ Please provide both image and name!", self.get_registered_workers_info()
         try:
             image_array = np.array(image)
-            embedding = DeepFace.represent(img_path=image_array, model_name='Facenet', enforce_detection=True)[0]['embedding']
-            
+            DeepFace.analyze(img_path=image_array, actions=['emotion'], enforce_detection=True)
+            embedding = DeepFace.represent(img_path=image_array, model_name='Facenet')[0]['embedding']
             if self._is_duplicate_face(embedding):
-                return "❌ 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()
-            
-            # Instantly update memory
-            self.known_face_ids.append(worker_id)
-            self.known_face_names.append(name)
-            self.known_face_embeddings.append(np.array(embedding))
-            self.next_worker_id += 1
-            
-            # Sync to backend and save
-            self._sync_worker_to_backend(worker_id, name, embedding, image_array)
+            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, embedding: List[float]) -> Optional[Tuple[str, str]]:
-        """Instantly adds a new worker to memory and then syncs to the backend."""
+    def _register_worker_auto(self, face_image: np.ndarray) -> Optional[Tuple[str, str]]:
         try:
-            # Check for duplicates using the embedding that was already calculated
-            if self._is_duplicate_face(embedding):
+            embedding = DeepFace.represent(img_path=face_image, model_name='Facenet', enforce_detection=False)[0]['embedding']
+            if self._is_duplicate_face(embedding): 
                 return None
-
-            # STEP 1: Update in-memory data INSTANTLY. This is the critical fix.
+                
             worker_id = f"W{self.next_worker_id:04d}"
             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()
             
-            self.known_face_ids.append(worker_id)
-            self.known_face_names.append(worker_name)
-            self.known_face_embeddings.append(np.array(embedding))
-            self.next_worker_id += 1
+            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)
             
-            logger.info(f"Added {worker_name} to memory. Now syncing to backend.")
-
-            # STEP 2: Sync to backend (Salesforce, local files). This can be slow but won't block the next frame.
-            self._sync_worker_to_backend(worker_id, worker_name, embedding, face_image)
-            self.save_local_worker_data()
+            # Mark attendance immediately after registration
+            self.mark_attendance(worker_id, worker_name)
             
             return worker_id, worker_name
         except Exception as e:
             logger.error(f"❌ Auto-registration error: {e}")
             return None
 
-    def _sync_worker_to_backend(self, worker_id: str, name: str, embedding: List[float], image_array: np.ndarray):
-        """Saves worker image and syncs data to Salesforce if available."""
+    def _add_worker_to_system(self, worker_id: str, name: str, embedding: List[float], image_array: np.ndarray):
+        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
+        
+        # Save face image
         face_pil = Image.fromarray(cv2.cvtColor(image_array, cv2.COLOR_BGR2RGB))
         face_pil.save(f"data/faces/{worker_id}.jpg")
+        
+        # Generate caption and sync to Salesforce
         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})
+                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})
+                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}")
 
-    def _is_duplicate_face(self, embedding: List[float]) -> bool:
-        """Checks if a face is too similar to an already registered one."""
-        if not self.known_face_embeddings: return False
+    def _is_duplicate_face(self, embedding: List[float], threshold: float = 8.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]
-        # Use the looser threshold to avoid re-registering known faces at different angles
-        return min(distances) < self.DUPLICATE_THRESHOLD
+        return min(distances) < threshold
 
     def mark_attendance(self, worker_id: str, worker_name: str) -> bool:
-        """Marks attendance in Salesforce if not already done today. Returns True if newly marked."""
-        today_str = date.today().isoformat()
-        if self._has_attended_today(worker_id, today_str):
+        # Check if already marked today
+        if worker_id in self.today_attendance:
             return False
-
+            
+        # Check Salesforce if not in session cache
+        if self._has_attended_today(worker_id):
+            self.today_attendance.add(worker_id)
+            return False
+            
         current_time = datetime.now()
+        
+        # Log to Salesforce if connected
         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.isoformat(), 'Status__c': "Present"})
-                logger.info(f"Salesforce attendance marked for {worker_id}")
-                return True
+                self.sf.Attendance__c.create({
+                    'Worker_ID__c': worker_id,
+                    'Name__c': worker_name,
+                    'Date__c': self.today_str,
+                    'Timestamp__c': current_time.isoformat(),
+                    'Status__c': "Present"
+                })
             except Exception as e:
                 logger.error(f"❌ Error saving attendance to Salesforce: {e}")
                 return False
-        return True # Assume success if not connected to Salesforce
+                
+        # Add to session log and tracking
+        log_msg = f"✅ [{current_time.strftime('%H:%M:%S')}] Marked Present: {worker_name} ({worker_id})"
+        self.session_log.append(log_msg)
+        self.today_attendance.add(worker_id)
+        self.last_recognition_time[worker_id] = time.time()
+        
+        return True
 
-    def _has_attended_today(self, worker_id: str, today_str: str) -> bool:
-        """Checks Salesforce to see if an attendance record exists for the worker today."""
+    def _has_attended_today(self, worker_id: str) -> bool:
         if self.sf:
             try:
-                if self.sf.query(f"SELECT Id FROM Attendance__c WHERE Worker_ID__c = '{worker_id}' AND Date__c = {today_str}")['totalSize'] > 0:
-                    return True
-            except Exception: pass
+                query = f"SELECT Id FROM Attendance__c WHERE Worker_ID__c = '{worker_id}' AND Date__c = '{self.today_str}'"
+                return self.sf.query(query)['totalSize'] > 0
+            except Exception as e:
+                logger.error(f"❌ Error checking attendance in Salesforce: {e}")
         return False
 
     # --- Video Processing ---
     def process_frame(self, frame: np.ndarray) -> np.ndarray:
+        """
+        Process a single video frame with reliable face recognition and attendance marking.
+        """
         try:
-            face_objs = DeepFace.extract_faces(img_path=frame, detector_backend='opencv', enforce_detection=False)
-
+            # Convert to RGB for better face detection
+            rgb_frame = cv2.cvtColor(frame, cv2.COLOR_BGR2RGB)
+            
+            # Detect faces with high confidence
+            face_objs = DeepFace.extract_faces(
+                img_path=rgb_frame,
+                detector_backend='opencv',
+                enforce_detection=False,
+                align=True,
+                target_size=(160, 160)  # Standard size for Facenet
+            
             for face_obj in face_objs:
-                if face_obj['confidence'] < 0.95: continue
+                confidence = face_obj['confidence']
+                
+                # Skip low confidence detections
+                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']
-                face_image = frame[y:y+h, x:x+w]
+                face_image = rgb_frame[y:y+h, x:x+w]
                 
-                if face_image.size == 0: continue
+                if face_image.size == 0:
+                    continue
 
-                color, label_text = (0, 0, 255), "Unknown" # Default to Red/Unknown
-                
+                # Get face embedding
                 try:
-                    embedding = DeepFace.represent(img_path=face_image, model_name='Facenet', enforce_detection=False)[0]['embedding']
+                    embedding_obj = DeepFace.represent(
+                        img_path=face_image,
+                        model_name='Facenet',
+                        enforce_detection=False,
+                        normalization='base'
+                    )
+                    embedding = np.array(embedding_obj[0]['embedding'])
+                except Exception as e:
+                    logger.error(f"Face embedding error: {e}")
+                    continue
+
+                # Initialize recognition variables
+                recognized = False
+                worker_id = None
+                worker_name = "Unknown"
+                color = (0, 0, 255)  # Default red for unknown
+                
+                # Compare with known faces if any exist
+                if self.known_face_embeddings:
+                    distances = [np.linalg.norm(embedding - known) for known in self.known_face_embeddings]
+                    min_dist = min(distances) if distances else float('inf')
+                    match_index = np.argmin(distances) if distances else -1
                     
-                    min_dist, match_index = -1, -1
-                    if self.known_face_embeddings:
-                        distances = [np.linalg.norm(np.array(embedding) - known) for known in self.known_face_embeddings]
-                        if distances:
-                            min_dist = min(distances)
-                            match_index = distances.index(min_dist)
-
-                    # CASE 1: CONFIDENT MATCH (Recognized Worker)
-                    if match_index != -1 and min_dist < self.RECOGNITION_THRESHOLD:
+                    # Check if match is good enough
+                    if min_dist < 8.0:  # Lower threshold for stricter matching
+                        recognized = True
                         worker_id = self.known_face_ids[match_index]
                         worker_name = self.known_face_names[match_index]
-                        color, label_text = (0, 255, 0), f"{worker_name} ({worker_id})" # Green
+                        color = (0, 255, 0)  # Green for known workers
                         
-                        if worker_id not in self.session_logged_ids:
-                            if self.mark_attendance(worker_id, worker_name):
-                                log_msg = f"✅ [{datetime.now().strftime('%H:%M:%S')}] Marked Present: {worker_name} ({worker_id})"
-                                self.session_log.append(log_msg)
-                                self.session_logged_ids.add(worker_id)
-                    
-                    # CASE 2: NEW FACE (Attempt to register)
-                    else:
-                        # Pass the calculated embedding to avoid doing it twice
-                        new_worker = self._register_worker_auto(face_image, embedding)
-                        if new_worker:
-                            worker_id, worker_name = new_worker
-                            color, label_text = (0, 165, 255), f"{worker_name} ({worker_id})" # Orange
-
-                            if worker_id not in self.session_logged_ids:
-                                log_msg = f"🆕 [{datetime.now().strftime('%H:%M:%S')}] Auto-registered: {worker_name} ({worker_id})"
-                                self.session_log.append(log_msg)
-                                self.mark_attendance(worker_id, worker_name)
-                                self.session_logged_ids.add(worker_id)
-                    # Note: If _register_worker_auto returns None (because it was a duplicate), the box remains red.
-                except Exception as e:
-                    logger.debug(f"Could not process a face. Error: {e}")
-
+                        # Mark attendance if not already done
+                        if worker_id not in self.today_attendance:
+                            self.mark_attendance(worker_id, worker_name)
+
+                # Handle unknown faces (potential new workers)
+                if not recognized and w > 80 and h > 80:  # Minimum face size
+                    # Attempt auto-registration
+                    new_worker = self._register_worker_auto(face_image)
+                    if new_worker:
+                        worker_id, worker_name = new_worker
+                        color = (0, 165, 255)  # Orange for new workers
+
+                # Draw rectangle and label
+                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_text, (x, y-10), cv2.FONT_HERSHEY_SIMPLEX, 0.7, 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"CRITICAL ERROR in process_frame: {e}")
+            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():
-            self.error_message = "❌ **Error:** Could not open video source."
+            err_msg = f"❌ Could not open video source {source}"
+            self.error_message = err_msg
             self.is_processing.clear()
             return
             
+        # Reset for new session
+        self.today_attendance.clear()
+        self.session_log.clear()
+        self.last_recognition_time.clear()
+        self.today_str = date.today().isoformat()
+        
         while self.is_processing.is_set():
             ret, frame = video_capture.read()
-            if not ret: break
-            
+            if not ret:
+                break
+                
             processed_frame = self.process_frame(frame)
-            if not self.frame_queue.full(): self.frame_queue.put(processed_frame)
             
+            if not self.frame_queue.full():
+                self.frame_queue.put(processed_frame)
+                
             self.last_processed_frame = processed_frame
             time.sleep(0.05)
             
@@ -349,141 +396,196 @@ class AttendanceSystem:
         self.is_processing.clear()
 
     def start_processing(self, source) -> str:
-        if self.is_processing.is_set(): return "⚠️ Processing is already active."
-        self.session_log.clear()
-        self.session_logged_ids.clear()
-        self.error_message = None; self.last_processed_frame = None; self.final_log = None
+        if self.is_processing.is_set():
+            return "⚠️ Processing is already active."
+            
         self.is_processing.set()
-        self.processing_thread = threading.Thread(target=self._processing_loop, args=(source,)); self.processing_thread.daemon = True
+        self.processing_thread = threading.Thread(
+            target=self._processing_loop,
+            args=(source,),
+            daemon=True
+        )
         self.processing_thread.start()
-        return "✅ Started processing..."
+        return f"✅ Started processing video source {source}..."
 
     def stop_processing(self) -> str:
         self.is_processing.clear()
-        return "✅ Processing stopped by user."
+        return "✅ Processing stopped."
 
-    # --- Helper & Reporting ---
+    # --- Helper Methods ---
     def _get_image_caption(self, image: Image.Image) -> str:
-        # ... (rest of this function is unchanged)
-        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=buffered.getvalue())
             response.raise_for_status()
-            result = response.json()
-            return result[0].get("generated_text", "No caption found.")
+            return response.json()[0].get("generated_text", "No caption")
         except Exception as e:
             logger.error(f"Hugging Face API error: {e}")
-            return "Caption generation failed."
+            return "Caption failed"
 
     def _upload_image_to_salesforce(self, image: Image.Image, record_id: str, worker_id: str) -> Optional[str]:
-        # ... (rest of this function is unchanged)
-        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')
-            cv = self.sf.ContentVersion.create({'Title': f'Image_{worker_id}', 'PathOnClient': f'{worker_id}.jpg', 'VersionData': encoded_image, 'FirstPublishLocationId': record_id})
-            return f"/{cv['id']}" # Relative URL
+            encoded = base64.b64encode(buffered.getvalue()).decode('utf-8')
+            cv = self.sf.ContentVersion.create({
+                'Title': f'Image_{worker_id}',
+                'PathOnClient': f'{worker_id}.jpg',
+                'VersionData': encoded,
+                'FirstPublishLocationId': record_id
+            })
+            return f"/{cv['id']}"
         except Exception as e:
             logger.error(f"Salesforce image upload error: {e}")
             return None
 
     def get_registered_workers_info(self) -> str:
-        # ... (rest of this function is unchanged)
-        if not self.sf: return "❌ Salesforce not connected."
+        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}"
-        
-# --- GRADIO UI (Unchanged) ---
+            if not records:
+                return "No workers registered."
+            return f"**👥 Registered Workers ({len(records)})**\n" + "\n".join(
+                [f"- {w['Name']} ({w['Worker_ID__c']})" for w in records]
+            )
+        except Exception as e:
+            return f"Error: {e}"
+
+# --- GRADIO UI ---
 attendance_system = AttendanceSystem()
+
 def create_interface():
-    # ... (The entire Gradio UI section remains the same as your original code) ...
     with gr.Blocks(theme=gr.themes.Soft(), title="Attendance System") as demo:
-        gr.Markdown("# 🎯 Advanced Face Recognition Attendance System")
+        gr.Markdown("# 🎯 Face Recognition Attendance System")
+        
         with gr.Tabs():
-            with gr.Tab("⚙️ Controls & Status"):
-                gr.Markdown("### 1. Choose Input Source & Start Processing")
+            with gr.Tab("⚙️ Controls"):
                 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.Column():
+                        input_source = gr.Radio(
+                            ["Webcam", "Video File"],
+                            label="Input Source",
+                            value="Webcam"
+                        )
+                        webcam_source = gr.Number(
+                            label="Webcam Index",
+                            value=0,
+                            visible=True
+                        )
+                        video_file = gr.Video(
+                            label="Video File",
+                            sources=["upload"],
+                            visible=False
+                        )
+                        
+                        def toggle_source(choice):
+                            return {
+                                "Webcam": [gr.Number(visible=True), gr.Video(visible=False)],
+                                "Video File": [gr.Number(visible=False), gr.Video(visible=True)]
+                            }[choice]
+                            
+                        input_source.change(
+                            fn=toggle_source,
+                            inputs=input_source,
+                            outputs=[webcam_source, video_file]
+                        )
+                        
+                    with gr.Column():
+                        start_btn = gr.Button("▶️ Start", variant="primary")
+                        stop_btn = gr.Button("⏹️ Stop", variant="stop")
+                        status = gr.Textbox(label="Status", interactive=False)
+                
+                gr.Markdown("**Color Legend:** <span style='color:green'>Green</span> = Known Worker | <span style='color:orange'>Orange</span> = New Worker | <span style='color:red'>Red</span> = Unknown")
+            
+            with gr.Tab("📹 Live View"):
+                video_output = gr.Image(label="Detection Output")
+                session_log = gr.Textbox(label="Session Log", lines=10, interactive=False)
             
-            with gr.Tab("📊 Output & Log"):
-                with gr.Row():
-                    with gr.Column(scale=2):
-                        video_output = gr.Image(label="Recognition Output", interactive=False)
-                    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")
-                        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)
+                        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", 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])
-
-        def start_wrapper(tab_index, cam_src, 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)
+                        worker_list = gr.Markdown(
+                            value=attendance_system.get_registered_workers_info(),
+                            label="Registered Workers"
+                        )
+                        refresh_btn = gr.Button("🔄 Refresh")
+        
+        # Event handlers
+        def start_processing(source_type, webcam_idx, video_path):
+            source = webcam_idx if source_type == "Webcam" else video_path
+            if source is None:
+                return "Please select an input source"
+            return attendance_system.start_processing(source)
+            
+        start_btn.click(
+            fn=start_processing,
+            inputs=[input_source, webcam_source, video_file],
+            outputs=[status]
+        )
+        
+        stop_btn.click(
+            fn=attendance_system.stop_processing,
+            outputs=[status]
+        )
+        
+        reg_btn.click(
+            fn=attendance_system.register_worker_manual,
+            inputs=[reg_image, reg_name],
+            outputs=[reg_status, worker_list]
+        )
         
-        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], outputs=[register_output, registered_workers_info])
-        refresh_workers_btn.click(fn=attendance_system.get_registered_workers_info, outputs=[registered_workers_info])
+        refresh_btn.click(
+            fn=attendance_system.get_registered_workers_info,
+            outputs=[worker_list]
+        )
         
-        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
+                    yield None, attendance_system.error_message, ""
+                    time.sleep(2)
+                    attendance_system.error_message = None
                     continue
-
+                    
                 if attendance_system.is_processing.is_set():
-                    frame, log_md = None, "\n".join(reversed(attendance_system.session_log)) 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
+                    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)
+                    
+                    log_text = "\n".join(reversed(attendance_system.session_log[-10:])) if attendance_system.session_log else "No activity yet"
+                    yield frame, "", log_text
                 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)) if attendance_system.final_log else "Processing complete. No log entries."
-                        yield final_frame, final_log_md
+                        final_log = "\n".join(reversed(attendance_system.final_log)) if attendance_system.final_log else "Session completed"
+                        yield final_frame, "", final_log
                     else:
-                        yield None, "System stopped. Go to 'Controls & Status' to start."
-                time.sleep(0.1)
-
-        demo.load(fn=update_ui_generator, outputs=[video_output, session_log_display])
+                        yield None, "System ready", "Waiting to start..."
+                time.sleep(0.05)
+                
+        demo.load(
+            fn=update_ui,
+            outputs=[video_output, status, session_log],
+            every=0.1
+        )
+    
     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)