feat: Enhance conversation verification UI with new buttons and error handling

src/interface/conversation_verification_ui.py

@@ -123,6 +123,10 @@ class VerificationInterface:
                         gr.Markdown("### Quick Actions")
                         mark_all_correct_btn = gr.Button("✅ Mark All Remaining as Correct", size="sm")
                         
+                        with gr.Row():
+                            mark_green_correct_btn = gr.Button("🟢 All GREEN Correct", size="sm", scale=1)
+                            skip_to_errors_btn = gr.Button("🔍 Skip to Errors", size="sm", scale=1)
+                        
                         # Export section
                         gr.Markdown("### Export Results")
                         export_btn = gr.Button("📊 Export to CSV", variant="primary")
@@ -180,6 +184,18 @@ class VerificationInterface:
                 outputs=[exchange_display, current_position, stats_display, progress_bar]
             )
             
+            mark_green_correct_btn.click(
+                fn=self._mark_all_green_correct,
+                inputs=[session_state],
+                outputs=[exchange_display, current_position, stats_display, progress_bar, current_index]
+            )
+            
+            skip_to_errors_btn.click(
+                fn=self._skip_to_next_error,
+                inputs=[session_state, current_index],
+                outputs=[exchange_display, current_position, current_index]
+            )
+            
             export_btn.click(
                 fn=self._export_results,
                 inputs=[session_state],
@@ -319,38 +335,57 @@ class VerificationInterface:
 
     def _handle_correct_feedback(self, session: VerificationSession, index: int) -> Tuple[str, str, str, str, int]:
         """Handle correct classification feedback."""
-        if index >= len(session.verification_records):
-            return "No more exchanges", f"Exchange {index + 1} of {len(session.verification_records)}", "", "", index
-        
-        record = session.verification_records[index]
-        
-        # Submit feedback
-        feedback = VerificationFeedback(
-            exchange_id=record.exchange_id,
-            is_correct=True
-        )
-        
-        self.manager.submit_exchange_verification(session.session_id, record.exchange_id, feedback)
-        
-        # Reload session to get updated data
-        updated_session = self.manager.load_session(session.session_id)
-        
-        # Move to next unverified exchange
-        next_index = self._find_next_unverified_index(updated_session, index)
-        
-        if next_index is not None:
-            next_record = updated_session.verification_records[next_index]
-            exchange_html = self._render_exchange_review(next_record)
-            position_html = f"Exchange {next_index + 1} of {len(updated_session.verification_records)}"
-        else:
-            exchange_html = "<div style='text-align: center; padding: 2em;'><h3>🎉 All exchanges verified!</h3><p>You can now export the results.</p></div>"
-            position_html = "Verification Complete"
-            next_index = index
-        
-        stats_html = self._render_statistics(updated_session)
-        progress_html = self._render_progress_bar(updated_session)
-        
-        return exchange_html, position_html, stats_html, progress_html, next_index
+        try:
+            if index >= len(session.verification_records):
+                return "No more exchanges", f"Exchange {index + 1} of {len(session.verification_records)}", "", "", index
+            
+            record = session.verification_records[index]
+            
+            # Submit feedback
+            feedback = VerificationFeedback(
+                exchange_id=record.exchange_id,
+                is_correct=True
+            )
+            
+            success = self.manager.submit_exchange_verification(session.session_id, record.exchange_id, feedback)
+            if not success:
+                return "❌ Failed to submit feedback", f"Exchange {index + 1} of {len(session.verification_records)}", "", "", index
+            
+            # Reload session to get updated data
+            updated_session = self.manager.load_session(session.session_id)
+            if not updated_session:
+                return "❌ Failed to reload session", f"Exchange {index + 1} of {len(session.verification_records)}", "", "", index
+            
+            # Update current session reference
+            self.current_session = updated_session
+            
+            # Move to next unverified exchange
+            next_index = self._find_next_unverified_index(updated_session, index)
+            
+            if next_index is not None:
+                next_record = updated_session.verification_records[next_index]
+                exchange_html = self._render_exchange_review(next_record)
+                position_html = f"Exchange {next_index + 1} of {len(updated_session.verification_records)}"
+            else:
+                exchange_html = """
+                <div style='text-align: center; padding: 2em; background-color: #d4edda; border-radius: 8px;'>
+                    <h3>🎉 All exchanges verified!</h3>
+                    <p>Great job! You can now export the results using the Export button below.</p>
+                </div>
+                """
+                position_html = "Verification Complete"
+                next_index = index
+            
+            stats_html = self._render_statistics(updated_session)
+            progress_html = self._render_progress_bar(updated_session)
+            
+            return exchange_html, position_html, stats_html, progress_html, next_index
+            
+        except Exception as e:
+            print(f"Error in _handle_correct_feedback: {e}")
+            import traceback
+            traceback.print_exc()
+            return f"❌ Error: {str(e)}", f"Exchange {index + 1}", "", "", index
 
     def _handle_incorrect_feedback(
         self, 
@@ -361,41 +396,67 @@ class VerificationInterface:
         notes: str
     ) -> Tuple[str, str, str, str, int, gr.Column]:
         """Handle incorrect classification feedback."""
-        if index >= len(session.verification_records):
-            return "No more exchanges", f"Exchange {index + 1} of {len(session.verification_records)}", "", "", index, gr.Column(visible=False)
-        
-        record = session.verification_records[index]
-        
-        # Submit feedback
-        feedback = VerificationFeedback(
-            exchange_id=record.exchange_id,
-            is_correct=False,
-            correct_classification=correct_classification,
-            correction_reason=correction_reason,
-            notes=notes if notes.strip() else None
-        )
-        
-        self.manager.submit_exchange_verification(session.session_id, record.exchange_id, feedback)
-        
-        # Reload session
-        updated_session = self.manager.load_session(session.session_id)
-        
-        # Move to next unverified exchange
-        next_index = self._find_next_unverified_index(updated_session, index)
-        
-        if next_index is not None:
-            next_record = updated_session.verification_records[next_index]
-            exchange_html = self._render_exchange_review(next_record)
-            position_html = f"Exchange {next_index + 1} of {len(updated_session.verification_records)}"
-        else:
-            exchange_html = "<div style='text-align: center; padding: 2em;'><h3>🎉 All exchanges verified!</h3><p>You can now export the results.</p></div>"
-            position_html = "Verification Complete"
-            next_index = index
-        
-        stats_html = self._render_statistics(updated_session)
-        progress_html = self._render_progress_bar(updated_session)
-        
-        return exchange_html, position_html, stats_html, progress_html, next_index, gr.Column(visible=False)
+        try:
+            if index >= len(session.verification_records):
+                return "No more exchanges", f"Exchange {index + 1} of {len(session.verification_records)}", "", "", index, gr.Column(visible=False)
+            
+            # Validate inputs
+            if not correct_classification:
+                return "❌ Please select correct classification", f"Exchange {index + 1}", "", "", index, gr.Column(visible=True)
+            
+            if not correction_reason:
+                return "❌ Please select correction reason", f"Exchange {index + 1}", "", "", index, gr.Column(visible=True)
+            
+            record = session.verification_records[index]
+            
+            # Submit feedback
+            feedback = VerificationFeedback(
+                exchange_id=record.exchange_id,
+                is_correct=False,
+                correct_classification=correct_classification,
+                correction_reason=correction_reason,
+                notes=notes.strip() if notes and notes.strip() else None
+            )
+            
+            success = self.manager.submit_exchange_verification(session.session_id, record.exchange_id, feedback)
+            if not success:
+                return "❌ Failed to submit correction", f"Exchange {index + 1}", "", "", index, gr.Column(visible=True)
+            
+            # Reload session
+            updated_session = self.manager.load_session(session.session_id)
+            if not updated_session:
+                return "❌ Failed to reload session", f"Exchange {index + 1}", "", "", index, gr.Column(visible=True)
+            
+            # Update current session reference
+            self.current_session = updated_session
+            
+            # Move to next unverified exchange
+            next_index = self._find_next_unverified_index(updated_session, index)
+            
+            if next_index is not None:
+                next_record = updated_session.verification_records[next_index]
+                exchange_html = self._render_exchange_review(next_record)
+                position_html = f"Exchange {next_index + 1} of {len(updated_session.verification_records)}"
+            else:
+                exchange_html = """
+                <div style='text-align: center; padding: 2em; background-color: #d4edda; border-radius: 8px;'>
+                    <h3>🎉 All exchanges verified!</h3>
+                    <p>Great job! You can now export the results using the Export button below.</p>
+                </div>
+                """
+                position_html = "Verification Complete"
+                next_index = index
+            
+            stats_html = self._render_statistics(updated_session)
+            progress_html = self._render_progress_bar(updated_session)
+            
+            return exchange_html, position_html, stats_html, progress_html, next_index, gr.Column(visible=False)
+            
+        except Exception as e:
+            print(f"Error in _handle_incorrect_feedback: {e}")
+            import traceback
+            traceback.print_exc()
+            return f"❌ Error: {str(e)}", f"Exchange {index + 1}", "", "", index, gr.Column(visible=True)
 
     def _navigate_previous(self, session: VerificationSession, index: int) -> Tuple[str, str, int]:
         """Navigate to previous exchange."""
@@ -417,44 +478,95 @@ class VerificationInterface:
 
     def _mark_all_remaining_correct(self, session: VerificationSession, current_index: int) -> Tuple[str, str, str, str]:
         """Mark all remaining unverified exchanges as correct."""
-        unverified_records = session.get_unverified_records()
-        
-        for record in unverified_records:
-            feedback = VerificationFeedback(
-                exchange_id=record.exchange_id,
-                is_correct=True
-            )
-            self.manager.submit_exchange_verification(session.session_id, record.exchange_id, feedback)
-        
-        # Reload session
-        updated_session = self.manager.load_session(session.session_id)
-        
-        exchange_html = "<div style='text-align: center; padding: 2em;'><h3>🎉 All exchanges verified!</h3><p>All remaining exchanges marked as correct.</p></div>"
-        position_html = "Verification Complete"
-        stats_html = self._render_statistics(updated_session)
-        progress_html = self._render_progress_bar(updated_session)
-        
-        return exchange_html, position_html, stats_html, progress_html
+        try:
+            unverified_records = session.get_unverified_records()
+            
+            if not unverified_records:
+                return """
+                <div style='text-align: center; padding: 2em; background-color: #fff3cd; border-radius: 8px;'>
+                    <h3>⚠️ No unverified exchanges</h3>
+                    <p>All exchanges have already been verified.</p>
+                </div>
+                """, "All Verified", "", ""
+            
+            print(f"🔄 Marking {len(unverified_records)} remaining exchanges as correct...")
+            
+            success_count = 0
+            for record in unverified_records:
+                feedback = VerificationFeedback(
+                    exchange_id=record.exchange_id,
+                    is_correct=True
+                )
+                if self.manager.submit_exchange_verification(session.session_id, record.exchange_id, feedback):
+                    success_count += 1
+            
+            # Reload session
+            updated_session = self.manager.load_session(session.session_id)
+            if not updated_session:
+                return "❌ Failed to reload session", "Error", "", ""
+            
+            # Update current session reference
+            self.current_session = updated_session
+            
+            exchange_html = f"""
+            <div style='text-align: center; padding: 2em; background-color: #d4edda; border-radius: 8px;'>
+                <h3>🎉 Batch verification complete!</h3>
+                <p>Marked <strong>{success_count}</strong> exchanges as correct.</p>
+                <p>You can now export the results using the Export button below.</p>
+            </div>
+            """
+            position_html = "Verification Complete"
+            stats_html = self._render_statistics(updated_session)
+            progress_html = self._render_progress_bar(updated_session)
+            
+            return exchange_html, position_html, stats_html, progress_html
+            
+        except Exception as e:
+            print(f"Error in batch verification: {e}")
+            import traceback
+            traceback.print_exc()
+            return f"❌ Batch verification error: {str(e)}", "Error", "", ""
 
     def _export_results(self, session: VerificationSession) -> str:
         """Export verification results to CSV."""
         try:
+            # Check if there are any verifications to export
+            verified_count = len([r for r in session.verification_records if r.is_correct is not None])
+            if verified_count == 0:
+                return """
+                <div style="background-color: #fff3cd; padding: 1em; border-radius: 4px;">
+                    <strong>⚠️ Nothing to Export</strong><br>
+                    Please verify some exchanges first before exporting.
+                </div>
+                """
+            
             from src.core.verification_exporter import VerificationExporter
             exporter = VerificationExporter()
             csv_path = exporter.export_session_to_csv(session)
             
+            # Get file size for display
+            import os
+            file_size = os.path.getsize(csv_path) if os.path.exists(csv_path) else 0
+            file_size_kb = file_size / 1024
+            
             return f"""
             <div style="background-color: #d4edda; padding: 1em; border-radius: 4px;">
                 <strong>✅ Export Successful!</strong><br>
-                File saved: <code>{csv_path}</code><br>
-                <small>Check your downloads folder</small>
+                <strong>File:</strong> <code>{os.path.basename(csv_path)}</code><br>
+                <strong>Size:</strong> {file_size_kb:.1f} KB<br>
+                <strong>Records:</strong> {verified_count} verified exchanges<br>
+                <small>📁 Saved to: verification_exports/</small>
             </div>
             """
         except Exception as e:
+            print(f"Export error: {e}")
+            import traceback
+            traceback.print_exc()
             return f"""
             <div style="background-color: #f8d7da; padding: 1em; border-radius: 4px;">
                 <strong>❌ Export Failed</strong><br>
-                Error: {str(e)}
+                <strong>Error:</strong> {str(e)}<br>
+                <small>Check console for details</small>
             </div>
             """
 
@@ -469,4 +581,96 @@ class VerificationInterface:
             if session.verification_records[i].is_correct is None:
                 return i
         
-        return None  # All verified
+        return None  # All verified
+
+    def _mark_all_green_correct(self, session: VerificationSession) -> Tuple[str, str, str, str, int]:
+        """Mark all GREEN classifications as correct."""
+        try:
+            green_records = [r for r in session.verification_records 
+                           if r.original_classification == 'GREEN' and r.is_correct is None]
+            
+            if not green_records:
+                return """
+                <div style='text-align: center; padding: 2em; background-color: #fff3cd; border-radius: 8px;'>
+                    <h3>⚠️ No unverified GREEN exchanges</h3>
+                    <p>All GREEN classifications have already been verified.</p>
+                </div>
+                """, "No GREEN to verify", "", "", 0
+            
+            print(f"🟢 Marking {len(green_records)} GREEN exchanges as correct...")
+            
+            success_count = 0
+            for record in green_records:
+                feedback = VerificationFeedback(
+                    exchange_id=record.exchange_id,
+                    is_correct=True
+                )
+                if self.manager.submit_exchange_verification(session.session_id, record.exchange_id, feedback):
+                    success_count += 1
+            
+            # Reload session
+            updated_session = self.manager.load_session(session.session_id)
+            if not updated_session:
+                return "❌ Failed to reload session", "Error", "", "", 0
+            
+            # Update current session reference
+            self.current_session = updated_session
+            
+            # Find next unverified exchange
+            next_index = self._find_next_unverified_index(updated_session, -1)
+            
+            if next_index is not None:
+                next_record = updated_session.verification_records[next_index]
+                exchange_html = self._render_exchange_review(next_record)
+                position_html = f"Exchange {next_index + 1} of {len(updated_session.verification_records)}"
+            else:
+                exchange_html = f"""
+                <div style='text-align: center; padding: 2em; background-color: #d4edda; border-radius: 8px;'>
+                    <h3>🎉 GREEN batch verification complete!</h3>
+                    <p>Marked <strong>{success_count}</strong> GREEN exchanges as correct.</p>
+                    <p>Continue with remaining exchanges or export results.</p>
+                </div>
+                """
+                position_html = "GREEN Verified"
+                next_index = 0
+            
+            stats_html = self._render_statistics(updated_session)
+            progress_html = self._render_progress_bar(updated_session)
+            
+            return exchange_html, position_html, stats_html, progress_html, next_index
+            
+        except Exception as e:
+            print(f"Error in GREEN batch verification: {e}")
+            return f"❌ Error: {str(e)}", "Error", "", "", 0
+
+    def _skip_to_next_error(self, session: VerificationSession, current_index: int) -> Tuple[str, str, int]:
+        """Skip to next exchange that needs attention (unverified or incorrect)."""
+        try:
+            # Look for next unverified exchange
+            next_unverified = self._find_next_unverified_index(session, current_index)
+            
+            if next_unverified is not None:
+                record = session.verification_records[next_unverified]
+                exchange_html = self._render_exchange_review(record)
+                position_html = f"Exchange {next_unverified + 1} of {len(session.verification_records)} (Unverified)"
+                return exchange_html, position_html, next_unverified
+            
+            # If no unverified, look for incorrect ones
+            for i in range(len(session.verification_records)):
+                record = session.verification_records[i]
+                if record.is_correct is False:
+                    exchange_html = self._render_exchange_review(record)
+                    position_html = f"Exchange {i + 1} of {len(session.verification_records)} (Incorrect)"
+                    return exchange_html, position_html, i
+            
+            # No errors found
+            return """
+            <div style='text-align: center; padding: 2em; background-color: #d4edda; border-radius: 8px;'>
+                <h3>✅ No errors found!</h3>
+                <p>All exchanges have been verified and are correct.</p>
+            </div>
+            """, "No Errors", current_index
+            
+        except Exception as e:
+            print(f"Error in skip to errors: {e}")
+            return f"❌ Error: {str(e)}", "Error", current_index

src/interface/simplified_gradio_app.py

@@ -306,6 +306,8 @@ def create_simplified_interface():
                         with gr.Row():
                             verify_conversation_btn = gr.Button("🔍 Verify Conversation", variant="secondary", scale=2, size="sm")
                         
+                        verification_status = gr.HTML(value="", visible=False)
+                        
                         # Quick examples
                         gr.Markdown("### ⚡ Quick Start:")
                         with gr.Row():
@@ -785,12 +787,20 @@ Changes apply only to your current session.
         def open_verification_window(session: SimplifiedSessionData):
             """Open verification window for current conversation."""
             if session is None or not hasattr(session.app_instance, 'conversation_logger'):
-                return "❌ No conversation to verify"
+                return """<div style="background-color: #f8d7da; padding: 0.75em; border-radius: 4px; margin: 0.5em 0;">
+                ❌ <strong>No conversation to verify</strong><br>
+                <small>Start a conversation first</small>
+                </div>"""
             
             try:
                 # Check if conversation has any entries
                 if not session.app_instance.conversation_logger.entries:
-                    return "❌ No conversation exchanges to verify"
+                    return """<div style="background-color: #fff3cd; padding: 0.75em; border-radius: 4px; margin: 0.5em 0;">
+                    ⚠️ <strong>No conversation exchanges to verify</strong><br>
+                    <small>Send some messages in the chat first</small>
+                    </div>"""
+                
+                print(f"🔍 Opening verification for {len(session.app_instance.conversation_logger.entries)} exchanges...")
                 
                 # Create verification session
                 from src.core.conversation_verification import ConversationVerificationManager
@@ -802,23 +812,48 @@ Changes apply only to your current session.
                     "Medical Professional"
                 )
                 
+                print(f"✅ Created verification session: {verification_session.session_id}")
+                
                 # Create verification interface
                 interface = VerificationInterface(manager)
                 verification_window = interface.create_verification_window(verification_session)
                 
-                # Launch verification window
-                verification_window.launch(
-                    server_name="127.0.0.1",
-                    server_port=7861,  # Different port from main app
-                    share=False,
-                    show_error=True,
-                    quiet=True
-                )
+                # Try to launch verification window in background
+                import threading
+                def launch_verification():
+                    try:
+                        verification_window.launch(
+                            server_name="127.0.0.1",
+                            server_port=7861,  # Different port from main app
+                            share=False,
+                            show_error=True,
+                            quiet=False,
+                            prevent_thread_lock=True
+                        )
+                    except Exception as e:
+                        print(f"❌ Error launching verification window: {e}")
                 
-                return f"✅ Verification window opened for {len(verification_session.verification_records)} exchanges"
+                # Launch in separate thread
+                thread = threading.Thread(target=launch_verification, daemon=True)
+                thread.start()
+                
+                print(f"✅ Verification window should open at http://127.0.0.1:7861")
+                
+                return f"""<div style="background-color: #d4edda; padding: 0.75em; border-radius: 4px; margin: 0.5em 0;">
+                ✅ <strong>Verification window opening...</strong><br>
+                <small>Verifying {len(verification_session.verification_records)} exchanges</small><br>
+                <small>Check: <a href="http://127.0.0.1:7861" target="_blank">http://127.0.0.1:7861</a></small>
+                </div>"""
                 
             except Exception as e:
-                return f"❌ Error opening verification: {str(e)}"
+                print(f"❌ Error opening verification: {str(e)}")
+                import traceback
+                traceback.print_exc()
+                
+                return f"""<div style="background-color: #f8d7da; padding: 0.75em; border-radius: 4px; margin: 0.5em 0;">
+                ❌ <strong>Error opening verification</strong><br>
+                <small>{str(e)}</small>
+                </div>"""
         
         # Prompt editing handlers
         def format_prompt_with_html(prompt_text: str) -> str:
@@ -1923,7 +1958,10 @@ To revert, use "Reset to Default" button.
         verify_conversation_btn.click(
             open_verification_window,
             inputs=[session_data],
-            outputs=[]  # No outputs needed as it opens new window
+            outputs=[verification_status]
+        ).then(
+            lambda: gr.HTML(visible=True),
+            outputs=[verification_status]
         )
         
         # Refresh conversation stats