Update main.py

main.py

@@ -3,8 +3,10 @@ import json
 import uuid
 import time
 import tempfile
+import hashlib
+import hmac
 from datetime import datetime, timezone
-from typing import Any, Dict, List, Tuple
+from typing import Any, Dict, List, Tuple, Optional
 
 import streamlit as st
 import pandas as pd
@@ -36,83 +38,213 @@ PHASES = [
 ]
 
 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"
 
 # =========================
-# AUTH HELPERS
+# PASSWORD HELPERS
+# =========================
+
+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
+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 get_oauth_info() -> Dict | None:
-    """
-    In Docker spaces, HF injects user info via the X-Space-User-Info request header
-    as a JSON string once the user has authenticated via /oauth/login.
-    """
+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:
-        headers = st.context.headers
-        user_info_raw = headers.get("X-Space-User-Info")
-        if user_info_raw:
-            data = json.loads(user_info_raw)
-            return {
-                "preferred_username": data.get("preferred_username", data.get("name", "")),
-                "name": data.get("name", ""),
-                "email": data.get("email", ""),
-                "picture": data.get("picture", None),
-            }
+        os.remove(tmp)
     except Exception:
         pass
-    return None
 
+# =========================
+# AUTH STATE
+# =========================
 
-def get_login_url() -> str:
-    """
-    In HF Docker spaces, OAuth login is at /oauth/login on the space host.
-    HF injects SPACE_HOST as an env var automatically.
-    """
-    space_host = os.getenv("SPACE_HOST", "")
-    if space_host:
-        return f"https://{space_host}/oauth/login"
-    return "/oauth/login"
+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 render_login_wall():
-    """Shows login prompt and stops rendering if not authenticated."""
-    user = get_oauth_info()
+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.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 = get_login_url()
-    st.markdown(
-        f'''<a href="{login_url}" target="_self">
-        <button style="background:#FF6B35;color:white;border:none;padding:12px 28px;
-        font-size:16px;border-radius:8px;cursor:pointer;font-weight:bold;">
-        🤗 Login with Hugging Face</button></a>''',
-        unsafe_allow_html=True,
-    )
+    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()
+
 
 # =========================
-# SUBMISSION CAP HELPERS
+# 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")
 
-
-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.
-    """
+def _count_submissions_today(username: str) -> int:
     try:
         files = api_client().list_repo_files(
             repo_id=DB_REPO_ID, repo_type=DB_REPO_TYPE, token=SUBMISSIONS_TOKEN
@@ -124,13 +256,11 @@ def _count_submissions_today(hf_username: str) -> int:
                 continue
             try:
                 p = hf_hub_download(
-                    repo_id=DB_REPO_ID,
-                    repo_type=DB_REPO_TYPE,
-                    filename=f,
-                    token=SUBMISSIONS_TOKEN,
+                    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:
+                if meta.get("username", "").lower() == username.lower():
                     ts = meta.get("timestamp", 0)
                     sub_date = datetime.fromtimestamp(ts, tz=timezone.utc).strftime("%Y-%m-%d")
                     if sub_date == today:
@@ -141,30 +271,10 @@ def _count_submissions_today(hf_username: str) -> int:
     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."
-        )
-        st.stop()
-
-
 def _validate_submission_json(obj: Any) -> Tuple[bool, str]:
     if not isinstance(obj, list):
         return False, "Submission must be a JSON list of annotations."
-
     required_keys = {"image_id", "score", "category_id", "area", "bbox", "segmentation"}
-
     for i, ann in enumerate(obj):
         if not isinstance(ann, dict):
             return False, f"Annotation at index {i} must be an object/dict."
@@ -181,13 +291,11 @@ def _validate_submission_json(obj: Any) -> Tuple[bool, str]:
             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]."
+            return False, f"bbox at index {i} must be a list of 4 numbers."
         if not isinstance(ann["segmentation"], list):
             return False, f"segmentation at index {i} must be a list."
-
     return True, "OK"
 
-
 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)
@@ -207,23 +315,11 @@ def _upload_json(data: Any, path_in_repo: str, commit_message: str = "") -> None
         except OSError:
             pass
 
-
-def _create_submission_record(
-    *,
-    pred: List[Dict[str, Any]],
-    team: str,
-    model_name: str,
-    phase_codename: str,
-    challenge_type: str,
-    original_filename: str,
-    hf_username: str,
-    hf_email: str,
-) -> str:
+def _create_submission_record(*, pred, team, model_name, phase_codename,
+                               challenge_type, original_filename, username, email) -> str:
     _require_token()
-
     submission_id = str(uuid.uuid4())
     ts = int(time.time())
-
     meta = {
         "submission_id": submission_id,
         "team": team.strip(),
@@ -232,28 +328,22 @@ def _create_submission_record(
         "challenge_type": challenge_type,
         "timestamp": ts,
         "original_filename": original_filename,
-        "hf_username": hf_username,
-        "hf_email": hf_email,
+        "username": username,
+        "email": email,
     }
-
     status = {"state": "queued", "timestamp": ts}
     base = f"submissions/{submission_id}"
-
     _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 _load_leaderboard_df() -> pd.DataFrame:
     _require_token()
     try:
         path = hf_hub_download(
-            repo_id=DB_REPO_ID,
-            repo_type=DB_REPO_TYPE,
-            filename="leaderboard.jsonl",
-            token=SUBMISSIONS_TOKEN,
+            repo_id=DB_REPO_ID, repo_type=DB_REPO_TYPE,
+            filename="leaderboard.jsonl", token=SUBMISSIONS_TOKEN
         )
     except HfHubHTTPError as e:
         if "404" in str(e):
@@ -278,15 +368,11 @@ def _load_leaderboard_df() -> pd.DataFrame:
     for col in ["team", "model", "phase_codename", "timestamp", *LEADERBOARD_METRICS]:
         if col not in df.columns:
             df[col] = None
-
     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."""
+def _load_user_submissions(username: str) -> List[Dict]:
     _require_token()
     try:
         files = api_client().list_repo_files(
@@ -306,11 +392,8 @@ def _load_user_submissions(hf_username: str) -> List[Dict]:
                 filename=f, token=SUBMISSIONS_TOKEN
             )
             meta = json.load(open(meta_path))
-
-            if meta.get("hf_username") != hf_username:
+            if meta.get("username", "").lower() != username.lower():
                 continue
-
-            # Get status
             try:
                 status_path = hf_hub_download(
                     repo_id=DB_REPO_ID, repo_type=DB_REPO_TYPE,
@@ -319,12 +402,7 @@ def _load_user_submissions(hf_username: str) -> List[Dict]:
                 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", {})
-
+            metrics = status.get("metrics", {}) if status.get("state") == "done" else {}
             results.append({
                 "submission_id": sid,
                 "team": meta.get("team", ""),
@@ -341,7 +419,6 @@ def _load_user_submissions(hf_username: str) -> List[Dict]:
     results.sort(key=lambda x: x["timestamp"], reverse=True)
     return results
 
-
 # =========================
 # UI PAGES
 # =========================
@@ -350,7 +427,6 @@ 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
@@ -361,19 +437,16 @@ def render_overview():
         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_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.")
@@ -385,7 +458,6 @@ def page_leaderboard():
             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"]
 
@@ -397,9 +469,7 @@ def page_leaderboard():
     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"]:
+    for col in ["username", "email", "phase_codename", "submission_id"]:
         if col in df_display.columns:
             df_display.drop(columns=[col], inplace=True)
 
@@ -407,43 +477,28 @@ def page_leaderboard():
         df_display,
         column_config={
             "Rank": st.column_config.Column("Rank", width="small"),
-            "team": "Team",
-            "model": "Model",
+            "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,
+        use_container_width=True, hide_index=True,
     )
 
-
 def page_submit():
     user = render_login_wall()
-    hf_username = user.get("preferred_username", "unknown")
-    hf_email = user.get("email", "")
+    username = user["username"]
 
     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})")
-
+        st.markdown(f"👤 Logged in as **{username}** ({user.get('team', '')})")
     with col_cap:
         with st.spinner("Checking daily limit..."):
-            subs_today = _count_submissions_today(hf_username)
+            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(
@@ -454,141 +509,104 @@ def page_submit():
         )
 
     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", ""))
+        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
-        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 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. Please upload a valid JSON file.")
+            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 ✅")
 
-        submit_clicked = st.button("Submit (Queue for Evaluation)", type="primary")
-
-        if submit_clicked:
+        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
-
-            # 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.")
+            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,
+                        pred=pred_obj, team=team, model_name=model_name,
+                        phase_codename=phase_codename, challenge_type=challenge_type,
                         original_filename=uploaded_file.name,
-                        hf_username=hf_username,
-                        hf_email=hf_email,
+                        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}")
-            st.info("Track your results in **My Submissions** once the evaluator processes your file.")
-
 
 def page_my_submissions():
     user = render_login_wall()
-    hf_username = user.get("preferred_username", "unknown")
+    username = user["username"]
 
     st.header("📋 My Submissions")
-    st.caption(f"Showing all submissions for @{hf_username}")
+    st.caption(f"Showing all submissions for **{username}**")
 
     with st.spinner("Loading your submissions..."):
-        submissions = _load_user_submissions(hf_username)
+        submissions = _load_user_submissions(username)
 
     if not submissions:
-        st.info("You haven't made any submissions yet. Head to **Submit Model** to get started!")
+        st.info("No submissions yet. Head to **Submit Model** to get started!")
         return
 
-    # Phase filter
     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]
 
-    # State badges
-    state_colors = {
-        "queued": "🟡",
-        "running": "🔵",
-        "done": "🟢",
-        "failed": "🔴",
-        "unknown": "⚪",
-    }
-
+    state_colors = {"queued": "🟡", "running": "🔵", "done": "🟢", "failed": "🔴", "unknown": "⚪"}
     df = pd.DataFrame(filtered)
-
     if "timestamp" in df.columns:
         df["submitted_at"] = pd.to_datetime(df["timestamp"], unit="s", errors="coerce")
-
     if "state" in df.columns:
         df["status"] = df["state"].apply(lambda s: f"{state_colors.get(s, '⚪')} {s.capitalize()}")
 
     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
-
     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",
+        "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")
 
     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")
@@ -596,56 +614,29 @@ def page_my_submissions():
         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}")
 
-
 # =========================
 # MAIN
 # =========================
 
 def main():
     st.sidebar.title("VizWiz Benchmark 🏆")
-
-    # Check login state for sidebar display
-    user = get_oauth_info()
+    user = get_logged_in_user()
 
     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}")
-        space_host = os.getenv("SPACE_HOST", "")
-        logout_url = f"https://{space_host}/oauth/logout" if space_host else "/oauth/logout"
-        st.sidebar.markdown(
-            f'''<a href="{logout_url}" target="_self">
-            <button style="width:100%;background:#555;color:white;border:none;
-            padding:8px;border-radius:6px;cursor:pointer;font-size:13px;">
-            Logout</button></a>''',
-            unsafe_allow_html=True,
-        )
+        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:
-        st.sidebar.info("Login to submit predictions and view your history.")
-        login_url = get_login_url()
-        st.sidebar.markdown(
-            f'''<a href="{login_url}" target="_self">
-            <button style="width:100%;background:#FF6B35;color:white;border:none;
-            padding:10px;border-radius:6px;cursor:pointer;font-size:14px;font-weight:bold;">
-            🤗 Login with HF</button></a>''',
-            unsafe_allow_html=True,
-        )
-        menu = ["Leaderboard", "Submit Model", "My Submissions"]
+        menu = ["Leaderboard", "Login", "Sign Up"]
 
     choice = st.sidebar.radio("Navigation", menu)
     st.sidebar.markdown("---")
@@ -657,11 +648,19 @@ def main():
 
     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()
 
-
 if __name__ == "__main__":
     main()