fix: normalize legacy CALYPSO scalars

Coding-Agent: Codex
Codex-Version: codex-cli 0.151.0
Model: gpt-5.6-sol
Reasoning-Effort: xhigh

Author: njzjz-bot

dpgen/generator/arginfo.py

@@ -621,6 +621,11 @@ def model_devi_amber_args() -> list[Argument]:
     ]
 
 
+def _is_scalar_or_singleton(value) -> bool:
+    """Accept legacy one-item lists while rejecting ambiguous CALYPSO values."""
+    return not isinstance(value, list) or len(value) == 1
+
+
 def model_devi_calypso_args() -> list[Argument]:
     """CALYPSO engine arguments."""
     doc_model_devi_jobs = (
@@ -707,7 +712,14 @@ def model_devi_calypso_args() -> list[Argument]:
                     default=[1, 1],
                     doc=doc_numberofformula,
                 ),
-                Argument("Volume", float, optional=True, doc=doc_volume),
+                Argument(
+                    "Volume",
+                    [float, int, list[float], list[int]],
+                    optional=True,
+                    extra_check=_is_scalar_or_singleton,
+                    extra_check_errmsg="Volume must be a scalar or a one-item list.",
+                    doc=doc_volume,
+                ),
                 Argument(
                     "DistanceOfIon",
                     list[list[float]],
@@ -716,17 +728,50 @@ def model_devi_calypso_args() -> list[Argument]:
                 ),
                 Argument(
                     "PsoRatio",
-                    float,
+                    [float, int, list[float], list[int]],
                     optional=True,
                     default=0.6,
+                    extra_check=_is_scalar_or_singleton,
+                    extra_check_errmsg="PsoRatio must be a scalar or a one-item list.",
                     doc=doc_psoratio,
                 ),
-                Argument("PopSize", int, optional=True, default=30, doc=doc_popsize),
-                Argument("MaxStep", int, optional=True, default=5, doc=doc_maxstep),
-                Argument("ICode", int, optional=True, default=1, doc=doc_icode),
+                Argument(
+                    "PopSize",
+                    [int, list[int]],
+                    optional=True,
+                    default=30,
+                    extra_check=_is_scalar_or_singleton,
+                    extra_check_errmsg="PopSize must be an integer or a one-item list.",
+                    doc=doc_popsize,
+                ),
+                Argument(
+                    "MaxStep",
+                    [int, list[int]],
+                    optional=True,
+                    default=5,
+                    extra_check=_is_scalar_or_singleton,
+                    extra_check_errmsg="MaxStep must be an integer or a one-item list.",
+                    doc=doc_maxstep,
+                ),
+                Argument(
+                    "ICode",
+                    [int, list[int]],
+                    optional=True,
+                    default=1,
+                    extra_check=_is_scalar_or_singleton,
+                    extra_check_errmsg="ICode must be an integer or a one-item list.",
+                    doc=doc_icode,
+                ),
                 Argument("Split", str, optional=True, default="T", doc=doc_split),
                 Argument("VSC", str, optional=True, default="F", doc=doc_vsc),
-                Argument("MaxNumAtom", int, optional=True, doc=doc_maxnumatom),
+                Argument(
+                    "MaxNumAtom",
+                    [int, list[int]],
+                    optional=True,
+                    extra_check=_is_scalar_or_singleton,
+                    extra_check_errmsg="MaxNumAtom must be an integer or a one-item list.",
+                    doc=doc_maxnumatom,
+                ),
                 Argument(
                     "CtrlRange", list[list[int]], optional=True, doc=doc_ctrlrange
                 ),
@@ -737,7 +782,15 @@ def model_devi_calypso_args() -> list[Argument]:
                     default=[0.001],
                     doc=doc_pstress,
                 ),
-                Argument("fmax", float, optional=True, default=0.01, doc=doc_fmax),
+                Argument(
+                    "fmax",
+                    [float, int, list[float], list[int]],
+                    optional=True,
+                    default=0.01,
+                    extra_check=_is_scalar_or_singleton,
+                    extra_check_errmsg="fmax must be a scalar or a one-item list.",
+                    doc=doc_fmax,
+                ),
             ],
         ),
         Argument("calypso_input_path", str, optional=True, doc=doc_calypso_input_path),

dpgen/generator/lib/make_calypso.py

@@ -162,6 +162,15 @@ def _make_model_devi_buffet(jdata, calypso_run_opt_path):
             raise FileNotFoundError("input.dat")
 
 
+def _unwrap_calypso_scalar(value, name):
+    """Normalize a legacy one-item CALYPSO list to its scalar value."""
+    if not isinstance(value, list):
+        return value
+    if len(value) != 1:
+        raise ValueError(f"{name} must be a scalar or a one-item list")
+    return value[0]
+
+
 def _make_model_devi_native_calypso(iter_index, model_devi_jobs, calypso_run_opt_path):
     for iiidx, jobbs in enumerate(model_devi_jobs):
         if iter_index in jobbs.get("times"):
@@ -176,12 +185,12 @@ def _make_model_devi_native_calypso(iter_index, model_devi_jobs, calypso_run_opt
     nameofatoms = cur_job.get("NameOfAtoms")
     numberofatoms = cur_job.get("NumberOfAtoms")
     numberofformula = cur_job.get("NumberOfFormula", [1, 1])
-    volume = cur_job.get("Volume")
+    volume = _unwrap_calypso_scalar(cur_job.get("Volume"), "Volume")
     distanceofion = cur_job.get("DistanceOfIon")
-    psoratio = cur_job.get("PsoRatio", 0.6)
-    popsize = cur_job.get("PopSize", 30)
-    maxstep = cur_job.get("MaxStep", 5)
-    icode = cur_job.get("ICode", 1)
+    psoratio = _unwrap_calypso_scalar(cur_job.get("PsoRatio", 0.6), "PsoRatio")
+    popsize = _unwrap_calypso_scalar(cur_job.get("PopSize", 30), "PopSize")
+    maxstep = _unwrap_calypso_scalar(cur_job.get("MaxStep", 5), "MaxStep")
+    icode = _unwrap_calypso_scalar(cur_job.get("ICode", 1), "ICode")
     split = cur_job.get("Split", "T")
     # Cluster
 
@@ -192,10 +201,10 @@ def _make_model_devi_native_calypso(iter_index, model_devi_jobs, calypso_run_opt
     ctrlrange = None
     vsc = cur_job.get("VSC", "F")
     if vsc == "T":
-        maxnumatom = cur_job.get("MaxNumAtom")
+        maxnumatom = _unwrap_calypso_scalar(cur_job.get("MaxNumAtom"), "MaxNumAtom")
         ctrlrange = cur_job.get("CtrlRange")
     # Optimization
-    fmax = cur_job.get("fmax", 0.01)
+    fmax = _unwrap_calypso_scalar(cur_job.get("fmax", 0.01), "fmax")
     # pstress is a List which contains the target stress
     pstress = cur_job.get("PSTRESS", [0.001])
     # pressures

tests/test_calypso_arginfo.py

@@ -0,0 +1,48 @@
+import unittest
+
+from dargs import Argument
+
+from dpgen.generator.arginfo import model_devi_args
+from dpgen.generator.lib.make_calypso import _unwrap_calypso_scalar
+
+
+class TestCalypsoArginfo(unittest.TestCase):
+    def test_legacy_singleton_scalars(self):
+        """The checked-in CALYPSO list spelling remains schema-compatible."""
+        arginfo = Argument("model_devi", dict, sub_variants=model_devi_args())
+        data = {
+            "model_devi_engine": "calypso",
+            "model_devi_skip": 0,
+            "model_devi_f_trust_lo": 0.05,
+            "model_devi_f_trust_hi": 0.15,
+            "model_devi_jobs": [
+                {
+                    "times": [0],
+                    "NameOfAtoms": ["Mg"],
+                    "NumberOfAtoms": [1],
+                    "Volume": [30],
+                    "DistanceOfIon": [[1.4]],
+                    "PsoRatio": [0.6],
+                    "PopSize": [30],
+                    "MaxStep": [5],
+                    "ICode": [1],
+                    "VSC": "T",
+                    "MaxNumAtom": [20],
+                    "CtrlRange": [[1, 20]],
+                    "fmax": [0.01],
+                }
+            ],
+        }
+
+        normalized = arginfo.normalize_value(data)
+        arginfo.check_value(normalized, strict=True)
+
+    def test_runtime_unwraps_singleton_scalars(self):
+        self.assertEqual(_unwrap_calypso_scalar([30], "Volume"), 30)
+        self.assertEqual(_unwrap_calypso_scalar(0.6, "PsoRatio"), 0.6)
+        with self.assertRaisesRegex(ValueError, "one-item list"):
+            _unwrap_calypso_scalar([1, 2], "PopSize")
+
+
+if __name__ == "__main__":
+    unittest.main()