Resume Feature Implementation

components/review_dashboard_page.py

@@ -171,8 +171,13 @@ class ReviewDashboardPage:
                         validation_status += f" ({validation.description})"
             
             # For deleted annotations, show special status
-            if is_deleted and validation_status == "Not Reviewed":
-                validation_status = "Not Reviewed (Deleted)"
+            if is_deleted:
+                if validation_status == "Not Reviewed":
+                    validation_status = "Not Reviewed (Deleted)"
+                elif validation_status == "Approved":
+                    validation_status = "Approved (Deleted)"
+                elif validation_status.startswith("Rejected"):
+                    validation_status = f"Rejected (Deleted{validation_status[8:] if validation_status[8:] else ''})"
                 
             return validation_status, is_deleted
 
@@ -355,48 +360,93 @@ class ReviewDashboardPage:
                         "validation_loaded": False  # Track if validation status has been loaded
                     })
 
-                # Find the first item that is not reviewed (prioritize non-deleted annotations)
+                # --- RESUME LOGIC: Find first unreviewed item ---
                 initial_idx = 0
                 if items:
+                    log.info(f"Starting resume logic search with {len(items)} items")
+                    # First, try to find the first unreviewed item that is not deleted
                     found_unreviewed = False
-                    
-                    # Check database for validation status to find first unreviewed item
                     for i, item_data in enumerate(items):
-                        # Check if this annotation has been validated by current user
-                        existing_validation = db.query(Validation).filter_by(
-                            annotation_id=item_data["annotation_id"],
-                            validator_id=user_id
-                        ).first()
-                        
-                        # If no validation exists, this is unreviewed
-                        if not existing_validation:
-                            # Prioritize non-deleted annotations
-                            if not item_data.get("is_deleted", False):
-                                initial_idx = i
-                                found_unreviewed = True
-                                log.info(f"Found first unreviewed non-deleted item at index {i} (annotation_id: {item_data['annotation_id']})")
-                                break
-                    
-                    # If no unreviewed non-deleted items found, look for any unreviewed items (including deleted)
-                    if not found_unreviewed:
-                        for i, item_data in enumerate(items):
-                            existing_validation = db.query(Validation).filter_by(
+                        if not item_data.get("is_deleted", False):
+                            # Check if this item has been reviewed by the current validator
+                            validation = db.query(Validation).filter_by(
                                 annotation_id=item_data["annotation_id"],
                                 validator_id=user_id
                             ).first()
                             
-                            if not existing_validation:
+                            if not validation:
+                                # This item hasn't been reviewed yet
                                 initial_idx = i
                                 found_unreviewed = True
-                                log.info(f"Found first unreviewed item at index {i} (annotation_id: {item_data['annotation_id']}) - may be deleted")
+                                log.info(f"✅ Resume point found in initial batch: index {initial_idx}, TTS ID {item_data['tts_id']}, filename: {item_data['filename']}")
                                 break
+                            else:
+                                log.info(f"Item {i} (TTS ID {item_data['tts_id']}) already reviewed by validator {user_id}")
+                        else:
+                            log.info(f"Item {i} (TTS ID {item_data['tts_id']}) is deleted, skipping")
                     
-                    # If all items have been reviewed, continue from the end
+                    # If no unreviewed non-deleted items found in initial batch, 
+                    # we need to load more items to find the resume point
                     if not found_unreviewed:
-                        initial_idx = len(items) - 1 if items else 0
-                        log.info(f"All loaded items have been reviewed, starting from index {initial_idx}")
+                        log.info("No unreviewed items found in initial batch, loading more items to find resume point")
+                        
+                        # Load more items to find the resume point
+                        offset = len(items)
+                        additional_query = db.query(
+                            Annotation,
+                            TTSData.filename,
+                            TTSData.sentence
+                        ).join(
+                            TTSData, Annotation.tts_data_id == TTSData.id
+                        ).filter(
+                            Annotation.annotator_id == target_annotator_obj.id
+                        ).order_by(Annotation.id).offset(offset).limit(20)  # Load more to find resume point
+                        
+                        additional_results = additional_query.all()
+                        log.info(f"Loaded {len(additional_results)} additional items to search for resume point")
+                        
+                        # Process additional items
+                        for annotation, filename, sentence in additional_results:
+                            is_deleted = not annotation.annotated_sentence or annotation.annotated_sentence.strip() == ""
+                            annotated_sentence_display = "[DELETED ANNOTATION]" if is_deleted else annotation.annotated_sentence
+                            
+                            items.append({
+                                "annotation_id": annotation.id,
+                                "tts_id": annotation.tts_data_id,
+                                "filename": filename,
+                                "sentence": sentence,
+                                "annotated_sentence": annotated_sentence_display,
+                                "is_deleted": is_deleted,
+                                "annotated_at": annotation.annotated_at.isoformat() if annotation.annotated_at else "",
+                                "validation_status": "Loading...",
+                                "validation_loaded": False
+                            })
+                        
+                        # Now search for the first unreviewed item in the expanded list
+                        log.info(f"Searching expanded list of {len(items)} items for resume point")
+                        for i, item_data in enumerate(items):
+                            if not item_data.get("is_deleted", False):
+                                validation = db.query(Validation).filter_by(
+                                    annotation_id=item_data["annotation_id"],
+                                    validator_id=user_id
+                                ).first()
+                                
+                                if not validation:
+                                    initial_idx = i
+                                    found_unreviewed = True
+                                    log.info(f"✅ Resume point found in expanded list: index {initial_idx}, TTS ID {item_data['tts_id']}, filename: {item_data['filename']}")
+                                    break
+                                else:
+                                    log.info(f"Item {i} (TTS ID {item_data['tts_id']}) already reviewed by validator {user_id}")
+                            else:
+                                log.info(f"Item {i} (TTS ID {item_data['tts_id']}) is deleted, skipping")
+                        
+                        # If still no unreviewed items found, start from the last item
+                        if not found_unreviewed:
+                            initial_idx = len(items) - 1 if items else 0
+                            log.info(f"⚠️ All items reviewed, starting at last item, index: {initial_idx}")
                     
-                    log.info(f"Set initial review index to {initial_idx} out of {len(items)} loaded items") 
+                    log.info(f"Final resume decision: starting at index {initial_idx} with {len(items)} total items loaded")
                 
                 # Set initial display
                 if items:
@@ -476,6 +526,7 @@ class ReviewDashboardPage:
             # Check if this is a deleted annotation
             is_deleted = current_item.get("is_deleted", False)
             
+            # Handle validation status display
             if current_item["validation_status"].startswith("Rejected"):
                 # Extract reason from status like "Rejected (reason)" or just use empty if no parenthesis
                 start_paren = current_item["validation_status"].find("(")
@@ -483,6 +534,14 @@ class ReviewDashboardPage:
                 if start_paren != -1 and end_paren != -1:
                     rejection_reason = current_item["validation_status"][start_paren+1:end_paren]
                 rejection_visible = True
+            elif current_item["validation_status"] == "Not Reviewed (Deleted)":
+                # Special handling for deleted annotations that haven't been reviewed
+                rejection_visible = False
+                rejection_reason = ""
+            elif current_item["validation_status"] == "Not Reviewed":
+                # Regular unreviewed items
+                rejection_visible = False
+                rejection_reason = ""
 
             return (
                 str(current_item["tts_id"]), 
@@ -505,6 +564,68 @@ class ReviewDashboardPage:
             else:
                 return f"���� **Phase 2 Review Mode** - No annotations found for review."
 
+        def find_next_unreviewed_item(items, current_idx, session):
+            """Find the next unreviewed item starting from current_idx"""
+            if not items or current_idx >= len(items):
+                log.warning(f"find_next_unreviewed_item: Invalid items or current_idx. items: {len(items) if items else 0}, current_idx: {current_idx}")
+                return current_idx
+                
+            user_id = session.get("user_id")
+            if not user_id:
+                log.warning("find_next_unreviewed_item: No user_id in session")
+                return current_idx
+                
+            log.info(f"Searching for next unreviewed item starting from index {current_idx} (TTS ID: {items[current_idx]['tts_id'] if current_idx < len(items) else 'N/A'})")
+                
+            # Start searching from the next item
+            start_idx = current_idx + 1
+            if start_idx >= len(items):
+                start_idx = 0  # Wrap around to beginning
+                log.info("Wrapping around to beginning of items list")
+                
+            # Search forward from start_idx
+            for i in range(len(items)):
+                check_idx = (start_idx + i) % len(items)
+                item_data = items[check_idx]
+                
+                log.info(f"Checking item {check_idx} (TTS ID: {item_data['tts_id']}, filename: {item_data['filename']})")
+                
+                # Skip deleted annotations
+                if item_data.get("is_deleted", False):
+                    log.info(f"Item {check_idx} is deleted, skipping")
+                    continue
+                    
+                # Check if this item has been reviewed
+                if not item_data.get("validation_loaded", False):
+                    # Load validation status on-demand
+                    with get_db() as db:
+                        try:
+                            validation = db.query(Validation).filter_by(
+                                annotation_id=item_data["annotation_id"],
+                                validator_id=user_id
+                            ).first()
+                            item_data["validation_loaded"] = True
+                            if validation:
+                                item_data["validation_status"] = "Approved" if validation.validated else f"Rejected ({validation.description})" if validation.description else "Rejected"
+                                log.info(f"Item {check_idx} validation status loaded: {item_data['validation_status']}")
+                            else:
+                                item_data["validation_status"] = "Not Reviewed"
+                                log.info(f"Item {check_idx} has no validation record - unreviewed")
+                        except Exception as e:
+                            log.error(f"Error loading validation status for item {check_idx}: {e}")
+                            item_data["validation_status"] = "Error loading status"
+                
+                # If not reviewed, this is our target
+                if item_data["validation_status"] == "Not Reviewed":
+                    log.info(f"✅ Found next unreviewed item at index {check_idx} (TTS ID: {item_data['tts_id']}, filename: {item_data['filename']})")
+                    return check_idx
+                else:
+                    log.info(f"Item {check_idx} already reviewed with status: {item_data['validation_status']}")
+                    
+            # If no unreviewed items found, return current index
+            log.info("⚠️ No unreviewed items found, staying at current position")
+            return current_idx
+
         def navigate_and_load_fn(items, current_idx, direction, session):
             """Combined navigation and loading function"""
             if not items:
@@ -703,6 +824,15 @@ class ReviewDashboardPage:
                 # Combine with existing items
                 all_items = items + new_items
                 log.info(f"Loaded {len(new_items)} more items, total now: {len(all_items)}")
+                
+                # If this is the first time loading more items, we might need to find the resume point
+                # This ensures that even if the initial batch didn't find unreviewed items, 
+                # we can still resume from the correct position
+                if len(items) == 5 and len(all_items) > 5:  # Initial batch was 5 items
+                    log.info("First load_more call, checking if we need to find resume point")
+                    # The resume logic in load_review_items_fn should have already handled this,
+                    # but we can add additional safety here if needed
+                
                 return all_items, total_count
 
         # Output definitions
@@ -782,9 +912,9 @@ class ReviewDashboardPage:
             fn=lambda: gr.update(value="❌ Reject"),  # Reset reject button
             outputs=[self.btn_reject]
         ).then(
-            fn=lambda items, idx, session: navigate_and_load_fn(items, idx, "next", session),
+            fn=lambda items, idx, session: find_next_unreviewed_item(items, idx, session),
             inputs=[self.items_state, self.idx_state, session_state],
-            outputs=[self.items_state, self.idx_state, self.review_info]
+            outputs=[self.idx_state]
         ).then(
             fn=show_current_review_item_fn,
             inputs=[self.items_state, self.idx_state, session_state],
@@ -805,9 +935,9 @@ class ReviewDashboardPage:
             inputs=[self.items_state, self.idx_state, session_state, self.rejection_mode_active],
             outputs=[self.header.progress_display]
         ).then(
-            fn=lambda items, idx, session, rejection_mode: navigate_and_load_fn(items, idx, "next", session) if not rejection_mode else (items, idx, ""),
+            fn=lambda items, idx, session, rejection_mode: find_next_unreviewed_item(items, idx, session) if not rejection_mode else idx,
             inputs=[self.items_state, self.idx_state, session_state, self.rejection_mode_active],
-            outputs=[self.items_state, self.idx_state, self.review_info]
+            outputs=[self.idx_state]
         ).then(
             fn=lambda items, idx, session, rejection_mode: show_current_review_item_fn(items, idx, session) if not rejection_mode else (
                 str(items[idx]["tts_id"]) if items and idx < len(items) else "",
@@ -833,9 +963,9 @@ class ReviewDashboardPage:
 
         # Skip button (just navigate to next)
         self.btn_skip.click(
-            fn=lambda items, idx, session: navigate_and_load_fn(items, idx, "next", session),
+            fn=lambda items, idx, session: find_next_unreviewed_item(items, idx, session),
             inputs=[self.items_state, self.idx_state, session_state],
-            outputs=[self.items_state, self.idx_state, self.review_info]
+            outputs=[self.idx_state]
         ).then(
             fn=show_current_review_item_fn,
             inputs=[self.items_state, self.idx_state, session_state],