feature/verify_email

Dockerfile

@@ -0,0 +1,24 @@
+FROM python:3.10-slim
+
+RUN apt-get update && apt-get install -y \
+    build-essential \
+    cmake \
+    libnetcdf-dev \
+    && rm -rf /var/lib/apt/lists/*
+
+RUN useradd -m -u 1000 user
+USER user
+
+ENV HOME=/home/user \
+	PATH=/home/user/.local/bin:$PATH
+
+WORKDIR $HOME/app
+
+RUN pip install --no-cache-dir --upgrade pip
+COPY --chown=user . $HOME/app
+RUN pip install -r requirements.txt
+
+EXPOSE 7860
+ENV GRADIO_SERVER_NAME="0.0.0.0"
+
+CMD ["python", "app.py"]

README.md

@@ -3,13 +3,15 @@ title: MecCog Challenge
 emoji: 🔋
 colorFrom: purple
 colorTo: green
-sdk: gradio
-sdk_version: "5.50.0"
+sdk: docker
 pinned: false
 hf_oauth: true
 hf_oauth_expiration_minutes: 480
 hf_oauth_scopes:
-  - email
+  - read-repos
+  - write-repos
+  - manage-repos
+  - inference-api
 ---
 
 Check out the configuration reference at https://huggingface.co/docs/hub/spaces-config-reference

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 = "MecCog"
+CHALLENGE_NAME="MecCogChallenge"
+_ORGANIZATION="MecCog"
 
-SUBMISSIONS_REPO = f"{_ORGANIZATION}/{CHALLENGE_NAME}"
-RESULTS_REPO = f"{_ORGANIZATION}/{CHALLENGE_NAME}"
-REGISTRATION_REPO = f"{_ORGANIZATION}/{CHALLENGE_NAME}"
+SUBMISSIONS_REPO = f'{_ORGANIZATION}/{CHALLENGE_NAME}Submissions'
+RESULTS_REPO = f'{_ORGANIZATION}/{CHALLENGE_NAME}Results'
+REGISTRATION_REPO = f'{_ORGANIZATION}/{CHALLENGE_NAME}Registrations'

app.py

@@ -7,29 +7,16 @@ 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}!")
-
-        active_tab = gr.BrowserState(0)
-
-        with gr.Tabs(elem_classes="tab-buttons") as tabs:
+        with gr.Tabs(elem_classes="tab-buttons"):
             challenge_page.get_description(gr=gr)
-            registration_page.get_registration_page(gr=gr, demo=demo)
-            submission_page.get_submission_page(gr=gr, demo=demo)
+            registration_page.get_registration_page(gr=gr)
+            submission_page.get_submission_page(gr=gr)
             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", id=0):
-        gr.Markdown(CHALLENGE_DESCRIPTION)
+    with gr.TabItem(TAB_TITLE, elem_id="boundary-benchmark-tab-table"):
+        gr.Markdown(CHALLENGE_DESCRIPTION)

components/registration/config.py

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

components/registration/registration_page.py

@@ -4,7 +4,6 @@ import json
 import logging
 from datetime import datetime, timezone
 
-import gradio
 import pandas as pd
 
 from about import REGISTRATION_REPO
@@ -17,18 +16,13 @@ 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,
-    rename_user_teams,
-)
-from components.utils import (
-    push_data_to_dataset,
-    load_data_from_dataset,
-    get_team,
-    prefill_user_info,
 )
+from components.utils import push_data_to_dataset, load_data_from_dataset, get_team
 
 logger = logging.getLogger(__name__)
 
@@ -38,12 +32,10 @@ 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()
 
-    if not name or not username:
-        return ["❌ You must be logged in with your HuggingFace account to register."]
+    # Email is always required
     if not email:
         errors.append("An email address is required.")
     elif not validate_email_format(email):
@@ -87,7 +79,6 @@ 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
@@ -107,19 +98,18 @@ def register_participant(data: dict) -> tuple[bool, str]:
     if errors:
         return False, "❌ Validation failed:\n" + "\n".join(f"  • {e}" for e in errors)
 
-    username = data["username"].strip()  # unique
-
-    email = data["email"].strip()
-    name = data["name"].strip()
-    affiliation = data["affiliation"].strip()
-    role = data["role"].strip()
+    email = data["email"].strip().lower()
+    name = data["name"].strip().lower()
+    affiliation = data["affiliation"].strip().lower()
+    role = data["role"].strip().lower()
     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()
+    team_name = data["team_name"].strip().lower()
     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 ────────────────────────────────────────────────
@@ -143,42 +133,34 @@ 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 by username + team_name) ──────────
-    existing_participant = participants_df[participants_df["username"] == username]
+    # ── 3. Resolve participant row (upsert) ──────────────────────────────────
+    existing_participant = participants_df[participants_df["email"] == email]
     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
-
-    registration_status = (
-        "Pending" if not institutional or is_second_team else "Validated"
-    )
-    if is_already_in_this_team:
-        registration_status = existing_in_this_team.iloc[0].get(
-            "registration_status", "Pending"
-        )
-
     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)
-        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.",
-            )
+
+    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.",
+        )
+
     # ── 4. Resolve team ──────────────────────────────────────────────────────
     if is_new_team:
         # ── 4a. Creating a new team ──────────────────────────────────────────
         new_team_row = {
             "team_name": team_name,
             "team_description": team_description,
-            "leader_username": username if is_leader else "",
-            "members_username": json.dumps([username]),
+            "leader_email": email if is_leader else "",
+            "member_emails": json.dumps([email]),
             "second_team_reason": second_team_reason,
             "created_at": now,
             "updated_at": now,
@@ -199,59 +181,68 @@ def register_participant(data: dict) -> tuple[bool, str]:
             )
 
         # Add participant to member list if not already there
-        members_username: list[str] = json.loads(
-            team_row.get("members_username") or "[]"
-        )
-        if username not in members_username:
-            members_username.append(username)
+        member_emails: list[str] = json.loads(team_row.get("member_emails") or "[]")
+        if email not in member_emails:
+            member_emails.append(email)
 
         # Assign leader if requested and slot is free
-        current_leader = (team_row.get("leader_username") or "").strip()
+        current_leader = (team_row.get("leader_email") or "").strip()
         if is_leader:
-            if current_leader and current_leader != username:
+            if current_leader and current_leader != email:
                 return False, (
                     f"❌ Team '{name}' already has a designated leader "
                     f"({current_leader}). "
                     "Please contact the current leader to transfer leadership."
                 )
-            new_leader = username
+            new_leader = email
         else:
             new_leader = current_leader  # unchanged
 
         # Update team row in-place
         mask = teams_df["team_name"] == team_name
-        teams_df.loc[mask, "members_username"] = json.dumps(members_username)
-        teams_df.loc[mask, "leader_username"] = new_leader
+        teams_df.loc[mask, "member_emails"] = json.dumps(member_emails)
+        teams_df.loc[mask, "leader_email"] = new_leader
         teams_df.loc[mask, "updated_at"] = now
         action_msg = f"Joined existing team '{team_name}' ({team_name})."
 
-    # ── 5. Upsert participant row (keyed on username + 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 ────────────────────────────────────────────
     participant_row = {
         "email": email,
         "name": name,
-        "username": username,
         "affiliation": affiliation,
         "role": role,
         "self_description": self_description,
-        "registration_status": registration_status,
-        "team_name": team_name,
-        "is_leader": is_leader,
+        "needs_manual_review": needs_manual_review,
+        "team_memberships": json.dumps(updated_memberships),
         "registered_at": registered_at,
         "updated_at": now,
     }
 
-    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:
+    if is_new_participant:
         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
 
-    # ── 6. Push both datasets back to HF ────────────────────────────────────
+    # ── 7. 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)
@@ -267,38 +258,31 @@ def register_participant(data: dict) -> tuple[bool, str]:
     review_note = (
         "Your registration requires manual review because no institutional email "
         "was provided – you may receive a follow-up email."
-        if registration_status == "Pending"
+        if needs_manual_review
         else ""
     )
     message = (
-        f"Registration {'created' if is_new_participant else 'updated'} for {username}. "
-        f"{action_msg} {leader_note} {review_note}"
+        f"✅ Registration {'created' if is_new_participant else 'updated'} for {email}. "
+        f"{action_msg}{leader_note}{review_note}"
     )
     return True, message
 
 
-def get_registration_page(gr, demo):
-    with gr.TabItem("Register", id=1):
+def get_registration_page(gr):
+    with gr.TabItem("Register"):
         gr.Markdown(REGISTRATION_DESCRIPTION)
 
-        gr.LoginButton()
-
         with gr.Row():
             with gr.Column():
-                username = gr.Textbox(
-                    label="Username from your Hugging Face account *",
-                    placeholder="Fetching from HuggingFace...",
-                    interactive=False,
+                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.",
                 )
                 name = gr.Textbox(
-                    label="Full name from your Hugging Face account *",
-                    placeholder="Fetching from HuggingFace...",
-                    interactive=False,
+                    label="Full Name *",
+                    placeholder="Jane Smith",
                 )
-                email = gr.Textbox(
-                    label="Email *", placeholder="myemail@domain.com", interactive=True
-                )
-
                 affiliation = gr.Textbox(
                     label="Affiliation / Institution *",
                     placeholder="University / Company name",
@@ -343,14 +327,13 @@ def get_registration_page(gr, demo):
                     visible=False,
                 )
 
-                def on_see_user_teams(hf_username: str):
-                    if not hf_username or not hf_username.strip():
+                def on_see_user_teams(user_email: str):
+                    if not user_email or not user_email.strip():
                         return gr.Dataframe(visible=False), gr.Markdown(
-                            "❌ You must be logged in with your HuggingFace account to see your teams.",
-                            visible=True,
+                            "❌ Please enter an email address.", visible=True
                         )
 
-                    teams = rename_user_teams(get_user_teams(username=hf_username))
+                    teams = get_user_teams(email=user_email)
 
                     if len(teams) > 0:
                         return gr.Dataframe(value=teams, visible=True), gr.Markdown(
@@ -363,7 +346,7 @@ def get_registration_page(gr, demo):
 
                 user_team_button.click(
                     fn=on_see_user_teams,
-                    inputs=[username],
+                    inputs=[email],
                     outputs=[user_teams, user_teams_empty_msg],
                 )
 
@@ -409,6 +392,7 @@ def get_registration_page(gr, demo):
 
         def on_register(
             registration_email: str,
+            registration_name: str,
             registration_affiliation: str,
             self_desc: str,
             is_new_team: bool,
@@ -417,19 +401,15 @@ def get_registration_page(gr, demo):
             role: str,
             is_leader: bool,
             second_reason: str,
-            oauth_profile: gradio.OAuthProfile | None,
         ):
-            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] = []
+            errors = []
 
             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(
@@ -453,9 +433,8 @@ def get_registration_page(gr, demo):
                 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,
@@ -478,6 +457,7 @@ def get_registration_page(gr, demo):
             fn=on_register,
             inputs=[
                 email,
+                name,
                 affiliation,
                 description,
                 is_new_team_checkbox,
@@ -489,9 +469,3 @@ def get_registration_page(gr, demo):
             ],
             outputs=[registration_status],
         )
-
-    demo.load(
-        fn=prefill_user_info,
-        inputs=[],
-        outputs=[username, name, email],
-    )

components/registration/utils.py

@@ -1,3 +1,4 @@
+import json
 import logging
 import re
 
@@ -9,21 +10,17 @@ 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.
@@ -40,35 +37,33 @@ def is_institutional_email(email: str) -> bool:
     return any(p in email.lower() for p in patterns)
 
 
-def get_user_teams(username: str) -> pd.DataFrame:
-    """
-    Return the teams associated with a given username.
 
-    :param username:The unique hf username to query.
-    :return:        The teams associated with a given username as a DataFrame,
-                    with human-readable columns for role and registration status.
+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:
     """
-    EMPTY_RESULT = pd.DataFrame(
-        columns=["team_name", "is_leader", "registration_status"]
-    )
+    Return the teams associated with a given email.
 
-    participants_df = load_data_from_dataset(
-        REGISTRATION_REPO, PARTICIPANTS_FILE_NAME, PARTICIPANT_COLUMNS
-    )
-    if participants_df.empty:
-        return EMPTY_RESULT
+    :param email:   The email address to query.
+    :return:        The teams associated with a given email as a DataFrame.
+    """
+    participants_df = load_data_from_dataset(REGISTRATION_REPO, PARTICIPANTS_FILE_NAME, PARTICIPANT_COLUMNS)
+    existing_participant = participants_df[participants_df["email"] == email]
 
-    existing_participant = participants_df[participants_df["username"] == username]
     if existing_participant.empty:
-        return EMPTY_RESULT
+        return pd.DataFrame(columns=["team_name", "role"])
 
-    return existing_participant[["team_name", "is_leader", "registration_status"]]
+    existing_teams = json.loads(
+        existing_participant.iloc[0].get("team_memberships") or "[]"
+    )
 
+    if not existing_teams:
+        return pd.DataFrame(columns=["team_name", "role"])
 
-def rename_user_teams(result: pd.DataFrame) -> pd.DataFrame:
-    result["role"] = result["is_leader"].map(
-        {True: "Leader", False: "Member", "True": "Leader", "False": "Member"}
-    )
-    return result[["team_name", "role", "registration_status"]].rename(
-        columns={"team_name": "Team Name"}
-    )
+    df = pd.DataFrame(existing_teams)
+    df["role"] = df["is_leader"].apply(lambda x: "Leader" if x else "Member")
+    return df[["team_name", "role"]]

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_username",
+    "submission_email",
     "created_at",
     "hypothesis",
     "submission_note",
     "method",
     "file_path",
-]
+]

components/submission/submission_page.py

@@ -3,9 +3,8 @@ 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, prefill_user_info
+from components.utils import check_team_has_leader
 from components.submission.config import (
     MAX_SUBMISSIONS_PER_HYPOTHESIS,
     SUBMISSION_PAGE_DESCRIPTION,
@@ -23,8 +22,8 @@ def validate_csv(uploaded_file: str) -> tuple[bool, list[str]]:
     return True, []
 
 
-def get_submission_page(gr, demo):
-    with gr.TabItem("✉️ Submit", id=2):
+def get_submission_page(gr):
+    with gr.TabItem("✉️ Submit"):
 
         # ── Section header ──────────────────────────────────────────────────
         gr.Markdown(SUBMISSION_PAGE_DESCRIPTION)
@@ -33,26 +32,18 @@ def get_submission_page(gr, demo):
 
         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="myemail@domain.com", interactive=True
-                )
                 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,
@@ -101,24 +92,22 @@ def get_submission_page(gr, demo):
 
         # -- Submission count display when team / hypothesis changes ---------
         def on_submission_team_or_hypothesis_change(
-            submission_username: str, submission_team_name: str, hypothesis: str
+            submission_email: 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_team_registration(
-                username=submission_username, team_name=submission_team_name
+            is_user_registered = validate_user_registration(
+                email=submission_email, team_name=submission_team_name
             )
             if not is_user_registered:
-                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."
+                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."
 
             count = get_team_submission_count(submission_team_name, hypothesis)
             remaining = MAX_SUBMISSIONS_PER_HYPOTHESIS - count
@@ -136,14 +125,14 @@ def get_submission_page(gr, demo):
         for widget in [team_name, hypothesis_dropdown]:
             widget.change(
                 fn=on_submission_team_or_hypothesis_change,
-                inputs=[username, team_name, hypothesis_dropdown],
+                inputs=[uploader_email, team_name, hypothesis_dropdown],
                 outputs=[submission_count_display],
             )
 
         # -- Prediction file upload & validation -----------------------------
         def on_submit(
             submission_team_name: str,
-            submission_username: str,
+            submission_email: str,
             submission_hypothesis: str,
             submission_file: str,
             submission_note: str,
@@ -153,7 +142,7 @@ def get_submission_page(gr, demo):
             success, status = on_validation(
                 file=predictions_file,
                 submission_team_name=submission_team_name,
-                submission_username=submission_username,
+                submission_email=submission_email,
                 submission_hypothesis=submission_hypothesis,
             )
             if not success:
@@ -164,7 +153,7 @@ def get_submission_page(gr, demo):
                 team_name=submission_team_name,
                 hypothesis=submission_hypothesis,
                 file_path=submission_file,
-                uploader_username=submission_username,
+                uploader_email=submission_email,
                 note=submission_note,
                 link_to_methods=report_link,
             )
@@ -191,7 +180,7 @@ def get_submission_page(gr, demo):
             fn=on_submit,
             inputs=[
                 team_name,
-                username,
+                uploader_email,
                 hypothesis_dropdown,
                 predictions_file,
                 note,
@@ -202,41 +191,29 @@ def get_submission_page(gr, demo):
 
         def on_validation(
             file: str | None,
-            submission_username: str,
+            submission_email: 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)
 
-            user_validation = validate_user_registration(
-                username=submission_username, team_name=submission_team_name
+            is_user_registered = validate_user_registration(
+                email=submission_email, team_name=submission_team_name
             )
-            if user_validation == "not registered":
-                errors.append(
-                    "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 == "pending":
-                errors.append(
-                    "Your registration is still pending. Please wait until your registration is validated or contact the challenge organizers.."
-                )
-            elif user_validation == "not validated":
+            if not is_user_registered:
                 errors.append(
-                    "Your registration was not accepted by the organizers. You can't submit your submission. Contact your organizers if you think it was an error."
+                    "Please provide your email address and the team you're registered into and the hypothesis corresponding to your hypothesis."
                 )
-
             if file is None:
                 errors.append("Please upload a CSV file.")
 
@@ -279,12 +256,6 @@ def get_submission_page(gr, demo):
 
         validation_button.click(
             fn=on_validation,
-            inputs=[predictions_file, username, team_name, hypothesis_dropdown],
+            inputs=[predictions_file, uploader_email, 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,7 +5,6 @@ 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
@@ -17,7 +16,7 @@ def submit_prediction(
     team_name: str,
     hypothesis: str,
     file_path: str,
-    uploader_username: str,
+    uploader_email: str,
     note: str | None,
     link_to_methods: str | None,
 ) -> tuple[bool, str]:
@@ -47,7 +46,7 @@ def submit_prediction(
                 {
                     "submission_id": submission_id,
                     "team_name": team_name,
-                    "submission_username": uploader_username,
+                    "submission_email": uploader_email,
                     "created_at": datetime.now(timezone.utc).isoformat(),
                     "hypothesis": hypothesis,
                     "submission_note": note or "",
@@ -80,40 +79,13 @@ def get_team_submission_count(team_name: str, hypothesis: str) -> int:
     ].shape[0]
 
 
-def validate_user_team_registration(username: str, team_name: str) -> bool:
+def validate_user_registration(email: str, team_name: str) -> bool:
     """
-    Verify that the given username is registered as part of the team with the given team_name.
+    Verify that the given email is registered as part of the team with the given team_name.
 
-    :param username:    The username to validate.
+    :param email:       The email to validate.
     :param team_name:   The team to validate.
-    :return:            True is the username is registered as part of the team with the given team_name. False otherwise.
+    :return:            True is the email is registered as part of the team with the given team_name. False otherwise.
     """
-    user_teams = get_user_teams(username=username)
+    user_teams = get_user_teams(email=email)
     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"
-    elif record.iloc[0]["registration_status"] == "Validated":
-        return "validated"
-    elif record.iloc[0]["registration_status"] == "Pending":
-        return "pending"
-    else:
-        return "not validated"

components/utils.py

@@ -4,10 +4,7 @@ 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
@@ -166,30 +163,4 @@ 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_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()
-
-    try:
-        resp = httpx.get(
-            "https://huggingface.co/oauth/userinfo",
-            headers={"Authorization": f"Bearer {oauth_token.token}"},
-            timeout=5,
-        )
-        resp.raise_for_status()
-        email = resp.json().get("email", "")
-    except Exception:
-        email = ''
-
-    return (
-        gr.update(value=oauth_profile.username),
-        gr.update(value=oauth_profile.name),
-        gr.update(value=email),
-    )
+    return bool((team.get("leader_email") or "").strip())

packages.txt

@@ -1,3 +0,0 @@
-build-essential
-cmake
-libnetcdf-dev

requirements.txt

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