Update app.py

app.py

@@ -1,213 +1,209 @@
 import gradio as gr
-import random
-import json
-import fastapi
-from fastapi import FastAPI, Request
-import os
 import argilla as rg
-from functools import lru_cache
+import pandas as pd
+import os
 import time
-import asyncio
-from fastapi.responses import HTMLResponse
-from fastapi.staticfiles import StaticFiles
-from fastapi.middleware.gzip import GZipMiddleware
+from collections import defaultdict
+from fastapi import FastAPI
+from functools import lru_cache
 
+# Initialize Argilla client with environment variables
 client = rg.Argilla(
     api_url=os.getenv("ARGILLA_API_URL", ""),
     api_key=os.getenv("ARGILLA_API_KEY", "")
 )
 
-countries = {
-  "Argentina": {
-    "iso": "ARG",
-    "emoji": "🇦🇷"
-  },
-  "Bolivia": {
-    "iso": "BOL",
-    "emoji": "🇧🇴"
-  },
-  "Chile": {
-    "iso": "CHL",
-    "emoji": "🇨🇱"
-  },
-  "Colombia": {
-    "iso": "COL",
-    "emoji": "🇨🇴"
-  },
-  "Costa Rica": {
-    "iso": "CRI",
-    "emoji": "🇨🇷"
-  },
-  "Cuba": {
-    "iso": "CUB",
-    "emoji": "🇨🇺"
-  },
-  "Ecuador": {
-    "iso": "ECU",
-    "emoji": "🇪🇨"
-  },
-  "El Salvador": {
-    "iso": "SLV",
-    "emoji": "🇸🇻"
-  },
-  "España": {
-    "iso": "ESP",
-    "emoji": "🇪🇸"
-  },
-  "Guatemala": {
-    "iso": "GTM",
-    "emoji": "🇬🇹"
-  },
-  "Honduras": {
-    "iso": "HND",
-    "emoji": "🇭🇳"
-  },
-  "México": {
-    "iso": "MEX",
-    "emoji": "🇲🇽"
-  },
-  "Nicaragua": {
-    "iso": "NIC",
-    "emoji": "🇳🇮"
-  },
-  "Panamá": {
-    "iso": "PAN",
-    "emoji": "🇵🇦"
-  },
-  "Paraguay": {
-    "iso": "PRY",
-    "emoji": "🇵🇾"
-  },
-  "Perú": {
-    "iso": "PER",
-    "emoji": "🇵🇪"
-  },
-  "Puerto Rico": {
-    "iso": "PRI",
-    "emoji": "🇵🇷"
-  },
-  "República Dominicana": {
-    "iso": "DOM",
-    "emoji": "🇩🇴"
-  },
-  "Uruguay": {
-    "iso": "URY",
-    "emoji": "🇺🇾"
-  },
-  "Venezuela": {
-    "iso": "VEN",
-    "emoji": "🇻🇪"
-  }
-}
-
+# Dataset information - list all the datasets to track
+DATASETS = [
+    "🇪🇸 España - ESP - Responder",
+    # Add more datasets as needed
+]
 
+# Cache results to avoid frequent API calls
 @lru_cache(maxsize=32)
-def count_answers_per_space_cached(country: str, cache_buster: int):
-    return count_answers_per_space(country)
+def get_user_contributions_cached(cache_buster: int):
+    return get_user_contributions()
 
-def count_answers_per_space(country: str):
-    iso = countries[country]["iso"]
-    emoji = countries[country]["emoji"]
-    
-    dataset_name = f"{emoji} {country} - {iso} - Responder"
+def get_user_contributions():
+    """Get contributions per user across all datasets"""
+    user_contributions = defaultdict(lambda: {"username": "", "contributions": 0, "datasets": {}})
+    user_id_to_username = {}
     
-    try:
-        dataset = client.datasets(dataset_name)
-        records = list(dataset.records(with_responses=True))
-        
-        total_questions = len(records)
-        
-        completed_questions = 0
-        total_answers = 0
-        # answers_per_user = {}
-        
-        for record in records:
-            record = record.to_dict()
-            responses = record["responses"]
-            if record["status"] == "completed":
-                # +1 completed questions
-                completed_questions += 1
-            if "answer_1" in responses:
-                answers = responses["answer_1"]
-                total_answers += len(answers)
+    # Process each dataset
+    for dataset_name in DATASETS:
+        try:
+            print(f"Processing dataset: {dataset_name}")
+            dataset = client.datasets(dataset_name)
+            records = list(dataset.records(with_responses=True))
+            
+            # Track contributions per user in this dataset
+            dataset_contributions = defaultdict(int)
+            
+            for record in records:
+                record_dict = record.to_dict()
+                if "answer_1" in record_dict["responses"]:
+                    for answer in record_dict["responses"]["answer_1"]:
+                        if answer["user_id"]:
+                            user_id = answer["user_id"]
+                            dataset_contributions[user_id] += 1
+                            
+                            # Get username if not already cached
+                            if user_id not in user_id_to_username:
+                                try:
+                                    user = client.users(id=user_id)
+                                    user_id_to_username[user_id] = user.username
+                                except Exception as e:
+                                    print(f"Error getting username for {user_id}: {e}")
+                                    user_id_to_username[user_id] = f"User-{user_id[:8]}"
+            
+            # Add dataset contributions to overall user stats
+            for user_id, count in dataset_contributions.items():
+                username = user_id_to_username.get(user_id, f"User-{user_id[:8]}")
+                user_contributions[user_id]["username"] = username
+                user_contributions[user_id]["contributions"] += count
+                user_contributions[user_id]["datasets"][dataset_name] = count
                 
-                # for answer in answers:
-                #     user_id = answer["user_id"]
-                #     answers_per_user[user_id] = answers_per_user.get(user_id, 0) + 1
-        
-        percentage_complete = (completed_questions / total_questions * 100) if total_questions > 0 else 0
-        
-        return {
-            "name": country,
-            "total_questions": total_questions,
-            "answered_questions": completed_questions,
-            "total_answers": total_answers,
-            "percent": round(percentage_complete, 2),
-            "documents": total_questions
-        }
-        
-    except Exception as e:
-        print(f"No dataset found for {dataset_name}: {e}")
-        return {
-            "name": country,
-            "total_questions": 0,
-            "answered_questions": 0,
-            "total_answers": 0,
-            "percent": 0,
-            "documents": 0
+        except Exception as e:
+            print(f"Error processing dataset {dataset_name}: {e}")
+    
+    # Convert to dataframe for easier handling
+    rows = []
+    for user_id, data in user_contributions.items():
+        row = {
+            "Username": data["username"],
+            "Total Contributions": data["contributions"]
         }
+        # Add individual dataset contributions
+        for dataset_name in DATASETS:
+            row[dataset_name] = data["datasets"].get(dataset_name, 0)
+        rows.append(row)
+    
+    df = pd.DataFrame(rows)
+    
+    # Sort by total contributions (descending)
+    if not df.empty:
+        df = df.sort_values("Total Contributions", ascending=False)
+    
+    return df
 
+# App setup
 app = FastAPI()
 
-# gzip compression middleware reduces transferred data size
-app.add_middleware(GZipMiddleware, minimum_size=1000)
-
-last_update_time = time.time()
-cached_html_content = None
+last_update_time = 0
+cached_data = None
 
-@app.get("/d3-map")
-async def serve_map(request: Request, refresh: bool = False):
-    global last_update_time, cached_html_content
+def create_leaderboard_ui():
+    """Create the leaderboard UI"""
+    global cached_data, last_update_time
     current_time = time.time()
     
-    # use cached content if available and not expired (5 minute cache)
-    if cached_html_content and current_time - last_update_time < 300 and not refresh:
-        return HTMLResponse(content=cached_html_content)
+    # Use cached data if available and not expired (5 minute cache)
+    if cached_data is not None and current_time - last_update_time < 300:
+        df = cached_data
+    else:
+        # Fetch fresh data
+        cache_buster = int(current_time)
+        df = get_user_contributions_cached(cache_buster)
+        cached_data = df
+        last_update_time = current_time
     
-    cache_buster = int(current_time)  # use current time to bust cache when refresh=True
+    # Add rank column
+    if not df.empty:
+        df = df.reset_index(drop=True)
+        df.index = df.index + 1
+        df = df.rename_axis("Rank")
+        df = df.reset_index()
     
-    country_data = {}
-    for country in countries.keys():
-        country_data[countries[country]["iso"]] = count_answers_per_space_cached(country, cache_buster)
+    # Format for better display
+    df_html = df.to_html(classes="leaderboard-table", border=0, index=False)
     
-    country_data_json = json.dumps(country_data)
-    
-    with open('template.txt', 'r') as f:
-        html_template = f.read()
-    
-    html_content = html_template.replace("COUNTRY_DATA_PLACEHOLDER", country_data_json)
-    
-    cached_html_content = html_content
-    last_update_time = current_time
-    
-    return HTMLResponse(content=html_content)
+    # Add some styling
+    styled_html = f"""
+    <div style="margin: 20px 0;">
+        <h2>🏆 Leaderboard of User Contributions</h2>
+        <p>Last updated: {time.strftime('%Y-%m-%d %H:%M:%S', time.localtime(last_update_time))}</p>
+        <style>
+            .leaderboard-table {{
+                width: 100%;
+                border-collapse: collapse;
+                font-family: Arial, sans-serif;
+            }}
+            .leaderboard-table th {{
+                background-color: #f2f2f2;
+                color: #333;
+                font-weight: bold;
+                text-align: left;
+                padding: 12px;
+                border-bottom: 2px solid #ddd;
+            }}
+            .leaderboard-table td {{
+                padding: 10px 12px;
+                border-bottom: 1px solid #ddd;
+            }}
+            .leaderboard-table tr:nth-child(even) {{
+                background-color: #f9f9f9;
+            }}
+            .leaderboard-table tr:hover {{
+                background-color: #f1f1f1;
+            }}
+            .leaderboard-table tr:nth-child(1) td:first-child,
+            .leaderboard-table tr:nth-child(1) td:nth-child(2) {{
+                font-weight: bold;
+                color: gold;
+            }}
+            .leaderboard-table tr:nth-child(2) td:first-child,
+            .leaderboard-table tr:nth-child(2) td:nth-child(2) {{
+                font-weight: bold;
+                color: silver;
+            }}
+            .leaderboard-table tr:nth-child(3) td:first-child,
+            .leaderboard-table tr:nth-child(3) td:nth-child(2) {{
+                font-weight: bold;
+                color: #cd7f32; /* bronze */
+            }}
+        </style>
+        {df_html}
+        <p><small>Note: This leaderboard shows user contributions across all tracked datasets.</small></p>
+    </div>
+    """
+    return styled_html
 
-def create_iframe(refresh=False):
-    param = f"refresh={str(refresh).lower()}&t={random.randint(1, 10000)}"
-    return f'<iframe src="/d3-map?{param}" style="width:100%; height:650px; border:none;"></iframe>'
+def refresh_data():
+    """Force refresh of the data"""
+    global cached_data, last_update_time
+    cached_data = None
+    last_update_time = 0
+    return create_leaderboard_ui()
 
-with gr.Blocks(theme=gr.themes.Soft(primary_hue="pink", secondary_hue="purple")) as demo:
-    gr.Markdown("# Mapa anotación")
+# Create Gradio interface
+with gr.Blocks(theme=gr.themes.Soft(primary_hue="blue", secondary_hue="indigo")) as demo:
+    gr.Markdown("# Contribution Leaderboard")
+    gr.Markdown("Track user contributions across datasets in real-time")
     
-    iframe_output = gr.HTML(create_iframe())
+    # Create leaderboard display
+    leaderboard_html = gr.HTML(create_leaderboard_ui)
     
-    def refresh():
-        return create_iframe(refresh=True)
+    # Add refresh button
+    refresh_btn = gr.Button("🔄 Refresh Data")
+    refresh_btn.click(fn=refresh_data, outputs=leaderboard_html)
     
-    gr.Button("Actualizar Datos").click(fn=refresh, outputs=iframe_output)
+    # Additional information
+    with gr.Accordion("About this leaderboard", open=False):
+        gr.Markdown("""
+        This leaderboard tracks user contributions across multiple datasets.
+        
+        ### How it works
+        - **Contributions**: Each response provided by a user counts as one contribution
+        - **Refresh**: Data is automatically cached for 5 minutes. Click the refresh button to update manually
+        - **Datasets tracked**: 
+          - 🇪🇸 España - ESP - Responder
+          - [Add more datasets as needed]
+        """)
 
+# Mount the Gradio app
 gr.mount_gradio_app(app, demo, path="/")
 
+# Run the app
 if __name__ == "__main__":
     import uvicorn
     uvicorn.run(app, host="0.0.0.0", port=7860)