feature/add_hf_auth

about.py

@@ -5,12 +5,12 @@ from huggingface_hub import HfApi
 load_dotenv()
 
 TOKEN = os.environ.get("HF_TOKEN")
-CACHE_PATH=os.getenv("HF_HOME", ".")
+CACHE_PATH = os.getenv("HF_HOME", ".")
 API = HfApi(token=TOKEN)
 
-CHALLENGE_NAME="MecCogChallenge"
-_ORGANIZATION="EmmaScharfmann"
+CHALLENGE_NAME = "MecCogChallenge"
+_ORGANIZATION = "MecCog"
 
-SUBMISSIONS_REPO = f'{_ORGANIZATION}/{CHALLENGE_NAME}Submissions'
-RESULTS_REPO = f'{_ORGANIZATION}/{CHALLENGE_NAME}Results'
-REGISTRATION_REPO = f'{_ORGANIZATION}/{CHALLENGE_NAME}Registrations'
+SUBMISSIONS_REPO = f"{_ORGANIZATION}/{CHALLENGE_NAME}"
+RESULTS_REPO = f"{_ORGANIZATION}/{CHALLENGE_NAME}"
+REGISTRATION_REPO = f"{_ORGANIZATION}/{CHALLENGE_NAME}"

app.py

@@ -7,16 +7,29 @@ from about import CHALLENGE_NAME
 
 PROBLEM_TYPES = ["hypothesis 1", "hypothesis 2", "hypothesis 3"]
 
+
 def gradio_interface() -> gr.Blocks:
     with gr.Blocks() as demo:
         gr.Markdown(f"## Welcome to the {CHALLENGE_NAME}!")
-        with gr.Tabs(elem_classes="tab-buttons"):
+
+        active_tab = gr.BrowserState(0)
+
+        with gr.Tabs(elem_classes="tab-buttons") as tabs:
             challenge_page.get_description(gr=gr)
-            registration_page.get_registration_page(gr=gr)
-            submission_page.get_submission_page(gr=gr)
+            registration_page.get_registration_page(gr=gr, demo=demo)
+            submission_page.get_submission_page(gr=gr, demo=demo)
             faq.get_faq(gr=gr)
             leaderboard_page.get_leaderboard(gr=gr)
- 
+
+        def restore_tab(idx):
+            return gr.Tabs(selected=idx)
+
+        def save_tab(evt: gr.SelectData):
+            return evt.index
+
+        tabs.select(fn=save_tab, inputs=None, outputs=[active_tab])
+        demo.load(fn=restore_tab, inputs=[active_tab], outputs=[tabs])
+
     return demo
 
 

components/challenge_page.py

@@ -16,5 +16,5 @@ CHALLENGE_DESCRIPTION = f"""
 
 
 def get_description(gr):
-    with gr.TabItem(TAB_TITLE, elem_id="boundary-benchmark-tab-table"):
-        gr.Markdown(CHALLENGE_DESCRIPTION)
+    with gr.TabItem(TAB_TITLE, elem_id="boundary-benchmark-tab-table", id=0):
+        gr.Markdown(CHALLENGE_DESCRIPTION)

components/registration/config.py

@@ -38,13 +38,15 @@ TEAMS_FILE_NAME = "teams.csv"
 # Schema – column names and dtypes for each dataset
 # ---------------------------------------------------------------------------
 PARTICIPANT_COLUMNS: list[str] = [
+    "username",
     "email",
     "name",
     "affiliation",
     "discord",
     "self_description",
     "needs_manual_review",
-    "team_memberships",
+    "team_name",
+    "is_leader",
     "registered_at",
     "updated_at",
 ]
@@ -52,9 +54,9 @@ PARTICIPANT_COLUMNS: list[str] = [
 TEAM_COLUMNS: list[str] = [
     "team_name",
     "team_description",
-    "leader_email",
-    "member_emails",  # JSON-encoded list[str]
+    "leader_username",
+    "members_username",  # JSON-encoded list[str]
     "second_team_reason",
     "created_at",
     "updated_at",
-]
+]

components/registration/registration_page.py

@@ -4,6 +4,7 @@ import json
 import logging
 from datetime import datetime, timezone
 
+import gradio
 import pandas as pd
 
 from about import REGISTRATION_REPO
@@ -16,13 +17,17 @@ from components.registration.config import (
     TEAM_COLUMNS,
 )
 from components.registration.utils import (
-    get_team_membership_entry,
     validate_email_domain,
     is_institutional_email,
     validate_email_format,
     get_user_teams,
 )
-from components.utils import push_data_to_dataset, load_data_from_dataset, get_team
+from components.utils import (
+    push_data_to_dataset,
+    load_data_from_dataset,
+    get_team,
+    prefill_user_info,
+)
 
 logger = logging.getLogger(__name__)
 
@@ -32,10 +37,12 @@ def _validate_registration_input(data: dict[str, str]) -> list[str]:
     errors: list[str] = []
     email = (data.get("email") or "").strip()
     name = (data.get("name") or "").strip()
+    username = (data.get("username") or "").strip()
     affiliation = (data.get("affiliation") or "").strip()
     role = (data.get("role") or "").strip()
 
-    # Email is always required
+    if not name or not username:
+        return ["❌ You must be logged in with your HuggingFace account to register."]
     if not email:
         errors.append("An email address is required.")
     elif not validate_email_format(email):
@@ -79,6 +86,7 @@ def register_participant(data: dict) -> tuple[bool, str]:
     Persist a participant registration to HuggingFace datasets.
 
     ``data`` keys (all str unless noted):
+        username            – always required, unique from huggingface account
         email               – always required
         name                – always required
         affiliation         – always required
@@ -98,18 +106,19 @@ def register_participant(data: dict) -> tuple[bool, str]:
     if errors:
         return False, "❌ Validation failed:\n" + "\n".join(f"  • {e}" for e in errors)
 
-    email = data["email"].strip().lower()
-    name = data["name"].strip().lower()
-    affiliation = data["affiliation"].strip().lower()
-    role = data["role"].strip().lower()
+    username = data["username"].strip()  # unique
+
+    email = data["email"].strip()
+    name = data["name"].strip()
+    affiliation = data["affiliation"].strip()
+    role = data["role"].strip()
     self_description = (data.get("self_description") or "").strip()
     is_new_team: bool = bool(data.get("is_new_team", False))
-    team_name = data["team_name"].strip().lower()
+    team_name = data["team_name"].strip()
     team_description = (data.get("team_description") or "").strip()
     is_leader: bool = bool(data.get("is_leader", False))
     second_team_reason = (data.get("second_team_reason") or "").strip()
     institutional = is_institutional_email(email=email)
-    needs_manual_review = not institutional
     now = datetime.now(timezone.utc).isoformat()
 
     # ── 2. Load both datasets ────────────────────────────────────────────────
@@ -133,34 +142,40 @@ def register_participant(data: dict) -> tuple[bool, str]:
             "❌ This team already exists. Please provide another Team name, or join an existing team. .",
         )
 
-    # ── 3. Resolve participant row (upsert) ──────────────────────────────────
-    existing_participant = participants_df[participants_df["email"] == email]
+    # ── 3. Resolve participant row (upsert by username + team_name) ──────────
+    existing_participant = participants_df[participants_df["username"] == username]
     is_new_participant = existing_participant.empty
 
+    existing_in_this_team = existing_participant[
+        existing_participant["team_name"] == team_name  # fix: was "team"
+    ]
+    is_already_in_this_team = not existing_in_this_team.empty
+
+    is_second_team = not existing_participant.empty and not is_already_in_this_team
+
+    needs_manual_review = not institutional or is_second_team
+    if is_already_in_this_team:
+        needs_manual_review = existing_in_this_team.iloc[0].get(
+            "needs_manual_review", True
+        )
+
     if is_new_participant:
-        existing_memberships: list[dict] = []
         registered_at = now
     else:
-        existing_memberships = json.loads(
-            existing_participant.iloc[0].get("team_memberships") or "[]"
-        )
         registered_at = existing_participant.iloc[0].get("registered_at", now)
-
-    already_has_team = len(existing_memberships) > 0
-    if already_has_team and not second_team_reason:
-        return (
-            False,
-            "❌ This user is already part of a team. Please provide a reason for joining a second team.",
-        )
-
+        if is_second_team and not second_team_reason:
+            return (
+                False,
+                "This user is already part of a team. Please provide a reason for joining a second team.",
+            )
     # ── 4. Resolve team ─────���────────────────────────────────────────────────
     if is_new_team:
         # ── 4a. Creating a new team ──────────────────────────────────────────
         new_team_row = {
             "team_name": team_name,
             "team_description": team_description,
-            "leader_email": email if is_leader else "",
-            "member_emails": json.dumps([email]),
+            "leader_username": username if is_leader else "",
+            "members_username": json.dumps([username]),
             "second_team_reason": second_team_reason,
             "created_at": now,
             "updated_at": now,
@@ -181,68 +196,59 @@ def register_participant(data: dict) -> tuple[bool, str]:
             )
 
         # Add participant to member list if not already there
-        member_emails: list[str] = json.loads(team_row.get("member_emails") or "[]")
-        if email not in member_emails:
-            member_emails.append(email)
+        members_username: list[str] = json.loads(
+            team_row.get("members_username") or "[]"
+        )
+        if username not in members_username:
+            members_username.append(username)
 
         # Assign leader if requested and slot is free
-        current_leader = (team_row.get("leader_email") or "").strip()
+        current_leader = (team_row.get("leader_username") or "").strip()
         if is_leader:
-            if current_leader and current_leader != email:
+            if current_leader and current_leader != username:
                 return False, (
                     f"❌ Team '{name}' already has a designated leader "
                     f"({current_leader}). "
                     "Please contact the current leader to transfer leadership."
                 )
-            new_leader = email
+            new_leader = username
         else:
             new_leader = current_leader  # unchanged
 
         # Update team row in-place
         mask = teams_df["team_name"] == team_name
-        teams_df.loc[mask, "member_emails"] = json.dumps(member_emails)
-        teams_df.loc[mask, "leader_email"] = new_leader
+        teams_df.loc[mask, "members_username"] = json.dumps(members_username)
+        teams_df.loc[mask, "leader_username"] = new_leader
         teams_df.loc[mask, "updated_at"] = now
         action_msg = f"Joined existing team '{team_name}' ({team_name})."
 
-    # ── 5. Build updated membership list for participant ─────────────────────
-    # If participant is already a member of this team, update is_leader in place
-    existing_team_names = [m["team_name"] for m in existing_memberships]
-    if team_name in existing_team_names:
-        updated_memberships = [
-            get_team_membership_entry(
-                team_name=m["team_name"],
-                is_leader=is_leader if m["team_name"] == team_name else m["is_leader"],
-            )
-            for m in existing_memberships
-        ]
-    else:
-        updated_memberships = existing_memberships + [
-            get_team_membership_entry(team_name=team_name, is_leader=is_leader)
-        ]
-
-    # ── 6. Upsert participant row ────────────────────────────────────────────
+    # ── 5. Upsert participant row (keyed on username + team_name) ────────────
     participant_row = {
         "email": email,
         "name": name,
+        "username": username,
         "affiliation": affiliation,
         "role": role,
         "self_description": self_description,
         "needs_manual_review": needs_manual_review,
-        "team_memberships": json.dumps(updated_memberships),
+        "team_name": team_name,
+        "is_leader": is_leader,
         "registered_at": registered_at,
         "updated_at": now,
     }
 
-    if is_new_participant:
+    if is_already_in_this_team:
+        mask = (participants_df["username"] == username) & (
+            participants_df["team_name"] == team_name
+        )
+        for col, val in participant_row.items():
+            participants_df.loc[mask, col] = val
+    else:
         participants_df = pd.concat(
             [participants_df, pd.DataFrame([participant_row])], ignore_index=True
         )
-    else:
-        for col, val in participant_row.items():
-            participants_df.loc[participants_df["email"] == email, col] = val
 
-    # ── 7. Push both datasets back to HF ────────────────────────────────────
+    # ── 6. Push both datasets back to HF ────────────────────────────────────
     try:
         push_data_to_dataset(participants_df, REGISTRATION_REPO, PARTICIPANTS_FILE_NAME)
         push_data_to_dataset(teams_df, REGISTRATION_REPO, TEAMS_FILE_NAME)
@@ -262,26 +268,34 @@ def register_participant(data: dict) -> tuple[bool, str]:
         else ""
     )
     message = (
-        f"✅ Registration {'created' if is_new_participant else 'updated'} for {email}. "
-        f"{action_msg}{leader_note}{review_note}"
+        f"Registration {'created' if is_new_participant else 'updated'} for {username}. "
+        f"{action_msg} {leader_note} {review_note}"
     )
     return True, message
 
 
-def get_registration_page(gr):
-    with gr.TabItem("Register"):
+def get_registration_page(gr, demo):
+    with gr.TabItem("Register", id=1):
         gr.Markdown(REGISTRATION_DESCRIPTION)
 
+        gr.LoginButton()
+
         with gr.Row():
             with gr.Column():
-                email = gr.Textbox(
-                    label="Institutional / Company Email *",
-                    placeholder="you@university.edu  or  you@company.com",
-                    info="Academic (.edu, .ac.*) or company domains are accepted automatically.",
+                username = gr.Textbox(
+                    label="Username from your Hugging Face account *",
+                    placeholder="Fetching from HuggingFace...",
+                    interactive=False,
                 )
                 name = gr.Textbox(
-                    label="Full Name *",
-                    placeholder="Jane Smith",
+                    label="Full name from your Hugging Face account *",
+                    placeholder="Fetching from HuggingFace...",
+                    interactive=False,
+                )
+                email = gr.Textbox(
+                    label="Email *",
+                    placeholder="Fetching from HuggingFace...",
+                    interactive=False,
                 )
                 affiliation = gr.Textbox(
                     label="Affiliation / Institution *",
@@ -327,13 +341,14 @@ def get_registration_page(gr):
                     visible=False,
                 )
 
-                def on_see_user_teams(user_email: str):
-                    if not user_email or not user_email.strip():
+                def on_see_user_teams(hf_username: str):
+                    if not hf_username or not hf_username.strip():
                         return gr.Dataframe(visible=False), gr.Markdown(
-                            "❌ Please enter an email address.", visible=True
+                            "❌ You must be logged in with your HuggingFace account to see your teams.",
+                            visible=True,
                         )
 
-                    teams = get_user_teams(email=user_email)
+                    teams = get_user_teams(username=hf_username)
 
                     if len(teams) > 0:
                         return gr.Dataframe(value=teams, visible=True), gr.Markdown(
@@ -346,7 +361,7 @@ def get_registration_page(gr):
 
                 user_team_button.click(
                     fn=on_see_user_teams,
-                    inputs=[email],
+                    inputs=[username],
                     outputs=[user_teams, user_teams_empty_msg],
                 )
 
@@ -392,7 +407,6 @@ def get_registration_page(gr):
 
         def on_register(
             registration_email: str,
-            registration_name: str,
             registration_affiliation: str,
             self_desc: str,
             is_new_team: bool,
@@ -401,15 +415,19 @@ def get_registration_page(gr):
             role: str,
             is_leader: bool,
             second_reason: str,
+            oauth_profile: gradio.OAuthProfile | None,
         ):
-            errors = []
+            if oauth_profile is None:
+                return gr.update(
+                    value="❌ You must be logged in with your HuggingFace account to register.",
+                    visible=True,
+                )
+
+            errors: list[str] = []
 
             if not registration_email.strip():
                 errors.append("Email is required.")
 
-            if not registration_name.strip():
-                errors.append("Full name is required.")
-
             if not registration_affiliation.strip():
                 errors.append("Affiliation is required.")
             if registration_email.strip() and not validate_email_domain(
@@ -433,8 +451,9 @@ def get_registration_page(gr):
                 return gr.update(value=msg, visible=True)
 
             data = {
+                "username": oauth_profile.username,
+                "name": oauth_profile.name,
                 "email": registration_email,
-                "name": registration_name,
                 "affiliation": registration_affiliation,
                 "self_description": self_desc,
                 "is_new_team": is_new_team,
@@ -457,7 +476,6 @@ def get_registration_page(gr):
             fn=on_register,
             inputs=[
                 email,
-                name,
                 affiliation,
                 description,
                 is_new_team_checkbox,
@@ -469,3 +487,9 @@ def get_registration_page(gr):
             ],
             outputs=[registration_status],
         )
+
+    demo.load(
+        fn=prefill_user_info,
+        inputs=[],
+        outputs=[username, name, email],
+    )

components/registration/utils.py

@@ -10,17 +10,21 @@ from components.utils import load_data_from_dataset
 
 logger = logging.getLogger(__name__)
 
+
 def validate_email_domain(email: str) -> bool:
     """Return True if email belongs to an academic or registered company domain."""
-    academic_tlds = [".edu", ".ac.uk", ".ac.", "university", "univ.", "institute", ".gov"]
+    academic_tlds = [
+        ".edu",
+        ".ac.uk",
+        ".ac.",
+        "university",
+        "univ.",
+        "institute",
+        ".gov",
+    ]
     return any(token in email.lower() for token in academic_tlds)
 
 
-def get_team_membership_entry(team_name: str, is_leader: bool) -> dict[str, str | bool]:
-    """Return a dictionary with information about a team."""
-    return {"team_name": team_name, "is_leader": is_leader}
-
-
 def validate_email_format(email: str) -> bool:
     """
     Validate the email format.
@@ -37,33 +41,22 @@ def is_institutional_email(email: str) -> bool:
     return any(p in email.lower() for p in patterns)
 
 
-
-def _participant_team_names(participant_row: pd.Series) -> list[str]:
-    """Return list of team_name the participant already belongs to."""
-    memberships = json.loads(participant_row.get("team_memberships") or "[]")
-    return [m["team_name"] for m in memberships]
-
-
-def get_user_teams(email: str) -> pd.DataFrame:
+def get_user_teams(username: str) -> pd.DataFrame:
     """
-    Return the teams associated with a given email.
+    Return the teams associated with a given username.
 
-    :param email:   The email address to query.
-    :return:        The teams associated with a given email as a DataFrame.
+    :param username:The unique hf username to query.
+    :return:        The teams associated with a given username as a DataFrame.
     """
-    participants_df = load_data_from_dataset(REGISTRATION_REPO, PARTICIPANTS_FILE_NAME, PARTICIPANT_COLUMNS)
-    existing_participant = participants_df[participants_df["email"] == email]
-
-    if existing_participant.empty:
+    participants_df = load_data_from_dataset(
+        REGISTRATION_REPO, PARTICIPANTS_FILE_NAME, PARTICIPANT_COLUMNS
+    )
+    if participants_df.empty:
         return pd.DataFrame(columns=["team_name", "role"])
 
-    existing_teams = json.loads(
-        existing_participant.iloc[0].get("team_memberships") or "[]"
-    )
+    existing_participant = participants_df[participants_df["username"] == username]
 
-    if not existing_teams:
+    if existing_participant.empty:
         return pd.DataFrame(columns=["team_name", "role"])
 
-    df = pd.DataFrame(existing_teams)
-    df["role"] = df["is_leader"].apply(lambda x: "Leader" if x else "Member")
-    return df[["team_name", "role"]]
+    return existing_participant[["team_name", "is_leader"]]

components/submission/config.py

@@ -23,10 +23,10 @@ You are allowed to submit up to {max} results per hypothesis.
 SUBMISSION_COLUMNS = [
     "submission_id",
     "team_name",
-    "submission_email",
+    "submission_username",
     "created_at",
     "hypothesis",
     "submission_note",
     "method",
     "file_path",
-]
+]

components/submission/submission_page.py

@@ -3,8 +3,9 @@ from components.submission.utils import (
     get_team_submission_count,
     submit_prediction,
     validate_user_registration,
+    validate_user_team_registration,
 )
-from components.utils import check_team_has_leader
+from components.utils import check_team_has_leader, prefill_user_info
 from components.submission.config import (
     MAX_SUBMISSIONS_PER_HYPOTHESIS,
     SUBMISSION_PAGE_DESCRIPTION,
@@ -22,8 +23,8 @@ def validate_csv(uploaded_file: str) -> tuple[bool, list[str]]:
     return True, []
 
 
-def get_submission_page(gr):
-    with gr.TabItem("✉️ Submit"):
+def get_submission_page(gr, demo):
+    with gr.TabItem("✉️ Submit", id=2):
 
         # ── Section header ──────────────────────────────────────────────────
         gr.Markdown(SUBMISSION_PAGE_DESCRIPTION)
@@ -32,18 +33,28 @@ def get_submission_page(gr):
 
         with gr.Row():
             with gr.Column():
+                gr.LoginButton()
+                username = gr.Textbox(
+                    label="Username from your Hugging Face account *",
+                    placeholder="Fetching from HuggingFace...",
+                    interactive=False,
+                )
+                name = gr.Textbox(
+                    label="Full name from your Hugging Face account *",
+                    placeholder="Fetching from HuggingFace...",
+                    interactive=False,
+                )
+                email = gr.Textbox(
+                    label="Email *",
+                    placeholder="Fetching from HuggingFace...",
+                    interactive=False,
+                )
                 team_name = gr.Textbox(
                     label="Team name *",
                     placeholder="My Awesome Lab",
                     info="Enter your team name.",
                     value="",
                 )
-                uploader_email = gr.Textbox(
-                    label=" Email *",
-                    info="Enter your email.",
-                    placeholder="you@university.edu",
-                    value="",
-                )
                 hypothesis_dropdown = gr.Dropdown(
                     label="Hypothesis *",
                     choices=PROBLEM_TYPES,
@@ -92,22 +103,24 @@ def get_submission_page(gr):
 
         # -- Submission count display when team / hypothesis changes ---------
         def on_submission_team_or_hypothesis_change(
-            submission_email: str, submission_team_name: str, hypothesis: str
+            submission_username: str, submission_team_name: str, hypothesis: str
         ):
+            if submission_username is None or not submission_username.strip():
+                return (
+                    " ❌You must be logged in with your HuggingFace account to register"
+                )
             if (
                 submission_team_name is None
-                or submission_email is None
-                or not submission_email.strip()
                 or not submission_team_name.strip()
                 or not hypothesis
             ):
                 return "❌ Enter your team name and select a hypothesis to see the number of results already submitted."
 
-            is_user_registered = validate_user_registration(
-                email=submission_email, team_name=submission_team_name
+            is_user_registered = validate_user_team_registration(
+                username=submission_username, team_name=submission_team_name
             )
             if not is_user_registered:
-                return "❌ The given email is not registered as part of the given team. Please provide a registered email and team or register on the registration panel."
+                return "❌ The username corresponding to the account you are logged in with is not registered as part of the given team. Please register on the registration panel."
 
             count = get_team_submission_count(submission_team_name, hypothesis)
             remaining = MAX_SUBMISSIONS_PER_HYPOTHESIS - count
@@ -125,14 +138,14 @@ def get_submission_page(gr):
         for widget in [team_name, hypothesis_dropdown]:
             widget.change(
                 fn=on_submission_team_or_hypothesis_change,
-                inputs=[uploader_email, team_name, hypothesis_dropdown],
+                inputs=[username, team_name, hypothesis_dropdown],
                 outputs=[submission_count_display],
             )
 
         # -- Prediction file upload & validation -----------------------------
         def on_submit(
             submission_team_name: str,
-            submission_email: str,
+            submission_username: str,
             submission_hypothesis: str,
             submission_file: str,
             submission_note: str,
@@ -142,7 +155,7 @@ def get_submission_page(gr):
             success, status = on_validation(
                 file=predictions_file,
                 submission_team_name=submission_team_name,
-                submission_email=submission_email,
+                submission_username=submission_username,
                 submission_hypothesis=submission_hypothesis,
             )
             if not success:
@@ -153,7 +166,7 @@ def get_submission_page(gr):
                 team_name=submission_team_name,
                 hypothesis=submission_hypothesis,
                 file_path=submission_file,
-                uploader_email=submission_email,
+                uploader_username=submission_username,
                 note=submission_note,
                 link_to_methods=report_link,
             )
@@ -180,7 +193,7 @@ def get_submission_page(gr):
             fn=on_submit,
             inputs=[
                 team_name,
-                uploader_email,
+                username,
                 hypothesis_dropdown,
                 predictions_file,
                 note,
@@ -191,29 +204,37 @@ def get_submission_page(gr):
 
         def on_validation(
             file: str | None,
-            submission_email: str,
+            submission_username: str,
             submission_team_name: str,
             submission_hypothesis: str,
         ) -> tuple[bool, str]:
             """Validate the given file according to the challenge's requirements."""
             errors: list[str] = []
+            if not submission_username.strip():
+                return False, gr.update(
+                    value=f"❌ You must be logged in with your HuggingFace account to register.",
+                    visible=True,
+                )
             if not submission_team_name.strip():
                 errors.append("Team name is required.")
-            if not submission_email.strip():
-                errors.append("Your email is required for compliance notifications.")
             if submission_hypothesis is None:
                 errors.append("Please select a hypothesis..")
             if errors:
                 status = "❌ " + "  |  ".join(errors)
                 return False, gr.update(value=status, visible=True)
 
-            is_user_registered = validate_user_registration(
-                email=submission_email, team_name=submission_team_name
+            user_validation = validate_user_registration(
+                username=submission_username, team_name=submission_team_name
             )
-            if not is_user_registered:
+            if user_validation == "not registered":
                 errors.append(
-                    "Please provide your email address and the team you're registered into and the hypothesis corresponding to your hypothesis."
+                    "The username corresponding to the account you are logged in with is not registered as part of the given team. Please register on the registration panel."
                 )
+            elif user_validation == "not validated":
+                errors.append(
+                    "Please wait until your registration is validated or contact the challenge organizers.."
+                )
+
             if file is None:
                 errors.append("Please upload a CSV file.")
 
@@ -256,6 +277,12 @@ def get_submission_page(gr):
 
         validation_button.click(
             fn=on_validation,
-            inputs=[predictions_file, uploader_email, team_name, hypothesis_dropdown],
+            inputs=[predictions_file, username, team_name, hypothesis_dropdown],
             outputs=[is_valid, validation_status],
         )
+
+    demo.load(
+        fn=prefill_user_info,
+        inputs=[],
+        outputs=[username, name, email],
+    )

components/submission/utils.py

@@ -5,6 +5,7 @@ import pandas as pd
 from huggingface_hub import HfApi
 
 from about import TOKEN, REGISTRATION_REPO
+from components.registration.config import PARTICIPANTS_FILE_NAME, PARTICIPANT_COLUMNS
 from components.registration.utils import get_user_teams
 from components.submission.config import SUBMISSION_COLUMNS, SUBMISSIONS_FILE_NAME
 from components.utils import load_data_from_dataset, push_data_to_dataset
@@ -16,7 +17,7 @@ def submit_prediction(
     team_name: str,
     hypothesis: str,
     file_path: str,
-    uploader_email: str,
+    uploader_username: str,
     note: str | None,
     link_to_methods: str | None,
 ) -> tuple[bool, str]:
@@ -46,7 +47,7 @@ def submit_prediction(
                 {
                     "submission_id": submission_id,
                     "team_name": team_name,
-                    "submission_email": uploader_email,
+                    "submission_username": uploader_username,
                     "created_at": datetime.now(timezone.utc).isoformat(),
                     "hypothesis": hypothesis,
                     "submission_note": note or "",
@@ -79,13 +80,38 @@ def get_team_submission_count(team_name: str, hypothesis: str) -> int:
     ].shape[0]
 
 
-def validate_user_registration(email: str, team_name: str) -> bool:
+def validate_user_team_registration(username: str, team_name: str) -> bool:
     """
-    Verify that the given email is registered as part of the team with the given team_name.
+    Verify that the given username is registered as part of the team with the given team_name.
 
-    :param email:       The email to validate.
+    :param username:    The username to validate.
     :param team_name:   The team to validate.
-    :return:            True is the email is registered as part of the team with the given team_name. False otherwise.
+    :return:            True is the username is registered as part of the team with the given team_name. False otherwise.
     """
-    user_teams = get_user_teams(email=email)
+    user_teams = get_user_teams(username=username)
     return len(user_teams[user_teams["team_name"] == team_name]) > 0
+
+
+def validate_user_registration(username: str, team_name: str) -> str:
+    """
+    Verify that the given username is validated as part of the team with the given team_name.
+
+    :param username:    The username to validate.
+    :param team_name:   The team to validate.
+    :return:            True is the username is registered and validated as part of the team with the given team_name. False otherwise.
+    """
+    participants_df = load_data_from_dataset(
+        REGISTRATION_REPO, PARTICIPANTS_FILE_NAME, PARTICIPANT_COLUMNS
+    )
+    if participants_df.empty:
+        return "not registered"
+    record = participants_df[
+        (participants_df["username"] == username)
+        & (participants_df["team_name"] == team_name)
+    ]
+    if record.empty:
+        return "not registered"
+    if record.iloc[0]["needs_manual_review"]:
+        return "not validated"
+    else:
+        return "validated"

components/utils.py

@@ -4,7 +4,10 @@ import pathlib
 import tempfile
 import json
 from pathlib import Path
+import httpx
 
+
+import gradio
 import gradio as gr
 import pandas as pd
 from huggingface_hub import hf_hub_download, HfApi
@@ -163,4 +166,27 @@ def check_team_has_leader(team_name: str) -> bool:
     team = get_team(teams_df, team_name)
     if team is None:
         return False
-    return bool((team.get("leader_email") or "").strip())
+    return bool((team.get("leader_username") or "").strip())
+
+
+def prefill_user_info(
+    oauth_profile: gradio.OAuthProfile | None,
+    oauth_token: gradio.OAuthToken | None,
+):
+    empty = lambda: gr.update(value="", placeholder="Log in with HuggingFace first")
+    if oauth_profile is None or oauth_token is None:
+        return empty(), empty(), empty()
+
+    resp = httpx.get(
+        "https://huggingface.co/api/whoami-v2",
+        headers={"Authorization": f"Bearer {oauth_token.token}"},
+        timeout=5,
+    )
+    resp.raise_for_status()
+    email = resp.json().get("email", "")
+
+    return (
+        gr.update(value=oauth_profile.username),
+        gr.update(value=oauth_profile.name),
+        gr.update(value=email),
+    )

requirements.txt

@@ -1,7 +1,9 @@
 gradio
 datasets
 huggingface_hub
+httpx
 gradio-leaderboard
 plotly
 dotenv
-pandas
+pandas
+gradio[oauth]