updates on files path

espn_ldbd/display/tabs.py

@@ -2,11 +2,8 @@ import gradio as gr
 import math
 import re
 
-from espn_ldbd.leaderboard.data import (
-    LeaderboardData,
-    LeaderboardDataset,
-)
-from espn_ldbd.submission.submit import submit_repo
+from espn_ldbd.leaderboard.data import LeaderboardData
+from espn_ldbd.leaderboard.dataset import LeaderboardDataset
 
 
 def create_leaderboard_tab(

espn_ldbd/leaderboard/data.py

@@ -1,15 +1,8 @@
-import os
-import threading
 import math
 from typing import Dict, Tuple
 
 import pandas as pd
 
-from datasets import Dataset, load_dataset, concatenate_datasets
-
-from huggingface_hub import HfApi
-from huggingface_hub.utils import HfHubHTTPError 
-
 
 class LeaderboardData:
     """Class to manage leaderboard data from datasets"""
@@ -116,128 +109,3 @@ class LeaderboardData:
         paginated_df = df.iloc[start_idx:end_idx].copy()
         
         return paginated_df, page, total_pages
-
-
-class LeaderboardDataset:
-    def __init__(self, min_time_submit: float = 10.0):
-        repo_id = os.environ.get("ESPNET_DB", None)
-        assert repo_id is not None
-        self._repo_id = repo_id
-        self._tasks = load_dataset(repo_id, "task_db", split="train")
-        self._subtasks_db = load_dataset(repo_id, "sub_task_db", split="train")
-        self._subtasks_cache = {}
-        self._new_submits = []
-
-        self._stop_event = threading.Event()
-        self._background_submission = None
-        self._hf_api = HfApi()
-        self._submit_lock = threading.Lock()
-        self._submit_timer = None
-        self._submit_period = min_time_submit
-        return
-
-    @property
-    def get_tasks(self):
-        return self._tasks
-
-    def get_subtasks(self, task_id: str):
-        if task_id not in self._subtasks_cache:
-            subtasks = self._subtasks_db.filter(
-                lambda sample: sample["task_id"] == task_id
-            )
-            self._subtasks_cache[task_id] = subtasks
-        return self._subtasks_cache[task_id]
-
-    def submit_repoid(self, repo_id: str) -> bool:
-        # Try to acquire lock without blocking
-        if not self._submit_lock.acquire(blocking=False):
-            return False, "Submission already in progress."
-
-        message = f"Error in submitting {repo_id}."
-        try:
-            # Cancel any existing timer
-            if self._submit_timer is not None:
-                self._submit_timer.cancel()
-
-            # Set a timer to release the lock after execution
-            def _release_lock():
-                self._submit_lock.release()
-                # print(f"[Dataset] Submit lock released after timeout")
-
-            # Validate existance of repository
-            try:
-                self._hf_api.model_info(repo_id)
-            except HfHubHTTPError as e:
-                return False, "The submitted repository does not exist."
-
-            # TODO(Fhrozen): add validation of repo_id for ESPnet format
-            self._new_submits.append({
-                "model_id": repo_id,
-                "reviewed": False,
-                "date_review": "",
-                "commit_version": "",
-                "valid_repo": True,
-                "need_review": True,
-            })
-            # Set timer to auto-release lock after 5 seconds
-            self._submit_timer = threading.Timer(self._submit_period, _release_lock)
-            self._submit_timer.start()
-
-            return True, ""
-        except Exception as e:
-            # Release lock on any error
-            self._submit_lock.release()
-            # print(f"[Dataset] Error in submit_repoid: {e}")
-            message += f" {e}"
-        return False, message
-
-    def _periodic_submissions_update(self):
-        if len(self._new_submits) == 0:
-            print("[Dataset] No additional submits were found.")
-            return
-
-        request_ds = load_dataset(self._repo_id, "request_db", split="train")
-        num_rows = len(self._new_submits)
-        new_ds = Dataset.from_list(self._new_submits)
-        request_ds = concatenate_datasets([request_ds, new_ds])
-        print(f"[Dataset] Adding {num_rows} new rows to request db.")
-        request_ds.push_to_hub(self._repo_id, config_name="request_db")
-        self._new_submits = []
-        return
-
-    def _scheduler_loop(self, interval_seconds):
-        print(
-            "[Dataset] Background Register submissions thread started. "
-            f"Running every {interval_seconds} seconds."
-        )
-        while not self._stop_event.is_set():
-            self._periodic_submissions_update()
-            self._stop_event.wait(interval_seconds)
-        return
-
-    def start_register_submission(self, hours=0, minutes=0, seconds=0):
-        total_interval = (hours * 3600) + (minutes * 60) + seconds
-        assert total_interval > 0, "Interval must be greater than 0"
-
-        if self._background_submission is not None and self._background_submission.is_alive():
-            print("[Dataset] Register submissions is already running.")
-
-        self._stop_event.clear()
-        # Create the thread
-        # target: the function to run
-        # args: arguments to pass to that function
-        # daemon=True: ensures the thread dies if the main program crashes hard
-        self._background_submission = threading.Thread(
-            target=self._scheduler_loop, 
-            args=(total_interval,),
-            daemon=True
-        )
-        self._background_submission.start()
-
-    def stop_register_submission(self):
-        print("[Dataset] Stopping Register submissions task...")
-        self._stop_event.set() # This breaks the wait() in the loop immediately
-        if self._background_submission:
-            self._background_submission.join() # Wait for the thread to clean up
-        print("[Dataset] Register submissions task stopped.")
-        return

espn_ldbd/leaderboard/dataset.py

@@ -0,0 +1,132 @@
+import os
+import threading
+
+from datasets import Dataset, load_dataset, concatenate_datasets
+
+from huggingface_hub import HfApi
+from huggingface_hub.utils import HfHubHTTPError 
+
+
+class LeaderboardDataset:
+    def __init__(self, min_time_submit: float = 10.0):
+        repo_id = os.environ.get("ESPNET_DB", None)
+        assert repo_id is not None
+        self._repo_id = repo_id
+        self._tasks = load_dataset(repo_id, "task_db", split="train")
+        self._subtasks_db = load_dataset(repo_id, "sub_task_db", split="train")
+        self._subtasks_cache = {}
+        self._new_submits = []
+
+        self._stop_event = threading.Event()
+        self._background_submission = None
+        self._hf_api = HfApi()
+        self._submit_lock = threading.Lock()
+        self._submit_timer = None
+        self._submit_period = min_time_submit
+        return
+
+    @property
+    def get_tasks(self):
+        return self._tasks
+
+    def get_subtasks(self, task_id: str):
+        if task_id not in self._subtasks_cache:
+            subtasks = self._subtasks_db.filter(
+                lambda sample: sample["task_id"] == task_id
+            )
+            self._subtasks_cache[task_id] = subtasks
+        return self._subtasks_cache[task_id]
+
+    def submit_repoid(self, repo_id: str) -> bool:
+        # Try to acquire lock without blocking
+        if not self._submit_lock.acquire(blocking=False):
+            return False, "Submission already in progress."
+
+        message = f"Error in submitting {repo_id}."
+        try:
+            # Cancel any existing timer
+            if self._submit_timer is not None:
+                self._submit_timer.cancel()
+
+            # Set a timer to release the lock after execution
+            def _release_lock():
+                self._submit_lock.release()
+                # print(f"[Dataset] Submit lock released after timeout")
+
+            # Validate existance of repository
+            try:
+                self._hf_api.model_info(repo_id)
+            except HfHubHTTPError as e:
+                return False, "The submitted repository does not exist."
+
+            # TODO(Fhrozen): add validation of repo_id for ESPnet format
+            self._new_submits.append({
+                "model_id": repo_id,
+                "reviewed": False,
+                "date_review": "",
+                "commit_version": "",
+                "valid_repo": True,
+                "need_review": True,
+            })
+            # Set timer to auto-release lock after 5 seconds
+            self._submit_timer = threading.Timer(self._submit_period, _release_lock)
+            self._submit_timer.start()
+
+            return True, ""
+        except Exception as e:
+            # Release lock on any error
+            self._submit_lock.release()
+            # print(f"[Dataset] Error in submit_repoid: {e}")
+            message += f" {e}"
+        return False, message
+
+    def _periodic_submissions_update(self):
+        if len(self._new_submits) == 0:
+            print("[Dataset] No additional submits were found.")
+            return
+
+        request_ds = load_dataset(self._repo_id, "request_db", split="train")
+        num_rows = len(self._new_submits)
+        new_ds = Dataset.from_list(self._new_submits)
+        request_ds = concatenate_datasets([request_ds, new_ds])
+        print(f"[Dataset] Adding {num_rows} new rows to request db.")
+        request_ds.push_to_hub(self._repo_id, config_name="request_db")
+        self._new_submits = []
+        return
+
+    def _scheduler_loop(self, interval_seconds):
+        print(
+            "[Dataset] Background Register submissions thread started. "
+            f"Running every {interval_seconds} seconds."
+        )
+        while not self._stop_event.is_set():
+            self._periodic_submissions_update()
+            self._stop_event.wait(interval_seconds)
+        return
+
+    def start_register_submission(self, hours=0, minutes=0, seconds=0):
+        total_interval = (hours * 3600) + (minutes * 60) + seconds
+        assert total_interval > 0, "Interval must be greater than 0"
+
+        if self._background_submission is not None and self._background_submission.is_alive():
+            print("[Dataset] Register submissions is already running.")
+
+        self._stop_event.clear()
+        # Create the thread
+        # target: the function to run
+        # args: arguments to pass to that function
+        # daemon=True: ensures the thread dies if the main program crashes hard
+        self._background_submission = threading.Thread(
+            target=self._scheduler_loop, 
+            args=(total_interval,),
+            daemon=True
+        )
+        self._background_submission.start()
+
+    def stop_register_submission(self):
+        print("[Dataset] Stopping Register submissions task...")
+        self._stop_event.set() # This breaks the wait() in the loop immediately
+        if self._background_submission:
+            self._background_submission.join() # Wait for the thread to clean up
+        print("[Dataset] Register submissions task stopped.")
+        return