add HG login

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

@@ -2,132 +2,19 @@ from about import CHALLENGE_NAME
 
 TAB_TITLE = "❔About"
 
-CHALLENGE_DESCRIPTION_1 = f"""
+CHALLENGE_DESCRIPTION = f"""
 ## About This Challenge
 
-**Welcome to the MecCog Challenge**, a collaborative effort to map the mechanisms by which the APOE4 genetic variant increases the risk of Alzheimer's disease.
+**Welcome to the {CHALLENGE_NAME}**, a community-driven effort to....
 
-### What You'll Do
+[ CHALLENGE DESCRIPTION ]
 
-Your task is to **find relevant research papers and extract key experimental findings** that relate to specific APOE4-Alzheimer's hypothesis you decide to select.
+[ LIST HYPOTHESIS ]
 
-For each hypothesis, you will:
-1. **Search the scientific literature** (PubMed, preprints, databases, web sources)
-2. **Identify papers** that bear on your specific mechanism
-3. **Extract experimental findings** from those papers (e.g., measurements, effects, experimental conditions)
-4. **Record everything** in a structured spreadsheet that we'll validate
-
-This is Step 1 of a multi-phase challenge. Later phases will ask you to assess evidence, estimate mechanism confidence, and design experiments — but for now, we focus on **finding and documenting what is already known**.
-
----
-
-## The Hypotheses
-
-Hypotheses will be released in batches starting **September 2026**. Check for new communications.
-
-**Focus on the hypothesis you decide to work on.** Don't catalog Alzheimer's mechanisms in general — we need findings that directly test or inform *the specific hypothesis you picked*.
-
-
----
-
-## Challenge Rules
-
-### What You Must Do
-
-✓ **Search thoroughly** — use PubMed, preprint servers (bioRxiv/medRxiv), Google Scholar, databases, and any sources you think are relevant.
-
-✓ **Extract precise findings** — include:
-  - A one-sentence description of each finding
-  - A direct quote from the paper (or mark `N/A` if not applicable)
-  - The experimental system tested (e.g., "primary mouse microglia", "human iPSC-derived neurons")
-  - Where in the paper the finding appears (figure panel, table, or text excerpt)
-  - Statistical details if available (effect size, P value, sample size)
-
-✓ **Fill the submission spreadsheet** — use the official template provided. Every field must have a value or the literal `N/A` (never leave blanks).
-
-✓ **Record metadata correctly** — include the DOI, PubMed ID (if applicable), and source type for each paper.
-
-✓ **Test your submission locally** — click on the "Validate" button, on the submission page. You will not be able to submit your submission if the validation failed.
-
-### What's Out of Bounds
-
-✗ **Don't pad your sheet** — include only papers and findings truly relevant to *your hypothesis*, not related Alzheimer's research in general.
-
-✗ **Don't fabricate** — every finding must exist in the paper at the location you cite. Misattributions will be caught and disqualify your submission.
-
-✗ **Don't skip ahead** — this is Step 1 only. Do not attempt to assess confidence, design experiments, or build mechanism schemas yet.
-
-✗ **Don't use fake identifiers** — DOIs and PubMed IDs must correspond to real, published sources.
-
-### Submission Format
-
-One spreadsheet per hypothesis. Download the official template from shared resources:
-"""
-
-CHALLENGE_DESCRIPTION_2 = """
-
-**Spreadsheet structure:**
-- **Row 1:** Column labels (provided in template)
-- **Row 2:** Your assigned hypothesis
-- **Row 3 onward:** One block per paper (paper row + finding rows)
-
-**Key columns:**
-- **DOI** — unique identifier for the source
-- **PubMed ID** — if applicable (digits only)
-- **Paper ID** — sequential (`P1`, `P2`, etc., in order of relevance)
-- **Finding ID** — (`P1.F1`, `P1.F2`, etc.)
-- **Finding description** — plain English, one sentence
-- **Finding quote** — exact text from the paper, or `N/A`
-- **Finding summary** — structured notation (e.g., `(APOE4) -> (↓ phagocytosis)`) or `N/A`
-- **Experimental system** — what cells/model was tested? (e.g., "mouse primary microglia")
-- **Data location** — figure panel (e.g., `Fig4C`), table number, or exact sentence
-- **Effect size, P value, sample size** — if reported; otherwise `N/A`
-
-### How You'll Be Evaluated
-
-**Your submission will be assessed on:**
-
-1. **Format validity** — Does it pass the automated validator? (Required to submit your submission)
-2. **Paper relevance** — Are the papers you found actually related to your hypothesis?
-3. **Finding accuracy** — Do the extracted findings genuinely appear where you cite them?
-4. **Consensus** — Do independent submissions (from other humans and agents) converge on the same papers and findings?
-5. **Completeness** — How thorough was your search? Did you miss obvious sources?
-6. **Expert review** — Specialist assessment of whether your extraction captures the key evidence.
-
-**No single "right answer" exists yet** — this is open scientific discovery. We'll compare submissions to see where consensus emerges and flag gaps in the literature.
-
----
-
-## How to Get Started
-
-1. Check the proposed hypothesis
-2. **Download the submission template** `submission_template.xlsx` (see above).
-3. **Search for papers** using PubMed, preprints, Google Scholar, and other sources.
-4. **Extract findings** and fill in the spreadsheet as you go.
-5. **Validate** your submission before uploading.
-6. **Upload your submission** on the submission page.
-
----
-
-## Timeline & Questions
-
-- **Step 1 (this task) launches:** September 2026
-- **Hypotheses released:** 
-- **Later phases:** Evidence assessment, mechanism confidence, experimental design (dates TBA)
-- **Questions?** Check the FAQ tab or contact the organizers — organizers and community are here to help.
-
----
-
-**Thank you for contributing to MecCog. Together, we're building a map of APOE4 mechanism.** 🧠
+[ CHALLENGE RULES ] 
 """
 
 
 def get_description(gr):
-    with gr.TabItem(TAB_TITLE, elem_id="boundary-benchmark-tab-table", id=0):
-        gr.Markdown(CHALLENGE_DESCRIPTION_1)
-        gr.DownloadButton(
-            label="📥 Download Template",
-            value="components/submission/submission_template.xlsx",
-            variant="secondary",
-        )
-        gr.Markdown(CHALLENGE_DESCRIPTION_2)
+    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,10 +3,8 @@ from components.submission.utils import (
     get_team_submission_count,
     submit_prediction,
     validate_user_registration,
-    validate_user_team_registration,
 )
-from components.submission.validate_submission import validate
-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,
@@ -14,8 +12,18 @@ from components.submission.config import (
 )
 
 
-def get_submission_page(gr, demo):
-    with gr.TabItem("✉️ Submit", id=2):
+def validate_csv(uploaded_file: str) -> tuple[bool, list[str]]:
+    """
+    Run the submission validator routine on the uploaded CSV.
+    Returns (passed: bool, messages: list[str]).
+    """
+    # TODO: implement your real validation logic
+    print(uploaded_file)
+    return True, []
+
+
+def get_submission_page(gr):
+    with gr.TabItem("✉️ Submit"):
 
         # ── Section header ──────────────────────────────────────────────────
         gr.Markdown(SUBMISSION_PAGE_DESCRIPTION)
@@ -24,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,
@@ -75,8 +75,8 @@ def get_submission_page(gr, demo):
                 is_valid = gr.State(value=False)
 
                 predictions_file = gr.File(
-                    label="Prediction File (.xlsx) *",
-                    file_types=[".xlsx"],
+                    label="Prediction File (.csv) *",
+                    file_types=[".csv"],
                     file_count="single",
                 )
                 submission_count_display = gr.Markdown(
@@ -92,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
@@ -127,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,
@@ -142,9 +140,9 @@ def get_submission_page(gr, demo):
         ):
             # --- guard: required fields ------------------------------------
             success, status = on_validation(
-                file=submission_file,
+                file=predictions_file,
                 submission_team_name=submission_team_name,
-                submission_username=submission_username,
+                submission_email=submission_email,
                 submission_hypothesis=submission_hypothesis,
             )
             if not success:
@@ -155,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,
             )
@@ -182,7 +180,7 @@ def get_submission_page(gr, demo):
             fn=on_submit,
             inputs=[
                 team_name,
-                username,
+                uploader_email,
                 hypothesis_dropdown,
                 predictions_file,
                 note,
@@ -193,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.")
 
@@ -259,20 +245,17 @@ def get_submission_page(gr, demo):
                     visible=True,
                 )
 
-            success, message = validate(path=file)
+            # TODO: add challenge requirements
+            success, message = validate_csv(uploaded_file=file)
             if not success:
-                return False, gr.update(value=message, visible=True)
+                return False, gr.update(value=f"❌ {message}.", visible=True)
 
-            return True, gr.update(value=message, visible=True)
+            return True, gr.update(
+                value=f"✅ The file validation was successful.", visible=True
+            )
 
         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/submission/validate_submission.py

@@ -1,547 +0,0 @@
-#!/usr/bin/env python3
-# -----------------------------------------------------------------------------
-# Papers & Findings submission validator — MecCog / APOE4 challenge
-# Author: Abigail Djossou
-# Date:   2026-07-03
-# -----------------------------------------------------------------------------
-"""
-Validator for MecCog "papers and findings" submission spreadsheets.
-
-Based on the official spreadsheet description. Checks structure and per-column rules, and prints
-a clear report telling the submitter exactly what to fix if the sheet is not valid.
-
-Usage:
-    python validate_submission.py submission.xlsx
-    python validate_submission.py submission.xlsx --strict   # warnings -> errors
-
-The spreadsheet layout (official):
-  Row 1  : column labels (must all be present, correct columns)
-  Row 2  : hypothesis being considered (must be present)
-  Row 3+ : blocks, one per paper/source. Each block is:
-             - a PAPER row  : DOI, source type, PubMed ID, ID = P1, P2, ...
-             - one FINDING row per finding : ID = P1.F1, P1.F2, ...
-
-Official columns:
-  B DOI | C Paper/source type | D PubMed ID | E Paper/Finding ID |
-  F Finding description | G Finding quote | H Finding summary |
-  I Finding relevance (0..1) | J Experimental system | K Data location |
-  L Effect size (int%) | M P value (<1.0) | N Sample size (int>0)
-
-Messages are written for challenge participants: they say which cell is wrong
-and what the expected format is, without referring to internal templates.
-"""
-
-import re
-from openpyxl import load_workbook
-from openpyxl.utils import get_column_letter, column_index_from_string
-
-# ---- official spec ------------------------------------------------------
-
-ALLOWED_SOURCE_TYPES = {
-    "pubmed published",
-    "pubmed preprint",
-    "web article",
-    "database",
-    "other",
-}
-
-# canonical field -> list of header aliases (lowercased, stripped) we accept
-FIELD_ALIASES = {
-    "doi": ["doi"],
-    "source_type": [
-        "paper/source type",
-        "paper type",
-        "source type",
-        "paper/source",
-        "type",
-    ],
-    "pmid": ["pubmed id", "pmid", "pubmed"],
-    "id": ["paper or source id", "paper/finding id", "finding id", "id", "code"],
-    "finding_desc": ["finding description", "findings", "finding"],
-    "quote": ["finding quote", "quote"],
-    "summary": ["finding summary", "summary"],
-    "relevance": ["finding relevance", "relevance"],
-    "exp_system": ["experimental system", "exp system"],
-    "data_location": [
-        "data location",
-        "data source",
-        "data location in the source",
-        "location",
-    ],
-    "effect_size": ["effect size"],
-    "p_value": ["p value", "p-value", "pvalue"],
-    "sample_size": ["sample size", "n"],
-}
-
-# official column letters (fallback if header mapping fails)
-OFFICIAL_COLS = {
-    "doi": "B",
-    "source_type": "C",
-    "pmid": "D",
-    "id": "E",
-    "finding_desc": "F",
-    "quote": "G",
-    "summary": "H",
-    "relevance": "I",
-    "exp_system": "J",
-    "data_location": "K",
-    "effect_size": "L",
-    "p_value": "M",
-    "sample_size": "N",
-}
-
-# fields required on a FINDING row
-FINDING_REQUIRED = ["finding_desc", "relevance", "exp_system", "data_location"]
-
-
-class Report:
-    def __init__(self):
-        self.errors = []
-        self.warnings = []
-
-    def err(self, row, col, msg):
-        self.errors.append((row, col, msg))
-
-    def warn(self, row, col, msg):
-        self.warnings.append((row, col, msg))
-
-    def dump(self, strict=False) -> tuple[bool, str]:
-        message = ""
-        errs = list(self.errors)
-        warns = list(self.warnings)
-        if strict:
-            errs += warns
-            warns = []
-        message += f"{'='*66}\n"
-        if not errs and not warns:
-            message += "✅ SUBMISSION VALID — no problems found.\n"
-            message += "=" * 66
-            message += "\nYour spreadsheet passed all checks. You can submit it.\n"
-            return True, message
-        status = "NOT VALID" if errs else "VALID (with suggestions)"
-        message += "❌ " if errs else "✅ "
-        message += f"SUBMISSION {status}: {len(errs)} thing(s) to fix, {len(warns)} suggestion(s)\n"
-
-        message += "=" * 66
-        if errs:
-            message += "\n\nMUST FIX (the submission will be rejected until these are corrected):"
-
-            for row, col, msg in sorted(errs, key=lambda x: (x[0] or 0, x[1] or "")):
-                loc = f"row {row}" + (f", column {col}" if col else "")
-                message += f"\n  • [{loc}] {msg}"
-        if warns:
-            message += "\n\nPLEASE CHECK (allowed, but worth reviewing):"
-            for row, col, msg in sorted(warns, key=lambda x: (x[0] or 0, x[1] or "")):
-                loc = f"row {row}" + (f", column {col}" if col else "")
-                message += f"\n  • [{loc}] {msg}"
-
-        return len(errs) == 0, message
-
-
-def norm(s):
-    return re.sub(r"\s+", " ", str(s).strip().lower()) if s is not None else ""
-
-
-def map_columns(ws, rpt):
-    """Map canonical field -> column letter, by header name, falling back to
-    official letters. Returns (colmap, header_ok)."""
-    header_row = 1
-    headers = {}
-    headers_raw = {}
-    for c in range(1, ws.max_column + 1):
-        v = ws.cell(row=header_row, column=c).value
-        if v is not None and str(v).strip():
-            letter = get_column_letter(c)
-            headers[letter] = norm(v)
-            headers_raw[letter] = str(v).strip()
-
-    colmap = {}
-    matched_by_header = {}
-    used_headers = False
-    matched_letters = set()
-    for field, aliases in FIELD_ALIASES.items():
-        found = None
-        for letter, htext in headers.items():
-            if htext in aliases:
-                found = letter
-                break
-        if found:
-            colmap[field] = found
-            matched_by_header[field] = True
-            matched_letters.add(found)
-            used_headers = True
-        else:
-            colmap[field] = OFFICIAL_COLS.get(field)
-            matched_by_header[field] = False
-
-    # ---- header conformance check (reported up front) ----
-    header_ok = True
-    OFFICIAL_LABELS = {
-        "doi": "DOI",
-        "source_type": "Paper/source type",
-        "pmid": "PubMed ID",
-        "id": "Paper/Finding ID",
-        "finding_desc": "Finding description",
-        "quote": "Finding quote",
-        "summary": "Finding summary",
-        "relevance": "Finding relevance",
-        "exp_system": "Experimental system",
-        "data_location": "Data location",
-        "effect_size": "Effect size",
-        "p_value": "P value",
-        "sample_size": "Sample size",
-    }
-    if not used_headers:
-        rpt.err(
-            1,
-            None,
-            "The column headers in row 1 were not recognised. "
-            "Please use the official submission template so the "
-            "columns are: " + ", ".join(OFFICIAL_LABELS.values()) + ".",
-        )
-        header_ok = False
-    else:
-        missing = [
-            OFFICIAL_LABELS[f]
-            for f in (
-                "doi",
-                "source_type",
-                "pmid",
-                "id",
-                "finding_desc",
-                "quote",
-                "summary",
-                "relevance",
-                "exp_system",
-                "data_location",
-                "effect_size",
-                "p_value",
-                "sample_size",
-            )
-            if not matched_by_header.get(f)
-        ]
-        if missing:
-            header_ok = False
-            rpt.err(
-                1,
-                None,
-                "These required columns are missing from row 1: "
-                + ", ".join(missing)
-                + ". Please add them (use the official "
-                "submission template) so every column is present with its "
-                "exact heading.",
-            )
-
-        # extra columns that aren't part of the official layout -> warn, ignored
-        extra = []
-        for letter, htext in headers.items():
-            if letter == "A":
-                continue  # column A carries the hypothesis (row 2), no data header
-            if letter not in matched_letters and htext:
-                extra.append((letter, htext))
-        for letter, htext in sorted(extra):
-            shown = headers_raw.get(letter, htext)
-            rpt.warn(
-                1,
-                letter,
-                f"Column '{shown}' is not an official column "
-                f"and will be ignored. If this was meant to be "
-                f"one of the required columns, please rename it "
-                f"to the exact official heading.",
-            )
-    return colmap, header_ok
-
-
-def cell(ws, row, letter):
-    if not letter:
-        return None
-    return ws.cell(row=row, column=column_index_from_string(letter)).value
-
-
-def is_paper_id(v):
-    return bool(re.fullmatch(r"P\d+", str(v).strip())) if v is not None else False
-
-
-def is_finding_id(v):
-    return bool(re.fullmatch(r"P\d+\.F\d+", str(v).strip())) if v is not None else False
-
-
-def validate(path, strict=False):
-    rpt = Report()
-    wb = load_workbook(path, data_only=True)
-    ws = wb.active
-    cm, header_ok = map_columns(ws, rpt)
-
-    # ---- row 2: hypothesis present ----
-    hyp = None
-    for letter in ("A", cm.get("doi")):
-        pass
-    # hypothesis is expected in row 2, column A (or first non-empty cell)
-    hyp_val = ws.cell(row=2, column=1).value
-    if not hyp_val or not str(hyp_val).strip():
-        # try any cell in row 2
-        row2 = [ws.cell(row=2, column=c).value for c in range(1, ws.max_column + 1)]
-        if not any(v and str(v).strip() for v in row2):
-            rpt.err(2, "A", "Hypothesis being considered is missing (row 2).")
-
-    # ---- iterate blocks from row 3 ----
-    expected_paper_n = 1
-    current_paper = None  # e.g. "P1"
-    finding_counters = {}  # paper -> next finding index expected
-    seen_dois = {}
-
-    r = 3
-    max_r = ws.max_row
-    while r <= max_r:
-        idv = cell(ws, r, cm["id"])
-        doi = cell(ws, r, cm["doi"])
-        # skip fully empty rows
-        rowvals = [ws.cell(row=r, column=c).value for c in range(1, ws.max_column + 1)]
-        if not any(v is not None and str(v).strip() for v in rowvals):
-            r += 1
-            continue
-
-        if is_paper_id(idv):
-            # ---- PAPER row ----
-            pid = str(idv).strip()
-            num = int(pid[1:])
-            if num != expected_paper_n:
-                rpt.err(
-                    r,
-                    cm["id"],
-                    f"Paper ID '{pid}' out of sequence; "
-                    f"expected 'P{expected_paper_n}'.",
-                )
-            expected_paper_n = num + 1
-            current_paper = pid
-            finding_counters[pid] = 1
-
-            # DOI required
-            if not doi or not str(doi).strip():
-                rpt.err(r, cm["doi"], f"{pid}: DOI is missing.")
-            else:
-                d = str(doi).strip().lower()
-                if not re.match(r"10\.\d{4,9}/\S+", d):
-                    rpt.warn(
-                        r,
-                        cm["doi"],
-                        f"{pid}: DOI '{doi}' does not look "
-                        f"like a standard DOI (10.xxxx/...).",
-                    )
-                if d in seen_dois:
-                    rpt.err(
-                        r,
-                        cm["doi"],
-                        f"{pid}: this DOI is already used by "
-                        f"{seen_dois[d]}. Each source must have "
-                        f"a unique DOI.",
-                    )
-                else:
-                    seen_dois[d] = pid
-
-            # source type
-            st = cell(ws, r, cm["source_type"])
-            if not st or not str(st).strip():
-                rpt.err(r, cm["source_type"], f"{pid}: Paper/source type missing.")
-            elif norm(st) not in ALLOWED_SOURCE_TYPES:
-                rpt.err(
-                    r,
-                    cm["source_type"],
-                    f"{pid}: source type '{st}' is not allowed. Use one of: "
-                    f"PubMed published, PubMed preprint, Web article, "
-                    f"Database, Other.",
-                )
-
-            # PMID (required for PubMed sources; recommended generally)
-            pmid = cell(ws, r, cm["pmid"])
-            st_norm = norm(st)
-            if st_norm.startswith("pubmed"):
-                if not pmid or not str(pmid).strip():
-                    rpt.err(
-                        r,
-                        cm["pmid"],
-                        f"{pid}: PubMed ID required for " f"PubMed sources.",
-                    )
-                elif not re.fullmatch(r"\d+", str(pmid).strip()):
-                    rpt.err(
-                        r,
-                        cm["pmid"],
-                        f"{pid}: PubMed ID '{pmid}' must be " f"digits only.",
-                    )
-
-        elif is_finding_id(idv):
-            # ---- FINDING row ----
-            fid = str(idv).strip()
-            fpaper, findex = fid.split(".")
-            if current_paper is None:
-                rpt.err(r, cm["id"], f"Finding '{fid}' appears before any paper row.")
-            elif fpaper != current_paper:
-                rpt.err(
-                    r,
-                    cm["id"],
-                    f"Finding '{fid}' does not belong to current "
-                    f"paper '{current_paper}'.",
-                )
-            else:
-                exp = finding_counters.get(current_paper, 1)
-                if int(findex[1:]) != exp:
-                    rpt.err(
-                        r,
-                        cm["id"],
-                        f"Finding '{fid}' out of sequence; "
-                        f"expected '{current_paper}.F{exp}'.",
-                    )
-                finding_counters[current_paper] = int(findex[1:]) + 1
-
-            # required finding fields (must be non-empty)
-            READABLE = {
-                "finding_desc": "Finding description",
-                "relevance": "Finding relevance",
-                "exp_system": "Experimental system",
-                "data_location": "Data location",
-            }
-            for fld in FINDING_REQUIRED:
-                v = cell(ws, r, cm[fld])
-                if v is None or not str(v).strip():
-                    rpt.err(
-                        r,
-                        cm[fld],
-                        f"{fid}: '{READABLE[fld]}' is required "
-                        f"but empty. Please fill it in.",
-                    )
-
-            # quote and summary must contain a value OR the text 'N/A' (never blank)
-            for fld, label in (
-                ("quote", "Finding quote"),
-                ("summary", "Finding summary"),
-            ):
-                v = cell(ws, r, cm[fld])
-                if v is None or not str(v).strip():
-                    rpt.err(
-                        r,
-                        cm[fld],
-                        f"{fid}: '{label}' must not be empty. "
-                        f"Enter the {label.lower()}, or 'N/A' if there is none.",
-                    )
-
-            # relevance 0..1
-            rel = cell(ws, r, cm["relevance"])
-            if rel is not None and str(rel).strip():
-                try:
-                    rv = float(rel)
-                    if not (0.0 <= rv <= 1.0):
-                        rpt.err(
-                            r,
-                            cm["relevance"],
-                            f"{fid}: relevance must be a "
-                            f"number between 0 and 1 (found {rv}).",
-                        )
-                except ValueError:
-                    rpt.err(
-                        r,
-                        cm["relevance"],
-                        f"{fid}: relevance must be a "
-                        f"number between 0 and 1 (found '{rel}').",
-                    )
-
-            # data location precision (warn if whole-figure only)
-            loc = cell(ws, r, cm["data_location"])
-            if loc and str(loc).strip():
-                locs = str(loc).strip()
-                if re.fullmatch(r"(fig(ure)?\s*\d+)", locs, flags=re.I):
-                    rpt.warn(
-                        r,
-                        cm["data_location"],
-                        f"{fid}: location '{locs}' may be imprecise "
-                        f"(panel not specified, e.g. Fig4C).",
-                    )
-
-            # effect size: whole number followed by %, or N/A (must not be blank)
-            es = cell(ws, r, cm.get("effect_size"))
-            if es is None or not str(es).strip():
-                rpt.err(
-                    r,
-                    cm.get("effect_size"),
-                    f"{fid}: 'Effect size' must "
-                    f"not be empty. Enter a whole number + '%' (e.g. 300%), "
-                    f"or 'N/A' if not available/applicable.",
-                )
-            elif norm(es) != "n/a" and not re.fullmatch(r"\d+%", str(es).strip()):
-                rpt.err(
-                    r,
-                    cm.get("effect_size"),
-                    f"{fid}: effect size '{es}' must be a whole number "
-                    f"followed by '%' (e.g. 300%), or 'N/A'.",
-                )
-
-            # p value: number < 1.0, or N/A (must not be blank)
-            pv = cell(ws, r, cm.get("p_value"))
-            if pv is None or not str(pv).strip():
-                rpt.err(
-                    r,
-                    cm.get("p_value"),
-                    f"{fid}: 'P value' must not be "
-                    f"empty. Enter a number less than 1.0, or 'N/A' if not "
-                    f"available/applicable.",
-                )
-            elif norm(pv) != "n/a":
-                m = re.search(r"[-+]?\d*\.?\d+(e[-+]?\d+)?", str(pv), flags=re.I)
-                if not m:
-                    rpt.err(
-                        r,
-                        cm.get("p_value"),
-                        f"{fid}: p value '{pv}' must be a number less than "
-                        f"1.0, or 'N/A'.",
-                    )
-                else:
-                    try:
-                        if float(m.group()) >= 1.0:
-                            rpt.err(
-                                r,
-                                cm.get("p_value"),
-                                f"{fid}: p value '{pv}' must be less than 1.0.",
-                            )
-                    except ValueError:
-                        rpt.err(
-                            r,
-                            cm.get("p_value"),
-                            f"{fid}: p value '{pv}' must be a number less "
-                            f"than 1.0, or 'N/A'.",
-                        )
-
-            # sample size: whole number > 0, or N/A (must not be blank)
-            ss = cell(ws, r, cm.get("sample_size"))
-            if ss is None or not str(ss).strip():
-                rpt.err(
-                    r,
-                    cm.get("sample_size"),
-                    f"{fid}: 'Sample size' must "
-                    f"not be empty. Enter a whole number greater than 0, or "
-                    f"'N/A' if not applicable.",
-                )
-            elif norm(ss) != "n/a":
-                if not re.fullmatch(r"\d+", str(ss).strip()) or int(ss) <= 0:
-                    rpt.err(
-                        r,
-                        cm.get("sample_size"),
-                        f"{fid}: sample size '{ss}' must be a whole number "
-                        f"greater than 0, or 'N/A'.",
-                    )
-
-        else:
-            # a non-empty row whose ID cell isn't a valid P#/P#.F# code
-            if idv is not None and str(idv).strip():
-                rpt.err(
-                    r,
-                    cm["id"],
-                    f"ID '{idv}' is neither a paper ID (P1) "
-                    f"nor a finding ID (P1.F1).",
-                )
-            else:
-                rpt.warn(r, cm["id"], "Non-empty row with no ID in the ID column.")
-        r += 1
-
-    if expected_paper_n == 1:
-        rpt.err(None, None, "No paper/source blocks found (expected P1, P2, ...).")
-
-    return rpt.dump(strict=strict)

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,10 +1,7 @@
-gradio==5.50.0
+gradio
 datasets
 huggingface_hub
-httpx
 gradio-leaderboard
 plotly
 dotenv
-pandas
-gradio[oauth]
-openpyxl
+pandas