switch formula->problem_id

src/datamodel/data.py

@@ -19,7 +19,7 @@ class F1Data:
         self._initialize()
 
     def _initialize(self):
-        logger.info("Initialize F1Data TOMEN='%s'", TOKEN)
+        logger.info("Initialize F1Data TOKEN='%s'", TOKEN)
         start_time = time.monotonic()
         cp_ds = load_dataset(self.cp_dataset_name, split=self.split, token=TOKEN)
         logger.info(
@@ -27,11 +27,11 @@ class F1Data:
             self.cp_dataset_name,
             time.monotonic() - start_time,
         )
-        self.code_problems: dict[str, str] = {r["id"]: r["code_problem"]["problem_description"] for r in cp_ds}
-        logger.info("Code problems info: %s", self.code_problems)
+        self.code_problems: dict[str, str] = {r["id"]: r["code_problem"] for r in cp_ds}
+        logger.info(f"Loaded %d code problems {len(self.code_problems)}")
 
     @functools.cached_property
-    def code_problem_formulas(self) -> set[str]:
+    def code_problem_ids(self) -> set[str]:
         return set(self.code_problems.keys())
 
 
@@ -39,4 +39,4 @@ if __name__ == "__main__":
     split = "hard"
     f1_data = F1Data(cp_ds_name=CODE_PROBLEMS_REPO, sub_ds_name=SUBMISSIONS_REPO, res_ds_name=RESULTS_REPO, split=split)
 
-    print(f"Found {len(f1_data.code_problem_formulas)} code problems in {split} split of {f1_data.cp_dataset_name}")
+    print(f"Found {len(f1_data.code_problem_ids)} code problems in {split} split of {f1_data.cp_dataset_name}")

src/submission/submit.py

@@ -11,6 +11,7 @@ from src.display.formatting import styled_error, styled_message, styled_warning
 from src.display.utils import ModelType
 from src.envs import API, SUBMISSIONS_REPO, TOKEN
 from src.logger import get_logger
+
 # from src.submission.check_validity import (
 #     already_submitted_models,
 #     check_model_card,
@@ -20,27 +21,29 @@ from src.logger import get_logger
 
 logger = get_logger(__name__)
 
+
 def validate_submission(lbdb: F1Data, pd_ds: pd.DataFrame) -> str | None:
     logger.info("Validating DS size %d columns %s set %s", len(pd_ds), pd_ds.columns, set(pd_ds.columns))
-    expected_cols = ["formula_name", "solution"]
+    expected_cols = ["problem_id", "solution"]
     if set(pd_ds.columns) != set(expected_cols):
         return f"Expected attributes: {expected_cols}, Got: {pd_ds.columns.tolist()}"
-    if any(type(v) != str for v in pd_ds["formula_name"]):
-        return "Not all formula_name values are of type str"
+    if any(type(v) != str for v in pd_ds["problem_id"]):
+        return "problem_id must be of type str"
     if any(type(v) != str for v in pd_ds["solution"]):
-        return "Not all solution values are of type str"
-    submitted_formulas = set(pd_ds["formula_name"])
-    if submitted_formulas != lbdb.code_problem_formulas:
-        missing = lbdb.code_problem_formulas - submitted_formulas
-        unknown = submitted_formulas - lbdb.code_problem_formulas
-        return f"Mismatched formula names: {len(missing)} missing, {len(unknown)} unknown"
-    if len(pd_ds) > len(lbdb.code_problem_formulas):
-        return "Duplicate formula solutions exist in uploaded file"
+        return "solution must be of type str"
+    submitted_ids = set(pd_ds["problem_id"])
+    if submitted_ids != lbdb.code_problem_ids:
+        missing = lbdb.code_problem_ids - submitted_ids
+        unknown = submitted_ids - lbdb.code_problem_ids
+        return f"Mismatched problem IDs: {len(missing)} missing, {len(unknown)} unknown"
+    if len(pd_ds) > len(lbdb.code_problem_ids):
+        return "Duplicate problem IDs exist in uploaded file"
     return None
 
+
 def add_new_solutions(
     lbdb: F1Data,
-    system_name : str,
+    system_name: str,
     org: str,
     sys_type: str,
     submission_path: str,
@@ -68,7 +71,6 @@ def add_new_solutions(
     if validation_error:
         return styled_error(validation_error)
 
-
     submission_id = f"{system_name}_{org}_{sys_type}_{datetime.now(timezone.utc).strftime('%Y%m%d_%H%M%S')}"
 
     # Seems good, creating the eval