update

app.py

@@ -3,9 +3,22 @@ import gradio as gr
 import pandas as pd
 from datetime import datetime
 import time
-from azure_count_ip_data import count_files_per_annotator
-from log_reader import RemoteLogReader
+import sys
+import importlib.util
 import threading
+from log_reader import RemoteLogReader
+
+# Define the path for the azure_count_ip_data module
+azure_count_ip_data_path = os.path.join(os.path.dirname(__file__), 'azure_count_ip_data.py')
+
+# Import the module dynamically
+spec = importlib.util.spec_from_file_location("azure_count_ip_data", azure_count_ip_data_path)
+azure_count_ip_data = importlib.util.module_from_spec(spec)
+spec.loader.exec_module(azure_count_ip_data)
+
+# Get the functions we need
+count_files_per_annotator = azure_count_ip_data.count_files_per_annotator
+count_deduplicated_files_per_annotator = azure_count_ip_data.count_deduplicated_files_per_annotator
 
 # Define the path for storing the data
 DATA_DIR = os.path.join(os.path.dirname(__file__), 'data')
@@ -29,18 +42,61 @@ def load_stats():
             last_update = f.read().strip()
         return df, last_update
     except (FileNotFoundError, pd.errors.EmptyDataError):
-        return pd.DataFrame(columns=['Annotator', 'Battle Count']), ""
+        return pd.DataFrame(columns=['Annotator', 'Total Count', 'Unique Count', 'Unique %']), ""
 
 def update_stats():
-    """Get the latest battle statistics"""
+    """Get the latest battle statistics with both total and deduplicated counts"""
     try:
         # Initialize RemoteLogReader
         reader = RemoteLogReader()
-        # Get annotator counts using Azure storage
-        annotator_counts = count_files_per_annotator(reader)
-        # Convert to DataFrame for better display
-        df = pd.DataFrame(list(annotator_counts.items()), columns=['Annotator', 'Battle Count'])
-        df = df.sort_values('Battle Count', ascending=False)
+        
+        # Get total annotator counts
+        total_counts = count_files_per_annotator(reader)
+        
+        # Get deduplicated annotator counts
+        unique_counts = count_deduplicated_files_per_annotator(reader)
+        
+        # Combine the data into a single DataFrame
+        data = []
+        all_annotators = set(total_counts.keys()) | set(unique_counts.keys())
+        
+        # Track totals for summary row
+        total_sum = 0
+        unique_sum = 0
+        
+        for annotator in all_annotators:
+            total = total_counts.get(annotator, 0)
+            unique = unique_counts.get(annotator, 0)
+            # Calculate percentage of unique prompts
+            percentage = round((unique / total * 100) if total > 0 else 0, 1)
+            
+            # Add to totals
+            total_sum += total
+            unique_sum += unique
+            
+            data.append({
+                'Annotator': annotator,
+                'Total Count': total,
+                'Unique Count': unique,
+                'Unique %': f"{percentage}%"
+            })
+        
+        # Add summary row
+        overall_percentage = round((unique_sum / total_sum * 100) if total_sum > 0 else 0, 1)
+        data.append({
+            'Annotator': 'TOTAL',
+            'Total Count': total_sum,
+            'Unique Count': unique_sum,
+            'Unique %': f"{overall_percentage}%"
+        })
+        
+        # Convert to DataFrame and sort by total count, keeping TOTAL at the bottom
+        df = pd.DataFrame(data)
+        # Move TOTAL row to the end
+        df = pd.concat([
+            df[df['Annotator'] != 'TOTAL'].sort_values('Total Count', ascending=False),
+            df[df['Annotator'] == 'TOTAL']
+        ]).reset_index(drop=True)
         
         # Get current time
         current_time = datetime.now().strftime("%Y-%m-%d %H:%M:%S")
@@ -51,7 +107,7 @@ def update_stats():
         return df, current_time
     except Exception as e:
         print(f"Error updating stats: {e}")
-        return pd.DataFrame(columns=['Annotator', 'Battle Count']), ""
+        return pd.DataFrame(columns=['Annotator', 'Total Count', 'Unique Count', 'Unique %']), ""
 
 def auto_update(state):
     """Background task to update stats every hour"""
@@ -86,7 +142,7 @@ def create_ui():
     
     with gr.Blocks(title="Battle Count Statistics") as app:
         gr.Markdown("# Battle Count Statistics")
-        gr.Markdown("Displays the count of valid battles per annotator. Updates automatically every hour.")
+        gr.Markdown("Displays the count of battles per annotator. 'Total Count' shows all valid battles, while 'Unique Count' shows deduplicated battles based on the first user prompt. Only conversations that pass the vote conditions are counted.")
         
         with gr.Row():
             last_update = gr.Textbox(
@@ -100,10 +156,12 @@ def create_ui():
                 value=get_current_stats,
                 interactive=False,
                 wrap=True,
+                column_widths=["40%", "20%", "20%", "20%"],
+                height=600
             )
         
-        # refresh_btn = gr.Button("Refresh Now")
-        # refresh_btn.click(fn=manual_refresh, outputs=[output, last_update])
+        refresh_btn = gr.Button("Refresh Now")
+        refresh_btn.click(fn=manual_refresh, outputs=[output, last_update])
     
     return app
 

azure_count_ip_data.py

@@ -204,6 +204,109 @@ def get_annotator_name(ip: Optional[str], username: Optional[str]) -> Optional[s
     
     return None
 
+def get_first_user_prompt(content: str) -> Optional[str]:
+    """Extract the first user prompt from the conversation content"""
+    try:
+        lines = [line.strip() for line in content.split('\n') if line.strip()]
+        if not lines:
+            return None
+            
+        # Parse the first line to get the messages
+        first_line_data = json.loads(lines[0])
+        
+        # Try different message formats
+        
+        # Format 1: state.messages array with ["<|im_start|>user", "hello"] format
+        messages = first_line_data.get('state', {}).get('messages', [])
+        if messages and len(messages) > 0:
+            first_message = messages[0]
+            if isinstance(first_message, list) and len(first_message) > 1:
+                # Format: ["<|im_start|>user", "hello"]
+                return first_message[1]
+        
+        # Format 2: state.messages array with {"role": "user", "content": "hello"} format
+        if messages and len(messages) > 0:
+            first_message = messages[0]
+            if isinstance(first_message, dict) and 'content' in first_message:
+                return first_message.get('content')
+        
+        # Format 3: Direct messages array in the root
+        messages = first_line_data.get('messages', [])
+        if messages and len(messages) > 0:
+            first_message = messages[0]
+            if isinstance(first_message, list) and len(first_message) > 1:
+                return first_message[1]
+            elif isinstance(first_message, dict) and 'content' in first_message:
+                return first_message.get('content')
+        
+        # Format 4: Look for a specific user role key
+        for key in ['user', 'human', 'Human']:
+            if key in first_line_data:
+                return first_line_data[key]
+        
+        log.warning(f"Could not extract first user prompt from content: {content[:200]}...")
+        return None
+    except Exception as e:
+        log.error(f"Error extracting first user prompt: {e}")
+        return None
+
+def count_deduplicated_files_per_annotator(reader: 'RemoteLogReader', start_date_str: str = "2025_02_18") -> Dict[str, int]:
+    """Count deduplicated files per annotator name from the given start date, considering both IP and username
+    
+    Deduplication is based on the first user prompt for each annotator.
+    Only counts conversations that pass the vote conditions.
+    """
+    # Convert start date string to datetime
+    start_date = datetime.strptime(start_date_str, "%Y_%m_%d")
+    
+    # Dictionary to store unique prompts per annotator
+    annotator_prompts = defaultdict(set)
+    
+    try:
+        # Get current date for iteration
+        current_date = start_date
+        today = datetime.now()
+        
+        while current_date <= today:
+            date_str = current_date.strftime("%Y_%m_%d")
+            
+            try:
+                # Get conversation logs for battle_anony mode
+                conv_logs = reader.get_conv_logs(date_str)
+                battle_anony_logs = conv_logs.get('battle_anony', {})
+                
+                # Process each conversation
+                for conv_id, messages in battle_anony_logs.items():
+                    if messages:
+                        # Convert messages to file content format
+                        content = '\n'.join(json.dumps(msg) for msg in messages)
+                        
+                        # First check if the conversation passes the vote conditions
+                        ip, username, vote_conditions_met = get_file_data(content)
+                        
+                        # Only proceed if vote conditions are met
+                        if vote_conditions_met:
+                            # Get annotator name from either IP or username
+                            annotator_name = get_annotator_name(ip, username)
+                            if annotator_name:
+                                # Extract first user prompt
+                                first_prompt = get_first_user_prompt(content)
+                                if first_prompt:
+                                    # Add to set of unique prompts for this annotator
+                                    annotator_prompts[annotator_name].add(first_prompt.strip())
+                            
+            except Exception as e:
+                log.error(f"Error processing logs for date {date_str}: {e}")
+            
+            # Move to next day
+            current_date += timedelta(days=1)
+                
+    except Exception as e:
+        log.error(f"Error accessing logs: {e}")
+    
+    # Convert sets to counts
+    return {name: len(prompts) for name, prompts in annotator_prompts.items()}
+
 def count_files_per_annotator(reader: 'RemoteLogReader', start_date_str: str = "2025_02_18") -> Dict[str, int]:
     """Count files per annotator name from the given start date, considering both IP and username"""
     # Convert start date string to datetime