update

app.py

@@ -238,6 +238,97 @@ def save_leaderboard(df: pd.DataFrame):
         json.dump(df.to_dict('records'), f, indent=2)
 
 
+# ============================================================================
+# Admin Functions
+# ============================================================================
+
+def check_admin_password(password: str) -> bool:
+    """
+    Check if provided password matches admin password.
+    Admin password is set via ADMIN_PASSWORD environment variable.
+    """
+    admin_password = os.environ.get('ADMIN_PASSWORD', '')
+
+    if not admin_password:
+        # If no admin password set, use a default (should be changed in production)
+        admin_password = 'admin-2025'
+
+    return password == admin_password
+
+
+def delete_model_submission(model_name: str) -> Tuple[bool, str]:
+    """
+    Delete a model submission from leaderboard and cleanup associated files.
+
+    Args:
+        model_name: Name of the model to delete
+
+    Returns:
+        (success, message)
+    """
+    try:
+        # Load current leaderboard
+        df = load_leaderboard()
+
+        if df.empty:
+            return False, "Leaderboard is empty"
+
+        # Check if model exists
+        if model_name not in df['model_name'].values:
+            return False, f"Model '{model_name}' not found in leaderboard"
+
+        # Get model info before deletion
+        model_row = df[df['model_name'] == model_name].iloc[0]
+        organization = model_row.get('organization', 'Unknown')
+        date = model_row.get('date', 'Unknown')
+
+        # Remove from leaderboard
+        df = df[df['model_name'] != model_name].reset_index(drop=True)
+        save_leaderboard(df)
+
+        # Cleanup associated files
+        model_dir_name = model_name.replace(" ", "_")
+        results_dir = RESULTS_DIR / model_dir_name
+        submissions_dir = SUBMISSIONS_DIR / model_dir_name
+
+        cleanup_info = []
+
+        # Remove results directory
+        if results_dir.exists():
+            shutil.rmtree(results_dir)
+            cleanup_info.append(f"Removed results: {results_dir}")
+
+        # Remove submissions directory
+        if submissions_dir.exists():
+            shutil.rmtree(submissions_dir)
+            cleanup_info.append(f"Removed submissions: {submissions_dir}")
+
+        message = f"✓ Successfully deleted model '{model_name}'\n"
+        message += f"  Organization: {organization}\n"
+        message += f"  Date: {date}\n\n"
+        if cleanup_info:
+            message += "Cleaned up:\n" + "\n".join(f"  - {info}" for info in cleanup_info)
+
+        return True, message
+
+    except Exception as e:
+        return False, f"Error deleting model: {str(e)}"
+
+
+def get_leaderboard_for_admin() -> pd.DataFrame:
+    """Get leaderboard data formatted for admin view."""
+    df = load_leaderboard()
+
+    if df.empty:
+        return pd.DataFrame(columns=["rank", "model_name", "organization", "date", "contact"])
+
+    # Select key columns for admin view
+    admin_cols = ["rank", "model_name", "organization", "date", "contact"]
+    available_cols = [col for col in admin_cols if col in df.columns]
+
+    return df[available_cols]
+
+
 def detect_evaluation_output_format(file_path: str) -> Tuple[bool, str]:
     """
     Detect if uploaded file is pre-processed evaluation output with LLM judge scores.
@@ -1300,6 +1391,127 @@ with gr.Blocks(title="MedVidBench Leaderboard", theme=gr.themes.Soft()) as demo:
             - Email: [Contact via GitHub](https://github.com/YuhaoSu)
             """)
 
+        # Tab 5: Admin Panel (Password Protected)
+        with gr.Tab("🔒 Admin"):
+            gr.Markdown("""
+            ### Admin Panel
+
+            This panel allows administrators to manage leaderboard submissions.
+
+            **Features**:
+            - View all submissions
+            - Delete individual models
+            - Cleanup test/dummy data
+
+            **Note**: Admin password is set via `ADMIN_PASSWORD` environment variable in HuggingFace Spaces settings.
+            """)
+
+            # Password authentication
+            with gr.Row():
+                admin_password_input = gr.Textbox(
+                    label="Admin Password",
+                    type="password",
+                    placeholder="Enter admin password",
+                    scale=3
+                )
+                login_btn = gr.Button("🔓 Login", variant="primary", scale=1)
+
+            login_status = gr.Markdown("", visible=True)
+
+            # Admin panel (hidden by default, shown after successful login)
+            with gr.Column(visible=False) as admin_panel:
+                gr.Markdown("### 📋 Current Submissions")
+
+                # Table showing all submissions
+                admin_table = gr.Dataframe(
+                    value=get_leaderboard_for_admin(),
+                    interactive=False,
+                    label="Leaderboard Entries",
+                    wrap=True
+                )
+
+                with gr.Row():
+                    refresh_admin_btn = gr.Button("🔄 Refresh List", size="sm")
+                    delete_model_input = gr.Textbox(
+                        label="Model Name to Delete",
+                        placeholder="Enter exact model name",
+                        scale=2
+                    )
+                    delete_btn = gr.Button("🗑️ Delete Model", variant="stop", scale=1)
+
+                delete_status = gr.Markdown("")
+
+                gr.Markdown("""
+                ---
+
+                ### ⚠️ Deletion Instructions
+
+                1. **Find the model** in the table above (check the `model_name` column)
+                2. **Copy the exact model name** (case-sensitive)
+                3. **Paste it** in the "Model Name to Delete" field
+                4. **Click "Delete Model"** - this will:
+                   - Remove the entry from leaderboard
+                   - Delete all associated files (`/data/results/{model_name}/`, `/data/submissions/{model_name}/`)
+                   - Update rankings
+
+                **⚠️ Warning**: Deletion is permanent and cannot be undone!
+
+                ### 🔐 Security Notes
+
+                - Set `ADMIN_PASSWORD` in HuggingFace Spaces → Settings → Secrets
+                - Default password (if not set): `medvidben ch_admin_2025` (change this!)
+                - Admin actions are not logged (consider adding audit trail)
+                """)
+
+            # Login handler
+            def handle_login(password):
+                if check_admin_password(password):
+                    return (
+                        "✓ Login successful! Admin panel unlocked.",
+                        gr.update(visible=True),  # Show admin panel
+                        get_leaderboard_for_admin()  # Load initial data
+                    )
+                else:
+                    return (
+                        "❌ Invalid password. Please try again.",
+                        gr.update(visible=False),  # Keep admin panel hidden
+                        get_leaderboard_for_admin()
+                    )
+
+            login_btn.click(
+                fn=handle_login,
+                inputs=[admin_password_input],
+                outputs=[login_status, admin_panel, admin_table]
+            )
+
+            # Refresh handler
+            def refresh_admin_table():
+                return get_leaderboard_for_admin()
+
+            refresh_admin_btn.click(
+                fn=refresh_admin_table,
+                outputs=[admin_table]
+            )
+
+            # Delete handler
+            def handle_delete(model_name):
+                if not model_name or not model_name.strip():
+                    return "❌ Please enter a model name", get_leaderboard_for_admin()
+
+                success, message = delete_model_submission(model_name.strip())
+
+                if success:
+                    # Refresh table after successful deletion
+                    return f"## ✓ Deletion Successful\n\n{message}", get_leaderboard_for_admin()
+                else:
+                    return f"## ❌ Deletion Failed\n\n{message}", get_leaderboard_for_admin()
+
+            delete_btn.click(
+                fn=handle_delete,
+                inputs=[delete_model_input],
+                outputs=[delete_status, admin_table]
+            )
+
 if __name__ == "__main__":
     # Launch with queue for better concurrency
     demo.queue(default_concurrency_limit=5)

cleanup_test_data.py

@@ -0,0 +1,195 @@
+#!/usr/bin/env python3
+"""
+Cleanup script to remove test/dummy submissions from leaderboard.
+
+Usage:
+    python cleanup_test_data.py --model-name "TestModel"
+    python cleanup_test_data.py --all-test  # Remove all models with "test" in name
+    python cleanup_test_data.py --list      # List all models
+"""
+
+import json
+import argparse
+import shutil
+from pathlib import Path
+
+# Configuration
+PERSISTENT_DIR = Path("/data") if Path("/data").exists() else Path(".")
+LEADERBOARD_FILE = PERSISTENT_DIR / "leaderboard.json"
+RESULTS_DIR = PERSISTENT_DIR / "results"
+SUBMISSIONS_DIR = PERSISTENT_DIR / "submissions"
+
+
+def load_leaderboard():
+    """Load leaderboard from file."""
+    if not LEADERBOARD_FILE.exists():
+        print(f"❌ Leaderboard file not found: {LEADERBOARD_FILE}")
+        return []
+
+    with open(LEADERBOARD_FILE, 'r') as f:
+        data = json.load(f)
+    return data if isinstance(data, list) else []
+
+
+def save_leaderboard(data):
+    """Save leaderboard to file."""
+    # Update ranks
+    for i, entry in enumerate(data, 1):
+        entry['rank'] = i
+
+    with open(LEADERBOARD_FILE, 'w') as f:
+        json.dump(data, f, indent=2)
+
+    print(f"✓ Saved leaderboard with {len(data)} entries")
+
+
+def list_models():
+    """List all models in leaderboard."""
+    data = load_leaderboard()
+
+    if not data:
+        print("Leaderboard is empty")
+        return
+
+    print(f"\n{'='*80}")
+    print(f"LEADERBOARD MODELS ({len(data)} total)")
+    print(f"{'='*80}\n")
+
+    for entry in data:
+        rank = entry.get('rank', '?')
+        model_name = entry.get('model_name', 'Unknown')
+        organization = entry.get('organization', 'Unknown')
+        date = entry.get('date', 'Unknown')
+
+        print(f"#{rank}: {model_name}")
+        print(f"     Organization: {organization}")
+        print(f"     Date: {date}")
+        print()
+
+
+def delete_model(model_name, dry_run=False):
+    """Delete a model from leaderboard and cleanup associated files."""
+    data = load_leaderboard()
+
+    # Find the model
+    model_entry = None
+    for entry in data:
+        if entry.get('model_name') == model_name:
+            model_entry = entry
+            break
+
+    if not model_entry:
+        print(f"❌ Model not found: {model_name}")
+        return False
+
+    print(f"\n{'='*80}")
+    print(f"DELETING MODEL: {model_name}")
+    print(f"{'='*80}\n")
+    print(f"Organization: {model_entry.get('organization')}")
+    print(f"Date: {model_entry.get('date')}")
+    print(f"Rank: {model_entry.get('rank')}")
+
+    if dry_run:
+        print("\n⚠️  DRY RUN - No changes will be made")
+
+    # Associated files/directories
+    model_dir_name = model_name.replace(" ", "_")
+    results_dir = RESULTS_DIR / model_dir_name
+
+    # Remove from leaderboard
+    if not dry_run:
+        data = [e for e in data if e.get('model_name') != model_name]
+        save_leaderboard(data)
+        print(f"✓ Removed from leaderboard")
+    else:
+        print(f"[DRY RUN] Would remove from leaderboard")
+
+    # Remove results directory
+    if results_dir.exists():
+        if not dry_run:
+            shutil.rmtree(results_dir)
+            print(f"✓ Removed results directory: {results_dir}")
+        else:
+            print(f"[DRY RUN] Would remove: {results_dir}")
+
+    # Check for submission files (might not exist after evaluation)
+    submission_dir = SUBMISSIONS_DIR / model_dir_name
+    if submission_dir.exists():
+        if not dry_run:
+            shutil.rmtree(submission_dir)
+            print(f"✓ Removed submissions directory: {submission_dir}")
+        else:
+            print(f"[DRY RUN] Would remove: {submission_dir}")
+
+    print(f"\n{'='*80}")
+    if dry_run:
+        print("✓ DRY RUN COMPLETE - No changes made")
+    else:
+        print("✓ MODEL DELETED SUCCESSFULLY")
+    print(f"{'='*80}\n")
+
+    return True
+
+
+def delete_test_models(dry_run=False):
+    """Delete all models with 'test' in name (case-insensitive)."""
+    data = load_leaderboard()
+
+    test_models = [
+        entry for entry in data
+        if 'test' in entry.get('model_name', '').lower() or
+           'test' in entry.get('organization', '').lower()
+    ]
+
+    if not test_models:
+        print("No test models found")
+        return
+
+    print(f"\n{'='*80}")
+    print(f"FOUND {len(test_models)} TEST MODELS")
+    print(f"{'='*80}\n")
+
+    for entry in test_models:
+        print(f"- {entry.get('model_name')} ({entry.get('organization')})")
+
+    print()
+
+    if not dry_run:
+        confirm = input("Delete all these models? (yes/no): ")
+        if confirm.lower() != 'yes':
+            print("Cancelled")
+            return
+
+    for entry in test_models:
+        model_name = entry.get('model_name')
+        delete_model(model_name, dry_run=dry_run)
+
+
+def main():
+    parser = argparse.ArgumentParser(
+        description="Cleanup test/dummy submissions from MedVidBench leaderboard"
+    )
+
+    group = parser.add_mutually_exclusive_group(required=True)
+    group.add_argument("--list", action="store_true",
+                      help="List all models in leaderboard")
+    group.add_argument("--model-name", type=str,
+                      help="Delete specific model by name")
+    group.add_argument("--all-test", action="store_true",
+                      help="Delete all models with 'test' in name")
+
+    parser.add_argument("--dry-run", action="store_true",
+                       help="Show what would be deleted without actually deleting")
+
+    args = parser.parse_args()
+
+    if args.list:
+        list_models()
+    elif args.model_name:
+        delete_model(args.model_name, dry_run=args.dry_run)
+    elif args.all_test:
+        delete_test_models(dry_run=args.dry_run)
+
+
+if __name__ == "__main__":
+    main()