Add periodic cache refresh for leaderboard data

- Add background refresh scheduler that checks for new data every hour
- Implement thread-safe caching with configurable TTL (CACHE_TTL_SECONDS env var)
- Register cache clear callback to invalidate viewer cache when data refreshes
- Add refresh_data_if_needed() function for on-demand refresh
- Data is fetched from GitHub repo and cached, then periodically refreshed

This ensures the leaderboard shows fresh data while maintaining good performance
through caching.

app.py

@@ -11,9 +11,13 @@ logger.info("Starting OpenHands Index application")
 
 # Setup mock data before anything else
 try:
-    from setup_data import setup_mock_data
+    from setup_data import setup_mock_data, start_background_refresh, CACHE_TTL_SECONDS
     setup_mock_data()
     logger.info("Data setup completed successfully")
+    
+    # Start background refresh scheduler (checks for new data every hour)
+    start_background_refresh()
+    logger.info(f"Background refresh scheduler started (interval: {CACHE_TTL_SECONDS}s)")
 except Exception as e:
     logger.error(f"Error during data setup: {e}", exc_info=True)
     logger.warning("Continuing with app startup despite error")

setup_data.py

@@ -1,18 +1,33 @@
 """
 Setup script to fetch data from GitHub repository or use mock data as fallback.
 This runs before the app starts to ensure data is available.
+Supports periodic refresh with caching.
 """
 import os
 import shutil
 import subprocess
 import sys
+import threading
+import time
+import logging
 from pathlib import Path
+from datetime import datetime, timedelta
 from config import DATA_DIR, EXTRACTED_DATA_DIR, CONFIG_NAME
 
+logger = logging.getLogger(__name__)
+
 GITHUB_REPO = "https://github.com/OpenHands/openhands-index-results.git"
 # Keep the full repo clone so we can use pydantic models from scripts/
 REPO_CLONE_DIR = Path("/tmp/openhands-index-results")
 
+# Cache management
+_last_fetch_time = None
+_fetch_lock = threading.Lock()
+_refresh_callbacks = []  # Callbacks to call after data refresh
+
+# Cache TTL can be configured via environment variable (default: 1 hour = 3600 seconds)
+CACHE_TTL_SECONDS = int(os.environ.get("CACHE_TTL_SECONDS", 3600))
+
 
 def get_repo_clone_dir() -> Path:
     """Get the path to the cloned openhands-index-results repository."""
@@ -135,28 +150,118 @@ def copy_mock_data():
     print(f"Target directory: {target_dir.absolute()}")
     return True
 
+def register_refresh_callback(callback):
+    """
+    Register a callback to be called after data is refreshed.
+    The callback should clear any caches that depend on the data.
+    """
+    global _refresh_callbacks
+    if callback not in _refresh_callbacks:
+        _refresh_callbacks.append(callback)
+
+
+def _notify_refresh_callbacks():
+    """Notify all registered callbacks that data has been refreshed."""
+    global _refresh_callbacks
+    for callback in _refresh_callbacks:
+        try:
+            callback()
+        except Exception as e:
+            logger.warning(f"Error in refresh callback: {e}")
+
+
+def get_last_fetch_time():
+    """Get the timestamp of the last successful data fetch."""
+    global _last_fetch_time
+    return _last_fetch_time
+
+
+def is_cache_stale():
+    """Check if the cache has expired (older than CACHE_TTL_SECONDS)."""
+    global _last_fetch_time
+    if _last_fetch_time is None:
+        return True
+    return datetime.now() - _last_fetch_time > timedelta(seconds=CACHE_TTL_SECONDS)
+
+
+def refresh_data_if_needed(force: bool = False) -> bool:
+    """
+    Refresh data from GitHub if the cache is stale or if forced.
+    
+    Args:
+        force: If True, refresh regardless of cache age
+        
+    Returns:
+        True if data was refreshed, False otherwise
+    """
+    global _last_fetch_time, _fetch_lock
+    
+    if not force and not is_cache_stale():
+        return False
+    
+    # Use lock to prevent concurrent refreshes
+    if not _fetch_lock.acquire(blocking=False):
+        logger.info("Another refresh is in progress, skipping...")
+        return False
+    
+    try:
+        logger.info("Refreshing data from GitHub...")
+        
+        # Remove old data to force re-fetch
+        target_dir = Path(EXTRACTED_DATA_DIR) / CONFIG_NAME
+        if target_dir.exists():
+            shutil.rmtree(target_dir)
+        
+        # Fetch new data
+        if fetch_data_from_github():
+            _last_fetch_time = datetime.now()
+            logger.info(f"✓ Data refreshed successfully at {_last_fetch_time}")
+            _notify_refresh_callbacks()
+            return True
+        else:
+            # If GitHub fails, try mock data as fallback
+            logger.warning("GitHub fetch failed, trying mock data...")
+            if copy_mock_data():
+                _last_fetch_time = datetime.now()
+                logger.info(f"✓ Using mock data (refreshed at {_last_fetch_time})")
+                _notify_refresh_callbacks()
+                return True
+            logger.error("Failed to refresh data from any source")
+            return False
+    finally:
+        _fetch_lock.release()
+
+
 def setup_mock_data():
     """
     Setup data for the leaderboard.
     First tries to fetch from GitHub, falls back to mock data if unavailable.
     """
+    global _last_fetch_time
+    
     print("=" * 60)
     print("STARTING DATA SETUP")
     print("=" * 60)
     
     target_dir = Path(EXTRACTED_DATA_DIR) / CONFIG_NAME
     
-    # Check if data already exists
-    if target_dir.exists() and any(target_dir.glob("*.jsonl")):
-        jsonl_files = list(target_dir.glob("*.jsonl"))
-        print(f"Data already exists at {target_dir}")
-        print(f"Found {len(jsonl_files)} JSONL files: {[f.name for f in jsonl_files]}")
-        return
+    # Check if data already exists and cache is not stale
+    if target_dir.exists():
+        results_dir = target_dir / "results"
+        has_results = results_dir.exists() and any(results_dir.iterdir())
+        has_jsonl = any(target_dir.glob("*.jsonl"))
+        
+        if has_results or has_jsonl:
+            if not is_cache_stale():
+                print(f"Data already exists at {target_dir} and cache is fresh")
+                return
+            print(f"Data exists but cache is stale, will refresh...")
     
     # Try to fetch from GitHub first
     print("\n--- Attempting to fetch from GitHub ---")
     try:
         if fetch_data_from_github():
+            _last_fetch_time = datetime.now()
             print("✓ Successfully using data from GitHub repository")
             return
     except Exception as e:
@@ -166,6 +271,7 @@ def setup_mock_data():
     print("\n--- GitHub data not available, falling back to mock data ---")
     try:
         if copy_mock_data():
+            _last_fetch_time = datetime.now()
             print("✓ Successfully using mock data")
             return
     except Exception as e:
@@ -175,5 +281,59 @@ def setup_mock_data():
     print("ERROR: No data available! Neither GitHub nor mock data could be loaded.")
     print("!" * 60)
 
+
+# Background refresh scheduler
+_scheduler_thread = None
+_scheduler_stop_event = threading.Event()
+
+
+def _background_refresh_loop():
+    """Background thread that periodically refreshes data."""
+    global _scheduler_stop_event
+    
+    logger.info(f"Background refresh scheduler started (interval: {CACHE_TTL_SECONDS}s)")
+    
+    while not _scheduler_stop_event.is_set():
+        # Wait for the TTL interval (or until stopped)
+        if _scheduler_stop_event.wait(timeout=CACHE_TTL_SECONDS):
+            break  # Stop event was set
+        
+        # Try to refresh data
+        try:
+            logger.info("Background refresh triggered")
+            refresh_data_if_needed(force=True)
+        except Exception as e:
+            logger.error(f"Error in background refresh: {e}")
+    
+    logger.info("Background refresh scheduler stopped")
+
+
+def start_background_refresh():
+    """Start the background refresh scheduler."""
+    global _scheduler_thread, _scheduler_stop_event
+    
+    if _scheduler_thread is not None and _scheduler_thread.is_alive():
+        logger.info("Background refresh scheduler already running")
+        return
+    
+    _scheduler_stop_event.clear()
+    _scheduler_thread = threading.Thread(target=_background_refresh_loop, daemon=True)
+    _scheduler_thread.start()
+    logger.info("Background refresh scheduler started")
+
+
+def stop_background_refresh():
+    """Stop the background refresh scheduler."""
+    global _scheduler_thread, _scheduler_stop_event
+    
+    if _scheduler_thread is None:
+        return
+    
+    _scheduler_stop_event.set()
+    _scheduler_thread.join(timeout=5)
+    _scheduler_thread = None
+    logger.info("Background refresh scheduler stopped")
+
+
 if __name__ == "__main__":
     setup_mock_data()

ui_components.py

@@ -361,9 +361,30 @@ plot_legend_html = f"""
     </div>
 """;
 
-# --- Global State for Viewers (simple caching) ---
+# --- Global State for Viewers (simple caching with TTL) ---
 CACHED_VIEWERS = {}
 CACHED_TAG_MAPS = {}
+_cache_lock = __import__('threading').Lock()
+
+
+def clear_viewer_cache():
+    """
+    Clear all cached viewers and tag maps.
+    Called when data is refreshed from the background scheduler.
+    """
+    global CACHED_VIEWERS, CACHED_TAG_MAPS
+    with _cache_lock:
+        CACHED_VIEWERS.clear()
+        CACHED_TAG_MAPS.clear()
+        print("[CACHE] Viewer cache cleared after data refresh")
+
+
+# Register the cache clear callback with the data refresh system
+try:
+    from setup_data import register_refresh_callback
+    register_refresh_callback(clear_viewer_cache)
+except ImportError:
+    pass  # setup_data may not be available during import
 
 
 class DummyViewer:
@@ -378,14 +399,15 @@ class DummyViewer:
 
 def get_leaderboard_viewer_instance(split: str):
     """
-    Fetches the LeaderboardViewer for a split, using a cache to avoid
+    Fetches the LeaderboardViewer for a split, using a thread-safe cache to avoid
     re-downloading data. On error, returns a stable DummyViewer object.
     """
     global CACHED_VIEWERS, CACHED_TAG_MAPS
 
-    if split in CACHED_VIEWERS:
-        # Cache hit: return the cached viewer and tag map
-        return CACHED_VIEWERS[split], CACHED_TAG_MAPS.get(split, {"Overall": []})
+    with _cache_lock:
+        if split in CACHED_VIEWERS:
+            # Cache hit: return the cached viewer and tag map
+            return CACHED_VIEWERS[split], CACHED_TAG_MAPS.get(split, {"Overall": []})
 
     # --- Cache miss: try to load data from the source ---
     try:
@@ -402,9 +424,10 @@ def get_leaderboard_viewer_instance(split: str):
         # Simplify tag map creation
         pretty_tag_map = create_pretty_tag_map(viewer.tag_map, INFORMAL_TO_FORMAL_NAME_MAP)
 
-        # Cache the results for next time
-        CACHED_VIEWERS[split] = viewer
-        CACHED_TAG_MAPS[split] = pretty_tag_map # Cache the pretty map directly
+        # Cache the results for next time (thread-safe)
+        with _cache_lock:
+            CACHED_VIEWERS[split] = viewer
+            CACHED_TAG_MAPS[split] = pretty_tag_map  # Cache the pretty map directly
 
         return viewer, pretty_tag_map
 
@@ -418,8 +441,9 @@ def get_leaderboard_viewer_instance(split: str):
         dummy_tag_map = {"Overall": []}
 
         # Cache the dummy objects so we don't try to fetch again on this run
-        CACHED_VIEWERS[split] = dummy_viewer
-        CACHED_TAG_MAPS[split] = dummy_tag_map
+        with _cache_lock:
+            CACHED_VIEWERS[split] = dummy_viewer
+            CACHED_TAG_MAPS[split] = dummy_tag_map
 
         return dummy_viewer, dummy_tag_map