Files
make-cad/test/test_notebook_params.py
NiJingzhe 332d95cd80 fix(params): recognise scad.var(name=..., default=...) keyword form
The editor only read the default from the second positional argument, so
keyword declarations were silently ignored.

Co-Authored-By: Claude Sonnet 5.5 <noreply@anthropic.com>
2026-10-20 21:51:31 +08:00

284 lines
13 KiB
Python

"""Notebook parameters, features and workspace scanning (read from files)."""
from __future__ import annotations
import json
import tempfile
import textwrap
import unittest
from pathlib import Path
import simplecadapi as scad
from simplecadapi.runtime.config import read_notebook_config
from simplecadapi.runtime.params import (
apply_saved_params,
commit_value,
list_parameters,
parameters_in_cell,
read_saved_params,
write_saved_params,
)
from simplecadapi.runtime.workspace import (
features_in_cell,
list_features,
scan_workspace,
)
HEADER = '# /// script\n# [tool.simplecadapi]\n# id = "{id}"\n# ///\n'
def notebook(id: str, *cells: str) -> str:
body = "".join(
f"@app.cell\ndef _():\n{textwrap.indent(textwrap.dedent(c).strip(), ' ')}\n return\n\n\n"
for c in cells
)
return HEADER.format(id=id) + "import marimo\n\napp = marimo.App()\n\n\n" + body
class ParameterCommentTest(unittest.TestCase):
def test_header_forms_and_inference(self) -> None:
for header in ("# ---- params ----", "# ---- params: disc ----"):
specs = parameters_in_cell(f"{header}\nA = 1.5\nN = 4\nF = True\nS = 'x'\n_t = 3\n")
self.assertEqual([s.name for s in specs], ["A", "N", "F"])
self.assertEqual([s.kind for s in specs], ["float", "int", "bool"])
self.assertEqual([s.control for s in specs], ["number", "number", "toggle"])
self.assertEqual(parameters_in_cell("# ---- params: disc ----\nA = 1\n")[0].group, "disc")
self.assertEqual(parameters_in_cell("# ---- params ----\nA = 1\n")[0].group, "")
def test_plain_constants_outside_a_params_cell_are_not_parameters(self) -> None:
self.assertEqual(parameters_in_cell("X = 3.0\n"), [])
def test_ui_comment_makes_a_parameter_anywhere(self) -> None:
(spec,) = parameters_in_cell('W = 20.0 # ui: slider(10, 40, step=2, unit="mm", label="Width")\n')
self.assertEqual(
(spec.control, spec.min, spec.max, spec.step, spec.unit, spec.label),
("slider", 10, 40, 2, "mm", "Width"),
)
self.assertEqual(spec.issues, ())
def test_scad_var_carries_unit_and_comment(self) -> None:
(spec,) = parameters_in_cell(
'# ---- params ----\nOD = scad.var("od", 100.0, comment="outer", unit="mm") # ui: slider(50, 200)\n'
)
self.assertEqual((spec.declared, spec.unit, spec.comment), ("var", "mm", "outer"))
self.assertEqual((spec.min, spec.max), (50, 200))
def test_bad_ui_comments_fall_back_and_say_why(self) -> None:
cases = {
"A = 1.0 # ui: slider(5, 1)": "min 5 is above max 1",
"A = 1.0 # ui: slider()": "slider needs min and max",
"A = 1.0 # ui: dial(1, 2)": "must be one of",
"A = 1 # ui: toggle()": "toggle needs a bool",
"A = True # ui: slider(1, 2)": "needs a number",
"A = 1.0 # ui: number(step=0)": "step must be positive",
"A = 1.0 # ui: number(speed=1)": "unknown ui option",
}
for code, message in cases.items():
(spec,) = parameters_in_cell(code + "\n")
self.assertTrue(any(message in issue for issue in spec.issues), (code, spec.issues))
self.assertIn(spec.control, ("number", "toggle"), code)
def test_list_parameters_reads_the_file(self) -> None:
with tempfile.TemporaryDirectory() as tmp:
path = Path(tmp) / "m.py"
path.write_text(
notebook("m", "# ---- params ----\nW = 20.0 # ui: slider(10, 40)\nFLAG = False"),
encoding="utf-8",
)
specs = list_parameters(path)
self.assertEqual([s.name for s in specs], ["W", "FLAG"])
self.assertTrue(specs[0].cell.startswith("c"))
class CommitValueTest(unittest.TestCase):
CODE = (
"# ---- params ----\n"
'W = 20.0 # ui: slider(10, 40)\n'
"N = 4\n"
"F = False\n"
'OD = scad.var("od", 100.0, comment="é", unit="mm") # 外径\n'
"T = scad.var(\n 't', 3.0)\n"
)
def test_literals_keep_the_rest_of_the_line(self) -> None:
out = commit_value(self.CODE, "W", 25)
assert out is not None
self.assertIn("W = 25.0 # ui: slider(10, 40)", out)
self.assertIn("N = 7", commit_value(self.CODE, "N", 7.0) or "")
self.assertIn("F = True", commit_value(self.CODE, "F", True) or "")
def test_var_default_is_replaced_not_the_name(self) -> None:
out = commit_value(self.CODE, "OD", 120)
assert out is not None
self.assertIn('OD = scad.var("od", 120.0, comment="é", unit="mm") # 外径', out)
def test_var_with_keyword_name_and_default_is_recognised(self) -> None:
code = 'J = scad.var(name="j1", default=0.0, comment="joint")\n'
out = commit_value(code, "J", 15)
self.assertEqual(out, 'J = scad.var(name="j1", default=15.0, comment="joint")\n')
def test_refuses_what_does_not_fit(self) -> None:
self.assertIsNone(commit_value(self.CODE, "MISSING", 1))
self.assertIsNone(commit_value(self.CODE, "F", 1.0))
self.assertIsNone(commit_value(self.CODE, "W", True))
def test_a_declaration_spanning_lines_is_edited_where_the_value_is(self) -> None:
self.assertIn("'t', 4.0)", commit_value(self.CODE, "T", 4.0) or "")
class FeatureHeaderTest(unittest.TestCase):
def test_header_parts(self) -> None:
(feature,) = features_in_cell(
"# ---- feature: base-plate (build, profile=sketch) ----\nx = 1\n", "c1"
)
self.assertEqual(
(feature.slug, feature.role, feature.tags, feature.cell),
("base-plate", "build", (("profile", "sketch"),), "c1"),
)
(bare,) = features_in_cell("\n# ---- feature: boss ----\n")
self.assertEqual((bare.slug, bare.role, bare.line), ("boss", "", 2))
def test_list_features_in_cell_order(self) -> None:
with tempfile.TemporaryDirectory() as tmp:
path = Path(tmp) / "m.py"
path.write_text(
notebook("m", "# ---- feature: a (build) ----\na = 1", "# ---- feature: b (add) ----\nb = 2"),
encoding="utf-8",
)
self.assertEqual([f.slug for f in list_features(path)], ["a", "b"])
class SavedParamsTest(unittest.TestCase):
def setUp(self) -> None:
self._tmp = tempfile.TemporaryDirectory()
self.addCleanup(self._tmp.cleanup)
path = Path(self._tmp.name) / "m.py"
path.write_text(notebook("m", "# ---- params ----\nW = 1.0"), encoding="utf-8")
config = read_notebook_config(path)
assert config is not None
self.config = config
def test_round_trip_and_clear(self) -> None:
self.assertEqual(read_saved_params(self.config), {})
write_saved_params(self.config, {"W": 2.5, "N": 3, "F": True})
self.assertEqual(read_saved_params(self.config), {"W": 2.5, "N": 3, "F": True})
write_saved_params(self.config, {"W": 9.0})
self.assertEqual(read_saved_params(self.config), {"W": 9.0})
write_saved_params(self.config, {})
self.assertEqual(read_saved_params(self.config), {})
def test_corrupt_file_is_ignored(self) -> None:
write_saved_params(self.config, {"W": 2.0})
from simplecadapi.runtime.params import saved_params_file
saved_params_file(self.config).write_text("{not json", encoding="utf-8")
self.assertEqual(read_saved_params(self.config), {})
def test_apply_keeps_type_and_var_declaration(self) -> None:
var = scad.var("od", 100.0, comment="outer", unit="mm")
glbls = {"OD": var, "N": 6, "F": False, "S": 1.5, "OTHER": 1.0}
write_saved_params(self.config, {"OD": 120, "N": 8.0, "F": True, "S": True, "OTHER": 9.0})
applied = apply_saved_params(self.config, {"OD", "N", "F", "S"}, glbls)
self.assertEqual(sorted(applied), ["F", "N", "OD"]) # S: a bool for a number is refused
self.assertEqual(glbls["OD"].default, 120.0)
self.assertEqual((glbls["OD"].name, glbls["OD"].unit, glbls["OD"].comment),
("od", var.unit, "outer"))
self.assertEqual((glbls["N"], type(glbls["N"])), (8, int))
self.assertIs(glbls["F"], True)
self.assertEqual(glbls["S"], 1.5)
self.assertEqual(glbls["OTHER"], 1.0) # not defined by the cell
class ScratchCellTest(unittest.TestCase):
def test_scratch_cells_are_not_recorded(self) -> None:
from simplecadapi.runtime.cells import NotebookCells
cells = NotebookCells(Path("m.py"), [])
self.assertNotIn("__scratch__", cells)
class WorkspaceScanTest(unittest.TestCase):
def test_scan_lists_only_simplecad_notebooks(self) -> None:
with tempfile.TemporaryDirectory() as tmp:
root = Path(tmp)
(root / "parts").mkdir()
(root / "parts" / "bar.py").write_text(notebook("bar", "b = 1"), encoding="utf-8")
(root / "parts" / "dims.py").write_text("X = 1\n", encoding="utf-8")
(root / "product.py").write_text(
notebook("product", 'p = scad.use("parts/bar.py", id="a")\np2 = scad.use("parts/gone.py")'),
encoding="utf-8",
)
(root / "__marimo__").mkdir()
(root / "__marimo__" / "x.py").write_text(notebook("x", "b = 1"), encoding="utf-8")
(root / "plain.py").write_text("import marimo\n", encoding="utf-8")
entries = {entry.path: entry for entry in scan_workspace(root)}
self.assertEqual(sorted(entries), ["parts/bar.py", "product.py"])
self.assertEqual(entries["parts/bar.py"].kind, "part")
product = entries["product.py"]
self.assertEqual(product.kind, "assembly")
self.assertEqual(product.uses, ("parts/bar.py", "parts/gone.py"))
json.dumps(product.to_dict())
def test_examples_are_a_workspace_without_changes(self) -> None:
examples = Path(__file__).resolve().parents[1] / "examples"
entries = {entry.path: entry for entry in scan_workspace(examples)}
link = entries["four_bar_linkage/link_bar.py"]
self.assertEqual((link.id, link.kind), ("link_bar", "part"))
assembly = entries["four_bar_linkage/four_bar_linkage.py"]
self.assertEqual(assembly.kind, "assembly")
self.assertIn("four_bar_linkage/link_bar.py", assembly.uses)
names = [spec.name for spec in list_parameters(examples / "flange_plate" / "flange_plate.py")]
self.assertIn("FLANGE_OD", names)
if __name__ == "__main__":
unittest.main()
class ModuleParametersTest(unittest.TestCase):
CODE = (
"from dataclasses import dataclass\n\n"
'TAG = "x"\n'
"WALL = 2.0 # ui: slider(1, 5, step=0.5, unit=\"mm\")\n"
"TABLE = 3\n\n\n"
"@dataclass(frozen=True)\n"
"class Dims:\n"
" L: float = 80.0 # arm span\n"
" N: int = 4 # ui: slider(2, 8)\n"
" name: str = 'a'\n\n"
" @property\n"
" def r(self) -> float:\n"
" return self.L / 2\n\n\n"
"class Plain:\n"
" K: float = 1.0\n"
)
def test_dataclass_fields_and_commented_constants_are_parameters(self) -> None:
from simplecadapi.runtime.params import parameters_in_module
specs = {spec.name: spec for spec in parameters_in_module(self.CODE)}
self.assertEqual(sorted(specs), ["Dims.L", "Dims.N", "WALL"])
self.assertEqual((specs["WALL"].control, specs["WALL"].unit, specs["WALL"].group), ("slider", "mm", "module"))
self.assertEqual((specs["Dims.N"].kind, specs["Dims.N"].control), ("int", "slider"))
self.assertEqual(specs["Dims.L"].to_dict()["label"], "L")
def test_values_are_written_where_they_are_declared(self) -> None:
from simplecadapi.runtime.params import commit_field_value
out = commit_field_value(self.CODE, "Dims", "L", 100)
assert out is not None
self.assertIn("L: float = 100.0 # arm span", out)
self.assertIsNone(commit_field_value(self.CODE, "Plain", "K", 2)) # not a dataclass
self.assertIsNone(commit_field_value(self.CODE, "Dims", "name", 2))
self.assertIn("WALL = 3.5 # ui:", commit_value(self.CODE, "WALL", 3.5) or "")
class VertexScopeTest(unittest.TestCase):
def test_vertices_resolve_through_a_solid_and_a_face(self) -> None:
import simplecadapi as scad
solid = scad.make_box_rsolid(10.0, 20.0, 30.0)
self.assertEqual(len(scad.ql.vertices().resolve(solid)), 8)
face = scad.ql.faces().where(scad.ql.prop("geom.center.z", "<=", 0.01)).exactly(1).resolve(solid)[0]
self.assertEqual(len(scad.ql.vertices().resolve(face)), 4)