Update leaderboard.py

leaderboard.py

@@ -7,6 +7,7 @@ import config
 import math
 from nc_py_api import Nextcloud
 
+
 # Dictionary to store ELO ratings
 elo_ratings = {}
 
@@ -27,37 +28,6 @@ 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(
@@ -142,27 +112,21 @@ 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():
-        if model not in archived_models:
-            size = get_model_size(model)
-            elo_ratings[model] = 1000 + (size * 100)
+        size = get_model_size(model)
+        elo_ratings[model] = 1000 + (size * 100)
     
-    # Replay all battles to update ELO ratings for active models
+    # Replay all battles to update ELO ratings
     for model, data in leaderboard.items():
-        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)
+        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)
 
 def ensure_elo_ratings_initialized():
     if not elo_ratings:
@@ -170,7 +134,6 @@ 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": {}}
@@ -186,59 +149,16 @@ 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]:
-    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
+    return load_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()
     
@@ -311,15 +231,9 @@ def get_elo_leaderboard():
     headers = ["#", "Model", "ELO Rating", "Wins", "Losses", "Total Battles", "Win Rate"]
     
     leaderboard = load_leaderboard()
-    
-    # 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:
+    
+    for model in all_models:
         # Get ELO rating
         rating = elo_ratings.get(model, 1000 + (get_model_size(model) * 100))
         
@@ -354,7 +268,7 @@ def get_elo_leaderboard():
     return table_data
 
 def create_backup():
-    # while True:
+    while True:
         try:
             leaderboard_data = load_leaderboard()
             timestamp = datetime.now().strftime("%Y%m%d_%H%M%S")
@@ -370,7 +284,7 @@ def create_backup():
             print(f"Backup created on Nextcloud: {backup_path}")
         except Exception as e:
             print(f"Error creating backup: {e}")
-        # time.sleep(43200)  # Sleep for 12 HOURS
+        time.sleep(43200)  # Sleep for 12 HOURS
 
 def start_backup_thread():
     backup_thread = threading.Thread(target=create_backup, daemon=True)