Update app.py

app.py

@@ -20,7 +20,6 @@ import openai
 import threading
 import time
 from collections import Counter
-from model_suggestions import add_suggestion, get_suggestions_html
 from release_notes import get_release_notes_html
 
 
@@ -85,7 +84,7 @@ def call_ollama_api(model, prompt):
     )
     
     try:
-        logger.info("Starting API call")
+        logger.info(f"Starting API call for model: {model}")
         response = client.chat.completions.create(
             model=model,
             messages=[
@@ -100,10 +99,10 @@ def call_ollama_api(model, prompt):
             ],
             timeout=180
         )
-        logger.info("Received response")
+        logger.info(f"Received response for model: {model}")
         
         if not response or not response.choices:
-            logger.error("Empty response received")
+            logger.error(f"Empty response received for model: {model}")
             return [
                 {"role": "user", "content": prompt},
                 {"role": "assistant", "content": "Error: Empty response from the model"}
@@ -111,7 +110,7 @@ def call_ollama_api(model, prompt):
             
         content = response.choices[0].message.content
         if not content:
-            logger.error("Empty content received")
+            logger.error(f"Empty content received for model: {model}")
             return [
                 {"role": "user", "content": prompt},
                 {"role": "assistant", "content": "Error: Empty content from the model"}
@@ -124,30 +123,37 @@ def call_ollama_api(model, prompt):
             thinking_content = thinking_match.group(1).strip()
             main_content = re.sub(r'<think>.*?</think>', '', content, flags=re.DOTALL).strip()
             
-            logger.info("Found thinking content, creating structured response")
+            logger.info(f"Found thinking content for model: {model}")
             return [
                 {"role": "user", "content": prompt},
                 {"role": "assistant", "content": f"{main_content}\n\n<details><summary>🤔 View thinking process</summary>\n\n{thinking_content}\n\n</details>"}
             ]
         
         # If no thinking tags, return normal content
-        logger.info("No thinking tags found, returning normal content")
+        logger.info(f"No thinking tags found for model: {model}")
         return [
             {"role": "user", "content": prompt},
             {"role": "assistant", "content": content.strip()}
         ]
         
     except requests.exceptions.Timeout:
-        logger.error("Timeout error after 180 seconds")
+        logger.error(f"Timeout error after 180 seconds for model: {model}")
         return [
             {"role": "user", "content": prompt},
             {"role": "assistant", "content": "Error: Model response timed out after 180 seconds"}
         ]
+    except openai.BadRequestError as e:
+        error_msg = str(e)
+        logger.error(f"Bad request error for model: {model}. Error: {error_msg}")
+        return [
+            {"role": "user", "content": prompt},
+            {"role": "assistant", "content": "Error: Unable to get response from the model"}
+        ]
     except Exception as e:
-        logger.error(f"Error calling Ollama API: {str(e)}", exc_info=True)
+        logger.error(f"Error calling Ollama API for model: {model}. Error: {str(e)}", exc_info=True)
         return [
             {"role": "user", "content": prompt},
-            {"role": "assistant", "content": f"Error: Unable to get response from the model. Error: {str(e)}"}
+            {"role": "assistant", "content": "Error: Unable to get response from the model"}
         ]
 
 # Generate responses using two randomly selected models
@@ -278,12 +284,11 @@ def record_vote(prompt, left_response, right_response, left_model, right_model,
     return (
         gr.update(value=result_message, visible=True),  # Show result as Markdown
         get_leaderboard(),                              # Update leaderboard
-        get_elo_leaderboard(),  # Add this line
+        get_elo_leaderboard(),                         # Update ELO leaderboard
         gr.update(interactive=False),                   # Disable left vote button
         gr.update(interactive=False),                   # Disable right vote button
         gr.update(interactive=False),                   # Disable tie button
-        gr.update(visible=True),                        # Show model names
-        get_leaderboard_chart()                         # Update leaderboard chart
+        gr.update(visible=True)                         # Show model names
     )
 
 def get_leaderboard_chart():
@@ -426,7 +431,20 @@ with gr.Blocks(css="""
     
     # Leaderboard Tab (now first)
     with gr.Tab("Leaderboard"):
-        leaderboard = gr.HTML(label="Leaderboard")
+        gr.Markdown("""
+        ### Main Leaderboard
+        This leaderboard uses a scoring system that balances win rate and total battles. The score is calculated using the formula:
+        **Score = Win Rate * (1 - 1 / (Total Battles + 1))**
+        
+        This formula rewards models with higher win rates and more battles. As the number of battles increases, the score approaches the win rate.
+        """)
+        leaderboard = gr.Dataframe(
+            headers=["Model", "Score", "Wins", "Losses", "Total Battles", "Win Rate"],
+            row_count=10,
+            col_count=6,
+            interactive=False,
+            label="Leaderboard"
+        )
     
     # Battle Arena Tab (now second)
     with gr.Tab("Battle Arena"):
@@ -473,50 +491,23 @@ with gr.Blocks(css="""
         
         new_battle_btn = gr.Button("New Battle")
     
-    # Performance Chart Tab
-    with gr.Tab("Performance Chart"):
-        leaderboard_chart = gr.Plot(label="Model Performance Chart")
-    
     # ELO Leaderboard Tab
     with gr.Tab("ELO Leaderboard"):
-        elo_leaderboard = gr.HTML(label="ELO Leaderboard")
-    
-    # Add this new tab
-    with gr.Tab("Suggest Models"):
-        with gr.Row():
-            model_url_input = gr.Textbox(
-                label="Model URL",
-                placeholder="hf.co/username/model-name-GGUF:Q4_K_M",
-                scale=4
-            )
-            submit_suggestion_btn = gr.Button("Submit Suggestion", scale=1, variant="primary")
-        
-        suggestion_status = gr.Markdown("Submit a model to see it listed below!")
-        suggestions_list = gr.HTML(get_suggestions_html())
-        refresh_suggestions_btn = gr.Button("Refresh List")
-
-        # Update button click handlers
-        submit_suggestion_btn.click(
-            add_suggestion,
-            inputs=[model_url_input],
-            outputs=[suggestion_status]
-        ).then(
-            lambda: (
-                get_suggestions_html(),  # Update suggestions list
-                ""   # Clear model URL input
-            ),
-            outputs=[
-                suggestions_list,
-                model_url_input
-            ]
-        )
-        
-        refresh_suggestions_btn.click(
-            get_suggestions_html,
-            outputs=[suggestions_list]
+        gr.Markdown("""
+        ### ELO Rating System
+        This leaderboard uses a modified ELO rating system that takes into account both the performance and size of the models.
+        Initial ratings are based on model size, with larger models starting at higher ratings.
+        The ELO rating is calculated based on wins and losses, with adjustments made based on the relative strengths of opponents.
+        """)
+        elo_leaderboard = gr.Dataframe(
+            headers=["Model", "ELO Rating", "Wins", "Losses", "Total Battles", "Win Rate"],
+            row_count=10,
+            col_count=6,
+            interactive=False,
+            label="ELO Leaderboard"
         )
     
-    # Add this new tab
+    # Latest Updates Tab
     with gr.Tab("Latest Updates"):
         release_notes = gr.HTML(get_release_notes_html())
         refresh_notes_btn = gr.Button("Refresh Updates")
@@ -541,14 +532,14 @@ with gr.Blocks(css="""
         lambda *args: record_vote(*args, "Left is better"),
         inputs=[prompt_input, left_output, right_output, left_model, right_model],
         outputs=[result, leaderboard, elo_leaderboard, left_vote_btn, 
-                 right_vote_btn, tie_btn, model_names_row, leaderboard_chart]
+                 right_vote_btn, tie_btn, model_names_row]
     )
     
     right_vote_btn.click(
         lambda *args: record_vote(*args, "Right is better"),
         inputs=[prompt_input, left_output, right_output, left_model, right_model],
         outputs=[result, leaderboard, elo_leaderboard, left_vote_btn, 
-                 right_vote_btn, tie_btn, model_names_row, leaderboard_chart]
+                 right_vote_btn, tie_btn, model_names_row]
     )
     
     tie_btn.click(
@@ -561,13 +552,12 @@ with gr.Blocks(css="""
         new_battle,
         outputs=[prompt_input, left_output, right_output, left_model, 
                 right_model, left_vote_btn, right_vote_btn, tie_btn,
-                result, leaderboard, model_names_row, leaderboard_chart, tie_count]
+                result, leaderboard, model_names_row, tie_count]
     )
     
-    # Update leaderboard and chart on launch
+    # Update leaderboard on launch
     demo.load(get_leaderboard, outputs=leaderboard)
     demo.load(get_elo_leaderboard, outputs=elo_leaderboard)
-    demo.load(get_leaderboard_chart, outputs=leaderboard_chart)
 
 if __name__ == "__main__":
     # Initialize ELO ratings before launching the app