Resume Feature Implementation

components/review_dashboard_page.py

@@ -3,7 +3,7 @@
 import gradio as gr
 import datetime
 import sentry_sdk
-from sqlalchemy import orm, func
+from sqlalchemy import orm
 
 from components.header import Header
 from utils.logger import Logger
@@ -26,10 +26,6 @@ class ReviewDashboardPage:
             # Review info banner
             with gr.Row():
                 self.review_info = gr.Markdown("", elem_classes="review-banner")
-            
-            # Position info display
-            with gr.Row():
-                self.position_info = gr.Markdown("", elem_classes="position-info")
 
             with gr.Row():
                 # Left Column - Review Content
@@ -72,7 +68,6 @@ class ReviewDashboardPage:
                             min_width=120
                         )
                         self.btn_jump = gr.Button("Go to ID", min_width=70)
-                        self.btn_jump_to_unreviewed = gr.Button("🎯 Jump to Unreviewed", min_width=150, variant="secondary")
 
                 # Right Column - Audio
                 with gr.Column(scale=2):
@@ -105,8 +100,7 @@ class ReviewDashboardPage:
             # List of interactive UI elements for enabling/disabling
             self.interactive_ui_elements = [
                 self.btn_prev, self.btn_next, self.btn_approve, self.btn_reject, 
-                self.btn_skip, self.btn_jump, self.jump_data_id_input, self.btn_load_voice,
-                self.btn_jump_to_unreviewed
+                self.btn_skip, self.btn_jump, self.jump_data_id_input, self.btn_load_voice
             ]
 
     def register_callbacks(self, login_page, session_state: gr.State, root_blocks: gr.Blocks):
@@ -224,19 +218,6 @@ class ReviewDashboardPage:
                         Validation.validator_id == user_id
                     ).count()
                     
-                    # Find the first unreviewed item to show current position
-                    first_unreviewed_query = db.query(Annotation.id).outerjoin(
-                        Validation, 
-                        (Annotation.id == Validation.annotation_id) & 
-                        (Validation.validator_id == user_id)
-                    ).filter(
-                        Annotation.annotator_id == target_annotator_obj.id,
-                        Validation.id.is_(None)  # No validation record exists for this reviewer
-                    ).order_by(Annotation.id).limit(1)
-                    
-                    first_unreviewed_result = first_unreviewed_query.first()
-                    current_position = "Completed" if not first_unreviewed_result else f"ID: {first_unreviewed_result.id}"
-                    
                     if total_count > 0:
                         percentage = (reviewed_count / total_count) * 100
                         
@@ -268,7 +249,7 @@ class ReviewDashboardPage:
                         # Estimate remaining items
                         remaining = total_count - reviewed_count
                         
-                        # Create the beautiful progress display with current position
+                        # Create the beautiful progress display
                         progress_html = f"""
                         <div class="progress-container">
                             <div class="progress-header">
@@ -286,9 +267,6 @@ class ReviewDashboardPage:
                                 📊 <code>{progress_bar}</code> 
                                 <span class="remaining-items">({remaining} remaining)</span>
                             </div>
-                            <div class="progress-position">
-                                🎯 <strong>Current Position:</strong> {current_position}
-                            </div>
                         </div>
                         """
                         
@@ -300,82 +278,18 @@ class ReviewDashboardPage:
                     log.error(f"Error calculating review progress for user {user_id}: {e}")
                     return f"⚠️ **Error calculating progress**"
 
-        def get_current_item_position_info(items, current_idx, session):
-            """Get information about the current item's position in the review queue"""
-            if not items or current_idx >= len(items):
-                return ""
-                
-            user_id = session.get("user_id")
-            username = session.get("username")
-            if not user_id or not username:
-                return ""
-                
-            # Find target annotator
-            target_annotator = None
-            for annotator_name, reviewer_name in conf.REVIEW_MAPPING.items():
-                if reviewer_name == username:
-                    target_annotator = annotator_name
-                    break
-                    
-            if not target_annotator:
-                return ""
-                
-            with get_db() as db:
-                try:
-                    # Get target annotator's ID
-                    target_annotator_obj = db.query(Annotator).filter_by(name=target_annotator).first()
-                    if not target_annotator_obj:
-                        return ""
-                    
-                    # Get total count
-                    total_count = db.query(Annotation).filter(
-                        Annotation.annotator_id == target_annotator_obj.id
-                    ).count()
-                    
-                    # Get count of reviewed items for this reviewer
-                    reviewed_count = db.query(Validation).join(
-                        Annotation, Validation.annotation_id == Annotation.id
-                    ).filter(
-                        Validation.validator_id == user_id,
-                        Annotation.annotator_id == target_annotator_obj.id
-                    ).count()
-                    
-                    # Get current item's position in the overall sequence
-                    current_item_id = items[current_idx]["annotation_id"]
-                    
-                    # Calculate position based on the actual review sequence
-                    # First, get all annotations for this target annotator ordered by ID
-                    all_annotations = db.query(Annotation.id).filter(
-                        Annotation.annotator_id == target_annotator_obj.id
-                    ).order_by(Annotation.id).all()
-                    
-                    # Create a list of annotation IDs
-                    all_annotation_ids = [ann.id for ann in all_annotations]
-                    
-                    # Find the position of current item in the overall sequence
-                    try:
-                        current_position = all_annotation_ids.index(current_item_id) + 1
-                    except ValueError:
-                        current_position = 0
-                    
-                    return f"📍 **Position:** {current_position} of {total_count} items"
-                    
-                except Exception as e:
-                    log.error(f"Error getting current item position: {e}")
-                    return ""
-
         def load_review_items_fn(session):
             user_id = session.get("user_id")
             username = session.get("username")
             
             if not user_id or not username:
                 log.warning("load_review_items_fn: user not found in session")
-                return [], 0, "", "", "", "", "", "", "", "", gr.update(value=None, autoplay=False), gr.update(visible=False, value=""), False, gr.update(value="❌ Reject"), ""
+                return [], 0, "", "", "", "", "", "", "", "", gr.update(value=None, autoplay=False), gr.update(visible=False, value=""), False, gr.update(value="❌ Reject")
 
             # Check if user is in Phase 2 (should be a reviewer)
             if username not in conf.REVIEW_MAPPING.values():
                 log.warning(f"User {username} is not assigned as a reviewer")
-                return [], 0, "", "", "", "", "", "", "", "", gr.update(value=None, autoplay=False), gr.update(visible=False, value=""), False, gr.update(value="❌ Reject"), ""
+                return [], 0, "", "", "", "", "", "", "", "", gr.update(value=None, autoplay=False), gr.update(visible=False, value=""), False, gr.update(value="❌ Reject")
 
             # Find which annotator this user should review
             target_annotator = None
@@ -386,135 +300,82 @@ class ReviewDashboardPage:
 
             if not target_annotator:
                 log.warning(f"No target annotator found for reviewer {username}")
-                return [], 0, "", "", "", "", "", "", "", "", gr.update(value=None, autoplay=False), gr.update(visible=False, value=""), False, gr.update(value="❌ Reject"), ""
+                return [], 0, "", "", "", "", "", "", "", "", gr.update(value=None, autoplay=False), gr.update(visible=False, value=""), False, gr.update(value="❌ Reject")
 
-            # Load annotations from target annotator with FAST INITIAL LOADING
+            # Load ALL annotations from target annotator to properly implement "continue from where left off"
             with get_db() as db:
                 # Get target annotator's ID
                 target_annotator_obj = db.query(Annotator).filter_by(name=target_annotator).first()
                 if not target_annotator_obj:
                     log.error(f"Target annotator {target_annotator} not found in database")
-                    return [], 0, f"Review Target Error: Annotator '{target_annotator}' not found.", "", "", "", "", "", "", "", gr.update(value=None, autoplay=False), gr.update(visible=False, value=""), False, gr.update(value="❌ Reject"), ""
+                    return [], 0, f"Review Target Error: Annotator '{target_annotator}' not found.", "", "", "", "", "", "", "", gr.update(value=None, autoplay=False), gr.update(visible=False, value=""), False, gr.update(value="❌ Reject")
                 
                 log.info(f"Found target annotator with ID: {target_annotator_obj.id}")
 
-                # Get total count for progress info (this is fast)
-                total_count = db.query(Annotation).filter(
+                # Load ALL annotations to properly implement resume functionality
+                # This is similar to phase 1 dashboard approach
+                all_annotations_query = db.query(
+                    Annotation,
+                    TTSData.filename,
+                    TTSData.sentence
+                ).join(
+                    TTSData, Annotation.tts_data_id == TTSData.id
+                ).filter(
                     Annotation.annotator_id == target_annotator_obj.id
-                ).count()
+                ).order_by(Annotation.id)
 
-                # RESUME LOGIC: Find the first unreviewed item by this reviewer
-                # Query to find the first unreviewed annotation for this reviewer
-                first_unreviewed_query = db.query(
-                    Annotation.id,
-                    Annotation.tts_data_id,
-                    Annotation.annotated_sentence,
-                    Annotation.annotated_at
-                ).outerjoin(
-                    Validation, 
-                    (Annotation.id == Validation.annotation_id) & 
-                    (Validation.validator_id == user_id)
-                ).filter(
-                    Annotation.annotator_id == target_annotator_obj.id,
-                    Validation.id.is_(None)  # No validation record exists for this reviewer
-                ).order_by(Annotation.id).limit(1)
+                all_results = all_annotations_query.all()
+                total_count = len(all_results)
 
-                first_unreviewed_result = first_unreviewed_query.first()
-                
-                if first_unreviewed_result:
-                    # Found unreviewed item - start from there
-                    first_unreviewed_id = first_unreviewed_result.id
-                    log.info(f"Found first unreviewed item with ID: {first_unreviewed_id}")
-                    
-                    # Load items starting from the unreviewed item
-                    # Load a batch around the unreviewed item for context
-                    BATCH_SIZE = 10
-                    offset = max(0, first_unreviewed_id - 5)  # Start 5 items before the unreviewed item
-                    
-                    # Query to get items around the unreviewed item
-                    items_query = db.query(
-                        Annotation,
-                        TTSData.filename,
-                        TTSData.sentence
-                    ).join(
-                        TTSData, Annotation.tts_data_id == TTSData.id
-                    ).filter(
-                        Annotation.annotator_id == target_annotator_obj.id,
-                        Annotation.id >= offset
-                    ).order_by(Annotation.id).limit(BATCH_SIZE)
-                    
-                    initial_results = items_query.all()
-                    
-                    # Find the index of the first unreviewed item in our loaded batch
-                    initial_idx = 0
-                    for i, (annotation, filename, sentence) in enumerate(initial_results):
-                        if annotation.id == first_unreviewed_id:
-                            initial_idx = i
-                            break
-                    
-                    log.info(f"Resuming at first unreviewed item, index: {initial_idx} (ID: {first_unreviewed_id})")
-                else:
-                    # No unreviewed items found - all items have been reviewed
-                    log.info(f"All items for {target_annotator} have been reviewed by {username}")
-                    
-                    # Load the last batch of items to show completion
-                    BATCH_SIZE = 10
-                    items_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.desc()).limit(BATCH_SIZE)
-                    
-                    # Reverse the results to maintain chronological order
-                    initial_results = list(reversed(items_query.all()))
-                    initial_idx = len(initial_results) - 1 if initial_results else 0
-                    
-                    log.info(f"All items reviewed, starting at last item, index: {initial_idx}")
-                    
-                    # Set completion message
-                    if initial_results:
-                        review_info_text = f"🎉 **Phase 2 Review Mode** - All annotations for {target_annotator} have been reviewed! Showing last {len(initial_results)} items for reference."
-                    else:
-                        review_info_text = f"🎉 **Phase 2 Review Mode** - All annotations for {target_annotator} have been reviewed! No items to display."
-                    
-                    return (
-                        [], 
-                        0, 
-                        review_info_text,
-                        "", "", "", "", "", "", "", gr.update(value=None, autoplay=False), gr.update(visible=False, value=""), False, gr.update(value="❌ Reject"), ""
-                    )
+                log.info(f"Loaded {total_count} annotations for target annotator ID {target_annotator_obj.id}")
 
-                # Process items with minimal data - validation status will be loaded on-demand
+                # Process all items and determine validation status immediately
                 items = []
-                for annotation, filename, sentence in initial_results:
-                    # Check if annotation is deleted (minimal processing)
+                for annotation, filename, sentence in all_results:
+                    # Check if annotation is deleted
                     is_deleted = not annotation.annotated_sentence or annotation.annotated_sentence.strip() == ""
                     annotated_sentence_display = "[DELETED ANNOTATION]" if is_deleted else annotation.annotated_sentence
                     
+                    # Get validation status immediately (not on-demand)
+                    validation_status, is_deleted_updated = get_validation_status_for_item(db, annotation.id, user_id, annotation)
+                    
                     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,
+                        "is_deleted": is_deleted_updated,
                         "annotated_at": annotation.annotated_at.isoformat() if annotation.annotated_at else "",
-                        "validation_status": "Loading...",  # Will be loaded on-demand
-                        "validation_loaded": False  # Track if validation status has been loaded
+                        "validation_status": validation_status,
+                        "validation_loaded": True  # Already loaded
                     })
 
-                log.info(f"Fast initial load: {len(items)} annotations out of {total_count} total for target annotator ID {target_annotator_obj.id}")
-
+                # --- Resume Logic: Find first unreviewed item (similar to phase 1 dashboard) ---
+                initial_idx = 0
+                if items:
+                    first_unreviewed_idx = -1
+                    for i, item_data in enumerate(items):
+                        if item_data["validation_status"] == "Not Reviewed":
+                            first_unreviewed_idx = i
+                            break
+                    
+                    if first_unreviewed_idx != -1:
+                        initial_idx = first_unreviewed_idx
+                        log.info(f"Resuming at first unreviewed item, index: {initial_idx} (ID: {items[initial_idx]['tts_id']})")
+                    else:  # All items are reviewed
+                        initial_idx = len(items) - 1
+                        log.info(f"All items reviewed, starting at last item, index: {initial_idx} (ID: {items[initial_idx]['tts_id']})")
+                else:  # No items assigned
+                    initial_idx = 0
+                    log.info("No items assigned to user, starting at index 0.") 
+                
                 # Set initial display
                 if items:
                     initial_item = items[initial_idx]
-                    review_info_text = f"🔍 **Phase 2 Review Mode** - Reviewing assigned annotations. Loaded {len(items)} of {total_count} total items. Resuming from ID: {initial_item['annotation_id']}"
-                    
+                    review_info_text = f"🔍 **Phase 2 Review Mode** - Reviewing assigned annotations. Loaded {len(items)} items."
                     # Ensure correct order of return values for 14 outputs
+                    # items, idx, review_info, tts_id, filename, sentence, ann_sentence, annotated_at, validation_status, annotator_placeholder, audio_update, rejection_reason_update, rejection_mode_reset, btn_reject_update
                     rejection_reason_val = ""
                     rejection_visible_val = False
                     if initial_item["validation_status"].startswith("Rejected"):
@@ -538,42 +399,27 @@ class ReviewDashboardPage:
                         gr.update(value=None, autoplay=False), # audio_update
                         gr.update(visible=rejection_visible_val, value=rejection_reason_val), # rejection_reason_input update
                         False,  # Reset rejection mode
-                        gr.update(value="❌ Reject"),  # Reset reject button
-                        get_current_item_position_info(items, initial_idx, session)  # Position info
+                        gr.update(value="❌ Reject")  # Reset reject button
                     )
                 else:
-                    # Ensure correct order and number of return values for empty items (15 outputs)
-                    return [], 0, f"🔍 **Phase 2 Review Mode** - No annotations found for review.", "", "", "", "", "", "", "", gr.update(value=None, autoplay=False), gr.update(visible=False, value=""), False, gr.update(value="❌ Reject"), ""
+                    # Ensure correct order and number of return values for empty items (14 outputs)
+                    return [], 0, f"🔍 **Phase 2 Review Mode** - No annotations found for review.", "", "", "", "", "", "", "", gr.update(value=None, autoplay=False), gr.update(visible=False, value=""), False, gr.update(value="❌ Reject")
+
+                # except Exception as e:
+                #     log.error(f"Error loading review items: {e}")
+                #     sentry_sdk.capture_exception(e)
+                #     gr.Error(f"Failed to load review data: {e}")
+                #     # Ensure correct order and number of return values for error case (14 outputs)
+                #     return [], 0, "", "", "", "", "", "", "", "", gr.update(value=None, autoplay=False), gr.update(visible=False, value=""), False, gr.update(value="❌ Reject")
 
         def show_current_review_item_fn(items, idx, session):
             if not items or idx >= len(items) or idx < 0:
-                # tts_id, filename, sentence, ann_sentence, annotated_at, validation_status, annotator_name_placeholder, audio_update, rejection_reason_update, rejection_mode_reset, btn_reject_update, position_info
-                return "", "", "", "", "", "", "", gr.update(value=None, autoplay=False), gr.update(visible=False, value=""), False, gr.update(value="❌ Reject"), ""
+                # tts_id, filename, sentence, ann_sentence, annotated_at, validation_status, annotator_name_placeholder, audio_update, rejection_reason_update, rejection_mode_reset, btn_reject_update
+                return "", "", "", "", "", "", "", gr.update(value=None, autoplay=False), gr.update(visible=False, value=""), False, gr.update(value="❌ Reject")
             
             current_item = items[idx]
             
-            # Load validation status on-demand if not already loaded
-            if not current_item.get("validation_loaded", False):
-                user_id = session.get("user_id")
-                if user_id:
-                    with get_db() as db:
-                        try:
-                            # Get the full annotation object for validation processing
-                            annotation_obj = db.query(Annotation).filter_by(id=current_item["annotation_id"]).first()
-                            if annotation_obj:
-                                validation_status, is_deleted = get_validation_status_for_item(db, current_item["annotation_id"], user_id, annotation_obj)
-                                current_item["validation_status"] = validation_status
-                                current_item["is_deleted"] = is_deleted
-                                current_item["validation_loaded"] = True
-                                
-                                # Update displayed annotation if deleted
-                                if is_deleted:
-                                    current_item["annotated_sentence"] = "[DELETED ANNOTATION]"
-                                
-                                log.info(f"Loaded validation status for item {idx}: {validation_status}")
-                        except Exception as e:
-                            log.error(f"Error loading validation status for item {idx}: {e}")
-                            current_item["validation_status"] = "Error loading status"
+            # Validation status is already loaded, no need for on-demand loading
             
             rejection_reason = ""
             rejection_visible = False
@@ -589,9 +435,6 @@ class ReviewDashboardPage:
                     rejection_reason = current_item["validation_status"][start_paren+1:end_paren]
                 rejection_visible = True
 
-            # Get position info
-            position_info = get_current_item_position_info(items, idx, session)
-
             return (
                 str(current_item["tts_id"]), 
                 current_item["filename"],
@@ -603,37 +446,25 @@ class ReviewDashboardPage:
                 gr.update(value=None, autoplay=False),
                 gr.update(visible=rejection_visible, value=rejection_reason),
                 False,  # Reset rejection mode
-                gr.update(value="❌ Reject"),  # Reset reject button text
-                position_info  # Position info
+                gr.update(value="❌ Reject")  # Reset reject button text
             )
 
         def update_review_info_fn(items, total_count):
-            """Update the review info banner with current loaded items count and position info"""
+            """Update the review info banner with current loaded items count"""
             if items:
-                current_item_id = items[0]["annotation_id"] if items else "N/A"
-                return f"🔍 **Phase 2 Review Mode** - Reviewing assigned annotations. Loaded {len(items)} of {total_count} total items. Starting from ID: {current_item_id}"
+                return f"🔍 **Phase 2 Review Mode** - Reviewing assigned annotations. Loaded {len(items)} items."
             else:
                 return f"🔍 **Phase 2 Review Mode** - No annotations found for review."
 
         def navigate_and_load_fn(items, current_idx, direction, session):
-            """Combined navigation and loading function"""
+            """Simple navigation function - all items are already loaded"""
             if not items:
                 return items, 0, ""
             
             # Navigate
             if direction == "next":
                 new_idx = min(current_idx + 1, len(items) - 1)
-                # Only load more items when user reaches the LAST item of a batch
-                should_load_more = (new_idx == len(items) - 1 and len(items) % 5 == 0)
-                if should_load_more:
-                    log.info(f"User reached end of loaded items ({new_idx}/{len(items)}), will load more items")
-                    # Load more items
-                    updated_items, total_count = load_more_items_fn(items, session, current_batch_size=10)
-                    # Update review info with new count
-                    review_info = update_review_info_fn(updated_items, total_count)
-                    return updated_items, new_idx, review_info
-                else:
-                    return items, new_idx, ""  # No review info update needed
+                return items, new_idx, ""  # No review info update needed
             else:  # prev
                 new_idx = max(current_idx - 1, 0)
                 return items, new_idx, ""  # No review info update needed
@@ -747,145 +578,7 @@ class ReviewDashboardPage:
             #     gr.Warning(f"Invalid Data ID format: {target_data_id}")
             return current_idx
 
-        def load_more_items_fn(items, session, current_batch_size=10):
-            """Load more items when user needs them (pagination support)"""
-            user_id = session.get("user_id")
-            username = session.get("username")
-            
-            if not user_id or not username:
-                return items, 0  # Return existing items if no user session
-                
-            # Find target annotator
-            target_annotator = None
-            for annotator_name, reviewer_name in conf.REVIEW_MAPPING.items():
-                if reviewer_name == username:
-                    target_annotator = annotator_name
-                    break
-                    
-            if not target_annotator:
-                return items, 0
-                
-            with get_db() as db:
-                target_annotator_obj = db.query(Annotator).filter_by(name=target_annotator).first()
-                if not target_annotator_obj:
-                    return items, 0
-                    
-                # Get total count for updated review info
-                total_count = db.query(Annotation).filter(
-                    Annotation.annotator_id == target_annotator_obj.id
-                ).count()
-                    
-                # Load next batch starting from where we left off
-                if items:
-                    # Get the last loaded annotation ID to continue from there
-                    last_loaded_id = items[-1]["annotation_id"]
-                    
-                    # Load next batch starting after the last loaded item
-                    query = db.query(
-                        Annotation,
-                        TTSData.filename,
-                        TTSData.sentence
-                    ).join(
-                        TTSData, Annotation.tts_data_id == TTSData.id
-                    ).filter(
-                        Annotation.annotator_id == target_annotator_obj.id,
-                        Annotation.id > last_loaded_id  # Continue from where we left off
-                    ).order_by(Annotation.id).limit(current_batch_size)
-                else:
-                    # No items loaded yet, start from the beginning
-                    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).limit(current_batch_size)
-                
-                results = query.all()
-                
-                # Process new items with minimal data - validation status loaded on-demand
-                new_items = []
-                for annotation, filename, sentence in results:
-                    # Check if annotation is deleted (minimal processing)
-                    is_deleted = not annotation.annotated_sentence or annotation.annotated_sentence.strip() == ""
-                    annotated_sentence_display = "[DELETED ANNOTATION]" if is_deleted else annotation.annotated_sentence
-                    
-                    new_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...",  # Will be loaded on-demand
-                        "validation_loaded": False  # Track if validation status has been loaded
-                    })
-                
-                # Combine with existing items
-                all_items = items + new_items
-                log.info(f"Loaded {len(new_items)} more items, total now: {len(all_items)}")
-                return all_items, total_count
-
-        def _jump_to_next_unreviewed_fn(items, session):
-            """Helper function to jump to the next unreviewed item in the review queue."""
-            user_id = session.get("user_id")
-            username = session.get("username")
-            if not user_id or not username:
-                gr.Error("User not logged in")
-                return items, 0, ""
-
-            # Find target annotator
-            target_annotator = None
-            for annotator_name, reviewer_name in conf.REVIEW_MAPPING.items():
-                if reviewer_name == username:
-                    target_annotator = annotator_name
-                    break
-
-            if not target_annotator:
-                gr.Error("User is not assigned as a reviewer")
-                return items, 0, ""
-
-            with get_db() as db:
-                try:
-                    # Get target annotator's ID
-                    target_annotator_obj = db.query(Annotator).filter_by(name=target_annotator).first()
-                    if not target_annotator_obj:
-                        return items, 0, f"⚠️ **Error:** Annotator '{target_annotator}' not found"
 
-                    # Find the first unreviewed annotation for this reviewer
-                    first_unreviewed_query = db.query(Annotation.id).outerjoin(
-                        Validation, 
-                        (Annotation.id == Validation.annotation_id) & 
-                        (Validation.validator_id == user_id)
-                    ).filter(
-                        Annotation.annotator_id == target_annotator_obj.id,
-                        Validation.id.is_(None)  # No validation record exists for this reviewer
-                    ).order_by(Annotation.id).limit(1)
-
-                    first_unreviewed_result = first_unreviewed_query.first()
-
-                    if first_unreviewed_result:
-                        target_id = first_unreviewed_result.id
-                        log.info(f"Jumping to next unreviewed item with ID: {target_id}")
-                        
-                        # Find this item in the current loaded items
-                        for i, item in enumerate(items):
-                            if item["annotation_id"] == target_id:
-                                return items, i, f"🎯 **Jumped to unreviewed item ID: {target_id}**"
-                        
-                        # If not found in current items, we need to load more items
-                        # For now, just show a message
-                        return items, 0, f"🎯 **Next unreviewed item ID: {target_id}** - Use navigation to reach it"
-                    else:
-                        log.info(f"No unreviewed items found for user {user_id}. Review queue is empty.")
-                        return items, 0, "🎉 **Phase 2 Review Mode** - All annotations for your assigned annotators have been reviewed! Your review queue is empty."
-                except Exception as e:
-                    log.error(f"Error jumping to next unreviewed item: {e}")
-                    sentry_sdk.capture_exception(e)
-                    return items, 0, f"⚠️ **Error:** Could not find next unreviewed item. Error: {e}"
 
         # Output definitions
         review_display_outputs = [
@@ -896,8 +589,7 @@ class ReviewDashboardPage:
             self.audio,
             self.rejection_reason_input, # Added rejection reason input to display outputs
             self.rejection_mode_active,  # Added rejection mode state
-            self.btn_reject,  # Added reject button to display outputs
-            self.position_info  # Added position info to display outputs
+            self.btn_reject  # Added reject button to display outputs
         ]
 
         # Trigger data loading when load_trigger changes (after successful login for a reviewer)
@@ -1049,28 +741,6 @@ class ReviewDashboardPage:
             outputs=self.jump_data_id_input
         )
 
-        # Jump to Unreviewed button
-        self.btn_jump_to_unreviewed.click(
-            fn=lambda: update_ui_interactive_state(False),
-            outputs=self.interactive_ui_elements
-        ).then(
-            fn=lambda items, session: _jump_to_next_unreviewed_fn(items, session),
-            inputs=[self.items_state, session_state],
-            outputs=[self.items_state, self.idx_state, self.review_info]
-        ).then(
-            fn=show_current_review_item_fn,
-            inputs=[self.items_state, self.idx_state, session_state],
-            outputs=review_display_outputs
-        ).then(
-            # Auto-load audio with autoplay after jumping
-            fn=download_voice_fn,
-            inputs=[self.filename],
-            outputs=[self.audio, self.original_audio_state, self.audio]
-        ).then(
-            fn=lambda: update_ui_interactive_state(True),
-            outputs=self.interactive_ui_elements
-        )
-
         # Load audio button
         self.btn_load_voice.click(
             fn=lambda: update_ui_interactive_state(False),