Update fun_stats.py

fun_stats.py

@@ -1,30 +1,193 @@
 import json
-import os
+from datetime import datetime, timezone
+from typing import Dict, Any
+from nc_py_api import Nextcloud
+import arena_config
+from leaderboard import load_leaderboard, get_human_readable_name, get_model_size
 
-LEADERBOARD_FILE = "leaderboard.json"
+def get_internal_stats() -> Dict[str, Any]:
+    leaderboard = load_leaderboard()
+    
+    total_battles = sum(
+        model_data['wins'] + model_data['losses']
+        for model_data in leaderboard.values()
+    )
+    
+    timestamp = datetime.now().strftime("%Y-%m-%d %H:%M:%S")
+    
+    active_models = len(leaderboard)
+    
+    most_battles = max(
+        (model_data['wins'] + model_data['losses'], model)
+        for model, model_data in leaderboard.items()
+    )
+    
+    highest_win_rate = max(
+        (model_data['wins'] / (model_data['wins'] + model_data['losses']) if (model_data['wins'] + model_data['losses']) > 0 else 0, model)
+        for model, model_data in leaderboard.items()
+    )
+    
+    most_diverse_opponent = max(
+        (len(model_data['opponents']), model)
+        for model, model_data in leaderboard.items()
+    )
+    
+    stats = {
+        "timestamp": timestamp,
+        "total_battles": total_battles,
+        "active_models": active_models,
+        "most_battles": {
+            "model": get_human_readable_name(most_battles[1]),
+            "battles": most_battles[0]
+        },
+        "highest_win_rate": {
+            "model": get_human_readable_name(highest_win_rate[1]),
+            "win_rate": f"{highest_win_rate[0]:.2%}"
+        },
+        "most_diverse_opponent": {
+            "model": get_human_readable_name(most_diverse_opponent[1]),
+            "unique_opponents": most_diverse_opponent[0]
+        }
+    }
+    
+    return stats
 
-def load_leaderboard():
-    if not os.path.exists(LEADERBOARD_FILE):
-        return {}
-    with open(LEADERBOARD_FILE, 'r') as f:
-        return json.load(f)
+def save_internal_stats(stats: Dict[str, Any]) -> bool:
+    nc = Nextcloud(
+        nextcloud_url=arena_config.NEXTCLOUD_URL,
+        nc_auth_user=arena_config.NEXTCLOUD_USERNAME,
+        nc_auth_pass=arena_config.NEXTCLOUD_PASSWORD
+    )
+    
+    try:
+        json_data = json.dumps(stats, indent=2)
+        nc.files.upload(arena_config.NEXTCLOUD_INTERNAL_STATS_PATH, json_data.encode('utf-8'))
+        return True
+    except Exception as e:
+        print(f"Error saving internal stats to Nextcloud: {str(e)}")
+        return False
+
+def save_local_stats(stats: Dict[str, Any], filename: str = "internal_stats.json") -> bool:
+    try:
+        with open(filename, 'w') as f:
+            json.dump(stats, f, indent=2)
+        return True
+    except Exception as e:
+        print(f"Error saving internal stats to local file: {str(e)}")
+        return False
 
-def get_fun_stats() -> str:
+def get_fun_stats() -> Dict[str, Any]:
     leaderboard = load_leaderboard()
-    if not leaderboard:
-        return "No stats available yet."
     
-    total_battles = sum(data['wins'] + data['losses'] for data in leaderboard.values())
-    total_wins = sum(data['wins'] for data in leaderboard.values())
-    total_losses = sum(data['losses'] for data in leaderboard.values())
-    win_rate = (total_wins / total_battles * 100) if total_battles > 0 else 0
+    total_battles = sum(
+        model_data['wins'] + model_data['losses']
+        for model_data in leaderboard.values()
+    )
+    
+    timestamp = datetime.now(timezone.utc).strftime("%Y-%m-%d %H:%M:%S UTC")
+    
+    active_models = len(leaderboard)
+    
+    most_battles = max(
+        (model_data['wins'] + model_data['losses'], model)
+        for model, model_data in leaderboard.items()
+    )
+    
+    highest_win_rate = max(
+        (model_data['wins'] / (model_data['wins'] + model_data['losses']) if (model_data['wins'] + model_data['losses']) > 0 else 0, model)
+        for model, model_data in leaderboard.items()
+    )
+    
+    most_diverse_opponent = max(
+        (len(model_data['opponents']), model)
+        for model, model_data in leaderboard.items()
+    )
+    
+    # Existing fun stats
+    underdog_champion = min(
+        ((get_model_size(model), model_data['wins'] / (model_data['wins'] + model_data['losses'])) if (model_data['wins'] + model_data['losses']) > 0 else (get_model_size(model), 0), model)
+        for model, model_data in leaderboard.items()
+    )
+    
+    most_consistent = min(
+        (abs(model_data['wins'] - model_data['losses']), model)
+        for model, model_data in leaderboard.items()
+        if (model_data['wins'] + model_data['losses']) > 10  # Minimum battles threshold
+    )
+    
+    biggest_rivalry = max(
+        (results['wins'] + results['losses'], (model, opponent))
+        for model, data in leaderboard.items()
+        for opponent, results in data['opponents'].items()
+    )
+    
+    # New fun stats
+    david_vs_goliath = max(
+        ((get_model_size(opponent) - get_model_size(model), model_data['opponents'][opponent]['wins']), (model, opponent))
+        for model, model_data in leaderboard.items()
+        for opponent in model_data['opponents']
+        if get_model_size(opponent) > get_model_size(model) and model_data['opponents'][opponent]['wins'] > 0
+    )
+    
+    comeback_king = max(
+        (model_data['wins'] - model_data['losses'], model)
+        for model, model_data in leaderboard.items()
+        if model_data['losses'] > model_data['wins']
+    )
+    
+    pyrrhic_victor = min(
+        (model_data['wins'] / (model_data['wins'] + model_data['losses']) if (model_data['wins'] + model_data['losses']) > 0 else float('inf'), model)
+        for model, model_data in leaderboard.items()
+        if model_data['wins'] > model_data['losses'] and (model_data['wins'] + model_data['losses']) > 10
+    )
+    
+    stats = {
+        "timestamp": timestamp,
+        "total_battles": total_battles,
+        "active_models": active_models,
+        "most_battles": {
+            "model": get_human_readable_name(most_battles[1]),
+            "battles": most_battles[0]
+        },
+        "highest_win_rate": {
+            "model": get_human_readable_name(highest_win_rate[1]),
+            "win_rate": f"{highest_win_rate[0]:.2%}"
+        },
+        "most_diverse_opponent": {
+            "model": get_human_readable_name(most_diverse_opponent[1]),
+            "unique_opponents": most_diverse_opponent[0]
+        },
+        "underdog_champion": {
+            "model": get_human_readable_name(underdog_champion[1]),
+            "size": f"{underdog_champion[0][0]}B",
+            "win_rate": f"{underdog_champion[0][1]:.2%}"
+        },
+        "most_consistent": {
+            "model": get_human_readable_name(most_consistent[1]),
+            "win_loss_difference": most_consistent[0]
+        },
+        "biggest_rivalry": {
+            "model1": get_human_readable_name(biggest_rivalry[1][0]),
+            "model2": get_human_readable_name(biggest_rivalry[1][1]),
+            "total_battles": biggest_rivalry[0]
+        },
+        "david_vs_goliath": {
+            "david": get_human_readable_name(david_vs_goliath[1][0]),
+            "goliath": get_human_readable_name(david_vs_goliath[1][1]),
+            "size_difference": f"{david_vs_goliath[0][0]:.1f}B",
+            "wins": david_vs_goliath[0][1]
+        },
+        "comeback_king": {
+            "model": get_human_readable_name(comeback_king[1]),
+            "comeback_margin": comeback_king[0]
+        },
+        "pyrrhic_victor": {
+            "model": get_human_readable_name(pyrrhic_victor[1]),
+            "win_rate": f"{pyrrhic_victor[0]:.2%}"
+        }
+    }
+    
+    return stats
 
-    stats_html = f"""
-    <ul>
-        <li><strong>Total Battles:</strong> {total_battles}</li>
-        <li><strong>Total Wins:</strong> {total_wins}</li>
-        <li><strong>Total Losses:</strong> {total_losses}</li>
-        <li><strong>Overall Win Rate:</strong> {win_rate:.2f}%</li>
-    </ul>
-    """
-    return stats_html
+if __name__ == "__main__":
+    stats = get_internal_stats()