leaderboard configuration

riddhibhagwat · riddhibhagwat · commit e8cda018ecea · 2025-04-15T08:30:41.000-04:00
diff --git a/.DS_Store b/.DS_Store
diff --git a/app/app.py b/app/app.py
@@ -16,9 +16,11 @@
 from huggingface_hub import InferenceClient
 from pandas import DataFrame
 from transformers import pipeline, AutoTokenizer, AutoModelForCausalLM
+import threading
+from collections import defaultdict
 
 
-BASE_MODEL = os.getenv("MODEL", "google/gemma-3-12b-it")
+BASE_MODEL = os.getenv("MODEL", "google/gemma-3-12b-pt")
 ZERO_GPU = (
     bool(os.getenv("ZERO_GPU", False)) or True
     if str(os.getenv("ZERO_GPU")).lower() == "true"
@@ -471,9 +473,63 @@ def wrangle_retry_data(
     )
     return history, update_dataframe(dataframe, history)
 
+# Global variables for tracking language data points
+LANGUAGE_DATA_POINTS = defaultdict(int)
+language_data_lock = threading.Lock()
+
+def get_leaderboard_data():
+    """Get sorted leaderboard data for all languages"""
+    with language_data_lock:
+        leaderboard_data = {lang: LANGUAGE_DATA_POINTS.get(lang, 0) for lang in LANGUAGES.keys()}
+        sorted_data = sorted(leaderboard_data.items(), key=lambda x: x[1], reverse=True)
+        return sorted_data
+
+def increment_language_data_point(language):
+    """Increment the data point count for a specific language"""
+    with language_data_lock:
+        LANGUAGE_DATA_POINTS[language] += 1
+    return get_leaderboard_data()
+
+def set_language_data_points(language, count):
+    """Manually set the data point count for a specific language"""
+    with language_data_lock:
+        LANGUAGE_DATA_POINTS[language] = count
+    return get_leaderboard_data()
+
+def load_initial_language_data():
+    """Load initial language data points from persistent storage or default values"""
+    data_points_path, use_persistent = get_persistent_storage_path("language_data_points.json")
+    
+    if data_points_path.exists():
+        try:
+            with open(data_points_path, "r", encoding="utf-8") as f:
+                data = json.load(f)
+                with language_data_lock:
+                    LANGUAGE_DATA_POINTS.clear()
+                    LANGUAGE_DATA_POINTS.update(data)
+        except Exception as e:
+            print(f"Error loading language data points: {e}")
+    
+    for lang in LANGUAGES.keys():
+        if lang not in LANGUAGE_DATA_POINTS:
+            LANGUAGE_DATA_POINTS[lang] = 0
+            
+    return get_leaderboard_data()
+
+def save_language_data_points():
+    """Save language data points to persistent storage"""
+    data_points_path, use_persistent = get_persistent_storage_path("language_data_points.json")
+    
+    try:
+        with language_data_lock:
+            with open(data_points_path, "w", encoding="utf-8") as f:
+                json.dump(dict(LANGUAGE_DATA_POINTS), f, ensure_ascii=False, indent=2)
+    except Exception as e:
+        print(f"Error saving language data points: {e}")
+
 
 def submit_conversation(dataframe, conversation_id, session_id, language):
-    """ "Submit the conversation to dataset repo"""
+    """ "Submit the conversation to dataset repo & update leaderboard"""
     if dataframe.empty or len(dataframe) < 2:
         gr.Info("No feedback to submit.")
         return (gr.Dataframe(value=None, interactive=False), [])
@@ -489,7 +545,10 @@ def submit_conversation(dataframe, conversation_id, session_id, language):
         "language": language,
     }
     save_feedback(input_object=conversation_data)
-    return (gr.Dataframe(value=None, interactive=False), [])
+    leaderboard_data = increment_language_data_point(language)
+    save_language_data_points()
+    
+    return (gr.Dataframe(value=None, interactive=False), [], leaderboard_data)
 
 
 def open_add_language_modal():
@@ -547,11 +606,72 @@ def save_new_language(lang_name, system_prompt):
 .user-agreement-container {
     box-shadow: 0 2px 5px rgba(0,0,0,0.1) !important;
 }
+
+/* Leaderboard styles */
+.leaderboard-container {
+    border-left: 1px solid #eaeaea;
+    padding-left: 1rem;
+    height: 100%;
+}
+.leaderboard-title {
+    font-weight: bold;
+    text-align: center;
+    margin-bottom: 1rem;
+}
+.leaderboard-item {
+    display: flex;
+    justify-content: space-between;
+    padding: 0.5rem 0;
+    border-bottom: 1px solid #f0f0f0;
+}
+.leaderboard-rank {
+    font-weight: bold;
+    margin-right: 0.5rem;
+}
+.leaderboard-language {
+    flex-grow: 1;
+}
+.leaderboard-count {
+    font-weight: bold;
+}
+.leaderboard-admin-panel {
+    margin-top: 1rem;
+    padding-top: 1rem;
+    border-top: 1px solid #eaeaea;
+}
 """
 
-with gr.Blocks(css=css) as demo:
+def get_config(request: gr.Request):
+    """Get configuration from cookies"""
+    config = {"feel_consent": False}
+    if request and 'feel_consent' in request.cookies:
+        config["feel_consent"] = request.cookies['feel_consent'] == 'true'
+    return config["feel_consent"]
+
+js = '''function js(){
+    window.set_cookie = function(key, value){
+        console.log('Setting cookie:', key, value);
+        document.cookie = key+'='+value+'; Path=/; SameSite=Strict; max-age=31536000';  // 1 year expiry
+        console.log('Current cookies:', document.cookie);
+        return [value]
+    }
+    
+    window.check_cookie = function(key){
+        console.log('Checking cookie:', key);
+        console.log('All cookies:', document.cookie);
+        const value = document.cookie.split('; ').find(row => row.startsWith(key + '='))?.split('=')[1];
+        console.log('Found value:', value);
+        return [value === 'true']
+    }
+}'''
+
+
+
+
+with gr.Blocks(css=css, js=js) as demo:
     # State variable to track if user has consented
-    user_consented = gr.State(False)
+    user_consented = gr.State(value=False)  
+    leaderboard_data = gr.State([])
     
     # Landing page with user agreement
     with gr.Group(visible=True) as landing_page:
@@ -598,6 +718,37 @@ def save_new_language(lang_name, system_prompt):
                         size="sm"
                     )
 
+            # Right column with leaderboard
+            with gr.Column(scale=3, elem_classes=["leaderboard-container"]):
+                gr.Markdown("# Language Leaderboard", elem_classes=["leaderboard-title"])
+                leaderboard_html = gr.HTML("Loading leaderboard...")
+                
+                with gr.Accordion("Admin Controls", open=False, visible=False) as admin_panel:
+                    with gr.Row():
+                        admin_language = gr.Dropdown(choices=list(LANGUAGES.keys()), label="Language")
+                        admin_count = gr.Number(value=0, label="Data Points")
+                    set_count_btn = gr.Button("Set Count")
+                    
+                # toggle button for admin panel?
+                admin_toggle = gr.Button("Admin Controls", visible=True)
+
+            # update leaderboard HTML
+            def update_leaderboard_html(data):
+                if not data:
+                    return "Loading leaderboard..."
+                
+                html = "<div class='leaderboard-content'>"
+                for idx, (lang, count) in enumerate(data):
+                    html += f"""
+                    <div class='leaderboard-item'>
+                        <span class='leaderboard-rank'>#{idx+1}</span>
+                        <span class='leaderboard-language'>{lang}</span>
+                        <span class='leaderboard-count'>{count}</span>
+                    </div>
+                    """
+                html += "</div>"
+                return html
+
 
         # Create a hidden group instead of a modal
         with gr.Group(visible=False) as add_language_modal:
@@ -627,7 +778,6 @@ def save_new_language(lang_name, system_prompt):
         chatbot = gr.Chatbot(
             elem_id="chatbot",
             editable="all",
-            bubble_full_width=False,
             value=[
                 {
                     "role": "system",
@@ -653,12 +803,12 @@ def save_new_language(lang_name, system_prompt):
     # Function to show main app after consent
     def show_main_app():
         return gr.Group(visible=False), gr.Group(visible=True), True
-
-    # Connect consent button to show main app
+    
     consent_btn.click(
         fn=show_main_app,
         inputs=[],
-        outputs=[landing_page, main_app, user_consented]
+        outputs=[landing_page, main_app, user_consented],
+        js="(value) => { console.log('Consent button clicked'); set_cookie('feel_consent', 'true'); console.log('Cookie set after consent'); return value; }"
     )
 
     ##############################
@@ -680,6 +830,11 @@ def show_main_app():
     ).then(update_dataframe, inputs=[dataframe, chatbot], outputs=[dataframe]).then(
         submit_conversation,
         inputs=[dataframe, conversation_id, session_id, language],
+        outputs=[dataframe, chatbot, leaderboard_data]
+    ).then(
+        update_leaderboard_html,
+        inputs=[leaderboard_data],
+        outputs=[leaderboard_html]
     )
 
     chatbot.like(
@@ -721,11 +876,27 @@ def on_app_load():
         language_choices = list(LANGUAGES.keys())
         
         return str(uuid.uuid4()), gr.Dropdown(choices=language_choices, value=language_choices[0])
-
+    
+    def toggle_admin_panel(visible):
+        return gr.Accordion(visible=not visible)
+    
+    def handle_set_count(language, count):
+        updated_data = set_language_data_points(language, int(count))
+        save_language_data_points()
+        return update_leaderboard_html(updated_data), updated_data
+    
     demo.load(
-        fn=on_app_load,
+        fn=lambda: (on_app_load(), load_initial_language_data()),
         inputs=None,
-        outputs=[session_id, language]
+        outputs=[
+            session_id, 
+            language,
+            leaderboard_data
+        ]
+    ).then(
+        fn=update_leaderboard_html,
+        inputs=[leaderboard_data],
+        outputs=[leaderboard_html]
     )
 
     add_language_btn.click(
@@ -744,4 +915,16 @@ def on_app_load():
         outputs=[add_language_modal, refresh_html, language]
     )
 
+    admin_toggle.click(
+        fn=toggle_admin_panel,
+        inputs=[admin_panel],
+        outputs=[admin_panel]
+    )
+    
+    set_count_btn.click(
+        fn=handle_set_count,
+        inputs=[admin_language, admin_count],
+        outputs=[leaderboard_html, leaderboard_data]
+    )
+
 demo.launch()
diff --git a/app/leadboard_config.py b/app/leadboard_config.py
@@ -0,0 +1,62 @@
+import json
+from pathlib import Path
+import argparse
+
+def set_initial_counts():
+    """command-line tool to set initial language data point counts"""
+    parser = argparse.ArgumentParser(description='setup initial language data point counts for FeeL leaderboard')
+    parser.add_argument('--language', type=str, help='Language to set count for')
+    parser.add_argument('--count', type=int, help='Count to set for the language')
+    parser.add_argument('--list', action='store_true', help='List current counts')
+    
+    args = parser.parse_args()
+    data_file = Path("language_data_points.json")
+    
+    # Load existing data if available
+    if data_file.exists():
+        with open(data_file, "r", encoding="utf-8") as f:
+            try:
+                data = json.load(f)
+            except json.JSONDecodeError:
+                print("Error reading data file. Creating new data.")
+                data = {}
+    else:
+        data = {}
+    
+    # Load available languages
+    languages_file = Path("languages.json")
+    if languages_file.exists():
+        with open(languages_file, "r", encoding="utf-8") as f:
+            languages = json.load(f)
+    else:
+        print("Warning: languages.json not found. Cannot verify language names.")
+        languages = {}
+    
+    # current counts
+    if args.list:
+        print("Current language data point counts:")
+        for lang in sorted(set(list(languages.keys()) + list(data.keys()))):
+            count = data.get(lang, 0)
+            print(f"{lang}: {count}")
+        return
+    
+    if args.language and args.count is not None:
+        if args.language not in languages and languages:
+            print(f"Warning: '{args.language}' is not in languages.json")
+            confirm = input("Continue anyway? (y/n): ")
+            if confirm.lower() != 'y':
+                return
+        
+        data[args.language] = args.count
+        
+        # saving
+        with open(data_file, "w", encoding="utf-8") as f:
+            json.dump(data, f, ensure_ascii=False, indent=2)
+        
+        print(f"Set count for {args.language} to {args.count}")
+    elif not args.list:
+        print("Please provide both --language and --count arguments")
+        parser.print_help()
+
+if __name__ == "__main__":
+    set_initial_counts()
