pydantic validation of x1, x2, ... syntax

app.py

@@ -3,6 +3,13 @@ import gradio as gr
 import pandas as pd
 from sklearn.preprocessing import MinMaxScaler
 from surrogate import CrabNetSurrogateModel, PARAM_BOUNDS
+from pydantic import (
+    BaseModel,
+    ValidationError,
+    ValidationInfo,
+    field_validator,
+    model_validator,
+)
 
 model = CrabNetSurrogateModel()
 
@@ -34,15 +41,82 @@ example_parameterization = {
     "train_frac": 0.5,
 }
 
-# Define the output parameters
 example_results = model.surrogate_evaluate([example_parameterization])
 example_result = example_results[0]
 
+scalers = {
+    param_info["name"]: MinMaxScaler()
+    for param_info in PARAM_BOUNDS
+    if param_info["type"] == "range"
+}
+
+
+class BlindedParameterization(BaseModel):
+    x1: float  # int
+    x2: float
+    x3: float  # int
+    x4: float  # int
+    x5: float
+    x6: float
+    x7: float  # int
+    x8: float
+    x9: float
+    x10: float  # int
+    x11: float  # int
+    x12: float
+    x13: float  # int
+    x14: float  # int
+    x15: float
+    x16: float  # int
+    x17: float  # int
+    x18: float  # int
+    x19: float
+    x20: float
+    c1: bool
+    c2: str
+    c3: str
+    f1: float
+
+    @field_validator("*")
+    def check_bounds(cls, v: int, info: ValidationInfo) -> int:
+        param = next(
+            (item for item in PARAM_BOUNDS if item["name"] == info.field_name),
+            None,
+        )
+        if param is None:
+            return v
+
+        if param["type"] == "range":
+            min_val, max_val = param["bounds"]
+            if not min_val <= v <= max_val:
+                raise ValueError(
+                    f"{info.field_name} must be between {min_val} and {max_val}"
+                )
+        elif param["type"] == "choice":
+            if v not in param["values"]:
+                raise ValueError(f"{info.field_name} must be one of {param['values']}")
+
+        return v
+
+    @model_validator(mode="after")
+    def check_constraints(self) -> "BlindedParameterization":
+        if self.x19 > self.x20:
+            raise ValueError(
+                f"Received x19={self.x19} which should be less than x20={self.x20}"
+            )
+        if self.x6 + self.x15 > 1.0:
+            raise ValueError(
+                f"Received x6={self.x6} and x15={self.x15} which should sum to less than or equal to 1.0"  # noqa: E501
+            )
+
 
 def evaluate(*args):
     # Create a DataFrame with the parameter names and scaled values
     params_df = pd.DataFrame([args], columns=[param["name"] for param in PARAM_BOUNDS])
 
+    # error checking
+    BlindedParameterization(**params_df.to_dict("records")[0])
+
     # Reverse the scaling for each parameter and reverse the renaming for choice parameters
     for param_info in PARAM_BOUNDS:
         key = param_info["name"]
@@ -65,13 +139,6 @@ def evaluate(*args):
     return results_list
 
 
-scalers = {
-    param_info["name"]: MinMaxScaler()
-    for param_info in PARAM_BOUNDS
-    if param_info["type"] == "range"
-}
-
-
 def get_interface(param_info, numeric_index, choice_index):
     key = param_info["name"]
     default_value = example_parameterization[key]