Update app.py

app.py

@@ -1,5 +1,5 @@
 """
-Space Keeper - Keeps HuggingFace Spaces alive during hackathon evaluation
+Space Keeper v2 - Keeps HuggingFace Spaces alive during hackathon evaluation
 Pings all Spaces in an organization on a schedule to prevent them from sleeping.
 """
 
@@ -8,6 +8,7 @@ import json
 from concurrent.futures import ThreadPoolExecutor, as_completed
 from datetime import datetime, timezone
 from pathlib import Path
+import threading
 
 import gradio as gr
 import requests
@@ -15,47 +16,61 @@ from huggingface_hub import HfApi
 from apscheduler.schedulers.background import BackgroundScheduler
 from apscheduler.triggers.interval import IntervalTrigger
 
-# Configuration
+# =============================================================================
+# CONFIGURATION
+# =============================================================================
 ORG_NAME = os.environ.get("ORG_NAME", "MCP-1st-Birthday")
-PING_INTERVAL_HOURS = int(os.environ.get("PING_INTERVAL_HOURS", "6"))
+PING_INTERVAL_HOURS = int(os.environ.get("PING_INTERVAL_HOURS", "12"))
 REQUEST_TIMEOUT = int(os.environ.get("REQUEST_TIMEOUT", "30"))
-PARALLEL_REQUESTS = int(os.environ.get("PARALLEL_REQUESTS", "10"))  # Ping 10 Spaces at once
-HF_TOKEN = os.environ.get("HF_TOKEN", None)  # Optional: needed for private Spaces
+PARALLEL_REQUESTS = int(os.environ.get("PARALLEL_REQUESTS", "10"))
+HF_TOKEN = os.environ.get("HF_TOKEN", None)
+
 LOG_FILE = Path("run_logs.json")
-MAX_LOG_ENTRIES = 100  # Keep last N runs
+MAX_LOG_ENTRIES = 100
 
-# Global state
+# =============================================================================
+# GLOBAL STATE
+# =============================================================================
 scheduler = BackgroundScheduler()
 api = HfApi(token=HF_TOKEN) if HF_TOKEN else HfApi()
+APP_START_TIME = datetime.now(timezone.utc)
+
+# Lock for thread-safe log updates
+log_lock = threading.Lock()
 
 
+# =============================================================================
+# LOGGING FUNCTIONS
+# =============================================================================
 def load_logs() -> list:
     """Load logs from file."""
-    if LOG_FILE.exists():
-        try:
-            with open(LOG_FILE, "r") as f:
-                return json.load(f)
-        except Exception:
-            return []
-    return []
+    with log_lock:
+        if LOG_FILE.exists():
+            try:
+                with open(LOG_FILE, "r") as f:
+                    return json.load(f)
+            except Exception:
+                return []
+        return []
 
 
 def save_logs(logs: list):
     """Save logs to file, keeping only the most recent entries."""
-    logs = logs[-MAX_LOG_ENTRIES:]
-    with open(LOG_FILE, "w") as f:
-        json.dump(logs, f, indent=2)
+    with log_lock:
+        logs = logs[-MAX_LOG_ENTRIES:]
+        with open(LOG_FILE, "w") as f:
+            json.dump(logs, f, indent=2)
 
 
+# =============================================================================
+# PING FUNCTIONS
+# =============================================================================
 def ping_space(space_id: str) -> dict:
     """Ping a single Space and return the result."""
-    # Convert space_id (org/name) to the actual app URL
-    # e.g., "MCP-1st-Birthday/my-app" -> "mcp-1st-birthday-my-app.hf.space"
     org, name = space_id.split("/")
     app_url = f"https://{org.lower()}-{name.lower()}.hf.space"
     hf_page_url = f"https://huggingface.co/spaces/{space_id}"
     
-    # Try the app URL first (this actually wakes up the Space)
     try:
         response = requests.get(app_url, timeout=REQUEST_TIMEOUT)
         return {
@@ -71,10 +86,9 @@ def ping_space(space_id: str) -> dict:
             "status": "timeout",
             "status_code": None,
             "url_pinged": app_url,
-            "error": f"Request timed out after {REQUEST_TIMEOUT}s"
+            "error": f"Timed out after {REQUEST_TIMEOUT}s"
         }
     except Exception as e:
-        # Fallback: try the HF page URL
         try:
             response = requests.get(hf_page_url, timeout=REQUEST_TIMEOUT)
             return {
@@ -84,7 +98,7 @@ def ping_space(space_id: str) -> dict:
                 "url_pinged": hf_page_url,
                 "error": None
             }
-        except Exception as e2:
+        except Exception:
             return {
                 "space_id": space_id,
                 "status": "error",
@@ -94,8 +108,8 @@ def ping_space(space_id: str) -> dict:
             }
 
 
-def run_ping_job(triggered_by: str = "scheduler") -> dict:
-    """Run the ping job for all Spaces in the org using parallel requests."""
+def run_ping_job(triggered_by: str = "scheduler", progress_callback=None) -> dict:
+    """Run the ping job for all Spaces in the org."""
     start_time = datetime.now(timezone.utc)
     
     # Get all Spaces in the org
@@ -118,18 +132,21 @@ def run_ping_job(triggered_by: str = "scheduler") -> dict:
         save_logs(logs)
         return run_result
     
-    # Ping Spaces in parallel (10 at a time by default)
-    results = []
     space_ids = [space.id for space in spaces]
+    total = len(space_ids)
+    results = []
+    completed = 0
     
     with ThreadPoolExecutor(max_workers=PARALLEL_REQUESTS) as executor:
-        # Submit all ping tasks
-        future_to_space = {executor.submit(ping_space, space_id): space_id for space_id in space_ids}
+        future_to_space = {executor.submit(ping_space, sid): sid for sid in space_ids}
         
-        # Collect results as they complete
         for future in as_completed(future_to_space):
             result = future.result()
             results.append(result)
+            completed += 1
+            
+            if progress_callback:
+                progress_callback(completed, total, result)
     
     end_time = datetime.now(timezone.utc)
     duration = (end_time - start_time).total_seconds()
@@ -149,7 +166,6 @@ def run_ping_job(triggered_by: str = "scheduler") -> dict:
         "results": results
     }
     
-    # Save to logs
     logs = load_logs()
     logs.append(run_result)
     save_logs(logs)
@@ -163,136 +179,303 @@ def scheduled_job():
     run_ping_job(triggered_by="scheduler")
 
 
-def manual_trigger():
-    """Manually trigger a ping run."""
-    result = run_ping_job(triggered_by="manual")
-    return format_run_result(result), get_logs_display()
-
+# =============================================================================
+# UI HELPER FUNCTIONS
+# =============================================================================
+def get_uptime() -> str:
+    """Get how long the app has been running."""
+    delta = datetime.now(timezone.utc) - APP_START_TIME
+    hours, remainder = divmod(int(delta.total_seconds()), 3600)
+    minutes, seconds = divmod(remainder, 60)
+    if hours > 0:
+        return f"{hours}h {minutes}m"
+    elif minutes > 0:
+        return f"{minutes}m {seconds}s"
+    else:
+        return f"{seconds}s"
+
+
+def get_next_run_time() -> str:
+    """Get the next scheduled run time."""
+    jobs = scheduler.get_jobs()
+    if jobs and jobs[0].next_run_time:
+        return jobs[0].next_run_time.strftime('%Y-%m-%d %H:%M:%S UTC')
+    return "Not scheduled"
+
+
+def get_stats() -> dict:
+    """Get statistics from logs."""
+    logs = load_logs()
+    if not logs:
+        return {
+            "total_runs": 0,
+            "last_run": "Never",
+            "last_run_status": "N/A",
+            "total_spaces_pinged": 0,
+            "total_successful": 0,
+            "total_failed": 0
+        }
+    
+    last_run = logs[-1]
+    return {
+        "total_runs": len(logs),
+        "last_run": last_run["timestamp"],
+        "last_run_status": "✅ Success" if last_run.get("failed", 0) == 0 else f"⚠️ {last_run.get('failed', 0)} failed",
+        "total_spaces_pinged": sum(r.get("total_spaces", 0) for r in logs),
+        "total_successful": sum(r.get("successful", 0) for r in logs),
+        "total_failed": sum(r.get("failed", 0) for r in logs)
+    }
 
-def format_run_result(result: dict) -> str:
-    """Format a single run result for display."""
-    if result["status"] == "error":
-        return f"""## ❌ Run Failed
 
-**Time:** {result['timestamp']}
-**Triggered by:** {result['triggered_by']}
-**Error:** {result['error']}
-"""
-    
-    status_emoji = "✅" if result["failed"] == 0 else "⚠️"
+def format_status_panel() -> str:
+    """Format the status panel with current configuration and stats."""
+    stats = get_stats()
+    token_status = "✅ Set" if HF_TOKEN else "❌ Not set"
     
-    output = f"""## {status_emoji} Run Completed
-
-**Time:** {result['timestamp']}
-**Triggered by:** {result['triggered_by']}
-**Duration:** {result['duration_seconds']}s
-**Spaces pinged:** {result['total_spaces']} ({result['successful']} successful, {result['failed']} failed)
+    return f"""## ⚙️ Configuration
+
+| Setting | Value |
+|---------|-------|
+| **Organization** | `{ORG_NAME}` |
+| **Ping Interval** | Every {PING_INTERVAL_HOURS} hours |
+| **Parallel Requests** | {PARALLEL_REQUESTS} at once |
+| **Request Timeout** | {REQUEST_TIMEOUT} seconds |
+| **HF Token** | {token_status} |
+
+## 📊 Statistics (since Space started)
+
+| Metric | Value |
+|--------|-------|
+| **App Uptime** | {get_uptime()} |
+| **Total Runs** | {stats['total_runs']} |
+| **Last Run** | {stats['last_run']} |
+| **Last Run Status** | {stats['last_run_status']} |
+| **Total Pings Sent** | {stats['total_spaces_pinged']} |
+
+## ⏰ Scheduler
+
+| | |
+|--|--|
+| **Next Scheduled Run** | {get_next_run_time()} |
+
+> **How it works:** A background thread automatically triggers a ping run every {PING_INTERVAL_HOURS} hours. 
+> If this Space sleeps, the scheduler stops. Keep this Space awake for reliable scheduling!
 """
-    
-    if result["failed"] > 0:
-        output += "\n### Failed Spaces:\n"
-        for r in result["results"]:
-            if r["status"] != "success":
-                output += f"- `{r['space_id']}`: {r['error']}\n"
-    
-    return output
 
 
-def get_logs_display() -> str:
-    """Get formatted logs for display."""
+def format_logs_panel() -> str:
+    """Format the logs panel showing recent runs."""
     logs = load_logs()
     
     if not logs:
-        return "No runs recorded yet. Click 'Run Now' to trigger a manual run."
-    
-    # Reverse to show most recent first
-    logs = list(reversed(logs))
+        return """## 📜 Run History
+
+*No runs recorded yet. Click "🚀 Run Now" to trigger your first ping run!*
+"""
     
-    output = "# Run History\n\n"
+    output = "## 📜 Run History\n\n"
     
-    for i, run in enumerate(logs[:20]):  # Show last 20 runs
+    for run in reversed(logs[-15:]):  # Show last 15 runs
         timestamp = run["timestamp"]
         triggered_by = run["triggered_by"]
         
         if run["status"] == "error":
-            output += f"### ❌ {timestamp}\n"
-            output += f"Triggered by: {triggered_by} | Error: {run['error']}\n\n"
+            output += f"**❌ {timestamp}** — {triggered_by} — Error: {run['error']}\n\n"
         else:
-            status_emoji = "✅" if run["failed"] == 0 else "⚠️"
-            output += f"### {status_emoji} {timestamp}\n"
-            output += f"Triggered by: {triggered_by} | "
-            output += f"Spaces: {run['total_spaces']} | "
-            output += f"Success: {run['successful']} | "
-            output += f"Failed: {run['failed']} | "
-            output += f"Duration: {run['duration_seconds']}s\n"
+            emoji = "✅" if run["failed"] == 0 else "⚠️"
+            output += f"**{emoji} {timestamp}** — {triggered_by} — "
+            output += f"{run['total_spaces']} spaces ({run['successful']} ok, {run['failed']} failed) — "
+            output += f"{run['duration_seconds']}s\n"
             
             if run["failed"] > 0:
-                failed_spaces = [r["space_id"] for r in run["results"] if r["status"] != "success"]
-                output += f"Failed: {', '.join(failed_spaces)}\n"
+                failed_list = [r["space_id"].split("/")[1] for r in run["results"] if r["status"] != "success"][:5]
+                output += f"   └─ Failed: {', '.join(failed_list)}"
+                if run["failed"] > 5:
+                    output += f" (+{run['failed'] - 5} more)"
+                output += "\n"
             output += "\n"
     
-    if len(logs) > 20:
-        output += f"\n*...and {len(logs) - 20} more runs (showing last 20)*\n"
-    
     return output
 
 
-def get_status() -> str:
-    """Get current scheduler status."""
-    next_run = scheduler.get_jobs()[0].next_run_time if scheduler.get_jobs() else None
-    token_status = "✅ Configured" if HF_TOKEN else "❌ Not set (only public Spaces will be listed)"
+# =============================================================================
+# MAIN FUNCTIONS FOR UI
+# =============================================================================
+def manual_trigger_with_progress(progress=gr.Progress(track_tqdm=True)):
+    """Manually trigger a ping run with live progress updates."""
+    
+    # Initial status
+    yield (
+        "## 🔄 Running...\n\nFetching list of Spaces from the organization...",
+        format_status_panel(),
+        format_logs_panel()
+    )
+    
+    start_time = datetime.now(timezone.utc)
+    
+    # Get spaces
+    try:
+        spaces = list(api.list_spaces(author=ORG_NAME))
+    except Exception as e:
+        error_msg = f"## ❌ Failed\n\nCould not list Spaces: {str(e)}"
+        run_result = {
+            "timestamp": start_time.isoformat(),
+            "triggered_by": "manual",
+            "status": "error",
+            "error": str(e),
+            "total_spaces": 0,
+            "successful": 0,
+            "failed": 0,
+            "duration_seconds": 0,
+            "results": []
+        }
+        logs = load_logs()
+        logs.append(run_result)
+        save_logs(logs)
+        yield (error_msg, format_status_panel(), format_logs_panel())
+        return
+    
+    space_ids = [space.id for space in spaces]
+    total = len(space_ids)
+    results = []
+    completed = 0
+    successful = 0
+    failed = 0
+    
+    yield (
+        f"## 🔄 Running...\n\nFound **{total} Spaces** to ping.\n\nStarting parallel pings ({PARALLEL_REQUESTS} at a time)...\n\n`[{completed}/{total}]` ░░░░░░░░░░ 0%",
+        format_status_panel(),
+        format_logs_panel()
+    )
+    
+    # Run pings in parallel
+    with ThreadPoolExecutor(max_workers=PARALLEL_REQUESTS) as executor:
+        future_to_space = {executor.submit(ping_space, sid): sid for sid in space_ids}
+        
+        for future in as_completed(future_to_space):
+            result = future.result()
+            results.append(result)
+            completed += 1
+            
+            if result["status"] == "success":
+                successful += 1
+            else:
+                failed += 1
+            
+            # Update progress bar
+            pct = int((completed / total) * 100)
+            filled = int(pct / 10)
+            bar = "█" * filled + "░" * (10 - filled)
+            
+            status_emoji = "✅" if result["status"] == "success" else "❌"
+            space_name = result["space_id"].split("/")[1]
+            
+            live_status = f"""## 🔄 Running...
+
+**Progress:** `[{completed}/{total}]` {bar} {pct}%
+
+**Last pinged:** {status_emoji} `{space_name}`
+
+**So far:** {successful} successful, {failed} failed
+"""
+            
+            # Only yield every 5 completions to avoid too many updates
+            if completed % 5 == 0 or completed == total:
+                yield (live_status, format_status_panel(), format_logs_panel())
+    
+    # Final results
+    end_time = datetime.now(timezone.utc)
+    duration = (end_time - start_time).total_seconds()
+    
+    run_result = {
+        "timestamp": start_time.isoformat(),
+        "triggered_by": "manual",
+        "status": "completed",
+        "error": None,
+        "total_spaces": total,
+        "successful": successful,
+        "failed": failed,
+        "duration_seconds": round(duration, 2),
+        "results": results
+    }
     
-    return f"""## Space Keeper Status
+    logs = load_logs()
+    logs.append(run_result)
+    save_logs(logs)
+    
+    # Format final summary
+    if failed == 0:
+        final_status = f"""## ✅ Completed Successfully!
+
+**Pinged {total} Spaces** in {round(duration, 1)} seconds.
+
+All Spaces responded successfully!
+"""
+    else:
+        failed_spaces = [r["space_id"].split("/")[1] for r in results if r["status"] != "success"]
+        failed_list = "\n".join([f"- `{s}`" for s in failed_spaces[:10]])
+        if len(failed_spaces) > 10:
+            failed_list += f"\n- ... and {len(failed_spaces) - 10} more"
+        
+        final_status = f"""## ⚠️ Completed with Issues
 
-**Organization:** `{ORG_NAME}`
-**Ping Interval:** Every {PING_INTERVAL_HOURS} hours
-**Parallel Requests:** {PARALLEL_REQUESTS} Spaces at once
-**Request Timeout:** {REQUEST_TIMEOUT} seconds
-**HF Token:** {token_status}
-**Next Scheduled Run:** {next_run.strftime('%Y-%m-%d %H:%M:%S UTC') if next_run else 'Not scheduled'}
+**Pinged {total} Spaces** in {round(duration, 1)} seconds.
 
----
+✅ **{successful}** successful  
+❌ **{failed}** failed
 
-This Space automatically pings all Spaces in the `{ORG_NAME}` organization to keep them from sleeping during the evaluation period.
+### Failed Spaces:
+{failed_list}
 """
+    
+    yield (final_status, format_status_panel(), format_logs_panel())
 
 
-def refresh_logs():
-    """Refresh the logs display."""
-    return get_logs_display()
+def refresh_all():
+    """Refresh all panels."""
+    return format_status_panel(), format_logs_panel()
 
 
-# Build the Gradio interface
+# =============================================================================
+# GRADIO UI
+# =============================================================================
 with gr.Blocks() as demo:
-    gr.Markdown("# 🔄 Space Keeper")
-    gr.Markdown("Keeps HuggingFace Spaces alive by pinging them on a schedule.")
+    gr.Markdown("""# 🔄 Space Keeper
+    
+Keeps HuggingFace Spaces alive by pinging them on a schedule. 
+This prevents Spaces from sleeping during the hackathon evaluation period.
+""")
     
     with gr.Row():
         with gr.Column(scale=1):
-            status_display = gr.Markdown(get_status())
+            status_panel = gr.Markdown(format_status_panel())
             
             with gr.Row():
                 run_btn = gr.Button("🚀 Run Now", variant="primary", size="lg")
-                refresh_btn = gr.Button("🔄 Refresh Logs", size="lg")
-            
-            last_run_display = gr.Markdown("Click 'Run Now' to trigger a manual ping run.")
+                refresh_btn = gr.Button("🔄 Refresh", size="lg")
         
-        with gr.Column(scale=2):
-            logs_display = gr.Markdown(get_logs_display())
+        with gr.Column(scale=1):
+            live_output = gr.Markdown("## Ready\n\nClick **🚀 Run Now** to ping all Spaces in the organization.\n\nThe scheduler will also run automatically every 12 hours.")
+            
+    gr.Markdown("---")
+    
+    logs_panel = gr.Markdown(format_logs_panel())
     
     # Event handlers
     run_btn.click(
-        fn=manual_trigger,
-        outputs=[last_run_display, logs_display]
+        fn=manual_trigger_with_progress,
+        outputs=[live_output, status_panel, logs_panel]
     )
     
     refresh_btn.click(
-        fn=refresh_logs,
-        outputs=[logs_display]
+        fn=refresh_all,
+        outputs=[status_panel, logs_panel]
     )
 
 
-# Start the scheduler
+# =============================================================================
+# START SCHEDULER
+# =============================================================================
 scheduler.add_job(
     scheduled_job,
     trigger=IntervalTrigger(hours=PING_INTERVAL_HOURS),
@@ -302,8 +485,10 @@ scheduler.add_job(
 )
 scheduler.start()
 
-print(f"Space Keeper started for org: {ORG_NAME}")
-print(f"Ping interval: {PING_INTERVAL_HOURS} hours")
+print(f"[{APP_START_TIME.isoformat()}] Space Keeper started")
+print(f"  Organization: {ORG_NAME}")
+print(f"  Ping interval: {PING_INTERVAL_HOURS} hours")
+print(f"  Next run: {get_next_run_time()}")
 
 if __name__ == "__main__":
     demo.launch()