validate cv

constants.py

@@ -36,7 +36,17 @@ REQUIRED_COLUMNS: list[str] = [
     "vh_protein_sequence",
     "vl_protein_sequence",
 ]
-ANTIBODY_NAMES = pd.read_csv("data/example-predictions.csv")["antibody_name"].tolist()
+# Cross validation
+CV_COLUMN = "hierarchical_cluster_IgG_isotype_stratified_fold"
+# Example files
+EXAMPLE_FILE_DICT = {
+    "GDPa1": "data/example-predictions.csv",
+    "GDPa1_CV": "data/example-predictions-cv.csv",
+}
+ANTIBODY_NAMES_DICT = {
+    "GDPa1": pd.read_csv(EXAMPLE_FILE_DICT["GDPa1"])["antibody_name"].tolist(),
+    "GDPa1_CV": pd.read_csv(EXAMPLE_FILE_DICT["GDPa1_CV"])["antibody_name"].tolist(),
+}
 
 # Huggingface API
 TOKEN = os.environ.get("HF_TOKEN")

submit.py

@@ -11,7 +11,12 @@ from constants import API, SUBMISSIONS_REPO
 from validation import validate_csv_file
 
 
-def make_submission(submitted_file: BinaryIO, user_state, anonymous_state):
+def make_submission(
+    submitted_file: BinaryIO,
+    user_state,
+    anonymous_state,
+    submission_type: str = "GDPa1",
+):
     if user_state is None:
         raise gr.Error("You must submit your username to submit a file.")
 
@@ -34,7 +39,7 @@ def make_submission(submitted_file: BinaryIO, user_state, anonymous_state):
     with path_obj.open("rb") as f_in:
         file_content = f_in.read().decode("utf-8")
 
-        validate_csv_file(file_content)
+        validate_csv_file(file_content, submission_type)
 
         # write to dataset
         filename = f"{submission_id}.json"

validation.py

@@ -4,8 +4,10 @@ import gradio as gr
 from constants import (
     REQUIRED_COLUMNS,
     MINIMAL_NUMBER_OF_ROWS,
-    ANTIBODY_NAMES,
     ASSAY_LIST,
+    CV_COLUMN,
+    EXAMPLE_FILE_DICT,
+    ANTIBODY_NAMES_DICT,
 )
 
 
@@ -46,7 +48,90 @@ def validate_csv_can_be_read(file_content: str) -> pd.DataFrame:
         raise gr.Error(f"❌ Unexpected error reading CSV file: {str(e)}")
 
 
-def validate_dataframe(df: pd.DataFrame) -> None:
+def validate_cv_submission(df: pd.DataFrame, submission_type: str = "GDPa1_CV") -> None:
+    """Validate cross-validation submission"""
+    # Must have CV_COLUMN for CV submissions
+    if CV_COLUMN not in df.columns:
+        raise gr.Error(f"❌ CV submissions must include a '{CV_COLUMN}' column")
+
+    # Load canonical fold assignments
+    expected_cv_df = pd.read_csv(EXAMPLE_FILE_DICT[submission_type])[
+        ["antibody_name", CV_COLUMN]
+    ]
+    antibody_check = expected_cv_df.merge(
+        df[["antibody_name", CV_COLUMN]],
+        on="antibody_name",
+        how="left",
+        suffixes=("_expected", "_submitted"),
+    )
+    # All antibodies should be present if using CV
+    missing_antibodies_mask = antibody_check[f"{CV_COLUMN}_submitted"].isna()
+    n_missing_antibodies = missing_antibodies_mask.sum()
+    if n_missing_antibodies > 0:
+        missing_antibodies = (
+            antibody_check[missing_antibodies_mask]["antibody_name"].head(5).tolist()
+        )
+        raise gr.Error(
+            f"❌ Missing predictions for {n_missing_antibodies} antibodies. Examples: {', '.join(missing_antibodies)}"
+        )
+    # CV fold assignments should match
+    fold_mismatches = antibody_check[
+        antibody_check[f"{CV_COLUMN}_expected"]
+        != antibody_check[f"{CV_COLUMN}_submitted"]
+    ]
+    if len(fold_mismatches) > 0:
+        examples = []
+        for _, row in fold_mismatches.head(3).iterrows():
+            examples.append(
+                f"{row['antibody_name']} (expected fold {row[f'{CV_COLUMN}_expected']}, got {row[f'{CV_COLUMN}_submitted']})"
+            )
+        raise gr.Error(
+            f"❌ Fold assignments don't match canonical CV folds: {'; '.join(examples)}"
+        )
+
+    # Merge on both columns for assay validation
+    merged_cv_df = expected_cv_df.merge(df, on=["antibody_name", CV_COLUMN], how="left")
+
+    # Check for missing assay predictions
+    assay_columns = get_assay_columns(merged_cv_df)
+    for assay_column in assay_columns:
+        missing_antibodies = merged_cv_df[merged_cv_df[assay_column].isna()][
+            "antibody_name"
+        ].unique()
+        if len(missing_antibodies) > 0:
+            raise gr.Error(
+                f"❌ Missing {assay_column} predictions for {len(missing_antibodies)} antibodies: {', '.join(missing_antibodies[:5])}"
+            )
+
+    # Step 5: Check that submission length matches expected
+    if len(merged_cv_df) != len(expected_cv_df):
+        raise gr.Error(
+            f"❌ Expected {len(expected_cv_df)} rows, got {len(merged_cv_df)}"
+        )
+
+
+def validate_full_dataset_submission(df: pd.DataFrame) -> None:
+    """Validate full dataset submission"""
+    if CV_COLUMN in df.columns:
+        raise gr.Error(
+            f"❌ Your submission contains a '{CV_COLUMN}' column. "
+            "Please select 'Cross-Validation Predictions' if you want to submit CV results."
+        )
+
+    # All names should be unique (duplicates check from original validation)
+    n_duplicates = df["antibody_name"].duplicated().sum()
+    if n_duplicates > 0:
+        raise gr.Error(
+            f"❌ Standard submissions should have only one prediction per antibody. Found {n_duplicates} duplicates."
+        )
+
+
+def get_assay_columns(df: pd.DataFrame) -> list[str]:
+    """Get all assay columns from the DataFrame"""
+    return [col for col in df.columns if col in ASSAY_LIST]
+
+
+def validate_dataframe(df: pd.DataFrame, submission_type: str = "GDPa1") -> None:
     """
     Validate the DataFrame content and structure.
 
@@ -54,18 +139,23 @@ def validate_dataframe(df: pd.DataFrame) -> None:
     ----------
     df: pd.DataFrame
         The DataFrame to validate.
+    submission_type: str
+        Type of submission: "GDPa1" or "GDPa1_CV"
 
     Raises
     ------
     gr.Error: If validation fails
     """
+    if submission_type not in EXAMPLE_FILE_DICT.keys():
+        raise ValueError(f"Invalid submission type: {submission_type}")
+
     # Required columns should be present
     missing_columns = set(REQUIRED_COLUMNS) - set(df.columns)
     if missing_columns:
         raise gr.Error(f"❌ Missing required columns: {', '.join(missing_columns)}")
 
     # Should include at least 1 assay column
-    assay_columns = [col for col in df.columns if col in ASSAY_LIST]
+    assay_columns = get_assay_columns(df)
     if len(assay_columns) < 1:
         raise gr.Error(
             "❌ CSV should include at least one of the following assay columns: "
@@ -96,14 +186,21 @@ def validate_dataframe(df: pd.DataFrame) -> None:
         )
 
     # All antibody names should be recognizable
-    unrecognized_antibodies = set(df["antibody_name"]) - set(ANTIBODY_NAMES)
+    unrecognized_antibodies = set(df["antibody_name"]) - set(
+        ANTIBODY_NAMES_DICT[submission_type]
+    )
     if unrecognized_antibodies:
         raise gr.Error(
             f"❌ Found unrecognized antibody names: {', '.join(unrecognized_antibodies)}"
         )
+    # Submission-type specific validation
+    if submission_type.endswith("_CV"):
+        validate_cv_submission(df, submission_type)
+    else:  # full_dataset
+        validate_full_dataset_submission(df)
 
 
-def validate_csv_file(file_content: str) -> None:
+def validate_csv_file(file_content: str, submission_type: str = "GDPa1") -> None:
     """
     Validate the uploaded CSV file.
 
@@ -111,10 +208,12 @@ def validate_csv_file(file_content: str) -> None:
     ----------
     file_content: str
         The content of the uploaded CSV file.
+    submission_type: str
+        Type of submission: "standard" or "cv"
 
     Raises
     ------
     gr.Error: If validation fails
     """
     df = validate_csv_can_be_read(file_content)
-    validate_dataframe(df)
+    validate_dataframe(df, submission_type)