Update leaderboard.py

leaderboard.py

@@ -7,7 +7,6 @@ import config
 import math
 from nc_py_api import Nextcloud
 
-
 # Dictionary to store ELO ratings
 elo_ratings = {}
 
@@ -28,6 +27,37 @@ def load_leaderboard() -> Dict[str, Any]:
         print(f"Error loading leaderboard: {str(e)}")
         return {}
 
+def load_archived_models() -> Dict[str, Any]:
+    try:
+        nc = Nextcloud(
+            nextcloud_url=config.NEXTCLOUD_URL,
+            nc_auth_user=config.NEXTCLOUD_USERNAME,
+            nc_auth_pass=config.NEXTCLOUD_PASSWORD
+        )
+        file_content = nc.files.download(config.ARCHIVED_MODELS_PATH)
+        if file_content:
+            return json.loads(file_content.decode('utf-8'))
+        else:
+            print(f"Error loading archived models: Received empty content from Nextcloud at {config.ARCHIVED_MODELS_PATH}")
+            return {}
+    except Exception as e:
+        print(f"Error loading archived models: {str(e)}")
+        return {}
+
+def save_archived_models(archived_data: Dict[str, Any]) -> bool:
+    try:
+        nc = Nextcloud(
+            nextcloud_url=config.NEXTCLOUD_URL,
+            nc_auth_user=config.NEXTCLOUD_USERNAME,
+            nc_auth_pass=config.NEXTCLOUD_PASSWORD
+        )
+        json_data = json.dumps(archived_data, indent=2)
+        nc.files.upload(config.ARCHIVED_MODELS_PATH, json_data.encode('utf-8'))
+        return True
+    except Exception as e:
+        print(f"Error saving archived models: {str(e)}")
+        return False
+
 def save_leaderboard(leaderboard_data: Dict[str, Any]) -> bool:
     try:
         nc = Nextcloud(
@@ -112,21 +142,27 @@ def update_elo_ratings(winner, loser):
 
 def initialize_elo_ratings():
     leaderboard = load_leaderboard()
+    archived_models = load_archived_models()
+    
+    # Initialize ELO for active models
     for model, _ in config.get_approved_models():
-        size = get_model_size(model)
-        elo_ratings[model] = 1000 + (size * 100)
+        if model not in archived_models:
+            size = get_model_size(model)
+            elo_ratings[model] = 1000 + (size * 100)
     
-    # Replay all battles to update ELO ratings
+    # Replay all battles to update ELO ratings for active models
     for model, data in leaderboard.items():
-        if model not in elo_ratings:
-            elo_ratings[model] = 1000 + (get_model_size(model) * 100)
-        for opponent, results in data['opponents'].items():
-            if opponent not in elo_ratings:
-                elo_ratings[opponent] = 1000 + (get_model_size(opponent) * 100)
-            for _ in range(results['wins']):
-                update_elo_ratings(model, opponent)
-            for _ in range(results['losses']):
-                update_elo_ratings(opponent, model)
+        if model not in archived_models: # Only process active models
+            if model not in elo_ratings:
+                elo_ratings[model] = 1000 + (get_model_size(model) * 100)
+            for opponent, results in data['opponents'].items():
+                if opponent not in archived_models: # Only consider active opponents
+                    if opponent not in elo_ratings:
+                        elo_ratings[opponent] = 1000 + (get_model_size(opponent) * 100)
+                    for _ in range(results['wins']):
+                        update_elo_ratings(model, opponent)
+                    for _ in range(results['losses']):
+                        update_elo_ratings(opponent, model)
 
 def ensure_elo_ratings_initialized():
     if not elo_ratings:
@@ -134,6 +170,7 @@ def ensure_elo_ratings_initialized():
 
 def update_leaderboard(winner: str, loser: str) -> Dict[str, Any]:
     leaderboard = load_leaderboard()
+    archived_models = load_archived_models()
     
     if winner not in leaderboard:
         leaderboard[winner] = {"wins": 0, "losses": 0, "opponents": {}}
@@ -149,16 +186,59 @@ def update_leaderboard(winner: str, loser: str) -> Dict[str, Any]:
     # Update ELO ratings
     update_elo_ratings(winner, loser)
     
+    # Check if any model needs to be archived
+    for model_name in list(leaderboard.keys()):
+        wins = leaderboard[model_name].get('wins', 0)
+        losses = leaderboard[model_name].get('losses', 0)
+        total_battles = wins + losses
+        
+        if total_battles >= config.ARCHIVE_BATTLE_THRESHOLD:
+            print(f"Archiving model: {model_name} with {total_battles} battles")
+            archived_models[model_name] = leaderboard.pop(model_name)
+            if model_name in elo_ratings:
+                del elo_ratings[model_name] # Remove from active ELO ratings
+    
     save_leaderboard(leaderboard)
+    save_archived_models(archived_models)
     return leaderboard
 
 def get_current_leaderboard() -> Dict[str, Any]:
-    return load_leaderboard()
+    leaderboard = load_leaderboard()
+    archived_models = load_archived_models()
+    
+    # Filter out archived models
+    active_leaderboard = {model: data for model, data in leaderboard.items() if model not in archived_models}
+    return active_leaderboard
 
 def get_human_readable_name(model_name: str) -> str:
     model_dict = dict(config.get_approved_models())
     return model_dict.get(model_name, model_name)
 
+def get_archived_models_list():
+    archived_data = load_archived_models()
+    table_data = []
+    headers = ["Model", "Wins", "Losses", "Total Battles", "Win Rate"]
+
+    for model, results in archived_data.items():
+        wins = results.get('wins', 0)
+        losses = results.get('losses', 0)
+        total_battles = wins + losses
+        win_rate = wins / total_battles if total_battles > 0 else 0
+
+        human_readable = get_human_readable_name(model)
+
+        row = [
+            human_readable,
+            wins,
+            losses,
+            total_battles,
+            f"{win_rate:.1%}"
+        ]
+        table_data.append(row)
+    
+    table_data.sort(key=lambda x: x[3], reverse=True) # Sort by total battles
+    return table_data
+
 def get_leaderboard():
     leaderboard = load_leaderboard()
     
@@ -231,9 +311,15 @@ def get_elo_leaderboard():
     headers = ["#", "Model", "ELO Rating", "Wins", "Losses", "Total Battles", "Win Rate"]
     
     leaderboard = load_leaderboard()
-    all_models = set(dict(config.get_approved_models()).keys()) | set(leaderboard.keys())
     
-    for model in all_models:
+    # Filter out archived models from the active list
+    archived_models = load_archived_models()
+    
+    # Combine approved models and models from the leaderboard, then filter out archived ones
+    all_models = set(dict(config.get_approved_models()).keys()) | set(leaderboard.keys())
+    active_models = [model for model in all_models if model not in archived_models]
+
+    for model in active_models:
         # Get ELO rating
         rating = elo_ratings.get(model, 1000 + (get_model_size(model) * 100))