Update main.py

main.py

@@ -3,14 +3,11 @@ import json
 import uuid
 import time
 import tempfile
-import hashlib
-import hmac
 from datetime import datetime, timezone
 from typing import Any, Dict, List, Tuple, Optional
 
-import streamlit as st
+import gradio as gr
 import pandas as pd
-from PIL import Image
 from huggingface_hub import HfApi, hf_hub_download
 from huggingface_hub.utils import HfHubHTTPError
 
@@ -18,229 +15,37 @@ from huggingface_hub.utils import HfHubHTTPError
 # CONFIG
 # =========================
 
-st.set_page_config(
-    page_title="VizWiz Benchmark Arena",
-    page_icon="🏆",
-    layout="wide",
-    initial_sidebar_state="expanded",
-)
-
-DB_REPO_ID = os.getenv("DB_REPO_ID", "NidhiS09/VizWiz-submissions-db")
+DB_REPO_ID = os.getenv("DB_REPO_ID", "VizWiz-Challenges/submissions-db")
 DB_REPO_TYPE = "dataset"
 SUBMISSIONS_TOKEN = os.getenv("SUBMISSIONS_TOKEN", "")
 
 DAILY_SUBMISSION_CAP = 5
 
 PHASES = [
-    {"label": "Dev (query-dev2024)", "codename": "test-dev2024"},
-    {"label": "Standard (query-standard2024)", "codename": "test-standard2024"},
-    {"label": "Challenge (query-challenge2024)", "codename": "test-challenge2024"},
+    {"label": "Dev (test-dev2024)",            "codename": "test-dev2024"},
+    {"label": "Standard (test-standard2024)",  "codename": "test-standard2024"},
+    {"label": "Challenge (test-challenge2024)", "codename": "test-challenge2024"},
 ]
 
 CHALLENGE_TYPES = ["Object Detection", "Instance Segmentation"]
 LEADERBOARD_METRICS = ["bbox_mAP", "bbox_AP50", "segm_mAP", "segm_AP50"]
 DEFAULT_SORT_METRIC = "segm_AP50"
-USERS_FILE = "users.jsonl"
 
 # =========================
-# PASSWORD HELPERS
+# HF API
 # =========================
 
-def _hash_password(password: str) -> str:
-    """SHA-256 hash with a salt stored in env, no bcrypt dependency needed."""
-    salt = os.getenv("PASSWORD_SALT", "vizwiz-benchmark-salt-2024")
-    return hashlib.sha256(f"{salt}{password}".encode()).hexdigest()
-
-def _verify_password(password: str, hashed: str) -> bool:
-    return hmac.compare_digest(_hash_password(password), hashed)
-
-# =========================
-# USER STORE (users.jsonl in private dataset)
-# =========================
-
-@st.cache_resource
+_api = None
 def api_client() -> HfApi:
-    return HfApi()
-
-def _load_users() -> Dict[str, Dict]:
-    """Returns dict of username -> user record."""
-    try:
-        path = hf_hub_download(
-            repo_id=DB_REPO_ID, repo_type=DB_REPO_TYPE,
-            filename=USERS_FILE, token=SUBMISSIONS_TOKEN
-        )
-        users = {}
-        with open(path, "r") as f:
-            for line in f:
-                line = line.strip()
-                if line:
-                    try:
-                        u = json.loads(line)
-                        users[u["username"].lower()] = u
-                    except Exception:
-                        continue
-        return users
-    except HfHubHTTPError as e:
-        if "404" in str(e):
-            return {}
-        raise
-    except Exception:
-        return {}
-
-def _save_user(user: Dict) -> None:
-    """Append a new user to users.jsonl."""
-    try:
-        path = hf_hub_download(
-            repo_id=DB_REPO_ID, repo_type=DB_REPO_TYPE,
-            filename=USERS_FILE, token=SUBMISSIONS_TOKEN
-        )
-        existing = open(path, "r").read()
-    except HfHubHTTPError as e:
-        existing = "" if "404" in str(e) else (_ for _ in ()).throw(e)
-
-    updated = (existing.rstrip("\n") + "\n" + json.dumps(user) + "\n") if existing.strip() else (json.dumps(user) + "\n")
-
-    with tempfile.NamedTemporaryFile("w", suffix=".jsonl", delete=False) as f:
-        f.write(updated)
-        tmp = f.name
-
-    api_client().upload_file(
-        path_or_fileobj=tmp,
-        path_in_repo=USERS_FILE,
-        repo_id=DB_REPO_ID,
-        repo_type=DB_REPO_TYPE,
-        token=SUBMISSIONS_TOKEN,
-        commit_message=f"new user: {user['username']}",
-    )
-    try:
-        os.remove(tmp)
-    except Exception:
-        pass
-
-# =========================
-# AUTH STATE
-# =========================
-
-def get_logged_in_user() -> Optional[Dict]:
-    return st.session_state.get("user", None)
-
-def login_user(user: Dict) -> None:
-    st.session_state["user"] = user
-
-def logout_user() -> None:
-    st.session_state.pop("user", None)
-
-def render_login_wall() -> Dict:
-    """Redirect to login if not authenticated."""
-    user = get_logged_in_user()
-    if user:
-        return user
-    st.warning("Please log in to access this page.")
-    st.session_state["redirect_after_login"] = True
-    st.stop()
-
-# =========================
-# AUTH PAGES
-# =========================
-
-def page_login():
-    st.header("🔐 Login")
-    col, _ = st.columns([1, 1])
-    with col:
-        username = st.text_input("Username", key="login_username").strip().lower()
-        password = st.text_input("Password", type="password", key="login_password")
-
-        if st.button("Login", type="primary", use_container_width=True):
-            if not username or not password:
-                st.error("Please enter username and password.")
-                return
-
-            with st.spinner("Verifying..."):
-                users = _load_users()
-
-            if username not in users:
-                st.error("Username not found.")
-                return
-
-            user = users[username]
-            if not _verify_password(password, user["password_hash"]):
-                st.error("Incorrect password.")
-                return
-
-            login_user(user)
-            st.success(f"Welcome back, {user['username']}!")
-            st.rerun()
-
-        st.markdown("---")
-        st.caption("Don't have an account?")
-        if st.button("Create an account →", use_container_width=True):
-            st.session_state["auth_page"] = "signup"
-            st.rerun()
-
-
-def page_signup():
-    st.header("✏️ Create Account")
-    col, _ = st.columns([1, 1])
-    with col:
-        username = st.text_input("Username", key="signup_username").strip()
-        email = st.text_input("Email", key="signup_email").strip()
-        team = st.text_input("Team / Organization", key="signup_team").strip()
-        password = st.text_input("Password", type="password", key="signup_password")
-        password2 = st.text_input("Confirm Password", type="password", key="signup_password2")
-
-        if st.button("Create Account", type="primary", use_container_width=True):
-            if not all([username, email, team, password, password2]):
-                st.error("Please fill in all fields.")
-                return
-            if len(username) < 3:
-                st.error("Username must be at least 3 characters.")
-                return
-            if password != password2:
-                st.error("Passwords do not match.")
-                return
-            if len(password) < 6:
-                st.error("Password must be at least 6 characters.")
-                return
-
-            with st.spinner("Creating account..."):
-                users = _load_users()
-                if username.lower() in users:
-                    st.error("Username already taken.")
-                    return
-
-                new_user = {
-                    "username": username,
-                    "email": email,
-                    "team": team,
-                    "password_hash": _hash_password(password),
-                    "created_at": int(time.time()),
-                }
-                try:
-                    _save_user(new_user)
-                except Exception as e:
-                    st.error(f"Failed to create account: {e}")
-                    return
-
-            login_user(new_user)
-            st.success(f"Account created! Welcome, {username}!")
-            st.rerun()
-
-        st.markdown("---")
-        st.caption("Already have an account?")
-        if st.button("← Back to Login", use_container_width=True):
-            st.session_state["auth_page"] = "login"
-            st.rerun()
-
+    global _api
+    if _api is None:
+        _api = HfApi()
+    return _api
 
 # =========================
 # SUBMISSION HELPERS
 # =========================
 
-def _require_token() -> None:
-    if not SUBMISSIONS_TOKEN:
-        st.error("Missing SUBMISSIONS_TOKEN. Add it in Space Settings → Secrets.")
-        st.stop()
-
 def _today_utc_str() -> str:
     return datetime.now(timezone.utc).strftime("%Y-%m-%d")
 
@@ -317,7 +122,8 @@ def _upload_json(data: Any, path_in_repo: str, commit_message: str = "") -> None
 
 def _create_submission_record(*, pred, team, model_name, phase_codename,
                                challenge_type, original_filename, username, email) -> str:
-    _require_token()
+    if not SUBMISSIONS_TOKEN:
+        raise ValueError("Missing SUBMISSIONS_TOKEN.")
     submission_id = str(uuid.uuid4())
     ts = int(time.time())
     meta = {
@@ -339,7 +145,9 @@ def _create_submission_record(*, pred, team, model_name, phase_codename,
     return submission_id
 
 def _load_leaderboard_df() -> pd.DataFrame:
-    _require_token()
+    empty = pd.DataFrame(columns=["team", "model", "phase_codename", *LEADERBOARD_METRICS, "timestamp"])
+    if not SUBMISSIONS_TOKEN:
+        return empty
     try:
         path = hf_hub_download(
             repo_id=DB_REPO_ID, repo_type=DB_REPO_TYPE,
@@ -347,7 +155,7 @@ def _load_leaderboard_df() -> pd.DataFrame:
         )
     except HfHubHTTPError as e:
         if "404" in str(e):
-            return pd.DataFrame(columns=["team", "model", "phase_codename", *LEADERBOARD_METRICS, "timestamp"])
+            return empty
         raise
 
     rows = []
@@ -362,7 +170,7 @@ def _load_leaderboard_df() -> pd.DataFrame:
                 continue
 
     if not rows:
-        return pd.DataFrame(columns=["team", "model", "phase_codename", *LEADERBOARD_METRICS, "timestamp"])
+        return empty
 
     df = pd.DataFrame(rows)
     for col in ["team", "model", "phase_codename", "timestamp", *LEADERBOARD_METRICS]:
@@ -373,7 +181,8 @@ def _load_leaderboard_df() -> pd.DataFrame:
     return df
 
 def _load_user_submissions(username: str) -> List[Dict]:
-    _require_token()
+    if not SUBMISSIONS_TOKEN:
+        return []
     try:
         files = api_client().list_repo_files(
             repo_id=DB_REPO_ID, repo_type=DB_REPO_TYPE, token=SUBMISSIONS_TOKEN
@@ -403,6 +212,7 @@ def _load_user_submissions(username: str) -> List[Dict]:
             except Exception:
                 status = {"state": "unknown"}
             metrics = status.get("metrics", {}) if status.get("state") == "done" else {}
+            error = status.get("error", "") if status.get("state") == "failed" else ""
             results.append({
                 "submission_id": sid,
                 "team": meta.get("team", ""),
@@ -411,6 +221,7 @@ def _load_user_submissions(username: str) -> List[Dict]:
                 "challenge_type": meta.get("challenge_type", ""),
                 "timestamp": meta.get("timestamp", 0),
                 "state": status.get("state", "unknown"),
+                "error": error[:120] if error else "",
                 **metrics,
             })
         except Exception:
@@ -420,247 +231,337 @@ def _load_user_submissions(username: str) -> List[Dict]:
     return results
 
 # =========================
-# UI PAGES
+# GRADIO HANDLER FUNCTIONS
 # =========================
 
-def render_overview():
-    with st.expander("ℹ️ Overview of the VizWiz Benchmark Arena"):
-        st.markdown("""
-        **VizWiz Object Localization Challenge** — Submit your model predictions and get scored automatically.
-        - 📤 **Submit**: Upload your prediction JSON for Dev, Standard, or Challenge phases
-        - 🏆 **Leaderboard**: View public rankings for the Standard phase
-        - 📋 **My Submissions**: Track all your past submissions and scores
-        """)
-        try:
-            overview_image = Image.open("src/overview_image.png").resize((600, 600))
-            st.image(overview_image, caption="Example of an object localization task")
-        except Exception:
-            pass
-
-def render_eval_details():
-    with st.expander("📐 How is the Score Calculated?"):
-        st.markdown("""
-        Your submission is evaluated automatically against hidden ground-truth annotations.
-        - **bbox_mAP** — bounding box mean average precision
-        - **bbox_AP50** — bounding box AP at IoU=0.50
-        - **segm_mAP** — segmentation mean average precision
-        - **segm_AP50** — segmentation AP at IoU=0.50 *(default ranking)*
-        """)
-
-def page_leaderboard():
-    st.header("🏆 Leaderboard — Standard Phase")
-    st.caption(f"Ranked by **{DEFAULT_SORT_METRIC}** (descending). Showing Standard phase submissions only.")
-
-    with st.spinner("Loading leaderboard..."):
-        try:
-            df = _load_leaderboard_df()
-        except Exception as e:
-            st.error(f"Could not load leaderboard: {e}")
-            return
+def load_leaderboard():
+    try:
+        df = _load_leaderboard_df()
+    except Exception as e:
+        return pd.DataFrame(), f"❌ Could not load leaderboard: {e}"
 
     if not df.empty and "phase_codename" in df.columns:
         df = df[df["phase_codename"] == "test-standard2024"]
 
     if df.empty:
-        st.info("No scored Standard phase submissions yet. Be the first!")
-        return
+        return pd.DataFrame(), "ℹ️ No scored Standard phase submissions yet. Be the first!"
 
     df_display = df.copy()
     df_display.insert(0, "Rank", range(1, len(df_display) + 1))
     if "timestamp" in df_display.columns:
-        df_display["timestamp"] = pd.to_datetime(df_display["timestamp"], unit="s", errors="coerce")
+        df_display["Scored At"] = pd.to_datetime(
+            df_display["timestamp"], unit="s", errors="coerce"
+        ).dt.strftime("%d %b %Y, %I:%M %p")
+        df_display.drop(columns=["timestamp"], inplace=True)
     for col in ["username", "email", "phase_codename", "submission_id"]:
         if col in df_display.columns:
             df_display.drop(columns=[col], inplace=True)
 
-    st.dataframe(
-        df_display,
-        column_config={
-            "Rank": st.column_config.Column("Rank", width="small"),
-            "team": "Team", "model": "Model",
-            "bbox_mAP": st.column_config.NumberColumn("bbox_mAP", format="%.4f"),
-            "bbox_AP50": st.column_config.NumberColumn("bbox_AP50", format="%.4f"),
-            "segm_mAP": st.column_config.NumberColumn("segm_mAP", format="%.4f"),
-            "segm_AP50": st.column_config.NumberColumn("segm_AP50", format="%.4f"),
-            "timestamp": st.column_config.DatetimeColumn("Scored at", format="D MMM YYYY, h:mm a"),
-        },
-        use_container_width=True, hide_index=True,
-    )
+    return df_display, ""
+
+
+def handle_submit(file, team, model_name, phase_label, challenge_type, profile: gr.OAuthProfile | None):
+    if profile is None:
+        return "❌ You must be logged in with your HuggingFace account to submit.", ""
+
+    username = profile.username
+    email = getattr(profile, "email", "") or ""
 
-def page_submit():
-    user = render_login_wall()
-    username = user["username"]
-
-    st.header("🚀 Submit Your Predictions")
-
-    col_info, col_cap = st.columns([3, 1])
-    with col_info:
-        st.markdown(f"👤 Logged in as **{username}** ({user.get('team', '')})")
-    with col_cap:
-        with st.spinner("Checking daily limit..."):
-            subs_today = _count_submissions_today(username)
-        remaining = DAILY_SUBMISSION_CAP - subs_today
-        color = "green" if remaining > 1 else ("orange" if remaining == 1 else "red")
-        st.markdown(
-            f'<div style="text-align:center;padding:8px;border-radius:8px;border:1px solid {color}">'
-            f'<b style="color:{color}">{remaining}/{DAILY_SUBMISSION_CAP}</b><br>'
-            f'<small>submissions left today</small></div>',
-            unsafe_allow_html=True,
+    if not SUBMISSIONS_TOKEN:
+        return "❌ Missing SUBMISSIONS_TOKEN. Add it in Space Settings → Secrets.", ""
+
+    if file is None:
+        return "❌ Please upload a JSON file.", ""
+
+    if not team.strip():
+        return "❌ Please enter a Team / Display Name.", ""
+
+    if not model_name.strip():
+        return "❌ Please enter a Model Name.", ""
+
+    # Daily cap check
+    subs_today = _count_submissions_today(username)
+    if subs_today >= DAILY_SUBMISSION_CAP:
+        return f"⛔ You've reached your daily limit of {DAILY_SUBMISSION_CAP} submissions. Come back tomorrow!", ""
+
+    # Parse JSON
+    try:
+        with open(file, "r", encoding="utf-8") as f:
+            pred_obj = json.load(f)
+    except Exception:
+        return "❌ Could not parse JSON file.", ""
+
+    # Validate
+    ok, msg = _validate_submission_json(pred_obj)
+    if not ok:
+        return f"❌ Invalid submission format: {msg}", ""
+
+    # Resolve phase codename
+    phase_codename = next((p["codename"] for p in PHASES if p["label"] == phase_label), phase_label)
+    original_filename = os.path.basename(file)
+
+    # Upload
+    try:
+        submission_id = _create_submission_record(
+            pred=pred_obj,
+            team=team,
+            model_name=model_name,
+            phase_codename=phase_codename,
+            challenge_type=challenge_type,
+            original_filename=original_filename,
+            username=username,
+            email=email,
         )
+    except Exception as e:
+        return f"❌ Upload failed: {e}", ""
 
-    st.markdown("---")
-    if remaining <= 0:
-        st.error(f"⛔ You've reached your daily limit of {DAILY_SUBMISSION_CAP} submissions. Come back tomorrow!")
-        return
-
-    col1, col2 = st.columns([2, 1])
-    with col2:
-        st.subheader("Submission Info")
-        team = st.text_input("Team / Display Name", value=st.session_state.get("team", user.get("team", "")))
-        model_name = st.text_input("Model Name", value=st.session_state.get("model_name", ""))
-        phase_label = st.selectbox("Phase", [p["label"] for p in PHASES])
-        phase_codename = next(p["codename"] for p in PHASES if p["label"] == phase_label)
-        challenge_type = st.radio("Challenge type", CHALLENGE_TYPES, horizontal=False)
-        st.session_state["team"] = team
-        st.session_state["model_name"] = model_name
-
-    with col1:
-        st.subheader("Upload Submission File")
-        uploaded_file = st.file_uploader("Choose a JSON file", type=["json"])
-        if uploaded_file is None:
-            st.info("Upload a JSON file containing a list of annotations.")
-            return
-        try:
-            raw = uploaded_file.getvalue().decode("utf-8")
-            pred_obj = json.loads(raw)
-        except Exception:
-            st.error("Could not parse JSON.")
-            return
-        ok, msg = _validate_submission_json(pred_obj)
-        if not ok:
-            st.error(f"Invalid submission format: {msg}")
-            return
-        st.success("Submission file looks valid ✅")
-
-        if st.button("Submit (Queue for Evaluation)", type="primary"):
-            if not team.strip():
-                st.error("Please enter a Team / Display Name.")
-                return
-            if not model_name.strip():
-                st.error("Please enter a Model Name.")
-                return
-            if _count_submissions_today(username) >= DAILY_SUBMISSION_CAP:
-                st.error("⛔ Daily submission limit reached.")
-                return
-            with st.spinner("Uploading submission..."):
-                try:
-                    submission_id = _create_submission_record(
-                        pred=pred_obj, team=team, model_name=model_name,
-                        phase_codename=phase_codename, challenge_type=challenge_type,
-                        original_filename=uploaded_file.name,
-                        username=username, email=user.get("email", ""),
-                    )
-                except Exception as e:
-                    st.error(f"Upload failed: {e}")
-                    return
-            st.balloons()
-            st.success("Submission queued successfully!")
-            st.code(f"Submission ID: {submission_id}")
+    remaining = DAILY_SUBMISSION_CAP - subs_today - 1
+    return (
+        f"✅ Submission queued successfully! You have {remaining}/{DAILY_SUBMISSION_CAP} submissions remaining today.",
+        submission_id,
+    )
 
-def page_my_submissions():
-    user = render_login_wall()
-    username = user["username"]
 
-    st.header("📋 My Submissions")
-    st.caption(f"Showing all submissions for **{username}**")
+def load_my_submissions(phase_filter: str, profile: gr.OAuthProfile | None):
+    if profile is None:
+        return pd.DataFrame(), "❌ Please log in to view your submissions.", ""
 
-    with st.spinner("Loading your submissions..."):
-        submissions = _load_user_submissions(username)
+    username = profile.username
+    submissions = _load_user_submissions(username)
 
     if not submissions:
-        st.info("No submissions yet. Head to **Submit Model** to get started!")
-        return
+        return pd.DataFrame(), "ℹ️ No submissions yet. Head to Submit to get started!", ""
 
-    phases_present = sorted(set(s["phase"] for s in submissions))
-    selected_phase = st.selectbox("Filter by phase", ["All"] + phases_present)
-    filtered = submissions if selected_phase == "All" else [s for s in submissions if s["phase"] == selected_phase]
+    if phase_filter and phase_filter != "All":
+        submissions = [s for s in submissions if s["phase"] == phase_filter]
 
-    state_colors = {"queued": "🟡", "running": "🔵", "done": "🟢", "failed": "🔴", "unknown": "⚪"}
-    df = pd.DataFrame(filtered)
+    state_icons = {"queued": "🟡", "running": "🔵", "done": "🟢", "failed": "🔴", "unknown": "⚪"}
+    df = pd.DataFrame(submissions)
     if "timestamp" in df.columns:
-        df["submitted_at"] = pd.to_datetime(df["timestamp"], unit="s", errors="coerce")
+        df["Submitted At"] = pd.to_datetime(
+            df["timestamp"], unit="s", errors="coerce"
+        ).dt.strftime("%d %b %Y, %I:%M %p")
     if "state" in df.columns:
-        df["status"] = df["state"].apply(lambda s: f"{state_colors.get(s, '⚪')} {s.capitalize()}")
+        df["Status"] = df["state"].apply(lambda s: f"{state_icons.get(s, '⚪')} {s.capitalize()}")
 
-    display_cols = ["submitted_at", "status", "team", "model", "phase", "challenge_type"]
+    display_cols = ["Submitted At", "Status", "team", "model", "phase", "challenge_type", "error"]
     metric_cols = [m for m in LEADERBOARD_METRICS if m in df.columns]
     display_cols += metric_cols
     df_display = df[[c for c in display_cols if c in df.columns]].copy()
-
-    col_config = {
-        "submitted_at": st.column_config.DatetimeColumn("Submitted At", format="D MMM YYYY, h:mm a"),
-        "status": "Status", "team": "Team", "model": "Model",
-        "phase": "Phase", "challenge_type": "Challenge Type",
-    }
+    df_display.rename(columns={
+        "team": "Team", "model": "Model", "phase": "Phase",
+        "challenge_type": "Challenge Type", "error": "Error",
+    }, inplace=True)
     for m in metric_cols:
-        col_config[m] = st.column_config.NumberColumn(m, format="%.4f")
+        if m in df_display.columns:
+            df_display[m] = df_display[m].apply(lambda x: f"{x:.4f}" if pd.notna(x) else "")
 
-    st.dataframe(df_display, column_config=col_config, use_container_width=True, hide_index=True)
-
-    st.markdown("---")
+    # Summary stats
     total = len(submissions)
-    done = sum(1 for s in submissions if s["state"] == "done")
+    done  = sum(1 for s in submissions if s["state"] == "done")
     today_count = sum(
         1 for s in submissions
         if datetime.fromtimestamp(s["timestamp"], tz=timezone.utc).strftime("%Y-%m-%d") == _today_utc_str()
     )
-    c1, c2, c3 = st.columns(3)
-    c1.metric("Total Submissions", total)
-    c2.metric("Scored", done)
-    c3.metric(f"Today ({DAILY_SUBMISSION_CAP} max)", f"{today_count}/{DAILY_SUBMISSION_CAP}")
+    stats = (
+        f"**Total:** {total} &nbsp;|&nbsp; "
+        f"**Scored:** {done} &nbsp;|&nbsp; "
+        f"**Today:** {today_count}/{DAILY_SUBMISSION_CAP}"
+    )
+
+    return df_display, "", stats
+
+
+def get_daily_cap_info(profile: gr.OAuthProfile | None):
+    if profile is None:
+        return ""
+    subs_today = _count_submissions_today(profile.username)
+    remaining = DAILY_SUBMISSION_CAP - subs_today
+    return f"**{remaining}/{DAILY_SUBMISSION_CAP}** submissions remaining today"
+
+
+def get_user_greeting(profile: gr.OAuthProfile | None):
+    if profile is None:
+        return "👋 Log in with your HuggingFace account to submit predictions."
+    return f"👤 Logged in as **{profile.username}**"
+
 
 # =========================
-# MAIN
+# BUILD UI
 # =========================
 
-def main():
-    st.sidebar.title("VizWiz Benchmark 🏆")
-    user = get_logged_in_user()
-
-    if user:
-        st.sidebar.markdown(f"👤 **{user['username']}**")
-        st.sidebar.caption(user.get("team", ""))
-        if st.sidebar.button("Logout", use_container_width=True):
-            logout_user()
-            st.rerun()
-        st.sidebar.markdown("---")
-        menu = ["Leaderboard", "Submit Model", "My Submissions"]
-    else:
-        menu = ["Leaderboard", "Login", "Sign Up"]
-
-    choice = st.sidebar.radio("Navigation", menu)
-    st.sidebar.markdown("---")
-    st.sidebar.caption("Submissions are queued to a private DB repo and evaluated automatically.")
-
-    render_overview()
-    render_eval_details()
-    st.markdown("---")
-
-    if choice == "Leaderboard":
-        page_leaderboard()
-    elif choice == "Login":
-        if "auth_page" not in st.session_state:
-            st.session_state["auth_page"] = "login"
-        if st.session_state["auth_page"] == "signup":
-            page_signup()
-        else:
-            page_login()
-    elif choice == "Sign Up":
-        page_signup()
-    elif choice == "Submit Model":
-        page_submit()
-    elif choice == "My Submissions":
-        page_my_submissions()
+OVERVIEW_MD = """
+## VizWiz Object Localization Challenge
+
+Submit your model predictions and get scored automatically against hidden ground-truth annotations.
+
+- 📤 **Submit** — Upload your prediction JSON for Dev, Standard, or Challenge phases
+- 🏆 **Leaderboard** — View public rankings for the Standard phase
+- 📋 **My Submissions** — Track all your past submissions and scores
+
+> Log in with your HuggingFace account to submit predictions.
+"""
+
+EVAL_DETAILS_MD = """
+### How is the Score Calculated?
+
+Your submission is evaluated automatically against hidden ground-truth annotations using **pycocotools**.
+
+| Metric | Description |
+|--------|-------------|
+| `bbox_mAP` | Bounding box mean average precision |
+| `bbox_AP50` | Bounding box AP at IoU = 0.50 |
+| `segm_mAP` | Segmentation mean average precision |
+| `segm_AP50` | Segmentation AP at IoU = 0.50 *(default ranking metric)* |
+"""
+
+FORMAT_MD = """
+### Submission Format
+
+Your JSON file must be a **list of annotation objects**, each containing:
+
+```json
+[
+  {
+    "image_id": 123,
+    "category_id": 101,
+    "score": 0.95,
+    "area": 1024.0,
+    "bbox": [x, y, width, height],
+    "segmentation": [[x1, y1, x2, y2, ...]]
+  },
+  ...
+]
+```
+"""
+
+with gr.Blocks(title="VizWiz Benchmark Arena", theme=gr.themes.Soft()) as demo:
+
+    gr.Markdown("# 🏆 VizWiz Benchmark Arena")
+
+    with gr.Row():
+        with gr.Column(scale=4):
+            gr.Markdown(OVERVIEW_MD)
+        with gr.Column(scale=1):
+            login_btn = gr.LoginButton(size="lg")
+            user_greeting = gr.Markdown("👋 Log in with HuggingFace to submit.")
+
+    gr.Markdown("---")
+
+    with gr.Tabs():
+
+        # ── LEADERBOARD TAB ──────────────────────────────────────────────
+        with gr.TabItem("🏆 Leaderboard"):
+            gr.Markdown("### Standard Phase Rankings")
+            gr.Markdown(f"Ranked by **{DEFAULT_SORT_METRIC}** (descending). Showing Standard phase submissions only.")
+
+            with gr.Accordion("📐 How is the Score Calculated?", open=False):
+                gr.Markdown(EVAL_DETAILS_MD)
+
+            lb_msg = gr.Markdown("")
+            lb_table = gr.Dataframe(interactive=False, wrap=True)
+            refresh_lb_btn = gr.Button("🔄 Refresh Leaderboard", variant="secondary", size="sm")
+
+            def refresh_leaderboard():
+                df, msg = load_leaderboard()
+                return df, msg
+
+            refresh_lb_btn.click(refresh_leaderboard, outputs=[lb_table, lb_msg])
+            demo.load(refresh_leaderboard, outputs=[lb_table, lb_msg])
+
+        # ── SUBMIT TAB ───────────────────────────────────────────────────
+        with gr.TabItem("🚀 Submit Model"):
+            with gr.Row():
+                submit_greeting = gr.Markdown("👋 Log in with HuggingFace to submit.")
+                cap_info = gr.Markdown("")
+
+            gr.Markdown("---")
+
+            with gr.Row():
+                with gr.Column(scale=3):
+                    gr.Markdown("#### Upload Submission File")
+                    file_input = gr.File(label="Choose a JSON file", file_types=[".json"])
+                    with gr.Accordion("📄 Submission Format", open=False):
+                        gr.Markdown(FORMAT_MD)
+
+                with gr.Column(scale=2):
+                    gr.Markdown("#### Submission Info")
+                    team_input    = gr.Textbox(label="Team / Display Name", placeholder="e.g. My Awesome Team")
+                    model_input   = gr.Textbox(label="Model Name", placeholder="e.g. ResNet50-FPN")
+                    phase_input   = gr.Dropdown(
+                        label="Phase",
+                        choices=[p["label"] for p in PHASES],
+                        value=PHASES[0]["label"],
+                    )
+                    challenge_input = gr.Radio(
+                        label="Challenge Type",
+                        choices=CHALLENGE_TYPES,
+                        value=CHALLENGE_TYPES[0],
+                    )
+
+            submit_btn    = gr.Button("Submit (Queue for Evaluation)", variant="primary", size="lg")
+            submit_status = gr.Markdown("")
+            submission_id_box = gr.Code(label="Submission ID", language=None, visible=False)
+
+            def do_submit(file, team, model_name, phase_label, challenge_type, profile: gr.OAuthProfile | None):
+                msg, sid = handle_submit(file, team, model_name, phase_label, challenge_type, profile)
+                show_id = bool(sid)
+                return msg, gr.update(value=sid, visible=show_id)
+
+            submit_btn.click(
+                do_submit,
+                inputs=[file_input, team_input, model_input, phase_input, challenge_input],
+                outputs=[submit_status, submission_id_box],
+            )
+
+            def update_submit_ui(profile: gr.OAuthProfile | None):
+                return get_user_greeting(profile), get_daily_cap_info(profile)
+
+            demo.load(update_submit_ui, outputs=[submit_greeting, cap_info])
+            login_btn.click(update_submit_ui, outputs=[submit_greeting, cap_info])
+
+        # ── MY SUBMISSIONS TAB ───────────────────────────────────────────
+        with gr.TabItem("📋 My Submissions"):
+            my_sub_greeting = gr.Markdown("👋 Log in with HuggingFace to view your submissions.")
+            my_sub_stats    = gr.Markdown("")
+
+            with gr.Row():
+                phase_filter = gr.Dropdown(
+                    label="Filter by Phase",
+                    choices=["All"] + [p["codename"] for p in PHASES],
+                    value="All",
+                    scale=2,
+                )
+                refresh_my_btn = gr.Button("🔄 Refresh", variant="secondary", scale=1)
+
+            my_sub_msg   = gr.Markdown("")
+            my_sub_table = gr.Dataframe(interactive=False, wrap=True)
+
+            def refresh_my_submissions(phase_filter, profile: gr.OAuthProfile | None):
+                df, msg, stats = load_my_submissions(phase_filter, profile)
+                greeting = get_user_greeting(profile)
+                return df, msg, stats, greeting
+
+            refresh_my_btn.click(
+                refresh_my_submissions,
+                inputs=[phase_filter],
+                outputs=[my_sub_table, my_sub_msg, my_sub_stats, my_sub_greeting],
+            )
+            phase_filter.change(
+                refresh_my_submissions,
+                inputs=[phase_filter],
+                outputs=[my_sub_table, my_sub_msg, my_sub_stats, my_sub_greeting],
+            )
+            demo.load(
+                refresh_my_submissions,
+                inputs=[phase_filter],
+                outputs=[my_sub_table, my_sub_msg, my_sub_stats, my_sub_greeting],
+            )
+
+    # Update top greeting on load / login
+    demo.load(get_user_greeting, outputs=[user_greeting])
+    login_btn.click(get_user_greeting, outputs=[user_greeting])
+
 
 if __name__ == "__main__":
-    main()
+    demo.launch()