Update app.py

app.py

@@ -440,46 +440,6 @@ def create_reranking_interface(task_data):
             
             return status, progress
         
-        def load_sample(sample_id):
-            """Load a specific sample into the interface."""
-            sample = next((s for s in samples if s["id"] == sample_id), None)
-            if not sample:
-                return [query_text.value] + [d.value for d in doc_containers] + [""] * len(ranking_inputs) + [""] * len(validation_indicators) + [sample_id, progress_text.value, status_box.value]
-            
-            # Update query
-            new_query = sample["query"]
-            
-            # Update documents
-            new_docs = []
-            for i, doc in enumerate(sample["candidates"]):
-                if i < len(doc_containers):
-                    new_docs.append(doc)
-                    
-            # Initialize rankings
-            new_rankings = [""] * len(ranking_inputs)
-            
-            # Check if this sample has already been annotated
-            existing_annotation = next((a for a in results["annotations"] if a["sample_id"] == sample_id), None)
-            if existing_annotation:
-                # Restore previous rankings
-                for i, rank in enumerate(existing_annotation["rankings"]):
-                    if i < len(new_rankings) and rank is not None:
-                        new_rankings[i] = str(rank)
-            
-            # Update progress
-            current_idx = samples.index(sample)
-            new_progress = f"Progress: {sum(completed_samples.values())}/{len(samples)}"
-            
-            new_status = f"Viewing query {current_idx + 1} of {len(samples)}"
-            if completed_samples[sample_id]:
-                new_status += " (already completed)"
-            
-            # Initialize validation indicators
-            validation_results = validate_rankings(*new_rankings)
-            validation_indicators_values = validation_results[:-1]  # Remove validity flag
-            
-            return [new_query] + new_docs + new_rankings + validation_indicators_values + [sample_id, new_progress, new_status]
-        
         def auto_save_and_navigate(direction, current_id, auto_save, *rankings):
             """Save rankings if auto-save is enabled, then navigate."""
             # Extract rankings (remove validation indicators)
@@ -539,113 +499,143 @@ def create_reranking_interface(task_data):
             except Exception as e:
                 return f"Error saving results: {str(e)}"
         
-        # Define optimized functions for the quick ranking buttons
+        # Optimize the navigation functions to reduce unnecessary updates
+        def handle_next(current_id, auto_save, *rankings):
+            """Optimized handler for next query navigation."""
+            # First, handle auto-save (only if needed)
+            new_id, status, progress = auto_save_and_navigate("next", current_id, auto_save, *rankings)
+            
+            # Return the new sample ID for a more efficient update
+            # The load_sample function will handle all UI updates in one batch
+            return new_id
+        
+        def handle_prev(current_id, auto_save, *rankings):
+            """Optimized handler for previous query navigation."""
+            # First, handle auto-save (only if needed)
+            new_id, status, progress = auto_save_and_navigate("prev", current_id, auto_save, *rankings)
+            
+            # Return the new sample ID for a more efficient update
+            # The load_sample function will handle all UI updates in one batch
+            return new_id
+        
+        # Optimize the load_sample function to handle all UI updates efficiently
+        def load_sample(sample_id):
+            """Load a specific sample into the interface."""
+            # Clear all validation indicators first for a cleaner transition
+            blank_validations = [""] * len(validation_indicators)
+            
+            # Find the sample data
+            sample = next((s for s in samples if s["id"] == sample_id), None)
+            if not sample:
+                return [query_text.value] + [d.value for d in doc_containers] + [""] * len(ranking_inputs) + blank_validations + [sample_id, progress_text.value, status_box.value]
+            
+            # Update query
+            new_query = sample["query"]
+            
+            # Update documents
+            new_docs = []
+            for i, doc in enumerate(sample["candidates"]):
+                if i < len(doc_containers):
+                    new_docs.append(doc)
+                    
+            # Initialize rankings
+            new_rankings = [""] * len(ranking_inputs)
+            
+            # Check if this sample has already been annotated
+            existing_annotation = next((a for a in results["annotations"] if a["sample_id"] == sample_id), None)
+            if existing_annotation:
+                # Restore previous rankings
+                for i, rank in enumerate(existing_annotation["rankings"]):
+                    if i < len(new_rankings) and rank is not None:
+                        new_rankings[i] = str(rank)
+            
+            # Update progress
+            current_idx = samples.index(sample)
+            new_progress = f"Progress: {sum(completed_samples.values())}/{len(samples)}"
+            
+            new_status = f"Viewing query {current_idx + 1} of {len(samples)}"
+            if completed_samples[sample_id]:
+                new_status += " (already completed)"
+            
+            # Initialize validation indicators (but don't run validation until needed)
+            # This improves load time
+            
+            return [new_query] + new_docs + new_rankings + blank_validations + [sample_id, new_progress, new_status]
+            
+        # Optimize the quick ranking functions for better performance
         def assign_sequential_ranks():
             """Assign sequential rankings (1,2,3...) to all documents."""
             sequential_ranks = [str(i+1) for i in range(len(samples[0]["candidates"]))]
-            # Return ranks plus a success message
-            return sequential_ranks + ["✅ Applied sequential ranking"]
+            # Return ranks only - validation will be done separately for better performance
+            return sequential_ranks
         
         def assign_reverse_ranks():
             """Assign reverse rankings (n,n-1...) to all documents."""
             n = len(samples[0]["candidates"])
             reverse_ranks = [str(n-i) for i in range(n)]
-            # Return ranks plus a success message
-            return reverse_ranks + ["✅ Applied reverse ranking"]
+            # Return ranks only - validation will be done separately for better performance
+            return reverse_ranks
         
         def clear_rankings():
             """Clear all rankings."""
             empty_ranks = [""] * len(samples[0]["candidates"])
-            # Return empty ranks plus a success message
-            return empty_ranks + ["✅ Cleared all rankings"]
-            
-        # Connect quick ranking buttons - add status message output
+            # Return empty ranks only - validation will be done separately for better performance
+            return empty_ranks
+        
+        # Add a function to update status after quick ranking operations
+        def update_status_after_ranking(operation_name):
+            """Update status box after a ranking operation."""
+            return f"✅ {operation_name} applied successfully"
+        
+        # Connect quick ranking buttons with more efficient handling
         sequential_btn.click(
             fn=assign_sequential_ranks,
             inputs=None,
-            outputs=ranking_inputs + [status_box]
+            outputs=ranking_inputs
+        ).then(
+            fn=lambda: update_status_after_ranking("Sequential ranking"),
+            inputs=None,
+            outputs=[status_box]
         )
         
         reverse_btn.click(
             fn=assign_reverse_ranks,
             inputs=None,
-            outputs=ranking_inputs + [status_box]
+            outputs=ranking_inputs
+        ).then(
+            fn=lambda: update_status_after_ranking("Reverse ranking"),
+            inputs=None,
+            outputs=[status_box]
         )
         
         clear_btn.click(
             fn=clear_rankings,
             inputs=None,
-            outputs=ranking_inputs + [status_box]
-        )
-        
-        # Optimize validation - reduce redundant validations
-        # Instead of connecting validation to each ranking input change,
-        # add a "Validate Rankings" button that runs validation on demand
-        
-        with gr.Row():
-            validate_btn = gr.Button("Validate Rankings", variant="secondary")
-        
-        # Connect validate button to the right function
-        validate_btn.click(
-            fn=lambda *rankings: validate_rankings(*rankings)[:-1] + ["Validation complete"],
-            inputs=ranking_inputs,
-            outputs=validation_indicators + [status_box]
-        )
-        
-        # Add a simpler validation for individual inputs that doesn't cascade to all inputs
-        def validate_single_input(rank, index):
-            """Lightweight validation for a single input."""
-            if rank is None or rank == "":
-                return '<span style="color: #dc3545;">⚠️</span>'
-            else:
-                return f'<span style="color: #28a745;">✓ {rank}</span>'
-        
-        # Connect simpler validation to each input
-        for i, ranking in enumerate(ranking_inputs):
-            ranking.change(
-                fn=lambda r, idx=i: validate_single_input(r, idx),
-                inputs=[ranking],
-                outputs=[validation_indicators[i]]
-            )
-        
-        # Wire up events (Gradio 3.x syntax)
-        submit_btn.click(
-            fn=submit_rankings,
-            inputs=ranking_inputs + [current_sample_id],
-            outputs=[status_box, progress_text]
+            outputs=ranking_inputs
+        ).then(
+            fn=lambda: update_status_after_ranking("Rankings cleared"),
+            inputs=None,
+            outputs=[status_box]
         )
         
-        # Auto-save and navigate events
-        def handle_next(current_id, auto_save, *rankings):
-            # First, handle auto-save
-            new_id, status, progress = auto_save_and_navigate("next", current_id, auto_save, *rankings)
-            # Then, load the new sample
-            outputs = load_sample(new_id)
-            # Add the status and progress
-            outputs[-2] = progress if status else outputs[-2]
-            outputs[-1] = status if status else outputs[-1]
-            return outputs
-        
-        def handle_prev(current_id, auto_save, *rankings):
-            # First, handle auto-save
-            new_id, status, progress = auto_save_and_navigate("prev", current_id, auto_save, *rankings)
-            # Then, load the new sample
-            outputs = load_sample(new_id)
-            # Add the status and progress
-            outputs[-2] = progress if status else outputs[-2]
-            outputs[-1] = status if status else outputs[-1]
-            return outputs
-        
-        # Connect navigation with Gradio 3.x syntax
+        # Connect navigation with more efficient data handling
         next_btn.click(
             fn=handle_next,
             inputs=[current_sample_id, auto_save_toggle] + ranking_inputs,
+            outputs=[current_sample_id]  # Only update the sample ID
+        ).then(
+            fn=load_sample,  # Then load the sample with all UI updates in one batch
+            inputs=[current_sample_id],
             outputs=[query_text] + doc_containers + ranking_inputs + validation_indicators + [current_sample_id, progress_text, status_box]
         )
         
         prev_btn.click(
             fn=handle_prev,
             inputs=[current_sample_id, auto_save_toggle] + ranking_inputs,
+            outputs=[current_sample_id]  # Only update the sample ID
+        ).then(
+            fn=load_sample,  # Then load the sample with all UI updates in one batch
+            inputs=[current_sample_id],
             outputs=[query_text] + doc_containers + ranking_inputs + validation_indicators + [current_sample_id, progress_text, status_box]
         )