Upload folder using huggingface_hub

.env

@@ -0,0 +1,3 @@
+SYNC_DB=true
+DATASET_ID=your-username/llm-arena-db
+SPACE_ID=your-username/llm-arena

.pytest_cache/.gitignore

@@ -0,0 +1,2 @@
+# Created by pytest automatically.
+*

.pytest_cache/CACHEDIR.TAG

@@ -0,0 +1,4 @@
+Signature: 8a477f597d28d172789f06886806bc55
+# This file is a cache directory tag created by pytest.
+# For information about cache directory tags, see:
+#	https://bford.info/cachedir/spec.html

.pytest_cache/README.md

@@ -0,0 +1,8 @@
+# pytest cache directory #
+
+This directory contains data from the pytest's cache plugin,
+which provides the `--lf` and `--ff` options, as well as the `cache` fixture.
+
+**Do not** commit this to version control.
+
+See [the docs](https://docs.pytest.org/en/stable/how-to/cache.html) for more information.

.pytest_cache/v/cache/lastfailed

@@ -0,0 +1,3 @@
+{
+  "GenAI-Arena/arena_elo/simple_test.py": true
+}

.pytest_cache/v/cache/stepwise

@@ -0,0 +1 @@
+[]

README.md

@@ -1,12 +1,6 @@
 ---
-title: Darija Chatbot Arena
-emoji: 💻
-colorFrom: blue
-colorTo: yellow
+title: darija-chatbot-arena
+app_file: app.py
 sdk: gradio
 sdk_version: 5.9.1
-app_file: app.py
-pinned: false
 ---
-
-Check out the configuration reference at https://huggingface.co/docs/hub/spaces-config-reference

app.py

@@ -0,0 +1,5 @@
+import gradio as gr
+from app.ui import app 
+
+if __name__ == "__main__":
+    app.launch(debug=True)

app/__init__.py

@@ -0,0 +1 @@
+from .ui import app

app/config.py

@@ -0,0 +1,27 @@
+import os
+
+#########################
+# General Configuration #
+#########################
+
+DB_NAME = "database.db"
+DB_PATH = f"/data/{DB_NAME}" if os.path.isdir("/data") else DB_NAME
+
+# LLM Models Configuration
+AVAILABLE_MODELS = {
+    "GPT-4": "gpt4",
+    "Claude-3": "claude3",
+    "Gemini-Pro": "gemini",
+    "Mixtral": "mixtral",
+    "Llama-2": "llama2",
+    # Add more models as needed
+}
+
+# General Configuration
+MAX_PROMPT_LENGTH = 2000
+MIN_PROMPT_LENGTH = 10
+
+# Sync settings
+SYNC_DB = True if os.getenv('SYNC_DB') else False
+DB_DATASET_ID = os.getenv('DATASET_ID')
+SPACE_ID = os.getenv('SPACE_ID')

app/db.py

@@ -0,0 +1,61 @@
+import sqlite3
+from .config import *
+import os
+import shutil
+from huggingface_hub import hf_hub_download
+
+def download_db():
+    if not os.path.isfile(DB_PATH):
+        print("Downloading DB...")
+        try:
+            cache_path = hf_hub_download(repo_id=DB_DATASET_ID, repo_type='dataset', filename=DB_NAME)
+            shutil.copyfile(cache_path, DB_PATH)
+            print("Downloaded DB")
+        except Exception as e:
+            print("Error while downloading DB:", e)
+
+def get_db():
+    return sqlite3.connect(DB_PATH)
+
+def create_db():
+    conn = get_db()
+    cursor = conn.cursor()
+    
+    # Model table - stores model info and vote counts
+    cursor.execute('''
+        CREATE TABLE IF NOT EXISTS model (
+            name TEXT UNIQUE,
+            upvote INTEGER DEFAULT 0,
+            downvote INTEGER DEFAULT 0
+        );
+    ''')
+    
+    # Vote table - stores individual votes with prompts and responses
+    cursor.execute('''
+        CREATE TABLE IF NOT EXISTS vote (
+            id INTEGER PRIMARY KEY AUTOINCREMENT,
+            username TEXT,
+            model TEXT,
+            vote INTEGER,
+            prompt TEXT,
+            response TEXT,
+            timestamp TIMESTAMP DEFAULT CURRENT_TIMESTAMP
+        );
+    ''')
+    
+    # Battle log table - stores battle outcomes with both responses
+    cursor.execute('''
+        CREATE TABLE IF NOT EXISTS votelog (
+            id INTEGER PRIMARY KEY AUTOINCREMENT,
+            username TEXT,
+            chosen TEXT,
+            rejected TEXT,
+            prompt TEXT,
+            chosen_response TEXT,
+            rejected_response TEXT,
+            timestamp TIMESTAMP DEFAULT CURRENT_TIMESTAMP
+        );
+    ''')
+    
+    conn.commit()
+    cursor.close()

app/init.py

@@ -0,0 +1,20 @@
+from .config import *
+from .db import *
+from huggingface_hub import CommitScheduler
+from pathlib import Path
+import os
+
+scheduler = None
+
+if SYNC_DB:
+    download_db()
+    # Sync local DB with remote repo every 5 minute (only if a change is detected)
+    scheduler = CommitScheduler(
+        repo_id=DB_DATASET_ID,
+        repo_type="dataset",
+        folder_path=Path(DB_PATH).parent,
+        every=5,
+        allow_patterns=DB_NAME,
+    )
+
+create_db()

app/leaderboard.py

@@ -0,0 +1,52 @@
+from .config import *
+from .db import *
+from .models import *
+
+import pandas as pd
+
+def get_leaderboard(reveal_prelim=False):
+    print("Getting leaderboard data...")
+    conn = get_db()
+    cursor = conn.cursor()
+    
+    sql = '''
+    SELECT name, 
+           SUM(CASE WHEN vote = 1 THEN 1 ELSE 0 END) as upvote, 
+           SUM(CASE WHEN vote = -1 THEN 1 ELSE 0 END) as downvote
+    FROM model
+    LEFT JOIN vote ON model.name = vote.model
+    GROUP BY name
+    '''
+    
+    print("Executing SQL query...")
+    cursor.execute(sql)
+    data = cursor.fetchall()
+    df = pd.DataFrame(data, columns=['name', 'upvote', 'downvote'])
+    df['votes'] = df['upvote'] + df['downvote']
+    print(f"Initial dataframe has {len(df)} models")
+
+    if not reveal_prelim:
+        print(f"Filtering out models with less than 100 votes... ({len(df[df['votes'] <= 100])} models will be filtered)")
+        df = df[df['votes'] > 100]  # Minimum vote threshold
+        print(f"After filtering: {len(df)} models remain")
+
+    print(f"Calculating ELO scores for {len(df)} models...")
+    # Calculate ELO scores
+    df['score'] = 1200  # Base ELO
+    for i in range(len(df)):
+        for j in range(len(df)):
+            if i != j:
+                expected_a = 1 / (1 + 10 ** ((df['score'].iloc[j] - df['score'].iloc[i]) / 400))
+                expected_b = 1 / (1 + 10 ** ((df['score'].iloc[i] - df['score'].iloc[j]) / 400))
+                actual_a = df['upvote'].iloc[i] / df['votes'].iloc[i] if df['votes'].iloc[i] > 0 else 0.5
+                actual_b = df['upvote'].iloc[j] / df['votes'].iloc[j] if df['votes'].iloc[j] > 0 else 0.5
+                df.iloc[i, df.columns.get_loc('score')] += 32 * (actual_a - expected_a)
+                df.iloc[j, df.columns.get_loc('score')] += 32 * (actual_b - expected_b)
+
+    df['score'] = round(df['score'])
+    df = df.sort_values(by='score', ascending=False)
+    df['order'] = ['#' + str(i+1) for i in range(len(df))]
+    
+    print(f"Returning final leaderboard data with {len(df)} models...")
+    # Return only the columns we want to display
+    return df[['order', 'name', 'score', 'votes']].values.tolist()

app/llm.py

@@ -0,0 +1,45 @@
+import threading
+from .config import *
+from .models import *
+from .utils import *
+import random
+
+def generate_response(prompt, model_name):
+    """
+    Replace this with actual API calls to your LLM endpoints
+    """
+    # Placeholder implementation
+    responses = {
+        "gpt4": "This is a simulated GPT-4 response",
+        "claude3": "This is a simulated Claude-3 response",
+        "gemini": "This is a simulated Gemini-Pro response",
+        "mixtral": "This is a simulated Mixtral response",
+        "llama2": "This is a simulated Llama-2 response"
+    }
+    return responses.get(model_name, "Model not found")
+
+def get_responses(prompt, model_a, model_b):
+    results = {}
+    
+    def predict_and_store(prompt, model, result_storage):
+        try:
+            if model in AVAILABLE_MODELS:
+                result = generate_response(prompt, AVAILABLE_MODELS[model])
+            else:
+                result = generate_response(prompt, model)
+            result_storage[model] = result
+        except Exception as e:
+            raise gr.Error(f'Unable to generate response: {str(e)}')
+    
+    thread1 = threading.Thread(target=predict_and_store, args=(prompt, model_a, results))
+    thread2 = threading.Thread(target=predict_and_store, args=(prompt, model_b, results))
+    
+    thread1.start()
+    thread2.start()
+    thread1.join()
+    thread2.join()
+    
+    return results[model_a], results[model_b]
+
+def random_models():
+    return random.sample(list(AVAILABLE_MODELS.keys()), 2) 

app/messages.py

@@ -0,0 +1,82 @@
+from .config import *
+
+############
+# Messages #
+############
+
+MUST_BE_LOGGEDIN = "Please login with Hugging Face to participate in the TTS Arena."
+DESCR = """
+# TTS Arena: Benchmarking TTS Models in the Wild
+Vote to help the community find the best available text-to-speech model!
+""".strip()
+BATTLE_INSTR = """
+## Battle
+Choose 2 candidates and vote on which one is better! Currently in beta.
+* Input text (English only) to synthesize audio (or press 🎲 for random text).
+* Listen to the two audio clips, one after the other.
+* Vote on which audio sounds more natural to you.
+"""
+INSTR = """
+## Vote
+* Input text (English only) to synthesize audio (or press 🎲 for random text).
+* Listen to the two audio clips, one after the other.
+* Vote on which audio sounds more natural to you.
+* _Note: Model names are revealed after the vote is cast._
+Note: It may take up to 30 seconds to synthesize audio.
+""".strip()
+request = ""
+if SPACE_ID:
+    request = f"""
+### Request a model
+Please [create a Discussion](https://huggingface.co/spaces/{SPACE_ID}/discussions/new) to request a model.
+"""
+ABOUT = f"""
+## About
+The TTS Arena evaluates leading speech synthesis models. It is inspired by LMsys's [Chatbot Arena](https://chat.lmsys.org/).
+### Motivation
+The field of speech synthesis has long lacked an accurate method to measure the quality of different models. Objective metrics like WER (word error rate) are unreliable measures of model quality, and subjective measures such as MOS (mean opinion score) are typically small-scale experiments conducted with few listeners. As a result, these measurements are generally not useful for comparing two models of roughly similar quality. To address these drawbacks, we are inviting the community to rank models in an easy-to-use interface, and opening it up to the public in order to make both the opportunity to rank models, as well as the results, more easily accessible to everyone.
+### The Arena
+The leaderboard allows a user to enter text, which will be synthesized by two models. After listening to each sample, the user can vote on which model sounds more natural. Due to the risks of human bias and abuse, model names are revealed only after a vote is submitted.
+### Credits
+Thank you to the following individuals who helped make this project possible:
+* VB ([Twitter](https://twitter.com/reach_vb) / [Hugging Face](https://huggingface.co/reach-vb))
+* Clémentine Fourrier ([Twitter](https://twitter.com/clefourrier) / [Hugging Face](https://huggingface.co/clefourrier))
+* Lucain Pouget ([Twitter](https://twitter.com/Wauplin) / [Hugging Face](https://huggingface.co/Wauplin))
+* Yoach Lacombe ([Twitter](https://twitter.com/yoachlacombe) / [Hugging Face](https://huggingface.co/ylacombe))
+* Main Horse ([Twitter](https://twitter.com/main_horse) / [Hugging Face](https://huggingface.co/main-horse))
+* Sanchit Gandhi ([Twitter](https://twitter.com/sanchitgandhi99) / [Hugging Face](https://huggingface.co/sanchit-gandhi))
+* Apolinário Passos ([Twitter](https://twitter.com/multimodalart) / [Hugging Face](https://huggingface.co/multimodalart))
+* Pedro Cuenca ([Twitter](https://twitter.com/pcuenq) / [Hugging Face](https://huggingface.co/pcuenq))
+{request}
+### Privacy statement
+We may store text you enter and generated audio. We store a unique ID for each session. You agree that we may collect, share, and/or publish any data you input for research and/or commercial purposes.
+### License
+Generated audio clips cannot be redistributed and may be used for personal, non-commercial use only.
+Random sentences are sourced from a filtered subset of the [Harvard Sentences](https://www.cs.columbia.edu/~hgs/audio/harvard.html).
+""".strip()
+LDESC = """
+## 🏆 Leaderboard
+Vote to help the community determine the best language models.
+The leaderboard displays models in descending order based on votes cast by the community.
+Important: In order to help keep results fair, the leaderboard hides results by default until the number of votes passes a threshold. 
+Tick the `Show preliminary results` to show models with few votes. Please note that preliminary results may be inaccurate.
+""".strip()
+ABOUT_MD = """
+# 🤖 LLM Arena
+
+A platform for comparing and ranking different Large Language Models through human feedback.
+
+## How it works
+
+1. **Battle Mode**: Compare responses from two different LLMs side-by-side and vote for the better one
+2. **Leaderboard**: See how models rank against each other based on user votes
+3. **Fair Comparison**: Models are randomly selected and anonymized during voting to prevent bias
+
+## Contributing
+
+Want to add a new model? Check out our [GitHub repository](link-to-repo) for instructions.
+
+## License
+
+This project is licensed under MIT License. Individual models may have their own licenses.
+"""

app/models.py

@@ -0,0 +1,19 @@
+# Models to include in the leaderboard
+AVAILABLE_MODELS = {
+    "GPT-4": "gpt4",
+    "Claude-3": "claude3",
+    "Gemini-Pro": "gemini",
+    "Mixtral": "mixtral",
+    "Llama-2": "llama2",
+    # Add more models as needed
+}
+
+# Model name mapping for display
+model_names = {
+    "gpt4": "GPT-4",
+    "claude3": "Claude-3",
+    "gemini": "Gemini-Pro",
+    "mixtral": "Mixtral",
+    "llama2": "Llama-2",
+    # Add more mappings as needed
+}

app/ui.py

@@ -0,0 +1,12 @@
+import gradio as gr
+from .config import *
+from .messages import *
+from .ui_battle import *
+from .ui_leaderboard import *
+
+with gr.Blocks() as about:
+    gr.Markdown(ABOUT_MD)
+
+with gr.Blocks(css="footer {visibility: hidden}", title="LLM Arena") as app:
+    gr.Markdown(ABOUT_MD)
+    gr.TabbedInterface([battle, leaderboard, about], ['Battle', 'Leaderboard', 'About'])

app/ui_battle.py

@@ -0,0 +1,132 @@
+import gradio as gr
+from .config import *
+from .vote import *
+from .messages import *
+from .llm import *
+import random
+
+def disable():
+    return [gr.update(interactive=False), gr.update(interactive=False)]
+def enable():
+    return [gr.update(interactive=True), gr.update(interactive=True)]
+
+with gr.Blocks() as battle:
+    battle_useridstate = gr.State()
+    
+    gr.Markdown("## 🤖 LLM Battle\nCompare two AI responses and vote for the better one!")
+    
+    with gr.Group():
+        with gr.Row():
+            prompt = gr.Textbox(
+                container=False, 
+                show_label=False, 
+                placeholder="Enter your prompt here...", 
+                lines=3,
+                max_lines=10,
+                scale=9999999,
+                min_width=0
+            )
+            random_prompt = gr.Button('🎲', scale=0, min_width=0, variant='tool')
+            
+    btn = gr.Button("Generate Responses", variant='primary')
+    
+    with gr.Row(visible=False) as response_row:
+        with gr.Column():
+            with gr.Group():
+                response1 = gr.Textbox(
+                    label="Model A Response",
+                    lines=8,
+                    max_lines=8,
+                    interactive=False
+                )
+                a_better = gr.Button("A is better", variant='primary')
+                model1_name = gr.Textbox(
+                    interactive=False,
+                    show_label=False,
+                    container=False,
+                    value="Vote to reveal model A",
+                    text_align="center",
+                    visible=False
+                )
+        with gr.Column():
+            with gr.Group():
+                response2 = gr.Textbox(
+                    label="Model B Response",
+                    lines=8,
+                    max_lines=8,
+                    interactive=False
+                )
+                b_better = gr.Button("B is better", variant='primary')
+                model2_name = gr.Textbox(
+                    interactive=False,
+                    show_label=False,
+                    container=False,
+                    value="Vote to reveal model B",
+                    text_align="center",
+                    visible=False
+                )
+
+    def generate_responses(prompt):
+        if len(prompt.strip()) < MIN_PROMPT_LENGTH:
+            raise gr.Error(f"Prompt must be at least {MIN_PROMPT_LENGTH} characters")
+        if len(prompt.strip()) > MAX_PROMPT_LENGTH:
+            raise gr.Error(f"Prompt must be less than {MAX_PROMPT_LENGTH} characters")
+            
+        model_a, model_b = random_models()
+        resp_a, resp_b = get_responses(prompt, model_a, model_b)
+        
+        return [
+            resp_a,  # response1
+            resp_b,  # response2
+            model_a,  # model1_name (actual model identifier)
+            model_b,  # model2_name (actual model identifier)
+            gr.update(visible=True),  # response_row
+            gr.update(interactive=True, visible=True),  # a_better
+            gr.update(interactive=True, visible=True),  # b_better
+            gr.update(visible=False),  # model1_name visibility
+            gr.update(visible=False)   # model2_name visibility
+        ]
+
+    # Event handlers
+    btn.click(
+        fn=generate_responses,
+        inputs=[prompt],
+        outputs=[
+            response1, 
+            response2, 
+            model1_name, 
+            model2_name, 
+            response_row, 
+            a_better, 
+            b_better,
+            model1_name,
+            model2_name
+        ]
+    )
+
+    a_better.click(
+        fn=a_is_better,
+        inputs=[model1_name, model2_name, battle_useridstate, prompt, response1, response2],
+        outputs=[a_better, b_better, model1_name, model2_name]
+    )
+    
+    b_better.click(
+        fn=b_is_better,
+        inputs=[model1_name, model2_name, battle_useridstate, prompt, response1, response2],
+        outputs=[a_better, b_better, model1_name, model2_name]
+    )
+
+    def get_random_prompt():
+        prompts = [
+            "What are the key differences between Python and JavaScript?",
+            "Explain quantum computing in simple terms.",
+            "Write a short story about a robot learning to feel emotions.",
+            "What are the pros and cons of remote work?",
+            "Explain how blockchain technology works."
+        ]
+        return random.choice(prompts)
+        
+    random_prompt.click(
+        fn=get_random_prompt,
+        outputs=[prompt]
+    )

app/ui_leaderboard.py

@@ -0,0 +1,46 @@
+import gradio as gr
+from .config import *
+from .leaderboard import *
+from .messages import *
+
+with gr.Blocks() as leaderboard:
+    gr.Markdown(LDESC)
+    
+    df = gr.Dataframe(
+        headers=['Rank', 'Model', 'Score', 'Total Votes'],
+        interactive=False,
+        wrap=True,
+        column_widths=['80px', '200px', '100px', '100px']
+    )
+    
+    reloadbtn = gr.Button("🔄 Refresh")
+    
+    reveal_prelim = gr.Checkbox(
+        label="Show preliminary results",
+        info="Include models with few votes",
+        value=True
+    )
+
+    def update_leaderboard(reveal_prelim):
+        return get_leaderboard(reveal_prelim)
+
+    # Update on checkbox changes
+    reveal_prelim.change(
+        update_leaderboard,
+        inputs=[reveal_prelim],
+        outputs=[df]
+    )
+    
+    # Update on refresh button click
+    reloadbtn.click(
+        update_leaderboard,
+        inputs=[reveal_prelim],
+        outputs=[df]
+    )
+    
+    # Initial load
+    leaderboard.load(
+        update_leaderboard,
+        inputs=[reveal_prelim],
+        outputs=[df]
+    )

app/utils.py

@@ -0,0 +1,6 @@
+import uuid
+
+def mkuuid(uid):
+    if not uid:
+        uid = uuid.uuid4()
+    return uid

app/vote.py

@@ -0,0 +1,124 @@
+from .utils import *
+from .config import *
+from .models import *
+from .db import *
+from .init import *
+
+import gradio as gr
+
+# Vote
+
+def upvote_model(model, uname, prompt="", response=""):
+    print("Establishing database connection for upvoting.")
+    conn = get_db()
+    cursor = conn.cursor()
+    print(f"Updating upvote count for model: {model}")
+    cursor.execute('UPDATE model SET upvote = upvote + 1 WHERE name = ?', (model,))
+    if cursor.rowcount == 0:
+        print(f"No existing entry found for model '{model}'. Inserting new model with upvote=1 and downvote=0.")
+        cursor.execute('INSERT OR REPLACE INTO model (name, upvote, downvote) VALUES (?, 1, 0)', (model,))
+    print(f"Inserting vote record: username={uname}, model={model}, vote=1, prompt={prompt}, response={response}")
+    cursor.execute('INSERT INTO vote (username, model, vote, prompt, response) VALUES (?, ?, ?, ?, ?)', 
+                  (uname, model, 1, prompt, response))
+    print("Committing upvote transaction.")
+    conn.commit()
+    print("Closing cursor after upvoting.")
+    cursor.close()
+
+def downvote_model(model, uname, prompt="", response=""):
+    print("Establishing database connection for downvoting.")
+    conn = get_db()
+    cursor = conn.cursor()
+    print(f"Updating downvote count for model: {model}")
+    cursor.execute('UPDATE model SET downvote = downvote + 1 WHERE name = ?', (model,))
+    if cursor.rowcount == 0:
+        print(f"No existing entry found for model '{model}'. Inserting new model with upvote=0 and downvote=1.")
+        cursor.execute('INSERT OR REPLACE INTO model (name, upvote, downvote) VALUES (?, 0, 1)', (model,))
+    print(f"Inserting vote record: username={uname}, model={model}, vote=-1, prompt={prompt}, response={response}")
+    cursor.execute('INSERT INTO vote (username, model, vote, prompt, response) VALUES (?, ?, ?, ?, ?)', 
+                  (uname, model, -1, prompt, response))
+    print("Committing downvote transaction.")
+    conn.commit()
+    print("Closing cursor after downvoting.")
+    cursor.close()
+
+# Battle Mode
+
+def a_is_better(model1, model2, userid, prompt="", response1="", response2=""):
+    print("Processing vote: A is better.")
+    print(f"Comparing models: {model1} vs {model2}")
+    if not model1 in AVAILABLE_MODELS.keys() and not model1 in AVAILABLE_MODELS.values():
+        print(f"Model '{model1}' is not available. Raising error.")
+        raise gr.Error('Sorry, please try voting again.')
+    userid = mkuuid(userid)
+    print(f"Generated UUID for user: {userid}")
+    if model1 and model2:
+        print("Establishing database connection for voting.")
+        conn = get_db()
+        cursor = conn.cursor()
+        print(f"Inserting votelog: username={userid}, chosen={model1}, rejected={model2}, prompt={prompt}, chosen_response={response1}, rejected_response={response2}")
+        cursor.execute('INSERT INTO votelog (username, chosen, rejected, prompt, chosen_response, rejected_response) VALUES (?, ?, ?, ?, ?, ?)', 
+                      (str(userid), model1, model2, prompt, response1, response2))
+        if scheduler:
+            print("Scheduler detected. Acquiring scheduler lock before committing.")
+            with scheduler.lock:
+                print("Committing votelog transaction with scheduler lock.")
+                conn.commit()
+        else:
+            print("Committing votelog transaction without scheduler lock.")
+            conn.commit()
+        print("Closing cursor after logging vote.")
+        cursor.close()
+        print(f"Upvoting model: {model1}")
+        upvote_model(model1, str(userid), prompt, response1)
+        print(f"Downvoting model: {model2}")
+        downvote_model(model2, str(userid), prompt, response2)
+    print("Reloading UI after voting.")
+    return reload(model1, model2, userid, chose_a=True)
+
+def b_is_better(model1, model2, userid, prompt="", response1="", response2=""):
+    print("Processing vote: B is better.")
+    print(f"Comparing models: {model1} vs {model2}")
+    if not model1 in AVAILABLE_MODELS.keys() and not model1 in AVAILABLE_MODELS.values():
+        print(f"Model '{model1}' is not available. Raising error.")
+        raise gr.Error('Sorry, please try voting again.')
+    userid = mkuuid(userid)
+    print(f"Generated UUID for user: {userid}")
+    if model1 and model2:
+        print("Establishing database connection for voting.")
+        conn = get_db()
+        cursor = conn.cursor()
+        print(f"Inserting votelog: username={userid}, chosen={model2}, rejected={model1}, prompt={prompt}, chosen_response={response2}, rejected_response={response1}")
+        cursor.execute('INSERT INTO votelog (username, chosen, rejected, prompt, chosen_response, rejected_response) VALUES (?, ?, ?, ?, ?, ?)', 
+                      (str(userid), model2, model1, prompt, response2, response1))
+        if scheduler:
+            print("Scheduler detected. Acquiring scheduler lock before committing.")
+            with scheduler.lock:
+                print("Committing votelog transaction with scheduler lock.")
+                conn.commit()
+        else:
+            print("Committing votelog transaction without scheduler lock.")
+            conn.commit()
+        print("Closing cursor after logging vote.")
+        cursor.close()
+        print(f"Upvoting model: {model2}")
+        upvote_model(model2, str(userid), prompt, response2)
+        print(f"Downvoting model: {model1}")
+        downvote_model(model1, str(userid), prompt, response1)
+    print("Reloading UI after voting.")
+    return reload(model1, model2, userid, chose_b=True)
+
+# Reload
+
+def reload(chosenmodel1=None, chosenmodel2=None, userid=None, chose_a=False, chose_b=False):
+    out = [
+        gr.update(interactive=False),  # a_better
+        gr.update(interactive=False),  # b_better
+        gr.update(value=f"Selected: {chosenmodel1}" if chose_a else chosenmodel1, 
+                 interactive=False, 
+                 visible=True),  # model1_name
+        gr.update(value=f"Selected: {chosenmodel2}" if chose_b else chosenmodel2, 
+                 interactive=False, 
+                 visible=True)   # model2_name
+    ]
+    return out

requirements.txt

@@ -0,0 +1,3 @@
+pandas
+sqlite3
+huggingface_hub

scripts/view_db.py

@@ -0,0 +1,61 @@
+import sqlite3
+import pandas as pd
+from tabulate import tabulate
+
+def view_db_content():
+    conn = sqlite3.connect("database.db")
+    
+    # Get models and their votes
+    print("\n=== Models and Vote Counts ===")
+    models_df = pd.read_sql_query("""
+        SELECT 
+            name,
+            upvote,
+            downvote,
+            CAST(upvote AS FLOAT) / NULLIF(upvote + downvote, 0) * 100 as win_rate,
+            upvote + downvote as total_votes
+        FROM model
+        ORDER BY win_rate DESC
+    """, conn)
+    print(tabulate(models_df, headers='keys', tablefmt='psql', showindex=False))
+    
+    # Get recent votes with response previews
+    print("\n=== Recent Votes ===")
+    votes_df = pd.read_sql_query("""
+        SELECT 
+            username,
+            model,
+            CASE 
+                WHEN vote = 1 THEN 'upvote'
+                ELSE 'downvote'
+            END as vote_type,
+            substr(prompt, 1, 50) || '...' as prompt_preview,
+            substr(response, 1, 50) || '...' as response_preview,
+            datetime(timestamp, 'localtime') as local_time
+        FROM vote
+        ORDER BY timestamp DESC
+        LIMIT 10
+    """, conn)
+    print(tabulate(votes_df, headers='keys', tablefmt='psql', showindex=False))
+    
+    # Get recent battles with response previews
+    print("\n=== Recent Battles ===")
+    battles_df = pd.read_sql_query("""
+        SELECT 
+            username,
+            chosen as winner,
+            rejected as loser,
+            substr(prompt, 1, 50) || '...' as prompt_preview,
+            substr(chosen_response, 1, 50) || '...' as winner_response,
+            substr(rejected_response, 1, 50) || '...' as loser_response,
+            datetime(timestamp, 'localtime') as local_time
+        FROM votelog
+        ORDER BY timestamp DESC
+        LIMIT 10
+    """, conn)
+    print(tabulate(battles_df, headers='keys', tablefmt='psql', showindex=False))
+    
+    conn.close()
+
+if __name__ == "__main__":
+    view_db_content()