Fix: accept numpy scalars and 0/1 for solver params

Author: LucasBoTang

python/cupdlpx/model.py

@@ -488,21 +488,36 @@ def _resolve_param_key(self, name: str) -> str:
 
     def _validate_param_value(self, key: str, value: Any) -> Any:
         if key in _BOOL_PARAMS:
-            if not isinstance(value, bool):
-                raise TypeError(f"Parameter '{key}' must be bool.")
-            return value
+            # accept a real bool, numpy bool, or an integer 0/1; store a Python bool
+            if isinstance(value, (bool, np.bool_)):
+                return bool(value)
+            if isinstance(value, (int, np.integer)):
+                if int(value) not in (0, 1):
+                    raise ValueError(f"Parameter '{key}' must be 0 or 1 when given as an int.")
+                return bool(value)
+            raise TypeError(f"Parameter '{key}' must be a bool (or 0/1).")
 
         if key in _INT_PARAMS:
-            if isinstance(value, bool) or not isinstance(value, int):
-                raise TypeError(f"Parameter '{key}' must be int.")
+            # accept any Python/numpy integer or an integer-valued float; store a Python int
+            if isinstance(value, (bool, np.bool_)):
+                raise TypeError(f"Parameter '{key}' must be an int.")
+            if isinstance(value, (int, np.integer)):
+                value = int(value)
+            elif isinstance(value, (float, np.floating)) and float(value).is_integer():
+                value = int(value)
+            else:
+                raise TypeError(f"Parameter '{key}' must be an int.")
             if key in _POSITIVE_INT_PARAMS and value <= 0:
                 raise ValueError(f"Parameter '{key}' must be positive.")
             if key not in _POSITIVE_INT_PARAMS and value < 0:
                 raise ValueError(f"Parameter '{key}' must be nonnegative.")
             return value
 
         if key in _FLOAT_PARAMS:
-            if isinstance(value, bool):
+            # accept any real number (Python/numpy int or float); store a Python float
+            if isinstance(value, (bool, np.bool_)):
+                raise TypeError(f"Parameter '{key}' must be a number.")
+            if not isinstance(value, (int, float, np.integer, np.floating)):
                 raise TypeError(f"Parameter '{key}' must be a number.")
             value = float(value)
             if not np.isfinite(value):

test/test_api_surface.py

@@ -206,15 +206,37 @@ def test_set_params_is_transactional(base_lp_data):
 
 def test_param_value_validation(base_lp_data):
     model = _model(base_lp_data)
+    # float params accept ints and numpy numbers
     model.setParam("TimeLimit", 12)
     assert model.getParam("TimeLimit") == 12.0
+    model.setParam("TimeLimit", np.float64(30.0))
+    assert model.getParam("TimeLimit") == 30.0
     model.setParam("OptimalityNorm", "LINF")
     assert model.getParam("OptimalityNorm") == "linf"
 
+    # bool params accept real/numpy bools and 0/1 (coerced to a Python bool)
+    model.setParam("OutputFlag", 1)
+    assert model.getParam("OutputFlag") is True
+    model.setParam("OutputFlag", 0)
+    assert model.getParam("OutputFlag") is False
+    model.setParam("OutputFlag", np.bool_(True))
+    assert model.getParam("OutputFlag") is True
+
+    # int params accept numpy ints and integer-valued floats (coerced to a Python int)
+    model.setParam("IterationLimit", np.int64(1000))
+    assert model.getParam("IterationLimit") == 1000 and isinstance(model.getParam("IterationLimit"), int)
+    model.setParam("IterationLimit", 2000.0)
+    assert model.getParam("IterationLimit") == 2000
+
+    # still-invalid inputs
     with pytest.raises(TypeError):
-        model.setParam("OutputFlag", 1)
+        model.setParam("IterationLimit", False)   # bool is not an int here
     with pytest.raises(TypeError):
-        model.setParam("IterationLimit", False)
+        model.setParam("IterationLimit", 1.5)     # non-integer float
+    with pytest.raises(TypeError):
+        model.setParam("OutputFlag", "yes")       # string is not a bool
+    with pytest.raises(ValueError):
+        model.setParam("OutputFlag", 2)           # only 0/1 allowed as int
     with pytest.raises(ValueError):
         model.setParam("IterationLimit", -1)
     with pytest.raises(ValueError):
@@ -261,7 +283,7 @@ def test_set_params_value_validation_is_transactional(base_lp_data):
     model = _model(base_lp_data)
     old_time_limit = model.getParam("TimeLimit")
     with pytest.raises(TypeError):
-        model.setParams(TimeLimit=123.0, OutputFlag=1)
+        model.setParams(TimeLimit=123.0, OutputFlag="yes")  # OutputFlag invalid
     assert model.getParam("TimeLimit") == old_time_limit