Update app.py

app.py

@@ -9,21 +9,20 @@ def create_reranking_interface(task_data):
     results = {"task_name": task_data["task_name"], "task_type": "reranking", "annotations": []}
     completed_samples = {s["id"]: False for s in samples}
     
-    # Track the current ordering of documents
-    current_document_order = gr.State([])
+    # Store the current document order for the active sample
+    current_order = []
     
-    def save_ranking(sample_id, doc_order):
+    def save_ranking(sample_id):
         """Save the current document ordering as rankings."""
         try:
-            if not doc_order:
+            if not current_order:
                 return "⚠️ No document ordering found", f"Progress: {sum(completed_samples.values())}/{len(samples)}"
             
-            # Convert document positions to rankings
-            # The first document (position 0) gets rank 1, etc.
+            # Convert document positions to rankings (position in list -> document's rank)
+            # First document (position 0) gets rank 1, etc.
             rankings = []
-            for i in range(len(doc_order)):
-                doc_idx = doc_order.index(i)
-                rankings.append(doc_idx + 1)  # Convert to 1-based ranks
+            for i, doc_idx in enumerate(current_order):
+                rankings.append(i + 1)  # Convert to 1-based ranks
             
             # Store this annotation in memory
             existing_idx = next((i for i, a in enumerate(results["annotations"]) if a["sample_id"] == sample_id), None)
@@ -53,159 +52,19 @@ def create_reranking_interface(task_data):
             # Return specific error message
             return f"Error: {str(e)}", f"Progress: {sum(completed_samples.values())}/{len(samples)}"
     
-    def initialize_documents(sample_id):
-        """Initialize the document order and content for a sample."""
-        sample = next((s for s in samples if s["id"] == sample_id), None)
-        if not sample:
-            return [], "", "Query not found", f"Progress: {sum(completed_samples.values())}/{len(samples)}"
-        
-        # Get the documents for this sample
-        docs = sample["candidates"]
-        
-        # Initialize the document order (0, 1, 2, ..., n-1)
-        doc_order = list(range(len(docs)))
-        
-        # Check if this sample has already been annotated to restore ordering
-        existing_annotation = next((a for a in results["annotations"] if a["sample_id"] == sample_id), None)
-        if existing_annotation and "rankings" in existing_annotation:
-            # Convert rankings back to positions
-            # If document 0 has rank 3, it should be in position 2
-            sorted_positions = []
-            for i in range(len(existing_annotation["rankings"])):
-                rank = existing_annotation["rankings"][i]
-                sorted_positions.append((i, rank))
-            
-            # Sort by rank (ascending)
-            sorted_positions.sort(key=lambda x: x[1])
-            
-            # Extract the original indices in their ranked order
-            doc_order = [pos[0] for pos in sorted_positions]
-        
-        # Current sample query
-        query = sample["query"]
-        
-        # Status message
-        status = f"Viewing query {samples.index(sample) + 1} of {len(samples)}"
-        if completed_samples[sample_id]:
-            status += " (already completed)"
-        
-        return doc_order, query, status, f"Progress: {sum(completed_samples.values())}/{len(samples)}"
-    
-    def move_document(doc_order, doc_idx, direction):
-        """Move a document up or down in the order."""
-        if not doc_order:
-            return doc_order
-        
-        # Create a copy of the order to avoid reference issues
-        new_order = doc_order.copy()
-        
-        # Find the current position of the document in the order
-        current_pos = new_order.index(doc_idx)
-        
-        # Calculate the new position
-        if direction == "up" and current_pos > 0:
+    def move_document_up(idx):
+        nonlocal current_order
+        if idx > 0:
             # Swap with the document above
-            new_order[current_pos], new_order[current_pos - 1] = new_order[current_pos - 1], new_order[current_pos]
-        elif direction == "down" and current_pos < len(new_order) - 1:
-            # Swap with the document below
-            new_order[current_pos], new_order[current_pos + 1] = new_order[current_pos + 1], new_order[current_pos]
-        
-        return new_order
+            current_order[idx], current_order[idx-1] = current_order[idx-1], current_order[idx]
+        return gr.update(value=f"Moved document up: {idx}")
     
-    def render_documents(doc_order, sample_id):
-        """Render the documents in the specified order."""
-        sample = next((s for s in samples if s["id"] == sample_id), None)
-        if not sample or not doc_order:
-            return gr.HTML.update(value="<p>No documents to display</p>")
-        
-        docs = sample["candidates"]
-        
-        # Build HTML for the document list
-        html = "<div class='document-list'>"
-        
-        for pos, doc_idx in enumerate(doc_order):
-            if doc_idx < len(docs):
-                doc_text = docs[doc_idx]
-                
-                # Calculate the rank (position + 1)
-                rank = pos + 1
-                
-                # Create a container for each document with buttons and rank
-                html += f"""
-                <div class='document-item' id='doc-{doc_idx}'>
-                    <div class='document-controls'>
-                        <div class='rank-display'>Rank: {rank}</div>
-                        <button class='move-up-btn' onclick='moveDocument({doc_idx}, "up")'>↑ Move Up</button>
-                        <button class='move-down-btn' onclick='moveDocument({doc_idx}, "down")'>↓ Move Down</button>
-                    </div>
-                    <div class='document-content'>
-                        <p><strong>Document {doc_idx + 1}:</strong> {doc_text}</p>
-                    </div>
-                </div>
-                """
-        
-        html += "</div>"
-        
-        # Add custom CSS
-        html += """
-        <style>
-        .document-list {
-            display: flex;
-            flex-direction: column;
-            gap: 10px;
-        }
-        .document-item {
-            border: 1px solid #ddd;
-            border-radius: 8px;
-            padding: 15px;
-            background-color: #f9f9f9;
-            display: flex;
-            flex-direction: column;
-        }
-        .document-controls {
-            display: flex;
-            align-items: center;
-            gap: 10px;
-            margin-bottom: 10px;
-        }
-        .rank-display {
-            font-weight: bold;
-            min-width: 80px;
-        }
-        .document-content {
-            padding: 5px;
-            background-color: white;
-            border-radius: 4px;
-        }
-        button {
-            padding: 5px 10px;
-            border-radius: 4px;
-            border: 1px solid #ccc;
-            cursor: pointer;
-        }
-        .move-up-btn {
-            background-color: #e0f7fa;
-        }
-        .move-down-btn {
-            background-color: #fff3e0;
-        }
-        </style>
-        """
-        
-        # Add JavaScript to handle button clicks
-        html += """
-        <script>
-        function moveDocument(docIdx, direction) {
-            // Call the Python function via Gradio's API
-            const event = new CustomEvent('move-document', {
-                detail: { docIdx: docIdx, direction: direction }
-            });
-            document.dispatchEvent(event);
-        }
-        </script>
-        """
-        
-        return gr.HTML.update(value=html)
+    def move_document_down(idx):
+        nonlocal current_order
+        if idx < len(current_order) - 1:
+            # Swap with the document below
+            current_order[idx], current_order[idx+1] = current_order[idx+1], current_order[idx]
+        return gr.update(value=f"Moved document down: {idx}")
     
     with gr.Blocks(theme=gr.themes.Soft()) as demo:
         gr.Markdown(f"# {task_data['task_name']} - Human Reranking Evaluation")
@@ -238,15 +97,76 @@ def create_reranking_interface(task_data):
             
             gr.Markdown("## Documents (Arrange in order of relevance, most relevant at top):")
             
-            # Container to display documents in their current order
-            document_list = gr.HTML()
+            # Create simple document list with move up/down buttons
+            document_containers = []
             
-            # For Gradio's event handling, we need actual buttons
-            # These are invisible and triggered by JavaScript
-            with gr.Row(visible=False):
-                up_btn = gr.Button("Up")
-                down_btn = gr.Button("Down")
-                doc_index = gr.Number(0, label="Document Index")
+            # Function to initialize the document list for a sample
+            def initialize_document_list(sample_id):
+                nonlocal current_order
+                
+                sample = next((s for s in samples if s["id"] == sample_id), None)
+                if not sample:
+                    return "Query not found", f"Progress: {sum(completed_samples.values())}/{len(samples)}"
+                
+                # Get the documents for this sample
+                docs = sample["candidates"]
+                
+                # Initialize document order (0, 1, 2, ..., n-1)
+                current_order = list(range(len(docs)))
+                
+                # Check if this sample has already been annotated to restore ordering
+                existing_annotation = next((a for a in results["annotations"] if a["sample_id"] == sample_id), None)
+                if existing_annotation and "rankings" in existing_annotation:
+                    # Sort documents based on previous rankings
+                    # This is a simplified version that just keeps the original order for now
+                    pass
+                
+                # Update UI
+                for i, doc_idx in enumerate(current_order):
+                    if i < len(document_containers) and doc_idx < len(docs):
+                        document_containers[i].value = f"Document {doc_idx+1} (Rank: {i+1}): {docs[doc_idx]}"
+                
+                # Status message
+                status = f"Viewing query {samples.index(sample) + 1} of {len(samples)}"
+                if completed_samples[sample_id]:
+                    status += " (already completed)"
+                
+                return status, f"Progress: {sum(completed_samples.values())}/{len(samples)}"
+            
+            # Create document display containers with up/down buttons
+            with gr.Column():
+                for i in range(10):  # Assuming max 10 documents per sample
+                    with gr.Group():
+                        with gr.Row():
+                            doc_text = gr.Textbox(label=f"Document {i+1}", interactive=False)
+                            document_containers.append(doc_text)
+                        
+                        with gr.Row():
+                            up_btn = gr.Button(f"⬆️ Move Up", size="sm")
+                            down_btn = gr.Button(f"⬇️ Move Down", size="sm")
+                        
+                        # Connect the up/down buttons
+                        up_btn.click(
+                            lambda idx=i: move_document_up(idx),
+                            inputs=[],
+                            outputs=[status_box]
+                        ).then(
+                            lambda: [gr.update(value=f"Document {current_order[j]+1} (Rank: {j+1}): {samples[0]['candidates'][current_order[j]]}") 
+                                    for j in range(len(current_order))],
+                            inputs=[],
+                            outputs=document_containers[:len(current_order)]
+                        )
+                        
+                        down_btn.click(
+                            lambda idx=i: move_document_down(idx),
+                            inputs=[],
+                            outputs=[status_box]
+                        ).then(
+                            lambda: [gr.update(value=f"Document {current_order[j]+1} (Rank: {j+1}): {samples[0]['candidates'][current_order[j]]}") 
+                                    for j in range(len(current_order))],
+                            inputs=[],
+                            outputs=document_containers[:len(current_order)]
+                        )
             
             with gr.Row():
                 prev_btn = gr.Button("← Previous Query", size="sm")
@@ -255,82 +175,67 @@ def create_reranking_interface(task_data):
             
             save_btn = gr.Button("💾 Save All Results", variant="secondary")
         
-        # Initialize the document order for the first sample
-        doc_order, query_val, status_val, progress_val = initialize_documents(samples[0]["id"])
-        current_document_order.value = doc_order
-        query_text.value = query_val
+        # Initialize the document list for the first sample
+        status_val, progress_val = initialize_document_list(samples[0]["id"])
         status_box.value = status_val
         progress_text.value = progress_val
         
-        # Render the documents in their initial order
-        document_list.value = render_documents(doc_order, samples[0]["id"]).value
-        
-        # Connect events for up/down buttons (these are triggered by JavaScript)
-        def doc_move_handler(doc_idx, direction, current_order, sample_id):
-            new_order = move_document(current_order, doc_idx, direction)
-            html_update = render_documents(new_order, sample_id)
-            return new_order, html_update
-        
-        up_btn.click(
-            doc_move_handler,
-            inputs=[doc_index, gr.Textbox(value="up"), current_document_order, current_sample_id],
-            outputs=[current_document_order, document_list]
-        )
-        
-        down_btn.click(
-            doc_move_handler,
-            inputs=[doc_index, gr.Textbox(value="down"), current_document_order, current_sample_id],
-            outputs=[current_document_order, document_list]
-        )
-        
-        # Load a sample and update the interface
-        def load_sample(sample_id):
-            doc_order, query_val, status_val, progress_val = initialize_documents(sample_id)
-            html_update = render_documents(doc_order, sample_id)
-            return doc_order, query_val, html_update, status_val, progress_val
-        
-        # Navigation events
-        def nav_sample(current_id, direction):
-            """Navigate to the previous or next sample."""
+        # Navigation functions
+        def nav_to_prev(current_id):
             current_sample = next((s for s in samples if s["id"] == current_id), None)
             if not current_sample:
                 return current_id
             
             current_idx = samples.index(current_sample)
+            if current_idx > 0:
+                prev_sample = samples[current_idx - 1]
+                return prev_sample["id"]
+            return current_id
+        
+        def nav_to_next(current_id):
+            current_sample = next((s for s in samples if s["id"] == current_id), None)
+            if not current_sample:
+                return current_id
             
-            if direction == "next" and current_idx < len(samples) - 1:
+            current_idx = samples.index(current_sample)
+            if current_idx < len(samples) - 1:
                 next_sample = samples[current_idx + 1]
                 return next_sample["id"]
-            elif direction == "prev" and current_idx > 0:
-                prev_sample = samples[current_idx - 1]
-                return prev_sample["id"]
-                
             return current_id
         
-        next_btn.click(
-            lambda id: nav_sample(id, "next"),
+        # Connect navigation buttons
+        prev_btn.click(
+            nav_to_prev,
             inputs=[current_sample_id],
             outputs=[current_sample_id]
         ).then(
-            load_sample,
+            lambda id: initialize_document_list(id),
             inputs=[current_sample_id],
-            outputs=[current_document_order, query_text, document_list, status_box, progress_text]
+            outputs=[status_box, progress_text]
+        ).then(
+            lambda id: next((s["query"] for s in samples if s["id"] == id), ""),
+            inputs=[current_sample_id],
+            outputs=[query_text]
         )
         
-        prev_btn.click(
-            lambda id: nav_sample(id, "prev"),
+        next_btn.click(
+            nav_to_next,
             inputs=[current_sample_id],
             outputs=[current_sample_id]
         ).then(
-            load_sample,
+            lambda id: initialize_document_list(id),
             inputs=[current_sample_id],
-            outputs=[current_document_order, query_text, document_list, status_box, progress_text]
+            outputs=[status_box, progress_text]
+        ).then(
+            lambda id: next((s["query"] for s in samples if s["id"] == id), ""),
+            inputs=[current_sample_id],
+            outputs=[query_text]
         )
         
-        # Submit rankings
+        # Submit button
         submit_btn.click(
             save_ranking,
-            inputs=[current_sample_id, current_document_order],
+            inputs=[current_sample_id],
             outputs=[status_box, progress_text]
         )