Update src/main.py

src/main.py

@@ -1,12 +1,10 @@
-# import streamlit as st
-# st.write("hello")
-
-
 import os
 import json
 import uuid
 import time
 import tempfile
+import hashlib
+from datetime import datetime, timezone
 from typing import Any, Dict, List, Tuple
 
 import streamlit as st
@@ -20,55 +18,155 @@ from huggingface_hub.utils import HfHubHTTPError
 # =========================
 
 st.set_page_config(
-    page_title="AI Benchmark Arena",
+    page_title="VizWiz Benchmark Arena",
     page_icon="🏆",
     layout="wide",
     initial_sidebar_state="expanded",
 )
 
-#Set this to the private dataset repo that acts as the "database"
 DB_REPO_ID = os.getenv("DB_REPO_ID", "NidhiS09/VizWiz-submissions-db")
 DB_REPO_TYPE = "dataset"
-# print(DB_REPO_ID)
-
-
-# This must exist as a Space Secret in the PUBLIC UI Space
 SUBMISSIONS_TOKEN = os.getenv("SUBMISSIONS_TOKEN", "")
 
-# Phase config (copied from EvalAI config intent)
+DAILY_SUBMISSION_CAP = 5
+
 PHASES = [
-    {"label": "Dev (qeury-dev2024)", "codename": "test-dev2024"},
+    {"label": "Dev (query-dev2024)", "codename": "test-dev2024"},
     {"label": "Standard (query-standard2024)", "codename": "test-standard2024"},
     {"label": "Challenge (query-challenge2024)", "codename": "test-challenge2024"},
 ]
 
 CHALLENGE_TYPES = ["Object Detection", "Instance Segmentation"]
 
-# Leaderboard columns from your EvalAI yaml
 LEADERBOARD_METRICS = ["bbox_mAP", "bbox_AP50", "segm_mAP", "segm_AP50"]
 DEFAULT_SORT_METRIC = "segm_AP50"
 
 # =========================
-# HELPERS
+# AUTH HELPERS
 # =========================
 
+def get_oauth_info() -> Dict | None:
+    """
+    Returns the HF OAuth user info dict if logged in, else None.
+    Keys: preferred_username, name, email, picture, ...
+    This works automatically when hf_oauth: true is set in README.md
+    """
+    try:
+        user_info = st.context.headers.get("X-Space-User-Info")
+        if user_info:
+            return json.loads(user_info)
+    except Exception:
+        pass
+
+    # Fallback: check session state (set after OAuth redirect)
+    if "oauth_info" in st.session_state and st.session_state["oauth_info"]:
+        return st.session_state["oauth_info"]
+
+    # Use st.experimental_user if available (newer Streamlit on HF Spaces)
+    try:
+        user = st.experimental_user
+        if user and getattr(user, "email", None):
+            return {
+                "preferred_username": getattr(user, "username", user.email.split("@")[0]),
+                "name": getattr(user, "name", user.email),
+                "email": user.email,
+                "picture": getattr(user, "picture", None),
+            }
+    except Exception:
+        pass
+
+    return None
+
+
+def render_login_wall():
+    """Shows login prompt and stops rendering if not authenticated."""
+    user = get_oauth_info()
+    if user:
+        return user
+
+    st.markdown("---")
+    st.markdown("## 🔐 Login Required")
+    st.info(
+        "You need to log in with your Hugging Face account to submit predictions "
+        "or view your submission history."
+    )
+    login_url = os.getenv("SPACE_HOST", "")
+    if login_url:
+        st.markdown(
+            f'<a href="https://{login_url}/oauth/login" target="_self">'
+            f'<button style="background:#FF6B35;color:white;border:none;padding:12px 28px;'
+            f'font-size:16px;border-radius:8px;cursor:pointer;">🤗 Login with Hugging Face</button></a>',
+            unsafe_allow_html=True,
+        )
+    else:
+        st.warning(
+            "OAuth login URL not available in local dev. "
+            "Deploy to HF Spaces with `hf_oauth: true` in README.md."
+        )
+    st.stop()
+
+
+# =========================
+# SUBMISSION CAP HELPERS
+# =========================
+
+def _today_utc_str() -> str:
+    return datetime.now(timezone.utc).strftime("%Y-%m-%d")
+
+
+def _count_submissions_today(hf_username: str) -> int:
+    """
+    Count how many submissions this user has made today by scanning submission metadata.
+    We do this by listing all submission files and checking meta.json for matching username + today's date.
+    Uses a lightweight approach: filter by filename listing only.
+    """
+    try:
+        files = api_client().list_repo_files(
+            repo_id=DB_REPO_ID, repo_type=DB_REPO_TYPE, token=SUBMISSIONS_TOKEN
+        )
+        today = _today_utc_str()
+        count = 0
+        for f in files:
+            if not (f.startswith("submissions/") and f.endswith("/meta.json")):
+                continue
+            try:
+                p = hf_hub_download(
+                    repo_id=DB_REPO_ID,
+                    repo_type=DB_REPO_TYPE,
+                    filename=f,
+                    token=SUBMISSIONS_TOKEN,
+                )
+                meta = json.load(open(p))
+                if meta.get("hf_username") == hf_username:
+                    ts = meta.get("timestamp", 0)
+                    sub_date = datetime.fromtimestamp(ts, tz=timezone.utc).strftime("%Y-%m-%d")
+                    if sub_date == today:
+                        count += 1
+            except Exception:
+                continue
+        return count
+    except Exception:
+        return 0
+
+
+# =========================
+# HF API HELPERS
+# =========================
+
+@st.cache_resource
+def api_client() -> HfApi:
+    return HfApi()
+
+
 def _require_token() -> None:
     if not SUBMISSIONS_TOKEN:
         st.error(
-            "Missing SUBMISSIONS_TOKEN. Add it in Space Settings → Secrets "
-            "(token must have read/write access ONLY to the private DB dataset repo)."
+            "Missing SUBMISSIONS_TOKEN. Add it in Space Settings → Secrets."
         )
         st.stop()
 
 
 def _validate_submission_json(obj: Any) -> Tuple[bool, str]:
-    """
-    Validates the submission format from your instructions:
-    - Top-level must be a list
-    - Each item must be a dict containing:
-      image_id (int), score (number), category_id (int), area (number),
-      bbox ([x,y,w,h]), segmentation (list)
-    """
     if not isinstance(obj, list):
         return False, "Submission must be a JSON list of annotations."
 
@@ -77,47 +175,38 @@ def _validate_submission_json(obj: Any) -> Tuple[bool, str]:
     for i, ann in enumerate(obj):
         if not isinstance(ann, dict):
             return False, f"Annotation at index {i} must be an object/dict."
-
         missing = required_keys - set(ann.keys())
         if missing:
             return False, f"Annotation at index {i} missing keys: {sorted(list(missing))}"
-
-        # Basic type checks
         if not isinstance(ann["image_id"], int):
             return False, f"image_id at index {i} must be an integer."
         if not isinstance(ann["category_id"], int):
             return False, f"category_id at index {i} must be an integer."
-
         if not isinstance(ann["score"], (int, float)):
             return False, f"score at index {i} must be a number."
-
         if not isinstance(ann["area"], (int, float)):
             return False, f"area at index {i} must be a number."
-
         bbox = ann["bbox"]
         if not (isinstance(bbox, list) and len(bbox) == 4 and all(isinstance(x, (int, float)) for x in bbox)):
             return False, f"bbox at index {i} must be a list of 4 numbers: [x, y, w, h]."
-
-        segm = ann["segmentation"]
-        if not isinstance(segm, list):
+        if not isinstance(ann["segmentation"], list):
             return False, f"segmentation at index {i} must be a list."
 
     return True, "OK"
 
 
-def _upload_json(api: HfApi, data: Dict[str, Any] | List[Any], path_in_repo: str) -> None:
+def _upload_json(data: Any, path_in_repo: str, commit_message: str = "") -> None:
     with tempfile.NamedTemporaryFile(mode="w", suffix=".json", delete=False) as tmp:
         json.dump(data, tmp, ensure_ascii=False)
         tmp_path = tmp.name
-
     try:
-        api.upload_file(
+        api_client().upload_file(
             path_or_fileobj=tmp_path,
             path_in_repo=path_in_repo,
             repo_id=DB_REPO_ID,
             repo_type=DB_REPO_TYPE,
             token=SUBMISSIONS_TOKEN,
-            commit_message=f"Add {path_in_repo}",
+            commit_message=commit_message or f"Add {path_in_repo}",
         )
     finally:
         try:
@@ -134,13 +223,10 @@ def _create_submission_record(
     phase_codename: str,
     challenge_type: str,
     original_filename: str,
+    hf_username: str,
+    hf_email: str,
 ) -> str:
-    """
-    Writes pred/meta/status to the private DB dataset repo.
-    Returns submission_id.
-    """
     _require_token()
-    api = HfApi()
 
     submission_id = str(uuid.uuid4())
     ts = int(time.time())
@@ -153,43 +239,34 @@ def _create_submission_record(
         "challenge_type": challenge_type,
         "timestamp": ts,
         "original_filename": original_filename,
+        "hf_username": hf_username,
+        "hf_email": hf_email,
     }
 
     status = {"state": "queued", "timestamp": ts}
-
     base = f"submissions/{submission_id}"
-    _upload_json(api, pred, f"{base}/pred.json")
-    _upload_json(api, meta, f"{base}/meta.json")
-    _upload_json(api, status, f"{base}/status.json")
+
+    _upload_json(pred, f"{base}/pred.json", f"pred {submission_id}")
+    _upload_json(meta, f"{base}/meta.json", f"meta {submission_id}")
+    _upload_json(status, f"{base}/status.json", f"status {submission_id}")
 
     return submission_id
 
 
-def _download_leaderboard_jsonl() -> str | None:
-    """
-    Downloads leaderboard.jsonl from the DB repo.
-    Returns local path or None if missing.
-    """
+def _load_leaderboard_df() -> pd.DataFrame:
     _require_token()
     try:
-        return hf_hub_download(
+        path = hf_hub_download(
             repo_id=DB_REPO_ID,
             repo_type=DB_REPO_TYPE,
             filename="leaderboard.jsonl",
             token=SUBMISSIONS_TOKEN,
         )
     except HfHubHTTPError as e:
-        # Most common: 404 when file doesn't exist yet
         if "404" in str(e):
-            return None
+            return pd.DataFrame(columns=["team", "model", "phase_codename", *LEADERBOARD_METRICS, "timestamp"])
         raise
 
-
-def _load_leaderboard_df() -> pd.DataFrame:
-    path = _download_leaderboard_jsonl()
-    if path is None:
-        return pd.DataFrame(columns=["team", "model", "phase_codename", *LEADERBOARD_METRICS, "timestamp"])
-
     rows = []
     with open(path, "r", encoding="utf-8") as f:
         for line in f:
@@ -199,33 +276,195 @@ def _load_leaderboard_df() -> pd.DataFrame:
             try:
                 rows.append(json.loads(line))
             except json.JSONDecodeError:
-                # Skip malformed lines rather than crashing the UI
                 continue
 
     if not rows:
         return pd.DataFrame(columns=["team", "model", "phase_codename", *LEADERBOARD_METRICS, "timestamp"])
 
     df = pd.DataFrame(rows)
-
-    # Ensure columns exist
     for col in ["team", "model", "phase_codename", "timestamp", *LEADERBOARD_METRICS]:
         if col not in df.columns:
             df[col] = None
 
-    # Sort descending by default metric
     if DEFAULT_SORT_METRIC in df.columns:
         df = df.sort_values(by=DEFAULT_SORT_METRIC, ascending=False, kind="mergesort")
 
     return df
 
 
+def _load_user_submissions(hf_username: str) -> List[Dict]:
+    """Load all submissions for a specific HF user."""
+    _require_token()
+    try:
+        files = api_client().list_repo_files(
+            repo_id=DB_REPO_ID, repo_type=DB_REPO_TYPE, token=SUBMISSIONS_TOKEN
+        )
+    except Exception:
+        return []
+
+    results = []
+    for f in files:
+        if not (f.startswith("submissions/") and f.endswith("/meta.json")):
+            continue
+        try:
+            sid = f.split("/")[1]
+            meta_path = hf_hub_download(
+                repo_id=DB_REPO_ID, repo_type=DB_REPO_TYPE,
+                filename=f, token=SUBMISSIONS_TOKEN
+            )
+            meta = json.load(open(meta_path))
+
+            if meta.get("hf_username") != hf_username:
+                continue
+
+            # Get status
+            try:
+                status_path = hf_hub_download(
+                    repo_id=DB_REPO_ID, repo_type=DB_REPO_TYPE,
+                    filename=f"submissions/{sid}/status.json", token=SUBMISSIONS_TOKEN
+                )
+                status = json.load(open(status_path))
+            except Exception:
+                status = {"state": "unknown"}
+
+            # Get results if done
+            metrics = {}
+            if status.get("state") == "done":
+                metrics = status.get("metrics", {})
+
+            results.append({
+                "submission_id": sid,
+                "team": meta.get("team", ""),
+                "model": meta.get("model", ""),
+                "phase": meta.get("phase_codename", ""),
+                "challenge_type": meta.get("challenge_type", ""),
+                "timestamp": meta.get("timestamp", 0),
+                "state": status.get("state", "unknown"),
+                **metrics,
+            })
+        except Exception:
+            continue
+
+    results.sort(key=lambda x: x["timestamp"], reverse=True)
+    return results
+
+
 # =========================
-# UI
+# UI PAGES
 # =========================
-#2 FUNCTIONS WERE HERE, RENDER_OVERVIEW AND RENDER EVAL
+
+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.
+        The leaderboard reports:
+        - **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
+
+    # Filter to standard phase only for public leaderboard
+    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
+
+    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")
+
+    # Drop hf_username / hf_email from public view
+    for col in ["hf_username", "hf_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,
+    )
+
 
 def page_submit():
-    st.header("🚀 Submit your Predictions")
+    user = render_login_wall()
+    hf_username = user.get("preferred_username", "unknown")
+    hf_email = user.get("email", "")
+
+    st.header("🚀 Submit Your Predictions")
+
+    # Show user info + daily cap status
+    col_info, col_cap = st.columns([3, 1])
+    with col_info:
+        avatar = user.get("picture", "")
+        name = user.get("name", hf_username)
+        if avatar:
+            st.markdown(
+                f'<img src="{avatar}" width="32" style="border-radius:50%;vertical-align:middle;margin-right:8px">'
+                f'<b>{name}</b> (@{hf_username})',
+                unsafe_allow_html=True,
+            )
+        else:
+            st.markdown(f"👤 Logged in as **{name}** (@{hf_username})")
+
+    with col_cap:
+        with st.spinner("Checking daily limit..."):
+            subs_today = _count_submissions_today(hf_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,
+        )
+
+    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])
 
@@ -233,26 +472,21 @@ def page_submit():
         st.subheader("Submission Info")
         team = st.text_input("Team / Display Name", value=st.session_state.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
-
-        st.caption("Your submission will be queued for evaluation. Scores appear on the leaderboard after processing.")
+        st.caption("Submissions are scored automatically. Results appear in My Submissions once processed.")
 
     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 that contains a list of annotations.")
+            st.info("Upload a JSON file containing a list of annotations.")
             return
 
-        # Parse JSON
         try:
             raw = uploaded_file.getvalue().decode("utf-8")
             pred_obj = json.loads(raw)
@@ -271,13 +505,19 @@ def page_submit():
 
         if submit_clicked:
             if not team.strip():
-                st.error("Please enter Team / Display Name.")
+                st.error("Please enter a Team / Display Name.")
                 return
             if not model_name.strip():
-                st.error("Please enter Model Name.")
+                st.error("Please enter a Model Name.")
+                return
+
+            # Re-check cap right before submitting
+            subs_today_fresh = _count_submissions_today(hf_username)
+            if subs_today_fresh >= DAILY_SUBMISSION_CAP:
+                st.error("⛔ Daily submission limit reached. Try again tomorrow.")
                 return
 
-            with st.spinner("Uploading submission to the private database repo..."):
+            with st.spinner("Uploading submission..."):
                 try:
                     submission_id = _create_submission_record(
                         pred=pred_obj,
@@ -286,6 +526,8 @@ def page_submit():
                         phase_codename=phase_codename,
                         challenge_type=challenge_type,
                         original_filename=uploaded_file.name,
+                        hf_username=hf_username,
+                        hf_email=hf_email,
                     )
                 except Exception as e:
                     st.error(f"Upload failed: {e}")
@@ -294,106 +536,129 @@ def page_submit():
             st.balloons()
             st.success("Submission queued successfully!")
             st.code(f"Submission ID: {submission_id}")
+            st.info("Track your results in **My Submissions** once the evaluator processes your file.")
 
-            st.info("Next: the private evaluator will score your submission and update the leaderboard.")
 
+def page_my_submissions():
+    user = render_login_wall()
+    hf_username = user.get("preferred_username", "unknown")
 
-def page_leaderboard():
-    st.header("🏆 Leaderboard")
-    st.write(f"Ranked by **{DEFAULT_SORT_METRIC}** (descending).")
+    st.header("📋 My Submissions")
+    st.caption(f"Showing all submissions for @{hf_username}")
 
-    with st.spinner("Loading leaderboard from private database repo..."):
-        try:
-            df = _load_leaderboard_df()
-        except Exception as e:
-            st.error(f"Could not load leaderboard: {e}")
-            return
+    with st.spinner("Loading your submissions..."):
+        submissions = _load_user_submissions(hf_username)
 
-    if df.empty:
-        st.info("No scored submissions yet. Submit a model to get started!")
+    if not submissions:
+        st.info("You haven't made any submissions yet. Head to **Submit Model** to get started!")
         return
 
-    # Add Rank column
-    df_display = df.copy()
-    df_display.insert(0, "Rank", range(1, len(df_display) + 1))
+    # Phase filter
+    phases_present = sorted(set(s["phase"] for s in submissions))
+    selected_phase = st.selectbox("Filter by phase", ["All"] + phases_present)
 
-    # Optional: pretty timestamp
-    if "timestamp" in df_display.columns:
-        df_display["timestamp"] = pd.to_datetime(df_display["timestamp"], unit="s", errors="coerce")
+    filtered = submissions if selected_phase == "All" else [s for s in submissions if s["phase"] == selected_phase]
 
-    st.dataframe(
-        df_display,
-        column_config={
-            "Rank": st.column_config.Column("Rank", width="small"),
-            "team": "Team",
-            "model": "Model",
-            "phase_codename": "Phase",
-            "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,
-    )
+    # State badges
+    state_colors = {
+        "queued": "🟡",
+        "running": "🔵",
+        "done": "🟢",
+        "failed": "🔴",
+        "unknown": "⚪",
+    }
 
+    df = pd.DataFrame(filtered)
 
-def main():
+    if "timestamp" in df.columns:
+        df["submitted_at"] = pd.to_datetime(df["timestamp"], unit="s", errors="coerce")
 
-    # st.write("✅ App booted and rendering UI")
-    
-    st.sidebar.title("AI Benchmark Arena 🏆")
+    if "state" in df.columns:
+        df["status"] = df["state"].apply(lambda s: f"{state_colors.get(s, '⚪')} {s.capitalize()}")
 
-    # Warn early if DB repo isn't configured
-    if DB_REPO_ID.startswith("NidhiS09/"):
-        st.sidebar.warning("Set DB_REPO_ID env var or hardcode your private DB dataset repo id in main.py.")
+    display_cols = ["submitted_at", "status", "team", "model", "phase", "challenge_type"]
+    metric_cols = [m for m in LEADERBOARD_METRICS if m in df.columns]
+    display_cols += metric_cols
 
-    menu = ["Submit Model", "Leaderboard"]
-    choice = st.sidebar.radio("Navigation", menu)
+    df_display = df[[c for c in display_cols if c in df.columns]].copy()
 
-    st.sidebar.markdown("---")
-    st.sidebar.caption("This Space queues submissions to a private DB repo and reads leaderboard results from it.")
+    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",
+    }
+    for m in metric_cols:
+        col_config[m] = st.column_config.NumberColumn(m, format="%.4f")
 
-    render_overview()
-    render_eval_details()
+    st.dataframe(df_display, column_config=col_config, use_container_width=True, hide_index=True)
+
+    # Summary stats
     st.markdown("---")
+    total = len(submissions)
+    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()
+    )
 
-    if choice == "Submit Model":
-        page_submit()
-    else:
-        page_leaderboard()
+    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}")
 
-def render_overview():
-    with st.expander("ℹ️ Overview of the AI Benchmark Arena"):
-        st.markdown(
-            """
-        **Note:** This Hugging Face Space queues submissions for evaluation and persists results in a private database repo.
-            """
-        )
-        # Keep this optional so missing image doesn't crash the Space
-        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:
-            st.info("Overview image not found at src/overview_image.png (optional).")
 
+# =========================
+# MAIN
+# =========================
 
-def render_eval_details():
-    with st.expander("📐 How is the Score Calculated?"):
-        st.markdown(
-            """
-        Your submission is evaluated offline by a private evaluator against hidden ground-truth annotations.
-        The leaderboard reports:
+def main():
+    st.sidebar.title("VizWiz Benchmark 🏆")
+
+    # Check login state for sidebar display
+    user = get_oauth_info()
+
+    if user:
+        hf_username = user.get("preferred_username", "")
+        avatar = user.get("picture", "")
+        if avatar:
+            st.sidebar.markdown(
+                f'<img src="{avatar}" width="40" style="border-radius:50%"><br>'
+                f'<b>@{hf_username}</b>',
+                unsafe_allow_html=True,
+            )
+        else:
+            st.sidebar.markdown(f"👤 @{hf_username}")
+        st.sidebar.markdown("---")
+        menu = ["Leaderboard", "Submit Model", "My Submissions"]
+    else:
+        st.sidebar.info("Login to submit predictions and view your history.")
+        login_url = os.getenv("SPACE_HOST", "")
+        if login_url:
+            st.sidebar.markdown(
+                f'<a href="https://{login_url}/oauth/login" target="_self">'
+                f'<button style="width:100%;background:#FF6B35;color:white;border:none;'
+                f'padding:10px;border-radius:6px;cursor:pointer;font-size:14px;">🤗 Login with HF</button></a>',
+                unsafe_allow_html=True,
+            )
+        menu = ["Leaderboard", "Submit Model", "My Submissions"]
 
-        - bbox_mAP
-        - bbox_AP50
-        - segm_mAP
-        - segm_AP50 (default ranking)
+    choice = st.sidebar.radio("Navigation", menu)
+    st.sidebar.markdown("---")
+    st.sidebar.caption("Submissions are queued to a private DB repo and evaluated automatically.")
 
-        Raw submissions are kept private; only scores and metadata are shown.
-            """
-        )
+    render_overview()
+    render_eval_details()
+    st.markdown("---")
+
+    if choice == "Leaderboard":
+        page_leaderboard()
+    elif choice == "Submit Model":
+        page_submit()
+    elif choice == "My Submissions":
+        page_my_submissions()
 
 
 if __name__ == "__main__":