progress tracking

components/review_dashboard_page.py

@@ -12,6 +12,11 @@ from config import conf
 from utils.database import get_db
 from data.models import Annotation, TTSData, Annotator, Validation
 from data.repository.annotator_workload_repo import AnnotatorWorkloadRepo
+from utils.user_progress import (
+    get_next_unreviewed_annotation, 
+    update_user_progress, 
+    get_annotations_from_position
+)
 
 log = Logger()
 LOADER = CloudServerAudioLoader(conf.FTP_URL)
@@ -302,7 +307,7 @@ class ReviewDashboardPage:
                 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")
 
-            # Load annotations from target annotator with FAST INITIAL LOADING
+            # Load annotations with PROGRESS TRACKING
             with get_db() as db:
                 # Get target annotator's ID
                 target_annotator_obj = db.query(Annotator).filter_by(name=target_annotator).first()
@@ -312,33 +317,28 @@ class ReviewDashboardPage:
                 
                 log.info(f"Found target annotator with ID: {target_annotator_obj.id}")
 
-                # FAST INITIAL QUERY: Load only essential data without complex validation processing
-                # Reduced batch size for instant loading in HuggingFace spaces
-                INITIAL_BATCH_SIZE = 5  # Load only 5 items initially for instant response
+                # 🎯 PROGRESS TRACKING: Find next unreviewed annotation position
+                next_annotation_id, next_position = get_next_unreviewed_annotation(db, user_id, target_annotator_obj.id)
                 
-                # Simple query to get basic annotation data quickly
-                initial_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(INITIAL_BATCH_SIZE)
-
-                initial_results = initial_query.all()
+                # Load batch size for responsive loading
+                INITIAL_BATCH_SIZE = 10  # Increased from 5 to 10 for better UX
+                
+                # Load annotations starting from the next unreviewed position
+                annotations_data = get_annotations_from_position(db, target_annotator_obj.id, next_position, INITIAL_BATCH_SIZE)
                 
                 # Get total count for progress info (this is fast)
                 total_count = db.query(Annotation).filter(
                     Annotation.annotator_id == target_annotator_obj.id
                 ).count()
 
-                log.info(f"Fast initial load: {len(initial_results)} annotations out of {total_count} total for target annotator ID {target_annotator_obj.id}")
+                log.info(f"Progress-aware load: Starting from position {next_position}, loaded {len(annotations_data)} annotations out of {total_count} total for target annotator ID {target_annotator_obj.id}")
 
                 # Process items with minimal data - validation status will be loaded on-demand
                 items = []
-                for annotation, filename, sentence in initial_results:
+                for annotation in annotations_data:
+                    # Get TTS data
+                    tts_data = annotation.tts_data
+                    
                     # 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
@@ -346,8 +346,8 @@ class ReviewDashboardPage:
                     items.append({
                         "annotation_id": annotation.id,
                         "tts_id": annotation.tts_data_id,
-                        "filename": filename,
-                        "sentence": sentence,
+                        "filename": tts_data.filename,
+                        "sentence": tts_data.sentence,
                         "annotated_sentence": annotated_sentence_display,
                         "is_deleted": is_deleted,
                         "annotated_at": annotation.annotated_at.isoformat() if annotation.annotated_at else "",
@@ -355,36 +355,28 @@ class ReviewDashboardPage:
                         "validation_loaded": False  # Track if validation status has been loaded
                     })
 
-                # Find the first item that is not reviewed (prioritize non-deleted annotations)
+                # 🎯 PROGRESS TRACKING: Start from first item (index 0) since we loaded from the correct position
                 initial_idx = 0
-                if items:
-                    found_unreviewed = False
-                    # First, try to find unreviewed non-deleted annotations
-                    for i, item_data in enumerate(items):
-                        if (item_data["validation_status"] == "Not Reviewed" and 
-                            not item_data.get("is_deleted", False)):
-                            initial_idx = i
-                            found_unreviewed = True
-                            break
-                    
-                    # If no unreviewed non-deleted items, look for any unreviewed items
-                    if not found_unreviewed:
-                        for i, item_data in enumerate(items):
-                            if item_data["validation_status"].startswith("Not Reviewed"):
-                                initial_idx = i
-                                found_unreviewed = True
-                                break
-                    
-                    # If no unreviewed items at all, use the last item
-                    if not found_unreviewed:
-                        initial_idx = len(items) - 1 if items else 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."
-                    # Ensure correct order of return values for 12 outputs
-                    # items, idx, review_info, tts_id, filename, sentence, ann_sentence, annotated_at, validation_status, annotator_placeholder, audio_update, rejection_reason_update
+                    review_info_text = f"🔍 **Phase 2 Review Mode** - Continuing from position {next_position + 1}/{total_count}. Loaded {len(items)} items."
+                    
+                    # Load validation status for the first item immediately
+                    try:
+                        annotation_obj = db.query(Annotation).filter_by(id=initial_item["annotation_id"]).first()
+                        if annotation_obj:
+                            validation_status, is_deleted = get_validation_status_for_item(db, initial_item["annotation_id"], user_id, annotation_obj)
+                            initial_item["validation_status"] = validation_status
+                            initial_item["is_deleted"] = is_deleted
+                            initial_item["validation_loaded"] = True
+                            
+                            if is_deleted:
+                                initial_item["annotated_sentence"] = "[DELETED ANNOTATION]"
+                    except Exception as e:
+                        log.warning(f"Failed to load initial validation status: {e}")
+                    
                     rejection_reason_val = ""
                     rejection_visible_val = False
                     if initial_item["validation_status"].startswith("Rejected"):
@@ -394,6 +386,8 @@ class ReviewDashboardPage:
                             rejection_reason_val = initial_item["validation_status"][start_paren+1:end_paren]
                         rejection_visible_val = True
                     
+                    log.info(f"🎯 User {username} resuming review from position {next_position}, annotation ID {initial_item['annotation_id']}")
+                    
                     return (
                         items, 
                         initial_idx, 
@@ -411,15 +405,9 @@ class ReviewDashboardPage:
                         gr.update(value="❌ Reject")  # Reset reject button
                     )
                 else:
-                    # 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")
+                    # All items have been reviewed
+                    review_info_text = f"🎉 **Review Complete!** - All {total_count} annotations have been reviewed for {target_annotator}."
+                    return [], 0, review_info_text, "", "", "", "", "", "", "", 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:
@@ -549,6 +537,33 @@ class ReviewDashboardPage:
                 db.commit()
                 log.info(f"Validation saved successfully for annotation_id: {annotation_id}")
                 
+                # 🎯 UPDATE USER PROGRESS TRACKING
+                try:
+                    username = session.get("username")
+                    if username:
+                        # Find target annotator for this user
+                        target_annotator = None
+                        for annotator_name, reviewer_name in conf.REVIEW_MAPPING.items():
+                            if reviewer_name == username:
+                                target_annotator = annotator_name
+                                break
+                        
+                        if target_annotator:
+                            target_annotator_obj = db.query(Annotator).filter_by(name=target_annotator).first()
+                            if target_annotator_obj:
+                                # Calculate the current position in the review list
+                                current_position = db.query(Annotation).filter(
+                                    Annotation.annotator_id == target_annotator_obj.id,
+                                    Annotation.id <= annotation_id
+                                ).count() - 1  # Convert to 0-based index
+                                
+                                # Update user progress
+                                update_user_progress(db, user_id, target_annotator_obj.id, annotation_id, current_position)
+                                log.info(f"🎯 Updated progress for user {user_id}: annotation {annotation_id} at position {current_position}")
+                except Exception as e:
+                    log.warning(f"Failed to update user progress: {e}")
+                    # Don't fail the validation save if progress tracking fails
+                
                 items[idx]["validation_status"] = "Approved" if approved else f"Rejected ({rejection_reason})" if rejection_reason else "Rejected"
                 
                 # Show rejection reason input only if rejected, otherwise hide and clear

data/models.py

@@ -158,4 +158,23 @@ class Validation(Base):
     validated_at = Column(DateTime, nullable=False)
 
     annotation = relationship("Annotation")
-    validator = relationship("Annotator", foreign_keys=[validator_id])  # Fixed: should reference Annotator
+    validator = relationship("Annotator", foreign_keys=[validator_id])  # Fixed: should reference Annotator
+
+
+# --------------------------------------------------------------------------- #
+#                                UserProgress                                 #
+# --------------------------------------------------------------------------- #
+class UserProgress(Base):
+    __tablename__ = "user_progress"
+
+    id = Column(Integer, primary_key=True)
+    user_id = Column(Integer, ForeignKey("annotators.id"), nullable=False)
+    target_annotator_id = Column(Integer, ForeignKey("annotators.id"), nullable=False)
+    last_reviewed_annotation_id = Column(Integer, ForeignKey("annotations.id"), nullable=True)
+    last_position = Column(Integer, default=0)  # Position in the review list
+    updated_at = Column(DateTime, nullable=False)
+    
+    # Relationships
+    user = relationship("Annotator", foreign_keys=[user_id])
+    target_annotator = relationship("Annotator", foreign_keys=[target_annotator_id])
+    last_reviewed_annotation = relationship("Annotation", foreign_keys=[last_reviewed_annotation_id])