likang
994d06aaea
- 新增 selector_candidate_demo，移除 provenance intent 后枚举候选 selector - 对候选分支执行有界重建与严格 STEP 比较 - 仅在候选遍历完整且唯一 strict 通过时生成 selector 映射记录 - 增加 selector 候选搜索、预算限制和记录生成的测试 - 保持生产 selector resolver 不受 Demo 逻辑影响 - 更新 CADFS 能力台账，记录 IMPRINT 派生 profile 的 lineage selector 缺口
2402 lines
142 KiB
Python
2402 lines
142 KiB
Python
from __future__ import annotations
|
|
|
|
import json, math, tempfile, unittest
|
|
from copy import deepcopy
|
|
from pathlib import Path
|
|
from cadfs_to_cdsl.compare import compare_steps
|
|
from cadfs_to_cdsl.featurescript_parser import parse_featurescript
|
|
from cadfs_to_cdsl.ir import Call
|
|
from cadfs_to_cdsl.lowering import (
|
|
UnsupportedCapability, _arc, _contours, _curve_endpoint_tangent,
|
|
_direct_hole_location, _direct_line_angle_axis, _direct_sketch_wire_path,
|
|
_direct_boolean_intersection_selector, _direct_primary_cut_intersection_selector, _global, _number,
|
|
_record_single_body_successor, lower_model,
|
|
)
|
|
from cadfs_to_cdsl.pipeline import compare_one, convert_one, rebuild_one
|
|
from cadfs_to_cdsl.rebuild import rebuild_candidate
|
|
from cadfs_to_cdsl.dataset import Sample
|
|
from cadfs_to_cdsl.dataset import scan_dataset
|
|
from cadfs_to_cdsl.tests.test_parser import SOURCE, TRANSFORM_SOURCE
|
|
|
|
|
|
LINE_ANGLE_TWO_ENTITY_SOURCE = '''FeatureScript 1511;
|
|
import(path : "onshape/std/geometry.fs", version : "1511.0");
|
|
const mm = millimeter;
|
|
const VERTEX = EntityType.VERTEX;
|
|
const EDGE = EntityType.EDGE;
|
|
const FACE = EntityType.FACE;
|
|
function v(x, y){return vector(x, y);}
|
|
annotation { "Feature Type Name" : "Feature" }
|
|
export const myFeature = defineFeature(function(context is Context, id is Id, definition is map)
|
|
precondition{}
|
|
{
|
|
{ var Q0; Q0=qCreatedBy(makeId("Top.planeOp"),FACE); var sketch=newSketch(context,id+"F0",{"sketchPlane":qUnion([Q0])}); skLineSegment(sketch,"E0",{"start":v(0,0)*mm,"end":v(10,0)*mm}); skLineSegment(sketch,"E1",{"start":v(0,0)*mm,"end":v(0,10)*mm}); skLineSegment(sketch,"E2",{"start":v(0,5)*mm,"end":v(10,5)*mm}); skPoint(sketch,"P0",{"position":v(0,10)*mm}); skPoint(sketch,"P1",{"position":v(10,0)*mm}); skSolve(sketch); }
|
|
{ var Q0; Q0=sQuery(id+"F0.wireOp",EDGE,"E0"); var Q1; Q1=sQuery(id+"F0.wireOp",EDGE,"E1"); cPlane(context,id+"F1",{"entities":qUnion([Q0,Q1]),"cplaneType":CPlaneType.LINE_ANGLE,"angle":0*degree}); }
|
|
{ var Q0; Q0=sQuery(id+"F0.wireOp",EDGE,"E0"); var Q1; Q1=sQuery(id+"F0.wireOp",EDGE,"E2"); cPlane(context,id+"F2",{"entities":qUnion([Q0,Q1]),"cplaneType":CPlaneType.LINE_ANGLE,"angle":0*degree}); }
|
|
{ var Q0; Q0=sQuery(id+"F0.wireOp",EDGE,"E0"); var Q1; Q1=sQuery(id+"F0.wireOp",VERTEX,"P0"); cPlane(context,id+"F3",{"entities":qUnion([Q0,Q1]),"cplaneType":CPlaneType.LINE_ANGLE,"angle":0*degree}); }
|
|
{ var Q0; Q0=sQuery(id+"F0.wireOp",VERTEX,"P0"); var Q1; Q1=sQuery(id+"F0.wireOp",EDGE,"E0"); cPlane(context,id+"F4",{"entities":qUnion([Q0,Q1]),"cplaneType":CPlaneType.LINE_ANGLE,"angle":90*degree,"oppositeDirection":true}); }
|
|
{ var Q0; Q0=sQuery(id+"F0.wireOp",EDGE,"E0"); var Q1; Q1=sQuery(id+"F0.wireOp",VERTEX,"P1"); cPlane(context,id+"F5",{"entities":qUnion([Q0,Q1]),"cplaneType":CPlaneType.LINE_ANGLE,"angle":0*degree}); }
|
|
{ var Q0; Q0=sQuery(id+"F0.wireOp",EDGE,"E0"); var Q1; Q1=qCreatedBy(id+"F1.planeOp",FACE); cPlane(context,id+"F6",{"entities":qUnion([Q0,Q1]),"cplaneType":CPlaneType.LINE_ANGLE,"angle":0*degree}); }
|
|
}'''
|
|
|
|
|
|
class LoweringTests(unittest.TestCase):
|
|
def test_direct_sketch_wire_path_accepts_only_one_nonconstruction_line_or_bspline(self):
|
|
plane = {"origin_mm": [0.0, 0.0, 0.0], "x_dir": [1.0, 0.0, 0.0], "normal": [0.0, 0.0, 1.0]}
|
|
line = {"type": "line", "start": [0.0, 0.0], "end": [10.0, 0.0], "source_entity_id": "E0"}
|
|
query = Call("qUnion", [[
|
|
Call("qConstructionFilter", [
|
|
Call("qBodyType", [
|
|
Call("qCreatedBy", [Call("__binary__", ["id", "+", "F0"]), "EDGE"]),
|
|
"BodyType.WIRE",
|
|
]),
|
|
"ConstructionObject.NO",
|
|
]),
|
|
]])
|
|
sketches = {"F0": {"workplane": plane}}
|
|
entities = {"F0": {"E0": line, "axis": {"type": "line", "start": [0.0, 0.0], "end": [0.0, 5.0], "construction": True}}}
|
|
|
|
self.assertEqual(
|
|
_direct_sketch_wire_path(
|
|
query, sketches, entities, featurescript_version="1511",
|
|
standard_library="onshape/std/geometry.fs", standard_library_version="1511.0",
|
|
),
|
|
("F0", "E0", line, sketches["F0"]),
|
|
)
|
|
self.assertIsNone(_direct_sketch_wire_path(
|
|
query, sketches, entities, featurescript_version="1512",
|
|
standard_library="onshape/std/geometry.fs", standard_library_version="1511.0",
|
|
))
|
|
self.assertIsNone(_direct_sketch_wire_path(
|
|
query, sketches, entities, featurescript_version="1511",
|
|
standard_library="onshape/std/geometry.fs", standard_library_version="1512.0",
|
|
))
|
|
self.assertIsNone(_direct_sketch_wire_path(
|
|
query, sketches, {"F0": {"E0": line, "E1": {**line, "source_entity_id": "E1"}}},
|
|
featurescript_version="1511", standard_library="onshape/std/geometry.fs", standard_library_version="1511.0",
|
|
))
|
|
self.assertIsNone(_direct_sketch_wire_path(
|
|
Call("qBodyType", [Call("qCreatedBy", ["F0", "EDGE"]), "BodyType.WIRE"]),
|
|
sketches, entities, featurescript_version="1511",
|
|
standard_library="onshape/std/geometry.fs", standard_library_version="1511.0",
|
|
))
|
|
self.assertIsNone(_direct_sketch_wire_path(
|
|
query.args[0][0], sketches, entities, featurescript_version="1511",
|
|
standard_library="onshape/std/geometry.fs", standard_library_version="1511.0",
|
|
))
|
|
|
|
def test_direct_hole_location_accepts_only_original_sketch_vertices(self):
|
|
plane = {"origin_mm": [0.0, 0.0, 0.0], "x_dir": [1.0, 0.0, 0.0], "normal": [0.0, 0.0, 1.0]}
|
|
sketches = {"F2": {"workplane": plane}}
|
|
entities = {"F2": {
|
|
"P0": {"type": "point", "point": [1.0, 2.0]},
|
|
"C0": {"type": "circle", "center": [3.0, 4.0], "radius_mm": 1.0},
|
|
"L0": {"type": "line", "start": [5.0, 6.0], "end": [7.0, 8.0]},
|
|
"A0": {"type": "arc", "start": [9.0, 10.0], "end": [11.0, 12.0]},
|
|
}}
|
|
|
|
def vertex(token: str) -> Call:
|
|
return Call("sQuery", ["F2.wireOp", "VERTEX", token])
|
|
|
|
self.assertEqual(_direct_hole_location(vertex("P0"), sketches, entities), ([1.0, 2.0, 0.0], plane))
|
|
self.assertEqual(_direct_hole_location(vertex("C0.center"), sketches, entities), ([3.0, 4.0, 0.0], plane))
|
|
self.assertEqual(_direct_hole_location(vertex("L0.end"), sketches, entities), ([7.0, 8.0, 0.0], plane))
|
|
self.assertEqual(_direct_hole_location(vertex("A0.start"), sketches, entities), ([9.0, 10.0, 0.0], plane))
|
|
self.assertIsNone(_direct_hole_location(Call("qAdjacent", [vertex("C0.center")]), sketches, entities))
|
|
self.assertIsNone(_direct_hole_location(vertex("C0.center.copy"), sketches, entities))
|
|
|
|
def test_strict_comparison_status_is_not_labeled_approximate(self):
|
|
with tempfile.TemporaryDirectory() as tmp:
|
|
output = Path(tmp); directory = output / "samples" / "strict-status"; directory.mkdir(parents=True)
|
|
sample = Sample("strict-status", {"step": str(directory / "gold.step")}, {}, {}, [])
|
|
(directory / "rebuild.step").touch(); (directory / "gold.step").touch()
|
|
(directory / "status.json").write_text(json.dumps({
|
|
"sample_id": sample.sample_id, "rebuild_status": "rebuilt",
|
|
"comparison_error": {"type": "TimeoutError", "message": "stale"},
|
|
}), encoding="utf-8")
|
|
(directory / "comparison.json").write_text(json.dumps({"decision": "strict_pass", "strict": {"passed": True}, "rp": {"passed": True}}), encoding="utf-8")
|
|
status = compare_one(sample, output, compare_mode="strict")
|
|
self.assertEqual(status["status"], "rebuilt_strict")
|
|
self.assertNotIn("comparison_error", status)
|
|
|
|
def test_missing_dataset_fails_explicitly(self):
|
|
with tempfile.TemporaryDirectory() as tmp:
|
|
with self.assertRaises(FileNotFoundError): scan_dataset(Path(tmp) / "missing")
|
|
|
|
def test_circle_extrude_is_valid_cdsl_11(self):
|
|
result = lower_model(parse_featurescript(SOURCE, "00000173"), {})
|
|
self.assertEqual(result.status, "converted_complete")
|
|
self.assertEqual(result.cdsl["schema_version"], "1.1.0")
|
|
self.assertEqual(result.cdsl["geometry"]["sketches"][0]["profile"]["radius_mm"], 9.53)
|
|
from engine.cdsl_engine.semantic_validation import validate_semantic_cdsl
|
|
self.assertTrue(validate_semantic_cdsl(result.cdsl)["future_rebuild_ready"])
|
|
|
|
def test_rectilinear_fillet_arc_recovers_its_exact_endpoint_radius(self):
|
|
arc = _arc([38.1, 63.5], [34.38, 72.48], [25.4, 76.2])
|
|
self.assertEqual(arc["center"], [25.4, 63.5])
|
|
self.assertAlmostEqual(arc["radius_mm"], 12.7)
|
|
self.assertFalse(arc["clockwise"])
|
|
|
|
def test_general_three_point_arc_remains_circumcircle_defined(self):
|
|
arc = _arc([0, 0], [2, 3], [5, 0])
|
|
self.assertAlmostEqual(arc["center"][0], 2.5)
|
|
self.assertAlmostEqual(arc["center"][1], 0.5)
|
|
self.assertAlmostEqual(arc["radius_mm"], math.hypot(2.5, 0.5))
|
|
|
|
def test_direct_extrude_lineage_succeeds_and_unregistered_loft_query_preserves_prefix(self):
|
|
root = Path(__file__).parents[2] / "data/cadfs-sample/CADFS_test"
|
|
cases = {
|
|
"00000715": ("f_F2", 2, True),
|
|
"00005267": ("f_F4", 4, False),
|
|
}
|
|
for sample_id, (fillet_id, selector_count, line_type) in cases.items():
|
|
with self.subTest(sample_id=sample_id):
|
|
feature = root / "featurescript_rp" / sample_id[:4] / f"{sample_id}.txt"
|
|
result = lower_model(parse_featurescript(feature.read_text(), sample_id), {})
|
|
self.assertEqual(result.status, "converted_complete")
|
|
fillet = next(item for item in result.cdsl["features"] if item["id"] == fillet_id)
|
|
self.assertEqual(len(fillet["selectors"]), selector_count)
|
|
self.assertTrue(all(item["owner_feature_id"] == fillet["depends_on"][0] for item in fillet["selectors"]))
|
|
if sample_id == "00000715":
|
|
self.assertTrue(all("geometry" not in item for item in fillet["selectors"]))
|
|
self.assertTrue(all(
|
|
item["selector_intent"]["query_family"] == "SWEPT_EDGE"
|
|
and item["selector_intent"]["derivation_policy"] == {"allowed": ["boundary"], "multiplicity": "one"}
|
|
and len(item["selector_intent"]["source_entities"]) == 2
|
|
for item in fillet["selectors"]
|
|
))
|
|
else:
|
|
self.assertTrue(all("bbox_mm" in item["geometry"] for item in fillet["selectors"]))
|
|
self.assertEqual(["curve_type" in item["geometry"] for item in fillet["selectors"]], [line_type] * selector_count)
|
|
self.assertTrue(all(
|
|
item["selector_intent"]["query_family"] == "SWEPT_EDGE"
|
|
and item["selector_intent"]["evidence"] == "feature_script_query"
|
|
and item["selector_intent"]["derivation_policy"] == {"allowed": ["continuation"], "multiplicity": "none"}
|
|
and item["selector_intent"]["source_query"]["featurescript_version"] == "1793"
|
|
for item in fillet["selectors"]
|
|
))
|
|
with tempfile.TemporaryDirectory() as directory:
|
|
rebuilt = Path(directory) / "rebuild.step"
|
|
outcome = rebuild_candidate(result.cdsl, rebuilt)
|
|
if sample_id == "00005267":
|
|
self.assertEqual(outcome["status"], "rebuild_failed")
|
|
self.assertEqual(outcome["error"]["message"], "f_F4: selector_query_unsupported during incremental replay")
|
|
self.assertTrue(rebuilt.exists())
|
|
self.assertEqual(outcome["last_executable_prefix"]["failed_feature_id"], "f_F4")
|
|
self.assertEqual(outcome["last_executable_prefix"]["last_feature_id"], "f_F3")
|
|
else:
|
|
self.assertEqual(outcome["status"], "rebuilt")
|
|
comparison = compare_steps(root / "step_abc" / sample_id[:4] / f"{sample_id}.step", rebuilt)
|
|
self.assertTrue(comparison["strict"]["passed"])
|
|
|
|
def test_swept_edge_requires_one_direct_shared_source_endpoint(self):
|
|
root = Path(__file__).parents[2] / "data/cadfs-sample/CADFS_test"
|
|
feature = root / "featurescript_rp/0000/00000715.txt"
|
|
source = feature.read_text(encoding="utf-8").replace(
|
|
'sQuery(id+"F0.wireOp",EDGE,"E8")',
|
|
'sQuery(id+"F0.wireOp",EDGE,"E1")',
|
|
1,
|
|
)
|
|
result = lower_model(parse_featurescript(source, "swept-edge-ambiguous"), {})
|
|
self.assertEqual(result.status, "converted_partial")
|
|
self.assertEqual(result.diagnostics, [{
|
|
"code": "feature_deferred",
|
|
"feature_id": "F2",
|
|
"operation": "fillet",
|
|
"message": "swept edge source endpoint provenance is unsupported",
|
|
}])
|
|
|
|
def test_full_revolve_swept_circle_edges_remain_deferred_with_prefixes(self):
|
|
root = Path(__file__).parents[2] / "data/cadfs-sample/CADFS_test"
|
|
for sample_id, dressup_id, selector_count in (
|
|
("00048326", "f_F3", 2),
|
|
("00025622", "f_F2", 1),
|
|
):
|
|
with self.subTest(sample_id=sample_id):
|
|
feature = root / "featurescript_rp" / sample_id[:4] / f"{sample_id}.txt"
|
|
result = lower_model(parse_featurescript(feature.read_text(), sample_id), {})
|
|
self.assertEqual(result.status, "converted_complete")
|
|
dressup = next(item for item in result.cdsl["features"] if item["id"] == dressup_id)
|
|
self.assertEqual(len(dressup["selectors"]), selector_count)
|
|
self.assertTrue(all(
|
|
selector["geometry"].get("curve_type") == "circle"
|
|
and len(selector["geometry"].get("circle_center_mm") or []) == 3
|
|
and selector["geometry"].get("radius_mm", 0) > 0
|
|
and selector["selector_intent"]["query_family"] == "SWEPT_EDGE"
|
|
and selector["selector_intent"]["evidence"] == "feature_script_query"
|
|
and selector["selector_intent"]["derivation_policy"]["multiplicity"] == "none"
|
|
for selector in dressup["selectors"]
|
|
))
|
|
with tempfile.TemporaryDirectory() as directory:
|
|
rebuilt = Path(directory) / "rebuild.step"
|
|
outcome = rebuild_candidate(result.cdsl, rebuilt)
|
|
self.assertEqual(outcome["status"], "rebuild_failed")
|
|
self.assertEqual(outcome["error"]["message"], f"{dressup_id}: selector_query_unsupported during incremental replay")
|
|
self.assertEqual(outcome["last_executable_prefix"]["failed_feature_id"], dressup_id)
|
|
|
|
def test_full_revolve_swept_circle_requires_one_direct_shared_source_endpoint(self):
|
|
root = Path(__file__).parents[2] / "data/cadfs-sample/CADFS_test"
|
|
feature = root / "featurescript_rp/0000/00001352.txt"
|
|
source = feature.read_text(encoding="utf-8").replace(
|
|
'sQuery(id+"F0.wireOp",EDGE,"E2")',
|
|
'sQuery(id+"F0.wireOp",EDGE,"E1")',
|
|
1,
|
|
)
|
|
result = lower_model(parse_featurescript(source, "revolve-swept-edge-ambiguous"), {})
|
|
self.assertEqual(result.status, "converted_partial")
|
|
self.assertIn({
|
|
"code": "feature_deferred",
|
|
"feature_id": "F2",
|
|
"operation": "fillet",
|
|
"message": "swept edge source endpoint provenance is unsupported",
|
|
}, result.diagnostics)
|
|
|
|
def test_equivalent_imprint_profile_preserves_but_does_not_bind_full_revolve_queries(self):
|
|
root = Path(__file__).parents[2] / "data/cadfs-sample/CADFS_test"
|
|
source = root / "featurescript_rp/0011/00112257.txt"
|
|
result = lower_model(parse_featurescript(source.read_text(), "00112257"), {})
|
|
self.assertEqual(result.status, "converted_complete")
|
|
fillet = next(item for item in result.cdsl["features"] if item["id"] == "f_F2")
|
|
self.assertEqual(len(fillet["selectors"]), 5)
|
|
self.assertTrue(all(
|
|
selector["geometry"].get("curve_type") == "circle"
|
|
and selector["selector_intent"]["query_family"] == "SWEPT_EDGE"
|
|
and selector["selector_intent"]["derivation_policy"]["multiplicity"] == "none"
|
|
for selector in fillet["selectors"]
|
|
))
|
|
|
|
from cadfs_to_cdsl.selector_binding import bind_candidate_selectors
|
|
prefix = dict(result.cdsl)
|
|
prefix["features"] = result.cdsl["features"][:2]
|
|
with self.assertRaisesRegex(ValueError, "f_F2: selector_query_unsupported after prefix rebuild"):
|
|
bind_candidate_selectors(prefix)
|
|
|
|
def test_changed_imprint_profile_does_not_inherit_full_revolve_source_edges(self):
|
|
root = Path(__file__).parents[2] / "data/cadfs-sample/CADFS_test"
|
|
source = root / "featurescript_rp/0059/00590828.txt"
|
|
result = lower_model(parse_featurescript(source.read_text(), "00590828"), {})
|
|
self.assertEqual(result.status, "converted_partial")
|
|
self.assertIn({
|
|
"code": "feature_deferred",
|
|
"feature_id": "F2",
|
|
"operation": "fillet",
|
|
"message": "swept edge source endpoint provenance is unsupported",
|
|
}, result.diagnostics)
|
|
|
|
def test_unsupported_operation_is_audited_not_invented(self):
|
|
source = SOURCE.replace('extrude(context, id + "F1",', 'draft(context, id + "F1",')
|
|
result = lower_model(parse_featurescript(source, "00000173"), {})
|
|
self.assertEqual(result.status, "deferred_no_executable_feature")
|
|
self.assertIsNone(result.cdsl)
|
|
self.assertEqual(result.diagnostics[0]["code"], "unsupported_operation")
|
|
|
|
def test_direct_translation_transform_is_baked_into_the_source_feature(self):
|
|
result = lower_model(parse_featurescript(TRANSFORM_SOURCE, "transform"), {})
|
|
self.assertEqual(result.status, "converted_complete")
|
|
self.assertEqual([item["id"] for item in result.cdsl["features"]], ["f_F1"])
|
|
self.assertEqual(result.history[-1]["feature_id"], "F2")
|
|
self.assertFalse(result.diagnostics)
|
|
self.assertEqual(result.cdsl["geometry"]["sketches"][0]["workplane"]["origin_mm"], [10.0, 0.0, 0.0])
|
|
|
|
def test_copy_transform_lowers_to_an_explicit_body_operation(self):
|
|
source = TRANSFORM_SOURCE.replace('"makeCopy":false', '"makeCopy":true')
|
|
result = lower_model(parse_featurescript(source, "transform-copy"), {})
|
|
self.assertEqual(result.status, "converted_complete")
|
|
self.assertFalse(result.diagnostics)
|
|
transform = result.cdsl["features"][-1]
|
|
self.assertEqual(transform["atomic_id"], "transform_bodies")
|
|
self.assertEqual(transform["params"], {
|
|
"source_feature_ids": ["f_F1"],
|
|
"transform": {"type": "translation", "translation_mm": [10.0, 0.0, 0.0]},
|
|
"make_copy": True,
|
|
})
|
|
|
|
def test_identity_copy_transform_creates_a_distinct_body_member(self):
|
|
source = TRANSFORM_SOURCE.replace(
|
|
'"transformType":TransformType.TRANSLATION_3D, "dx":10 * mm, "dy":0 * mm, "dz":0 * mm, "makeCopy":false',
|
|
'"transformType":TransformType.COPY',
|
|
)
|
|
result = lower_model(parse_featurescript(source, "identity-copy"), {})
|
|
self.assertEqual(result.status, "converted_complete")
|
|
self.assertFalse(result.diagnostics)
|
|
self.assertEqual(result.cdsl["features"][-1]["params"], {
|
|
"source_feature_ids": ["f_F1"],
|
|
"transform": {"type": "translation", "translation_mm": [0.0, 0.0, 0.0]},
|
|
"make_copy": True,
|
|
})
|
|
|
|
from engine.cdsl_engine.runtime import rebuild_cdsl
|
|
with tempfile.TemporaryDirectory() as directory:
|
|
rebuilt = rebuild_cdsl(result.cdsl, Path(directory) / "identity-copy.step")
|
|
self.assertEqual([item["feature_id"] for item in rebuilt["feature_results"]], ["f_F1", "f_F2"])
|
|
self.assertEqual(rebuilt["solid_count"], 2)
|
|
self.assertTrue(any(item["operation"] == "translation" for item in rebuilt["topology_deltas"]))
|
|
|
|
def test_identity_copy_transform_preserves_direct_source_provenance(self):
|
|
root = Path(__file__).parents[2] / "data/cadfs-sample/CADFS_test"
|
|
cases = {
|
|
"00548763": {"f_F2": "f_F1"},
|
|
"00853763": {"f_F6": "f_F5"},
|
|
# F3 is the exact single-body successor of F1 after a regular
|
|
# additive fusion. COPY must reference that live member rather
|
|
# than resurrecting F1's consumed runtime body key.
|
|
"00981258": {"f_F4": "f_F3", "f_F11": "f_F10"},
|
|
}
|
|
for sample_id, expected_sources in cases.items():
|
|
with self.subTest(sample_id=sample_id):
|
|
feature = root / "featurescript_rp" / sample_id[:4] / f"{sample_id}.txt"
|
|
if not feature.exists():
|
|
self.skipTest("CADFS sample is not installed")
|
|
result = lower_model(parse_featurescript(feature.read_text(), sample_id), {})
|
|
transforms = {item["id"]: item for item in result.cdsl["features"] if item["atomic_id"] == "transform_bodies"}
|
|
self.assertFalse(any(
|
|
item.get("feature_id") in {feature_id[2:] for feature_id in expected_sources}
|
|
and str(item.get("capability") or "").startswith("transform")
|
|
for item in result.diagnostics
|
|
))
|
|
for feature_id, source_feature_id in expected_sources.items():
|
|
self.assertEqual(transforms[feature_id]["params"], {
|
|
"source_feature_ids": [source_feature_id],
|
|
"transform": {"type": "translation", "translation_mm": [0.0, 0.0, 0.0]},
|
|
"make_copy": True,
|
|
})
|
|
|
|
def test_transform_lowers_one_proven_mirror_copy_member(self):
|
|
root = Path(__file__).parents[2] / "data/cadfs-sample/CADFS_test"
|
|
cases = {
|
|
"00120430": {"f_F5": {"pattern_feature_id": "f_F4", "source_feature_id": "f_F1", "instance_index": 1}},
|
|
"00749755": {"f_F4": {"pattern_feature_id": "f_F3", "source_feature_id": "f_F1", "instance_index": 1}},
|
|
}
|
|
for sample_id, expected in cases.items():
|
|
with self.subTest(sample_id=sample_id):
|
|
feature = root / "featurescript_rp" / sample_id[:4] / f"{sample_id}.txt"
|
|
if not feature.exists():
|
|
self.skipTest("CADFS sample is not installed")
|
|
result = lower_model(parse_featurescript(feature.read_text(), sample_id), {})
|
|
transforms = {item["id"]: item for item in result.cdsl["features"] if item["atomic_id"] == "transform_bodies"}
|
|
for feature_id, reference in expected.items():
|
|
self.assertEqual(transforms[feature_id]["params"]["pattern_instance_refs"], [reference])
|
|
self.assertFalse(any(
|
|
item.get("feature_id") in {feature_id[2:] for feature_id in expected}
|
|
and item.get("capability") == "transform_pattern_copy"
|
|
for item in result.diagnostics
|
|
))
|
|
|
|
def test_transform_lowers_source_qualified_multi_source_copy_members(self):
|
|
root = Path(__file__).parents[2] / "data/cadfs-sample/CADFS_test"
|
|
feature = root / "featurescript_rp/0069/00699847.txt"
|
|
if not feature.exists():
|
|
self.skipTest("CADFS sample is not installed")
|
|
|
|
result = lower_model(parse_featurescript(feature.read_text(), "00699847"), {})
|
|
self.assertEqual(result.status, "converted_complete")
|
|
self.assertFalse(result.diagnostics)
|
|
transforms = {item["id"]: item for item in result.cdsl["features"] if item["atomic_id"] == "transform_bodies"}
|
|
self.assertEqual(transforms["f_F3"]["params"]["source_feature_ids"], ["f_F1", "f_F2"])
|
|
self.assertEqual(transforms["f_F4"]["params"]["transform_copy_refs"], [
|
|
{"transform_feature_id": "f_F3", "source_feature_id": "f_F1"},
|
|
{"transform_feature_id": "f_F3", "source_feature_id": "f_F2"},
|
|
])
|
|
self.assertEqual(transforms["f_F4"]["depends_on"], ["f_F1", "f_F2", "f_F3"])
|
|
|
|
def test_uniform_scale_lowers_to_a_non_rigid_body_transform(self):
|
|
source = TRANSFORM_SOURCE.replace(
|
|
'"transformType":TransformType.TRANSLATION_3D, "dx":10 * mm, "dy":0 * mm, "dz":0 * mm, "makeCopy":false',
|
|
'"transformType":TransformType.SCALE_UNIFORMLY, "scale":0.5, '
|
|
'"scalePoint":qCreatedBy(makeId("Origin.pointOp"), VERTEX), "makeCopy":false',
|
|
)
|
|
result = lower_model(parse_featurescript(source, "uniform-scale"), {})
|
|
self.assertEqual(result.status, "converted_complete")
|
|
self.assertFalse(result.diagnostics)
|
|
transform = result.cdsl["features"][-1]
|
|
self.assertEqual(transform["atomic_id"], "transform_bodies")
|
|
self.assertEqual(transform["params"], {
|
|
"source_feature_ids": ["f_F1"],
|
|
"transform": {"type": "uniform_scale", "center_mm": [0.0, 0.0, 0.0], "scale_factor": 0.5},
|
|
"make_copy": False,
|
|
})
|
|
|
|
from engine.cdsl_engine.runtime import rebuild_cdsl
|
|
with tempfile.TemporaryDirectory() as directory:
|
|
rebuilt = rebuild_cdsl(result.cdsl, Path(directory) / "uniform-scale.step")
|
|
self.assertEqual(rebuilt["solid_count"], 1)
|
|
self.assertAlmostEqual(rebuilt["volume_mm3"], math.pi * 9.53 ** 2 * 120 / 8)
|
|
self.assertEqual(rebuilt["bbox_mm"], {"min": [-4.765, -4.765, 0.0], "max": [4.765, 4.765, 60.0]})
|
|
self.assertTrue(any(item["operation"] == "uniform_scale" for item in rebuilt["topology_deltas"]))
|
|
|
|
def test_uniform_scale_resolves_direct_circle_center_and_rejects_invalid_centers(self):
|
|
source = TRANSFORM_SOURCE.replace(
|
|
'"center":v(0, 0) * mm, "radius":9.53 * mm',
|
|
'"center":v(10, 0) * mm, "radius":9.53 * mm',
|
|
).replace(
|
|
'"transformType":TransformType.TRANSLATION_3D, "dx":10 * mm, "dy":0 * mm, "dz":0 * mm, "makeCopy":false',
|
|
'"transformType":TransformType.SCALE_UNIFORMLY, "scale":0.5, '
|
|
'"scalePoint":sQuery(id + "F0.wireOp", VERTEX, "E0.center"), "makeCopy":false',
|
|
)
|
|
result = lower_model(parse_featurescript(source, "uniform-scale-circle-center"), {})
|
|
self.assertEqual(result.status, "converted_complete")
|
|
self.assertEqual(result.cdsl["features"][-1]["params"]["transform"], {
|
|
"type": "uniform_scale", "center_mm": [10.0, 0.0, 0.0], "scale_factor": 0.5,
|
|
})
|
|
|
|
zero_factor = lower_model(parse_featurescript(source.replace('"scale":0.5', '"scale":0'), "uniform-scale-zero"), {})
|
|
self.assertEqual(zero_factor.status, "converted_partial")
|
|
self.assertEqual(zero_factor.diagnostics[-1]["capability"], "transform_uniform_scale")
|
|
|
|
unresolved_center = lower_model(parse_featurescript(source.replace(
|
|
'sQuery(id + "F0.wireOp", VERTEX, "E0.center")',
|
|
'qCreatedBy(id + "F1", VERTEX)',
|
|
), "uniform-scale-unresolved-center"), {})
|
|
self.assertEqual(unresolved_center.status, "converted_partial")
|
|
self.assertEqual(unresolved_center.diagnostics[-1]["capability"], "transform_uniform_scale_center")
|
|
|
|
def test_non_copy_uniform_scale_preserves_a_later_source_owner_alias(self):
|
|
root = Path(__file__).parents[2] / "data/cadfs-sample/CADFS_test"
|
|
feature = root / "featurescript_rp/0041/00417936.txt"
|
|
if not feature.exists(): self.skipTest("CADFS sample is not installed")
|
|
result = lower_model(parse_featurescript(feature.read_text(), "00417936"), {})
|
|
self.assertEqual(result.status, "converted_complete")
|
|
transforms = [item for item in result.cdsl["features"] if item["atomic_id"] == "transform_bodies"]
|
|
self.assertEqual([item["params"]["source_feature_ids"] for item in transforms], [["f_F1"], ["f_F2"]])
|
|
self.assertEqual([item["params"]["transform"]["scale_factor"] for item in transforms], [10.0, 1.5])
|
|
|
|
from engine.cdsl_engine.runtime import rebuild_cdsl
|
|
with tempfile.TemporaryDirectory() as directory:
|
|
rebuilt = rebuild_cdsl(result.cdsl, Path(directory) / "sequential-uniform-scale.step")
|
|
self.assertEqual(rebuilt["solid_count"], 1)
|
|
self.assertEqual([item["feature_id"] for item in rebuilt["feature_results"]], ["f_F1", "f_F2", "f_F3"])
|
|
self.assertEqual(
|
|
[item["operation"] for item in rebuilt["topology_deltas"]],
|
|
["extrude", "uniform_scale", "uniform_scale"],
|
|
)
|
|
|
|
def test_single_body_successor_aliases_clear_at_body_graph_boundaries(self):
|
|
for boundary in (
|
|
{"id": "f_copy", "atomic_id": "transform_bodies", "params": {"make_copy": True}},
|
|
{"id": "f_boolean", "atomic_id": "boolean_bodies", "params": {}},
|
|
{"id": "f_pattern", "atomic_id": "pattern_circular", "params": {}},
|
|
{"id": "f_delete", "atomic_id": "delete_bodies", "params": {}},
|
|
):
|
|
with self.subTest(boundary=boundary["atomic_id"]):
|
|
aliases = {}
|
|
state = {"owner": None, "sources": set()}
|
|
_record_single_body_successor(aliases, state, {
|
|
"id": "f_base", "atomic_id": "extrude_add_blind",
|
|
"params": {"result_mode": "new_body"},
|
|
})
|
|
_record_single_body_successor(aliases, state, {
|
|
"id": "f_add", "atomic_id": "extrude_add_blind", "params": {},
|
|
})
|
|
self.assertEqual(aliases, {"f_base": "f_add"})
|
|
|
|
_record_single_body_successor(aliases, state, boundary)
|
|
self.assertEqual(aliases, {})
|
|
self.assertIsNone(state["owner"])
|
|
self.assertEqual(state["sources"], set())
|
|
|
|
def test_shell_parts_lowers_to_a_live_member_or_proven_sole_body_alias(self):
|
|
root = Path(__file__).parents[2] / "data/cadfs-sample/CADFS_test"
|
|
|
|
successor = root / "featurescript_rp/0010/00107631.txt"
|
|
result = lower_model(parse_featurescript(successor.read_text(), "00107631"), {})
|
|
shell = next(feature for feature in result.cdsl["features"] if feature["id"] == "f_F3")
|
|
self.assertEqual(shell["params"]["target_feature_id"], "f_F2")
|
|
self.assertFalse(any(
|
|
diagnostic.get("capability") == "shell_parts_body_source"
|
|
for diagnostic in result.diagnostics
|
|
))
|
|
|
|
patterned = root / "featurescript_rp/0054/00542223.txt"
|
|
result = lower_model(parse_featurescript(patterned.read_text(), "00542223"), {})
|
|
shell = next(feature for feature in result.cdsl["features"] if feature["id"] == "f_F7")
|
|
self.assertEqual(shell["params"]["target_feature_id"], "f_F5")
|
|
self.assertFalse(any(
|
|
diagnostic.get("capability") == "shell_parts_body_source"
|
|
for diagnostic in result.diagnostics
|
|
))
|
|
|
|
def test_translation_distance_lowers_from_a_linear_sketch_direction(self):
|
|
source = TRANSFORM_SOURCE.replace(
|
|
'skCircle(sketch, "E0", {"center":v(0, 0) * mm, "radius":9.53 * mm}); skSolve(sketch);',
|
|
'skCircle(sketch, "E0", {"center":v(0, 0) * mm, "radius":9.53 * mm}); '
|
|
'skLineSegment(sketch, "E1", {"start":v(0, 0) * mm, "end":v(1, 0) * mm, "construction":true}); skSolve(sketch);',
|
|
).replace(
|
|
'"transformType":TransformType.TRANSLATION_3D, "dx":10 * mm, "dy":0 * mm, "dz":0 * mm, "makeCopy":false',
|
|
'"transformType":TransformType.TRANSLATION_DISTANCE, "transformDirection":sQuery(id + "F0.wireOp", EDGE, "E1"), '
|
|
'"distance":10 * mm, "oppositeDirection":true, "makeCopy":false',
|
|
)
|
|
moved = lower_model(parse_featurescript(source, "distance-move"), {})
|
|
self.assertEqual(moved.status, "converted_complete")
|
|
self.assertFalse(moved.diagnostics)
|
|
self.assertEqual(moved.cdsl["geometry"]["sketches"][0]["workplane"]["origin_mm"], [-10.0, 0.0, 0.0])
|
|
|
|
datum_plane = TRANSFORM_SOURCE.replace(
|
|
'"transformType":TransformType.TRANSLATION_3D, "dx":10 * mm, "dy":0 * mm, "dz":0 * mm, "makeCopy":false',
|
|
'"transformType":TransformType.TRANSLATION_DISTANCE, '
|
|
'"transformDirection":qCreatedBy(makeId("Front.planeOp"), FACE), '
|
|
'"distance":10 * mm, "makeCopy":true',
|
|
)
|
|
datum_result = lower_model(parse_featurescript(datum_plane, "distance-datum-plane"), {})
|
|
self.assertEqual(datum_result.status, "converted_complete")
|
|
self.assertEqual(datum_result.cdsl["features"][-1]["params"], {
|
|
"source_feature_ids": ["f_F1"],
|
|
"transform": {"type": "translation", "translation_mm": [0.0, -10.0, 0.0]},
|
|
"make_copy": True,
|
|
})
|
|
|
|
square = (
|
|
'skLineSegment(sketch, "E0", {"start":v(0, 0) * mm, "end":v(10, 0) * mm}); '
|
|
'skLineSegment(sketch, "E1", {"start":v(10, 0) * mm, "end":v(10, 10) * mm}); '
|
|
'skLineSegment(sketch, "E2", {"start":v(10, 10) * mm, "end":v(0, 10) * mm}); '
|
|
'skLineSegment(sketch, "E3", {"start":v(0, 10) * mm, "end":v(0, 0) * mm}); skSolve(sketch);'
|
|
)
|
|
swept_face = TRANSFORM_SOURCE.replace(
|
|
'skCircle(sketch, "E0", {"center":v(0, 0) * mm, "radius":9.53 * mm}); skSolve(sketch);', square,
|
|
).replace(
|
|
'"transformType":TransformType.TRANSLATION_3D, "dx":10 * mm, "dy":0 * mm, "dz":0 * mm, "makeCopy":false',
|
|
'"transformType":TransformType.TRANSLATION_DISTANCE, '
|
|
'"transformDirection":makeQuery(id + "F1.opExtrude", "SWEPT_FACE", FACE, '
|
|
'{"derivedFrom":sQuery(id + "F0.wireOp", EDGE, "E0")}), '
|
|
'"distance":10 * mm, "makeCopy":true',
|
|
)
|
|
swept_result = lower_model(parse_featurescript(swept_face, "distance-swept-face"), {})
|
|
self.assertEqual(swept_result.status, "converted_complete")
|
|
self.assertEqual(swept_result.cdsl["features"][-1]["params"], {
|
|
"source_feature_ids": ["f_F1"],
|
|
"transform": {"type": "translation", "translation_mm": [0.0, -10.0, 0.0]},
|
|
"make_copy": True,
|
|
})
|
|
|
|
copied = lower_model(parse_featurescript(source.replace('"makeCopy":false', '"makeCopy":true'), "distance-copy"), {})
|
|
self.assertEqual(copied.status, "converted_complete")
|
|
self.assertFalse(copied.diagnostics)
|
|
self.assertEqual(copied.cdsl["features"][-1]["params"], {
|
|
"source_feature_ids": ["f_F1"],
|
|
"transform": {"type": "translation", "translation_mm": [-10.0, 0.0, 0.0]},
|
|
"make_copy": True,
|
|
})
|
|
|
|
from engine.cdsl_engine.runtime import rebuild_cdsl
|
|
with tempfile.TemporaryDirectory() as directory:
|
|
rebuilt = rebuild_cdsl(copied.cdsl, Path(directory) / "distance-copy.step")
|
|
self.assertEqual(rebuilt["solid_count"], 2)
|
|
self.assertEqual(rebuilt["bbox_mm"]["min"], [-19.53, -9.53, 0.0])
|
|
self.assertEqual(rebuilt["bbox_mm"]["max"], [9.53, 9.53, 120.0])
|
|
|
|
def test_translation_distance_cap_edge_uses_its_physical_frame(self):
|
|
root = Path(__file__).parents[2] / "data/cadfs-sample/CADFS_test"
|
|
feature = root / "featurescript_rp/0066/00665176.txt"
|
|
if not feature.exists(): self.skipTest("CADFS sample is not installed")
|
|
result = lower_model(parse_featurescript(feature.read_text(), "00665176"), {})
|
|
transforms = {item["id"]: item for item in result.cdsl["features"] if item["atomic_id"] == "transform_bodies"}
|
|
self.assertEqual(transforms["f_F2"]["params"]["transform"], {"type": "translation", "translation_mm": [0.0, 0.0, 381.0]})
|
|
self.assertEqual(transforms["f_F3"]["params"]["transform"], {"type": "translation", "translation_mm": [127.0, 0.0, 0.0]})
|
|
self.assertEqual(transforms["f_F4"]["params"]["transform"], {"type": "translation", "translation_mm": [-127.0, 0.0, 0.0]})
|
|
self.assertNotIn("F2", [item.get("feature_id") for item in result.diagnostics])
|
|
self.assertNotIn("F3", [item.get("feature_id") for item in result.diagnostics])
|
|
self.assertNotIn("F4", [item.get("feature_id") for item in result.diagnostics])
|
|
|
|
def test_translation_distance_cap_face_uses_its_physical_normal(self):
|
|
source = TRANSFORM_SOURCE.replace(
|
|
'"transformType":TransformType.TRANSLATION_3D, "dx":10 * mm, "dy":0 * mm, "dz":0 * mm, "makeCopy":false',
|
|
'"transformType":TransformType.TRANSLATION_DISTANCE, '
|
|
'"transformDirection":makeQuery(id + "F1.opExtrude", "CAP_FACE", FACE, '
|
|
'{"derivedFrom":sQuery(id + "F0.wireOp", EDGE, "E0"), "isStart":false}), '
|
|
'"distance":10 * mm, "makeCopy":true',
|
|
)
|
|
result = lower_model(parse_featurescript(source, "distance-cap-face"), {})
|
|
self.assertEqual(result.status, "converted_complete")
|
|
self.assertFalse(result.diagnostics)
|
|
self.assertEqual(result.cdsl["features"][-1]["params"], {
|
|
"source_feature_ids": ["f_F1"],
|
|
"transform": {"type": "translation", "translation_mm": [0.0, 0.0, 10.0]},
|
|
"make_copy": True,
|
|
})
|
|
|
|
root = Path(__file__).parents[2] / "data/cadfs-sample/CADFS_test"
|
|
feature = root / "featurescript_rp/0007/00078650.txt"
|
|
if not feature.exists(): self.skipTest("CADFS sample is not installed")
|
|
real = lower_model(parse_featurescript(feature.read_text(), "00078650"), {})
|
|
self.assertEqual(real.status, "converted_complete")
|
|
transform = next(item for item in real.cdsl["features"] if item["id"] == "f_F4")
|
|
self.assertEqual(transform["params"], {
|
|
"source_feature_ids": ["f_F1", "f_F2", "f_F3"],
|
|
"transform": {"type": "translation", "translation_mm": [0.0, -431.8, 0.0]},
|
|
"make_copy": True,
|
|
})
|
|
|
|
def test_translation_distance_rejects_a_curved_direction(self):
|
|
source = TRANSFORM_SOURCE.replace(
|
|
'"transformType":TransformType.TRANSLATION_3D, "dx":10 * mm, "dy":0 * mm, "dz":0 * mm, "makeCopy":false',
|
|
'"transformType":TransformType.TRANSLATION_DISTANCE, "transformDirection":sQuery(id + "F0.wireOp", EDGE, "E0"), '
|
|
'"distance":10 * mm, "makeCopy":false',
|
|
)
|
|
result = lower_model(parse_featurescript(source, "distance-curve"), {})
|
|
self.assertEqual(result.status, "converted_partial")
|
|
self.assertEqual(result.diagnostics[-1]["capability"], "transform_translation_direction")
|
|
|
|
cap_circle = lower_model(parse_featurescript(source.replace(
|
|
'sQuery(id + "F0.wireOp", EDGE, "E0")',
|
|
'makeQuery(id + "F1.opExtrude", "CAP_EDGE", EDGE, {"derivedFrom":sQuery(id + "F0.wireOp", EDGE, "E0"), "isStart":false})',
|
|
), "distance-cap-circle"), {})
|
|
self.assertEqual(cap_circle.status, "converted_partial")
|
|
self.assertEqual(cap_circle.diagnostics[-1]["capability"], "transform_translation_direction")
|
|
|
|
def test_translation_entity_lowers_direct_line_and_vertex_vectors(self):
|
|
sketch = (
|
|
'skCircle(sketch, "E0", {"center":v(0, 0) * mm, "radius":9.53 * mm}); '
|
|
'skLineSegment(sketch, "E1", {"start":v(0, 0) * mm, "end":v(2, 0) * mm, "construction":true}); '
|
|
'skPoint(sketch, "E2", {"position":v(0, 0) * mm}); '
|
|
'skPoint(sketch, "E3", {"position":v(0, 5) * mm}); skSolve(sketch);'
|
|
)
|
|
line_source = TRANSFORM_SOURCE.replace(
|
|
'skCircle(sketch, "E0", {"center":v(0, 0) * mm, "radius":9.53 * mm}); skSolve(sketch);', sketch,
|
|
).replace(
|
|
'"transformType":TransformType.TRANSLATION_3D, "dx":10 * mm, "dy":0 * mm, "dz":0 * mm, "makeCopy":false',
|
|
'"transformType":TransformType.TRANSLATION_ENTITY, "transformLine":sQuery(id + "F0.wireOp", EDGE, "E1"), '
|
|
'"oppositeDirectionEntity":false, "makeCopy":true',
|
|
)
|
|
copied = lower_model(parse_featurescript(line_source, "entity-line-copy"), {})
|
|
self.assertEqual(copied.status, "converted_complete")
|
|
self.assertEqual(copied.cdsl["features"][-1]["params"], {
|
|
"source_feature_ids": ["f_F1"],
|
|
"transform": {"type": "translation", "translation_mm": [2.0, 0.0, 0.0]},
|
|
"make_copy": True,
|
|
})
|
|
|
|
vertex_source = line_source.replace(
|
|
'"transformLine":sQuery(id + "F0.wireOp", EDGE, "E1"), "oppositeDirectionEntity":false, "makeCopy":true',
|
|
'"transformLine":qUnion([sQuery(id + "F0.wireOp", VERTEX, "E2"), sQuery(id + "F0.wireOp", VERTEX, "E3")]), '
|
|
'"oppositeDirectionEntity":false, "makeCopy":false',
|
|
)
|
|
moved = lower_model(parse_featurescript(vertex_source, "entity-vertices-move"), {})
|
|
self.assertEqual(moved.status, "converted_complete")
|
|
self.assertEqual(moved.cdsl["geometry"]["sketches"][0]["workplane"]["origin_mm"], [0.0, 5.0, 0.0])
|
|
|
|
curved = lower_model(parse_featurescript(line_source.replace('EDGE, "E1"', 'EDGE, "E0"'), "entity-curve"), {})
|
|
self.assertEqual(curved.status, "converted_partial")
|
|
self.assertEqual(curved.diagnostics[-1]["capability"], "transform_translation_entity")
|
|
|
|
cap_circle = lower_model(parse_featurescript(line_source.replace(
|
|
'sQuery(id + "F0.wireOp", EDGE, "E1")',
|
|
'makeQuery(id + "F1.opExtrude", "CAP_EDGE", EDGE, {"derivedFrom":sQuery(id + "F0.wireOp", EDGE, "E0"), "isStart":false})',
|
|
), "entity-cap-circle"), {})
|
|
self.assertEqual(cap_circle.status, "converted_partial")
|
|
self.assertEqual(cap_circle.diagnostics[-1]["capability"], "transform_translation_entity")
|
|
|
|
def test_translation_entity_real_line_cap_and_body_lifecycle_boundaries(self):
|
|
root = Path(__file__).parents[2] / "data/cadfs-sample/CADFS_test"
|
|
direct = root / "featurescript_rp/0012/00122249.txt"
|
|
cap_edge = root / "featurescript_rp/0018/00184423.txt"
|
|
absorbed = root / "featurescript_rp/0022/00226751.txt"
|
|
if not all(path.exists() for path in (direct, cap_edge, absorbed)):
|
|
self.skipTest("CADFS samples are not installed")
|
|
|
|
direct_result = lower_model(parse_featurescript(direct.read_text(), "00122249"), {})
|
|
self.assertEqual(direct_result.status, "converted_complete")
|
|
moved_sketch = next(item for item in direct_result.cdsl["geometry"]["sketches"] if item["id"] == "sketch_F1__f_F2")
|
|
self.assertEqual(moved_sketch["workplane"]["origin_mm"], [-7.0, 0.0, 0.0])
|
|
|
|
cap_result = lower_model(parse_featurescript(cap_edge.read_text(), "00184423"), {})
|
|
transform = next(item for item in cap_result.cdsl["features"] if item["id"] == "f_F2")
|
|
self.assertEqual(transform["params"]["transform"], {"type": "translation", "translation_mm": [12.7, 0.0, 0.0]})
|
|
self.assertEqual(cap_result.status, "converted_complete")
|
|
self.assertFalse(cap_result.diagnostics)
|
|
transforms = {item["id"]: item for item in cap_result.cdsl["features"] if item["atomic_id"] == "transform_bodies"}
|
|
self.assertEqual(
|
|
{feature_id: item["params"]["source_feature_ids"] for feature_id, item in transforms.items()},
|
|
{"f_F2": ["f_F1"], "f_F3": ["f_F2"], "f_F4": ["f_F3"], "f_F5": ["f_F4"], "f_F6": ["f_F4"]},
|
|
)
|
|
self.assertEqual(transforms["f_F5"]["params"]["transform"]["type"], "translation")
|
|
for actual, expected in zip(transforms["f_F5"]["params"]["transform"]["translation_mm"], [0.0, -12.7, 0.0]):
|
|
self.assertAlmostEqual(actual, expected)
|
|
from engine.cdsl_engine.runtime import rebuild_cdsl
|
|
with tempfile.TemporaryDirectory() as directory:
|
|
rebuilt = rebuild_cdsl(cap_result.cdsl, Path(directory) / "transform-copy-chain.step")
|
|
self.assertEqual(rebuilt["solid_count"], 6)
|
|
self.assertEqual([item["feature_id"] for item in rebuilt["feature_results"]], [
|
|
"f_F1", "f_F2", "f_F3", "f_F4", "f_F5", "f_F6",
|
|
])
|
|
self.assertFalse(rebuilt["runtime_diagnostics"])
|
|
|
|
absorbed_result = lower_model(parse_featurescript(absorbed.read_text(), "00226751"), {})
|
|
self.assertEqual(absorbed_result.diagnostics[-1]["capability"], "transform_body_lifecycle")
|
|
|
|
def test_direct_swept_body_delete_lowers_to_a_body_graph_operation(self):
|
|
source = SOURCE.replace(
|
|
'\n});\n',
|
|
'''
|
|
{ var Q0; Q0=makeQuery(id + "F1.opExtrude", "SWEPT_BODY", BODY, {});
|
|
deleteBodies(context, id + "F2", {"entities":qUnion([Q0])}); }
|
|
});
|
|
''',
|
|
)
|
|
result = lower_model(parse_featurescript(source, "delete-body"), {})
|
|
self.assertEqual(result.status, "converted_complete")
|
|
delete = result.cdsl["features"][-1]
|
|
self.assertEqual(delete["atomic_id"], "delete_bodies")
|
|
self.assertEqual(delete["params"], {"target_feature_ids": ["f_F1"]})
|
|
|
|
def test_symmetric_cut_lowers_to_two_sided_cut(self):
|
|
source = SOURCE.replace('"depth":120 * mm', '"operationType":NewBodyOperationType.REMOVE, "depth":120 * mm, "symmetric":true')
|
|
result = lower_model(parse_featurescript(source, "symmetric-cut"), {})
|
|
self.assertEqual(result.status, "converted_complete")
|
|
feature = result.cdsl["features"][0]
|
|
self.assertEqual(feature["atomic_id"], "extrude_cut_two_sided")
|
|
self.assertEqual(feature["params"]["distance_mm"], 60.0)
|
|
self.assertEqual(feature["params"]["reverse_distance_mm"], 60.0)
|
|
|
|
def test_through_all_extrudes_reuse_the_engine_extent_contract(self):
|
|
for operation_type, expected_atomic in [
|
|
("NewBodyOperationType.NEW", "extrude_add_blind"),
|
|
("NewBodyOperationType.REMOVE", "extrude_cut_blind"),
|
|
]:
|
|
with self.subTest(operation_type=operation_type):
|
|
source = SOURCE.replace(
|
|
'"depth":120 * mm',
|
|
f'"operationType":{operation_type}, "depth":120 * mm, "endBound":BoundingType.THROUGH_ALL',
|
|
)
|
|
result = lower_model(parse_featurescript(source, f"through-all-{operation_type}"), {})
|
|
self.assertEqual(result.status, "converted_complete")
|
|
feature = result.cdsl["features"][0]
|
|
self.assertEqual(feature["atomic_id"], expected_atomic)
|
|
self.assertEqual(feature["params"]["end_condition"]["type"], "through_all")
|
|
|
|
def test_up_to_next_extrudes_reuse_the_engine_extent_contract(self):
|
|
for operation_type, expected_atomic in [
|
|
("NewBodyOperationType.NEW", "extrude_add_blind"),
|
|
("NewBodyOperationType.REMOVE", "extrude_cut_blind"),
|
|
]:
|
|
with self.subTest(operation_type=operation_type):
|
|
source = SOURCE.replace(
|
|
'"depth":120 * mm',
|
|
f'"operationType":{operation_type}, "depth":120 * mm, "endBound":BoundingType.UP_TO_NEXT',
|
|
)
|
|
result = lower_model(parse_featurescript(source, f"up-to-next-{operation_type}"), {})
|
|
self.assertEqual(result.status, "converted_complete")
|
|
feature = result.cdsl["features"][0]
|
|
self.assertEqual(feature["atomic_id"], expected_atomic)
|
|
self.assertEqual(feature["params"]["end_condition"]["type"], "through_next")
|
|
|
|
def test_implicit_extrude_after_a_body_uses_default_new_body_semantics(self):
|
|
source = SOURCE.replace(
|
|
'\n});\n',
|
|
'''
|
|
{ var Q0; Q0=qSketchRegion(id + "F0", true);
|
|
extrude(context, id + "F2", {"entities":qUnion([Q0]), "depth":20 * mm}); }
|
|
});
|
|
''',
|
|
)
|
|
result = lower_model(parse_featurescript(source, "implicit-add"), {})
|
|
first, second = result.cdsl["features"]
|
|
self.assertEqual(first["params"]["result_mode"], "new_body")
|
|
self.assertEqual(second["params"]["result_mode"], "new_body")
|
|
|
|
def test_up_to_body_extrude_captures_target_and_offset(self):
|
|
root = Path(__file__).parents[2] / "data/cadfs-sample/CADFS_test"
|
|
feature = root / "featurescript_rp/0069/00694309.txt"
|
|
if not feature.exists(): self.skipTest("CADFS sample is not installed")
|
|
result = lower_model(parse_featurescript(feature.read_text(), "00694309"), {})
|
|
self.assertEqual(result.status, "converted_complete")
|
|
extrude = next(item for item in result.cdsl["features"] if item["id"] == "f_F3")
|
|
end = extrude["params"]["end_condition"]
|
|
self.assertEqual(end["type"], "up_to_body")
|
|
self.assertEqual(end["offset_mm"], 3.0)
|
|
self.assertEqual(end["reference"]["kind"], "body")
|
|
self.assertEqual(end["reference"]["owner_feature_id"], "f_F1")
|
|
self.assertEqual(end["reference"]["source"], "runtime_snapshot")
|
|
self.assertNotIn("stable_id", end["reference"])
|
|
self.assertEqual(end["reference"]["selector_intent"]["query_family"], "SWEPT_BODY")
|
|
self.assertEqual(end["reference"]["selector_intent"]["evidence"], "active_body_member")
|
|
self.assertEqual(
|
|
end["reference"]["selector_intent"]["derivation_policy"],
|
|
{"allowed": ["boundary"], "multiplicity": "one"},
|
|
)
|
|
fillet = next(item for item in result.cdsl["features"] if item["id"] == "f_F4")
|
|
self.assertEqual(len(fillet["selectors"]), 1)
|
|
self.assertEqual(fillet["selectors"][0]["selector_intent"]["query_family"], "CAP_EDGE")
|
|
self.assertEqual(
|
|
fillet["selectors"][0]["selector_intent"]["derivation_policy"],
|
|
{"allowed": ["boundary", "continuation"], "multiplicity": "one"},
|
|
)
|
|
from engine.cdsl_engine.semantic_validation import validate_semantic_cdsl
|
|
|
|
mixed_evidence = deepcopy(result.cdsl)
|
|
mixed_reference = next(
|
|
item for item in mixed_evidence["features"] if item["id"] == "f_F3"
|
|
)["params"]["end_condition"]["reference"]
|
|
mixed_reference["stable_id"] = "body:f_F1"
|
|
with self.assertRaisesRegex(ValueError, "invalid SWEPT_BODY member contract"):
|
|
validate_semantic_cdsl(mixed_evidence)
|
|
|
|
def test_up_to_surface_extrude_captures_the_cap_face(self):
|
|
root = Path(__file__).parents[2] / "data/cadfs-sample/CADFS_test"
|
|
feature = root / "featurescript_rp/0092/00925274.txt"
|
|
if not feature.exists(): self.skipTest("CADFS sample is not installed")
|
|
result = lower_model(parse_featurescript(feature.read_text(), "00925274"), {})
|
|
extrude = next(item for item in result.cdsl["features"] if item["id"] == "f_F3")
|
|
end = extrude["params"]["end_condition"]
|
|
self.assertEqual(end["type"], "up_to_surface")
|
|
self.assertEqual(end["reference"]["kind"], "face")
|
|
self.assertEqual(end["reference"]["owner_feature_id"], "f_F1")
|
|
self.assertEqual(end["reference"]["output_role"], "extrude.start")
|
|
self.assertEqual(end["reference"]["source"], "runtime_snapshot")
|
|
self.assertNotIn("geometry", end["reference"])
|
|
self.assertEqual(end["reference"]["selector_intent"]["query_family"], "CAP_FACE")
|
|
self.assertEqual(end["reference"]["selector_intent"]["evidence"], "operation_role")
|
|
swept = next(item for item in result.cdsl["features"] if item["id"] == "f_F6")
|
|
swept_reference = swept["params"]["end_condition"]["reference"]
|
|
self.assertEqual(swept_reference["selector_intent"]["query_family"], "SWEPT_FACE")
|
|
self.assertEqual(
|
|
swept_reference["selector_intent"]["derivation_policy"],
|
|
{"allowed": ["boundary", "continuation"], "multiplicity": "one"},
|
|
)
|
|
self.assertEqual(swept_reference["selector_intent"]["evidence"], "kernel_history")
|
|
self.assertEqual(swept_reference["selector_intent"]["source_entity"], {"sketch_id": "F0", "entity_id": "E0"})
|
|
self.assertEqual(swept_reference["source"], "runtime_snapshot")
|
|
self.assertNotIn("stable_id", swept_reference)
|
|
self.assertNotIn("binding_feature_id", swept_reference)
|
|
self.assertNotIn("geometry", swept_reference)
|
|
mirror = next(item for item in result.cdsl["features"] if item["id"] == "f_F18")
|
|
self.assertTrue(mirror["params"]["mirror_current_body"])
|
|
|
|
def test_mirrored_copy_cap_face_uses_the_mirrored_loft_frame(self):
|
|
root = Path(__file__).parents[2] / "data/cadfs-sample/CADFS_test"
|
|
feature = root / "featurescript_rp/0061/00612529.txt"
|
|
if not feature.exists(): self.skipTest("CADFS sample is not installed")
|
|
|
|
result = lower_model(parse_featurescript(feature.read_text(), "00612529"), {})
|
|
sketch = next(item for item in result.cdsl["geometry"]["sketches"] if item["id"] == "sketch_F6")
|
|
plane = sketch["workplane"]
|
|
|
|
self.assertEqual(plane["origin_mm"], [0.0, 50.0, 0.0])
|
|
self.assertEqual(plane["normal"], [0.0, 1.0, 0.0])
|
|
self.assertEqual(plane["x_dir"], [-1.0, 0.0, 0.0])
|
|
|
|
spline = sketch["profile"]["contours"][0]["segments"][0]
|
|
first = spline["points"][0]
|
|
self.assertEqual([
|
|
plane["origin_mm"][index]
|
|
+ plane["x_dir"][index] * first[0]
|
|
+ (plane["normal"][(index + 1) % 3] * plane["x_dir"][(index + 2) % 3]
|
|
- plane["normal"][(index + 2) % 3] * plane["x_dir"][(index + 1) % 3]) * first[1]
|
|
for index in range(3)
|
|
], [-60.68, 50.0, 66.22])
|
|
|
|
def test_line_angle_opposite_direction_preserves_the_sketch_side(self):
|
|
root = Path(__file__).parents[2] / "data/cadfs-sample/CADFS_test"
|
|
feature = root / "featurescript_rp/0092/00925274.txt"
|
|
if not feature.exists(): self.skipTest("CADFS sample is not installed")
|
|
result = lower_model(parse_featurescript(feature.read_text(), "00925274"), {})
|
|
sketch = next(item for item in result.cdsl["geometry"]["sketches"] if item["id"] == "sketch_F8")
|
|
plane = sketch["workplane"]
|
|
y_dir = [
|
|
plane["normal"][1] * plane["x_dir"][2] - plane["normal"][2] * plane["x_dir"][1],
|
|
plane["normal"][2] * plane["x_dir"][0] - plane["normal"][0] * plane["x_dir"][2],
|
|
plane["normal"][0] * plane["x_dir"][1] - plane["normal"][1] * plane["x_dir"][0],
|
|
]
|
|
center = sketch["profile"]["center"]
|
|
self.assertAlmostEqual(plane["origin_mm"][2] + y_dir[2] * center[1], 25.0)
|
|
|
|
def test_line_angle_cylinder_reference_uses_the_surface_generatrix(self):
|
|
root = Path(__file__).parents[2] / "data/cadfs-sample/CADFS_test"
|
|
feature = root / "featurescript_rp/0092/00925274.txt"
|
|
if not feature.exists(): self.skipTest("CADFS sample is not installed")
|
|
result = lower_model(parse_featurescript(feature.read_text(), "00925274"), {})
|
|
sketch = next(item for item in result.cdsl["geometry"]["sketches"] if item["id"] == "sketch_F5")
|
|
plane = sketch["workplane"]
|
|
self.assertAlmostEqual(plane["normal"][0], -0.5)
|
|
self.assertAlmostEqual(plane["normal"][1], -math.sqrt(3) / 2)
|
|
self.assertAlmostEqual(plane["origin_mm"][0], -12.15)
|
|
self.assertAlmostEqual(plane["origin_mm"][1], -24.3 * math.sqrt(3) / 2)
|
|
|
|
def test_line_angle_direct_circle_uses_the_featurescript_circle_axis(self):
|
|
root = Path(__file__).parents[2] / "data/cadfs-sample/CADFS_test"
|
|
feature = root / "featurescript_rp/0003/00030209.txt"
|
|
if not feature.exists(): self.skipTest("CADFS sample is not installed")
|
|
result = lower_model(parse_featurescript(feature.read_text(), "00030209"), {})
|
|
self.assertEqual(result.status, "converted_partial")
|
|
planes = {
|
|
item["id"]: item["params"]["plane"]
|
|
for item in result.cdsl["features"]
|
|
if item["atomic_id"] == "reference_plane"
|
|
}
|
|
expected_centers = {
|
|
"f_F1": [45.78, 0.0, 26.2],
|
|
"f_F2": [13.9, 0.0, 26.5],
|
|
"f_F4": [-17.08, 0.0, 23.46],
|
|
"f_F5": [-44.4, 0.0, 19.8],
|
|
}
|
|
self.assertEqual(set(planes), set(expected_centers))
|
|
for feature_id, center in expected_centers.items():
|
|
with self.subTest(feature_id=feature_id):
|
|
plane = planes[feature_id]
|
|
self.assertEqual(plane["origin_mm"], center)
|
|
self.assertEqual(plane["x_dir"], [0.0, -1.0, 0.0])
|
|
self.assertAlmostEqual(plane["normal"][0], 1.0)
|
|
self.assertAlmostEqual(plane["normal"][1], 0.0)
|
|
self.assertAlmostEqual(plane["normal"][2], 0.0)
|
|
self.assertFalse(any(
|
|
diagnostic.get("operation") == "cPlane"
|
|
for diagnostic in result.diagnostics
|
|
))
|
|
|
|
opposite_source = feature.read_text().replace(
|
|
'"angle" : 90 * degree, "width"',
|
|
'"angle" : 90 * degree, "oppositeDirection" : true, "width"',
|
|
1,
|
|
)
|
|
opposite = lower_model(parse_featurescript(opposite_source, "line-angle-circle-opposite"), {})
|
|
opposite_plane = next(
|
|
item for item in opposite.cdsl["features"] if item["id"] == "f_F1"
|
|
)["params"]["plane"]
|
|
self.assertAlmostEqual(opposite_plane["normal"][0], -1.0)
|
|
self.assertAlmostEqual(opposite_plane["normal"][1], 0.0)
|
|
self.assertAlmostEqual(opposite_plane["normal"][2], 0.0)
|
|
|
|
def test_line_angle_two_entities_follow_axis_plane_order_and_swap_rules(self):
|
|
root = Path(__file__).parents[2] / "data/cadfs-sample/CADFS_test"
|
|
cases = {
|
|
# F8 selects Right plane first, then the direct F7 line. The
|
|
# standard library must swap them before calculating the frame.
|
|
"00298026": ("f_F8", [0.0, -1.0, 0.0], [0.43837114678907757, 0.0, -0.898794046299167]),
|
|
# F1 supplies the direct line first and the default plane second.
|
|
"00586156": ("f_F1", [0.0, 0.0, 1.0], [-math.sqrt(0.5), -math.sqrt(0.5), 0.0]),
|
|
}
|
|
for sample_id, (feature_id, expected_x, expected_normal) in cases.items():
|
|
with self.subTest(sample_id=sample_id):
|
|
source = root / "featurescript_rp" / sample_id[:4] / f"{sample_id}.txt"
|
|
result = lower_model(parse_featurescript(source.read_text(), sample_id), {})
|
|
plane = next(item for item in result.cdsl["features"] if item["id"] == feature_id)["params"]["plane"]
|
|
self.assertEqual(plane["x_dir"], expected_x)
|
|
for actual, expected in zip(plane["normal"], expected_normal):
|
|
self.assertAlmostEqual(actual, expected)
|
|
self.assertFalse(any(
|
|
diagnostic.get("operation") == "cPlane"
|
|
and diagnostic.get("feature_id") == feature_id.removeprefix("f_")
|
|
for diagnostic in result.diagnostics
|
|
))
|
|
|
|
def test_line_angle_two_direct_entities_cover_axis_point_and_degenerate_contracts(self):
|
|
result = lower_model(parse_featurescript(LINE_ANGLE_TWO_ENTITY_SOURCE, "line-angle-two-entities"), {})
|
|
self.assertEqual(result.status, "converted_partial")
|
|
planes = {
|
|
item["id"]: item["params"]["plane"]
|
|
for item in result.cdsl["features"]
|
|
if item["atomic_id"] == "reference_plane"
|
|
}
|
|
# Nonparallel axes, parallel offset axes, and an axis plus a direct
|
|
# point each use the exact source direction, rather than a sketch
|
|
# workplane frame.
|
|
for feature_id in ("f_F1", "f_F2", "f_F3"):
|
|
self.assertEqual(planes[feature_id]["x_dir"], [1.0, 0.0, 0.0])
|
|
self.assertEqual(planes[feature_id]["normal"], [0.0, 0.0, 1.0])
|
|
# A point selected before its axis triggers FeatureScript's swap. The
|
|
# signed angle also follows oppositeDirection.
|
|
self.assertEqual(planes["f_F4"]["x_dir"], [1.0, 0.0, 0.0])
|
|
self.assertAlmostEqual(planes["f_F4"]["normal"][0], 0.0)
|
|
self.assertAlmostEqual(planes["f_F4"]["normal"][1], 1.0)
|
|
self.assertAlmostEqual(planes["f_F4"]["normal"][2], 0.0)
|
|
# A cPlane output is represented as qCreatedBy(...planeOp, FACE),
|
|
# not a sketch source. It is accepted only because F1 is an existing
|
|
# reference-plane frame, and it supplies the true zero-angle side.
|
|
self.assertEqual(planes["f_F6"]["x_dir"], [1.0, 0.0, 0.0])
|
|
self.assertEqual(planes["f_F6"]["normal"], [0.0, 0.0, -1.0])
|
|
self.assertIn({
|
|
"code": "feature_deferred",
|
|
"feature_id": "F5",
|
|
"operation": "cPlane",
|
|
"message": "line-angle reference selection is degenerate",
|
|
}, result.diagnostics)
|
|
|
|
def test_line_angle_direct_axis_refuses_a_topology_derived_query(self):
|
|
direct = Call("sQuery", ["F0.wireOp", "EDGE", "E0"], 1)
|
|
derived = Call("makeQuery", [
|
|
"F1.opExtrude", "CAP_EDGE", "EDGE",
|
|
{"derivedFrom": direct, "isStart": False},
|
|
], 2)
|
|
sketch_by_source = {"F0": {"workplane": {
|
|
"origin_mm": [0.0, 0.0, 0.0], "x_dir": [1.0, 0.0, 0.0], "normal": [0.0, 0.0, 1.0],
|
|
}}}
|
|
entity_by_sketch = {"F0": {"E0": {
|
|
"type": "line", "start": [0.0, 0.0], "end": [10.0, 0.0], "source_entity_id": "E0",
|
|
}}}
|
|
self.assertIsNotNone(_direct_line_angle_axis(direct, sketch_by_source, entity_by_sketch))
|
|
self.assertIsNone(_direct_line_angle_axis(derived, sketch_by_source, entity_by_sketch))
|
|
|
|
def test_line_angle_direct_axis_refuses_a_query_wrapper_and_keeps_the_prefix(self):
|
|
direct = Call("sQuery", ["F0.wireOp", "EDGE", "E0"], 1)
|
|
wrapped = Call("qAdjacent", [direct, "VERTEX", "EDGE"], 2)
|
|
sketch_by_source = {"F0": {"workplane": {
|
|
"origin_mm": [0.0, 0.0, 0.0], "x_dir": [1.0, 0.0, 0.0], "normal": [0.0, 0.0, 1.0],
|
|
}}}
|
|
entity_by_sketch = {"F0": {"E0": {
|
|
"type": "line", "start": [0.0, 0.0], "end": [10.0, 0.0], "source_entity_id": "E0",
|
|
}}}
|
|
self.assertIsNone(_direct_line_angle_axis(wrapped, sketch_by_source, entity_by_sketch))
|
|
|
|
model = parse_featurescript(LINE_ANGLE_TWO_ENTITY_SOURCE, "line-angle-wrapped-axis")
|
|
plane = next(item for item in model.features if item.feature_id == "F1")
|
|
plane.params["entities"].args[0][0] = wrapped
|
|
result = lower_model(model, {})
|
|
self.assertIn({
|
|
"code": "feature_deferred",
|
|
"feature_id": "F1",
|
|
"operation": "cPlane",
|
|
"message": "line-angle reference selection is unsupported",
|
|
}, result.diagnostics)
|
|
self.assertIn("f_F2", {item["id"] for item in result.cdsl["features"]})
|
|
|
|
def test_line_angle_rejects_a_circle_center_vertex_as_an_axis(self):
|
|
root = Path(__file__).parents[2] / "data/cadfs-sample/CADFS_test"
|
|
feature = root / "featurescript_rp/0003/00030209.txt"
|
|
if not feature.exists(): self.skipTest("CADFS sample is not installed")
|
|
source = feature.read_text().replace(
|
|
'Q0=sQuery(id+"F0.wireOp",EDGE,"E0");',
|
|
'Q0=sQuery(id+"F0.wireOp",VERTEX,"E0.center");',
|
|
1,
|
|
)
|
|
result = lower_model(parse_featurescript(source, "line-angle-circle-center"), {})
|
|
self.assertIn({
|
|
"code": "feature_deferred",
|
|
"feature_id": "F1",
|
|
"operation": "cPlane",
|
|
"message": "line-angle reference selection is unsupported",
|
|
}, result.diagnostics)
|
|
|
|
def test_open_nonconstruction_geometry_is_preserved_as_reference(self):
|
|
source = SOURCE.replace('skSolve(sketch);', 'skLineSegment(sketch, "open", {"start":v(0, 0) * mm, "end":v(20, 0) * mm}); skSolve(sketch);', 1)
|
|
result = lower_model(parse_featurescript(source, "open-profile"), {})
|
|
self.assertEqual(result.status, "converted_complete")
|
|
profile = result.cdsl["geometry"]["sketches"][0]["profile"]
|
|
self.assertEqual(profile["type"], "analytic_contours")
|
|
self.assertEqual(profile["construction"][0]["type"], "line")
|
|
|
|
def test_open_imprint_profiles_and_mixed_sketch_context_lower_for_00789939(self):
|
|
root = Path(__file__).parents[2] / "data/cadfs-sample/CADFS_test"
|
|
feature = root / "featurescript_rp/0078/00789939.txt"
|
|
if not feature.exists(): self.skipTest("CADFS sample is not installed")
|
|
result = lower_model(parse_featurescript(feature.read_text(), "00789939"), {})
|
|
|
|
features = {item["id"]: item for item in result.cdsl["features"]}
|
|
sketches = {item["id"]: item for item in result.cdsl["geometry"]["sketches"]}
|
|
self.assertEqual(features["f_F8"]["sketch_id"], "sketch_F7__f_F8")
|
|
self.assertEqual(features["f_F10"]["sketch_id"], "sketch_F9__f_F10")
|
|
self.assertEqual(features["f_F12"]["sketch_id"], "sketch_F11")
|
|
self.assertFalse(sketches["sketch_F7__f_F8"]["profile"]["contours"][0]["closed"])
|
|
self.assertEqual(sketches["sketch_F7__f_F8"]["workplane"]["origin_mm"], [45.7, 0.0, 0.0])
|
|
self.assertEqual(sketches["sketch_F9__f_F10"]["workplane"]["origin_mm"], [-44.3, -0.0, -0.0])
|
|
self.assertEqual(sketches["sketch_F7__f_F8"]["workplane"]["normal"], [1.0, -0.0, -0.0])
|
|
self.assertEqual(sketches["sketch_F9__f_F10"]["workplane"]["normal"], [-1.0, -0.0, -0.0])
|
|
self.assertEqual(sketches["sketch_F9__f_F10"]["workplane"]["x_dir"], [-0.0, -1.0, -0.0])
|
|
|
|
def test_offset_face_profile_is_the_proven_linear_extrusion_wall(self):
|
|
root = Path(__file__).parents[2] / "data/cadfs-sample/CADFS_test"
|
|
feature = root / "featurescript_rp/0078/00789939.txt"
|
|
if not feature.exists(): self.skipTest("CADFS sample is not installed")
|
|
result = lower_model(parse_featurescript(feature.read_text(), "00789939"), {})
|
|
|
|
features = {item["id"]: item for item in result.cdsl["features"]}
|
|
sketches = {item["id"]: item for item in result.cdsl["geometry"]["sketches"]}
|
|
self.assertEqual(features["f_F15"]["sketch_id"], "sketch_F5__f_F15")
|
|
sketch = sketches["sketch_F5__f_F15"]
|
|
self.assertEqual(sketch["workplane"]["origin_mm"], [-0.0, 52.19, -0.0])
|
|
self.assertEqual(sketch["workplane"]["normal"], [0.0, -1.0, 0.0])
|
|
points = {
|
|
tuple(round(component, 6) for component in endpoint)
|
|
for segment in sketch["profile"]["contours"][0]["segments"]
|
|
for endpoint in (segment["start"], segment["end"])
|
|
}
|
|
self.assertEqual(points, {(-45.0, 2.5), (45.0, 2.5), (45.0, 6.0), (-45.0, 6.0)})
|
|
|
|
def test_offset_face_profile_defers_when_query_has_multiple_source_edges(self):
|
|
root = Path(__file__).parents[2] / "data/cadfs-sample/CADFS_test"
|
|
feature = root / "featurescript_rp/0078/00789939.txt"
|
|
if not feature.exists(): self.skipTest("CADFS sample is not installed")
|
|
source = feature.read_text(encoding="utf-8").replace(
|
|
'Q0=makeQuery(id+"F5.opShell","OFFSET_FACE",FACE,{"disambiguationData":[OSD([sQuery(id+"F3.wireOp",EDGE,"E1.bottom")])]});',
|
|
'Q0=makeQuery(id+"F5.opShell","OFFSET_FACE",FACE,{"disambiguationData":[OSD([sQuery(id+"F3.wireOp",EDGE,"E1.bottom"),sQuery(id+"F3.wireOp",EDGE,"E1.top")])]});',
|
|
1,
|
|
)
|
|
result = lower_model(parse_featurescript(source, "00789939-offset-face-multi-source"), {})
|
|
|
|
self.assertNotIn("f_F15", {item["id"] for item in result.cdsl["features"]})
|
|
diagnostic = next(item for item in result.diagnostics if item.get("feature_id") == "F15")
|
|
self.assertEqual(diagnostic["capability"], "extrude_profile_topology:offset_face")
|
|
|
|
def test_offset_face_profile_defers_for_non_direct_shell_provenance(self):
|
|
root = Path(__file__).parents[2] / "data/cadfs-sample/CADFS_test"
|
|
feature = root / "featurescript_rp/0058/00588094.txt"
|
|
if not feature.exists(): self.skipTest("CADFS sample is not installed")
|
|
result = lower_model(parse_featurescript(feature.read_text(), "00588094"), {})
|
|
|
|
self.assertNotIn("f_F14", {item["id"] for item in result.cdsl["features"]})
|
|
diagnostic = next(item for item in result.diagnostics if item.get("feature_id") == "F14")
|
|
self.assertEqual(diagnostic["capability"], "extrude_profile_topology:offset_face")
|
|
|
|
def test_circular_pattern_uses_the_proven_fused_body_successor(self):
|
|
root = Path(__file__).parents[2] / "data/cadfs-sample/CADFS_test"
|
|
feature = root / "featurescript_rp/0054/00542223.txt"
|
|
if not feature.exists(): self.skipTest("CADFS sample is not installed")
|
|
result = lower_model(parse_featurescript(feature.read_text(), "00542223"), {})
|
|
|
|
features = {item["id"]: item for item in result.cdsl["features"]}
|
|
self.assertEqual(features["f_F6"]["params"]["source_feature_ids"], ["f_F5"])
|
|
|
|
def test_circular_copy_boolean_uses_the_proven_fused_body_successor(self):
|
|
root = Path(__file__).parents[2] / "data/cadfs-sample/CADFS_test"
|
|
feature = root / "featurescript_rp/0025/00253824.txt"
|
|
if not feature.exists(): self.skipTest("CADFS sample is not installed")
|
|
result = lower_model(parse_featurescript(feature.read_text(), "00253824"), {})
|
|
|
|
features = {item["id"]: item for item in result.cdsl["features"]}
|
|
self.assertEqual(result.status, "converted_complete")
|
|
self.assertEqual(features["f_F5"]["params"]["source_feature_ids"], ["f_F4"])
|
|
self.assertEqual(features["f_F6"]["params"], {
|
|
"operation": "union",
|
|
"keep_tools": False,
|
|
"target_feature_ids": ["f_F4"],
|
|
"tool_pattern_instance_refs": [
|
|
{"pattern_feature_id": "f_F5", "source_feature_id": "f_F4", "instance_index": 2},
|
|
{"pattern_feature_id": "f_F5", "source_feature_id": "f_F4", "instance_index": 1},
|
|
],
|
|
})
|
|
|
|
def test_shared_sketch_edge_produces_each_bounded_region(self):
|
|
segments = [
|
|
{"type": "line", "start": [0, 0], "end": [1, 0]},
|
|
{"type": "line", "start": [1, 0], "end": [2, 0]},
|
|
{"type": "line", "start": [2, 0], "end": [2, 1]},
|
|
{"type": "line", "start": [2, 1], "end": [1, 1]},
|
|
{"type": "line", "start": [1, 1], "end": [0, 1]},
|
|
{"type": "line", "start": [0, 1], "end": [0, 0]},
|
|
{"type": "line", "start": [1, 0], "end": [1, 1]},
|
|
]
|
|
contours, construction = _contours(segments)
|
|
self.assertEqual(len(contours), 2)
|
|
self.assertFalse(construction)
|
|
self.assertEqual(sorted(len(item["segments"]) for item in contours), [4, 4])
|
|
|
|
def test_vertex_on_long_line_is_split_before_region_extraction(self):
|
|
segments = [
|
|
{"type": "line", "start": [0, 0], "end": [2, 0]},
|
|
{"type": "line", "start": [2, 0], "end": [2, 2]},
|
|
{"type": "line", "start": [2, 2], "end": [0, 2]},
|
|
{"type": "line", "start": [0, 2], "end": [0, 0]},
|
|
{"type": "line", "start": [2, 0.5], "end": [3, 0.5]},
|
|
{"type": "line", "start": [3, 0.5], "end": [3, 1.5]},
|
|
{"type": "line", "start": [3, 1.5], "end": [2, 1.5]},
|
|
]
|
|
contours, construction = _contours(segments)
|
|
self.assertEqual(len(contours), 2)
|
|
self.assertFalse(construction)
|
|
|
|
def test_surface_operation_on_a_closed_region_lowers_to_a_solid_revolve(self):
|
|
root = Path(__file__).parents[2] / "data/cadfs-sample/CADFS_test"
|
|
feature = root / "featurescript_rp/0095/00957738.txt"
|
|
if not feature.exists(): self.skipTest("CADFS sample is not installed")
|
|
result = lower_model(parse_featurescript(feature.read_text(), "00957738"), {})
|
|
self.assertEqual(result.status, "converted_complete")
|
|
feature = next(item for item in result.cdsl["features"] if item["id"] == "f_F2")
|
|
self.assertEqual(feature["atomic_id"], "revolve_add")
|
|
self.assertNotIn("result_mode", feature["params"])
|
|
|
|
def test_explicit_surface_body_lowers_to_the_surface_revolve_contract(self):
|
|
root = Path(__file__).parents[2] / "data/cadfs-sample/CADFS_test"
|
|
feature = root / "featurescript_rp/0078/00784880.txt"
|
|
if not feature.exists(): self.skipTest("CADFS sample is not installed")
|
|
result = lower_model(parse_featurescript(feature.read_text(), "00784880"), {})
|
|
self.assertEqual(result.status, "converted_complete")
|
|
feature = next(item for item in result.cdsl["features"] if item["id"] == "f_F3")
|
|
self.assertEqual(feature["atomic_id"], "revolve_surface")
|
|
self.assertNotIn("result_mode", feature["params"])
|
|
|
|
def test_mixed_extrude_lowers_selected_circular_surface_wires(self):
|
|
root = Path(__file__).parents[2] / "data/cadfs-sample/CADFS_test"
|
|
feature = root / "featurescript_rp/0071/00710855.txt"
|
|
if not feature.exists(): self.skipTest("CADFS sample is not installed")
|
|
result = lower_model(parse_featurescript(feature.read_text(), "00710855"), {})
|
|
|
|
self.assertEqual(result.status, "converted_complete")
|
|
features = {item["id"]: item for item in result.cdsl["features"]}
|
|
self.assertEqual(features["f_F1_surface"]["atomic_id"], "extrude_surface")
|
|
self.assertEqual(features["f_F1_surface"]["params"], {
|
|
"distance_mm": 63.5,
|
|
"reverse": False,
|
|
"reverse_distance_mm": 63.5,
|
|
})
|
|
self.assertEqual(features["f_F5_surface"]["atomic_id"], "extrude_surface")
|
|
sketches = {item["id"]: item for item in result.cdsl["geometry"]["sketches"]}
|
|
radii = [
|
|
contour["segments"][0]["radius_mm"]
|
|
for contour in sketches["sketch_F0__f_F1_surface"]["profile"]["contours"]
|
|
]
|
|
self.assertEqual(radii, [19.0, 16.0])
|
|
profile = sketches[features["f_F5"]["sketch_id"]]["profile"]
|
|
self.assertEqual(profile["type"], "analytic_contours")
|
|
self.assertEqual(
|
|
[(item["role"], item["segments"][0]["radius_mm"]) for item in profile["contours"]],
|
|
[("outer", 25.5), ("inner", 19.0)],
|
|
)
|
|
|
|
def test_mixed_extrude_preserves_prefix_when_cap_edge_chamfer_query_is_deferred(self):
|
|
root = Path(__file__).parents[2] / "data/cadfs-sample/CADFS_test"
|
|
feature = root / "featurescript_rp/0071/00710855.txt"
|
|
if not feature.exists(): self.skipTest("CADFS sample is not installed")
|
|
result = lower_model(parse_featurescript(feature.read_text(), "00710855"), {})
|
|
|
|
with tempfile.TemporaryDirectory() as tmp:
|
|
from cadfs_to_cdsl.rebuild import rebuild_candidate
|
|
rebuilt = rebuild_candidate(result.cdsl, Path(tmp) / "rebuilt.step")
|
|
|
|
self.assertEqual(rebuilt["status"], "rebuild_failed")
|
|
self.assertEqual(rebuilt["error"]["message"], "f_F10: selector_query_unsupported during incremental replay")
|
|
self.assertEqual(rebuilt["last_executable_prefix"]["failed_feature_id"], "f_F10")
|
|
self.assertEqual(rebuilt["last_executable_prefix"]["last_feature_id"], "f_F9")
|
|
|
|
def test_fit_spline_loft_lowers_to_executable_loft_add(self):
|
|
root = Path(__file__).parents[2] / "data/cadfs-sample/CADFS_test"
|
|
feature = root / "featurescript_rp/0061/00612529.txt"
|
|
if not feature.exists(): self.skipTest("CADFS sample is not installed")
|
|
result = lower_model(parse_featurescript(feature.read_text(), "00612529"), {})
|
|
self.assertIsNotNone(result.cdsl)
|
|
features = {item["id"]: item for item in result.cdsl["features"]}
|
|
self.assertEqual(features["f_F3"]["atomic_id"], "loft_add")
|
|
self.assertEqual(features["f_F3"]["params"]["profile_sketch_ids"], ["sketch_F2", "sketch_F0"])
|
|
self.assertEqual(features["f_F4"]["atomic_id"], "pattern_mirror")
|
|
self.assertEqual(features["f_F4"]["params"]["source_feature_ids"], ["f_F3"])
|
|
sketches = {item["id"]: item for item in result.cdsl["geometry"]["sketches"]}
|
|
self.assertEqual(sketches["sketch_F0"]["profile"]["contours"][0]["segments"][0]["type"], "bspline")
|
|
self.assertNotIn("loft", {item.get("operation") for item in result.diagnostics})
|
|
|
|
def test_fit_spline_loft_candidate_rebuilds(self):
|
|
root = Path(__file__).parents[2] / "data/cadfs-sample/CADFS_test"
|
|
feature = root / "featurescript_rp/0061/00612529.txt"
|
|
if not feature.exists(): self.skipTest("CADFS sample is not installed")
|
|
result = lower_model(parse_featurescript(feature.read_text(), "00612529"), {})
|
|
with tempfile.TemporaryDirectory() as tmp:
|
|
from cadfs_to_cdsl.rebuild import rebuild_candidate
|
|
rebuilt = rebuild_candidate(result.cdsl, Path(tmp) / "rebuilt.step")
|
|
self.assertEqual(rebuilt["status"], "rebuilt")
|
|
self.assertGreater(rebuilt["result"]["volume_mm3"], 0)
|
|
|
|
def test_closed_fit_splines_lower_to_periodic_contours_and_join_split_imprints(self):
|
|
root = Path(__file__).parents[2] / "data/cadfs-sample/CADFS_test"
|
|
feature = root / "featurescript_rp/0061/00612529.txt"
|
|
if not feature.exists(): self.skipTest("CADFS sample is not installed")
|
|
result = lower_model(parse_featurescript(feature.read_text(), "00612529"), {})
|
|
|
|
self.assertEqual(result.status, "converted_complete")
|
|
self.assertNotIn("F8", {item.get("feature_id") for item in result.diagnostics})
|
|
sketches = {item["id"]: item for item in result.cdsl["geometry"]["sketches"]}
|
|
for sketch_id in ("sketch_F0", "sketch_F2", "sketch_F5", "sketch_F6"):
|
|
segment = sketches[sketch_id]["profile"]["contours"][0]["segments"][0]
|
|
self.assertTrue(segment["periodic"])
|
|
self.assertEqual(segment["parameterization"], "centripetal")
|
|
features = {item["id"]: item for item in result.cdsl["features"]}
|
|
self.assertEqual(features["f_F8"]["sketch_id"], "sketch_F6")
|
|
|
|
def test_open_fit_spline_reversal_preserves_parameter_and_tangent_semantics(self):
|
|
root = Path(__file__).parents[2] / "data/cadfs-sample/CADFS_test"
|
|
feature = root / "featurescript_rp/0028/00287955.txt"
|
|
if not feature.exists(): self.skipTest("CADFS sample is not installed")
|
|
result = lower_model(parse_featurescript(feature.read_text(), "00287955"), {})
|
|
|
|
sketches = {item["id"]: item for item in result.cdsl["geometry"]["sketches"]}
|
|
spline = sketches["sketch_F13__f_F14"]["profile"]["contours"][0]["segments"][1]
|
|
source_points = [[33.77, 39.06], [38.2, 35.02], [36.58, 30.72], [33.77, 28.66]]
|
|
source_parameters = [0.0]
|
|
for start, end in zip(source_points, source_points[1:]):
|
|
source_parameters.append(source_parameters[-1] + math.sqrt(math.dist(start, end)))
|
|
source_parameters = [value / source_parameters[-1] for value in source_parameters]
|
|
|
|
self.assertEqual(spline["points"], list(reversed(source_points)))
|
|
self.assertEqual(spline["start_tangent"], [11.58, -1.2])
|
|
self.assertEqual(spline["end_tangent"], [-14.95, 1.46])
|
|
self.assertEqual(
|
|
spline["parameters"],
|
|
[source_parameters[-1] - value for value in reversed(source_parameters)],
|
|
)
|
|
|
|
def test_draft_and_boolean_bodies_preserve_explicit_source_body_selection(self):
|
|
root = Path(__file__).parents[2] / "data/cadfs-sample/CADFS_test"
|
|
feature = root / "featurescript_rp/0083/00835610.txt"
|
|
if not feature.exists(): self.skipTest("CADFS sample is not installed")
|
|
result = lower_model(parse_featurescript(feature.read_text(), "00835610"), {})
|
|
|
|
features = {item["id"]: item for item in result.cdsl["features"]}
|
|
self.assertEqual(features["f_F1"]["params"]["draft"], {"angle_deg": 49.0, "pull_direction": True})
|
|
self.assertEqual(features["f_F3"]["sketch_id"], "sketch_F0__f_F3")
|
|
self.assertEqual(features["f_F3"]["params"]["draft"], {"angle_deg": 49.0, "pull_direction": True})
|
|
self.assertEqual(features["f_F4"]["atomic_id"], "boolean_bodies")
|
|
self.assertEqual(features["f_F4"]["params"], {
|
|
"operation": "subtract",
|
|
"target_feature_ids": ["f_F3"],
|
|
"tool_feature_ids": ["f_F2"],
|
|
"keep_tools": False,
|
|
})
|
|
self.assertEqual(features["f_F8"]["atomic_id"], "revolve_add")
|
|
self.assertNotIn("result_mode", features["f_F8"]["params"])
|
|
|
|
def test_drafted_cap_face_profile_executes_from_a_builder_proven_boolean_successor(self):
|
|
root = Path(__file__).parents[2] / "data/cadfs-sample/CADFS_test"
|
|
feature = root / "featurescript_rp/0083/00835610.txt"
|
|
if not feature.exists(): self.skipTest("CADFS sample is not installed")
|
|
result = lower_model(parse_featurescript(feature.read_text(), "00835610"), {})
|
|
|
|
features = {item["id"]: item for item in result.cdsl["features"]}
|
|
self.assertEqual(result.status, "converted_complete")
|
|
cap_extrude = features["f_F5"]
|
|
self.assertEqual(cap_extrude["atomic_id"], "extrude_from_face")
|
|
self.assertNotIn("sketch_id", cap_extrude)
|
|
selector = cap_extrude["selectors"][0]
|
|
self.assertEqual({key: selector[key] for key in (
|
|
"kind", "owner_feature_id", "output_role", "source", "confidence",
|
|
)}, {
|
|
"kind": "face", "owner_feature_id": "f_F3", "output_role": "extrude.start",
|
|
"source": "runtime_snapshot", "confidence": 1.0,
|
|
})
|
|
self.assertNotIn("selector_intent_version", selector)
|
|
self.assertEqual(selector["selector_intent"]["query_family"], "CAP_FACE")
|
|
|
|
from engine.cdsl_engine.runtime import rebuild_cdsl
|
|
with tempfile.TemporaryDirectory() as directory:
|
|
rebuilt = rebuild_cdsl(result.cdsl, Path(directory) / "drafted-cap-face.step")
|
|
resolution = next(item for item in rebuilt["selector_resolution"] if item["feature_id"] == "f_F5")
|
|
self.assertEqual(resolution["status"], "resolved")
|
|
self.assertEqual(resolution["selected"]["owner_feature_ids"], ["f_F3"])
|
|
self.assertEqual(resolution["selected"]["output_roles"], ["extrude.start"])
|
|
self.assertIn("f_F5", [item["feature_id"] for item in rebuilt["feature_results"]])
|
|
|
|
def test_drafted_cap_face_with_an_inner_loop_remains_an_explicit_capability_gap(self):
|
|
root = Path(__file__).parents[2] / "data/cadfs-sample/CADFS_test"
|
|
feature = root / "featurescript_rp/0026/00268467.txt"
|
|
if not feature.exists(): self.skipTest("CADFS sample is not installed")
|
|
result = lower_model(parse_featurescript(feature.read_text(), "00268467"), {})
|
|
|
|
features = {item["id"]: item for item in result.cdsl["features"]}
|
|
self.assertNotIn("f_F2", features)
|
|
diagnostics = [item for item in result.diagnostics if item.get("feature_id") == "F2"]
|
|
self.assertEqual(len(diagnostics), 1)
|
|
self.assertEqual(diagnostics[0]["capability"], "extrude_profile_topology:cap_face")
|
|
|
|
def test_nested_cap_edge_union_preserves_outer_profile_and_runtime_prefix(self):
|
|
root = Path(__file__).parents[2] / "data/cadfs-sample/CADFS_test"
|
|
feature = root / "featurescript_rp/0095/00950564.txt"
|
|
if not feature.exists(): self.skipTest("CADFS sample is not installed")
|
|
result = lower_model(parse_featurescript(feature.read_text(), "00950564"), {})
|
|
|
|
self.assertEqual(result.status, "converted_complete")
|
|
self.assertFalse(result.diagnostics)
|
|
features = {item["id"]: item for item in result.cdsl["features"]}
|
|
self.assertEqual(features["f_F3"]["sketch_id"], "sketch_F2")
|
|
self.assertEqual(features["f_F5"]["sketch_id"], "sketch_F4")
|
|
# F12's direct SWEPT_BODY(F1) names the one physical body after its
|
|
# additive and dress-up successors. The lowering must retain that
|
|
# proven successor, never substitute an implicit active aggregate.
|
|
self.assertEqual(features["f_F12"]["params"]["source_feature_ids"], ["f_F11"])
|
|
self.assertIn("f_F11", features["f_F12"]["depends_on"])
|
|
from engine.cdsl_engine.runtime import analyze_cdsl
|
|
f12_analysis = next(item for item in analyze_cdsl(result.cdsl).as_dict()["feature_results"] if item["feature_id"] == "f_F12")
|
|
self.assertEqual(f12_analysis["resolved_status"], "executable")
|
|
self.assertFalse(any(item["code"] == "body_source_unavailable" for item in f12_analysis["blockers"]))
|
|
|
|
# Later chamfers have a separate selector gap. The retained prefix
|
|
# proves the two CAP_EDGE profile unions themselves execute through
|
|
# their dependent extrusions.
|
|
prefix = deepcopy(result.cdsl)
|
|
prefix["features"] = [item for item in prefix["features"] if item["id"] not in {"f_F10", "f_F11", "f_F12"}]
|
|
from engine.cdsl_engine.runtime import rebuild_cdsl
|
|
with tempfile.TemporaryDirectory() as directory:
|
|
rebuilt = rebuild_cdsl(prefix, Path(directory) / "cap-edge-union-prefix.step")
|
|
self.assertFalse(rebuilt["runtime_diagnostics"])
|
|
self.assertEqual(
|
|
[item["feature_id"] for item in rebuilt["feature_results"]],
|
|
["f_F1", "f_F3", "f_F5", "f_F7", "f_F9"],
|
|
)
|
|
|
|
def test_two_sided_blind_extrude_records_physical_cap_workplanes(self):
|
|
root = Path(__file__).parents[2] / "data/cadfs-sample/CADFS_test"
|
|
feature = root / "featurescript_rp/0024/00247322.txt"
|
|
if not feature.exists(): self.skipTest("CADFS sample is not installed")
|
|
result = lower_model(parse_featurescript(feature.read_text(), "00247322"), {})
|
|
|
|
# The CAP_FACE(F4, isStart:true) workplane is the blind cap opposite
|
|
# F4's primary direction, not the source sketch plane. F5 preserves
|
|
# that cap's exact F4 ownership, so its CAP_EDGE can form F7's hole.
|
|
self.assertEqual(result.status, "converted_complete")
|
|
self.assertFalse(result.diagnostics)
|
|
sketches = {item["id"]: item for item in result.cdsl["geometry"]["sketches"]}
|
|
self.assertEqual(sketches["sketch_F3"]["workplane"]["origin_mm"], [0.0, 0.0, 40.0])
|
|
self.assertEqual(sketches["sketch_F6"]["workplane"]["origin_mm"], [0.0, 0.0, 40.3])
|
|
self.assertEqual(sketches["sketch_F6"]["workplane"]["normal"], [0.0, 0.0, 1.0])
|
|
self.assertEqual(sketches["sketch_F8"]["workplane"]["origin_mm"], [0.0, 0.0, 41.8])
|
|
self.assertEqual(sketches["sketch_F10"]["workplane"]["origin_mm"], [0.0, 0.0, 41.8])
|
|
features = {item["id"]: item for item in result.cdsl["features"]}
|
|
self.assertEqual(features["f_F7"]["selectors"][0]["geometry"], {
|
|
"normal": [0.0, 0.0, 1.0], "plane_offset_mm": 40.3,
|
|
})
|
|
|
|
# F9 rotates F4 only after F5/F7 have consumed it. It cannot be baked
|
|
# into the earlier F4 sketch. The CAP_EDGE geometry is preserved for
|
|
# diagnostics, but no source-qualified cap-edge lineage exists for
|
|
# this two-sided profile contract.
|
|
prefix = deepcopy(result.cdsl)
|
|
prefix["features"] = [
|
|
item for item in prefix["features"]
|
|
if item["id"] in {"f_F1", "f_F2", "f_F4", "f_F5", "f_F7"}
|
|
]
|
|
with tempfile.TemporaryDirectory() as directory:
|
|
rebuilt = rebuild_candidate(prefix, Path(directory) / "two-sided-cap-prefix.step")
|
|
self.assertEqual(rebuilt["status"], "rebuild_failed")
|
|
self.assertEqual(rebuilt["error"]["message"], "f_F7: selector_query_unsupported during incremental replay")
|
|
self.assertEqual(rebuilt["last_executable_prefix"]["last_feature_id"], "f_F5")
|
|
|
|
from engine.cdsl_engine.runtime import analyze_cdsl
|
|
f9 = next(item for item in analyze_cdsl(result.cdsl).as_dict()["feature_results"] if item["feature_id"] == "f_F9")
|
|
self.assertIn("body_source_unavailable", [item["code"] for item in f9["blockers"]])
|
|
|
|
def test_cap_face_profile_executes_from_a_builder_proven_dressup_successor(self):
|
|
root = Path(__file__).parents[2] / "data/cadfs-sample/CADFS_test"
|
|
feature = root / "featurescript_rp/0001/00016195.txt"
|
|
if not feature.exists(): self.skipTest("CADFS sample is not installed")
|
|
result = lower_model(parse_featurescript(feature.read_text(), "00016195"), {})
|
|
self.assertEqual(result.status, "converted_complete")
|
|
feature = next(item for item in result.cdsl["features"] if item["id"] == "f_F3")
|
|
self.assertEqual(feature["atomic_id"], "extrude_from_face")
|
|
self.assertNotIn("sketch_id", feature)
|
|
|
|
from engine.cdsl_engine.runtime import rebuild_cdsl
|
|
with tempfile.TemporaryDirectory() as directory:
|
|
rebuilt = rebuild_cdsl(result.cdsl, Path(directory) / "cap-face.step")
|
|
resolution = next(item for item in rebuilt["selector_resolution"] if item["feature_id"] == "f_F3")
|
|
self.assertEqual(resolution["status"], "resolved")
|
|
self.assertEqual(resolution["selected"]["owner_feature_ids"], ["f_F1"])
|
|
self.assertEqual(resolution["selected"]["output_roles"], ["extrude.end"])
|
|
|
|
def test_transformed_cap_face_uses_its_attachment_plane_origin(self):
|
|
root = Path(__file__).parents[2] / "data/cadfs-sample/CADFS_test"
|
|
feature = root / "featurescript_rp/0083/00835610.txt"
|
|
if not feature.exists(): self.skipTest("CADFS sample is not installed")
|
|
result = lower_model(parse_featurescript(feature.read_text(), "00835610"), {})
|
|
|
|
sketches = {item["id"]: item for item in result.cdsl["geometry"]["sketches"]}
|
|
plane = sketches["sketch_F14"]["workplane"]
|
|
|
|
self.assertAlmostEqual(plane["origin_mm"][0], 0.0)
|
|
self.assertAlmostEqual(plane["origin_mm"][1], 0.0)
|
|
self.assertAlmostEqual(plane["origin_mm"][2], -24.08)
|
|
self.assertAlmostEqual(plane["normal"][0], 0.0)
|
|
self.assertAlmostEqual(plane["normal"][1], 0.0)
|
|
self.assertAlmostEqual(plane["normal"][2], 1.0)
|
|
|
|
def test_chamfer_tangent_propagation_lowers_to_engine_param(self):
|
|
root = Path(__file__).parents[2] / "data/cadfs-sample/CADFS_test"
|
|
feature = root / "featurescript_rp/0000/00002243.txt"
|
|
if not feature.exists(): self.skipTest("CADFS sample is not installed")
|
|
result = lower_model(parse_featurescript(feature.read_text(), "00002243"), {})
|
|
chamfer = next(item for item in result.cdsl["features"] if item["id"] == "f_F4")
|
|
self.assertTrue(chamfer["params"]["tangent_propagation"])
|
|
|
|
def test_imprint_profile_query_selects_one_shared_edge_region(self):
|
|
root = Path(__file__).parents[2] / "data/cadfs-sample/CADFS_test"
|
|
feature = root / "featurescript_rp/0003/00035682.txt"
|
|
if not feature.exists(): self.skipTest("CADFS sample is not installed")
|
|
result = lower_model(parse_featurescript(feature.read_text(), "00035682"), {})
|
|
revolve = next(item for item in result.cdsl["features"] if item["id"] == "f_F1")
|
|
self.assertEqual(revolve["sketch_id"], "sketch_F0__f_F1")
|
|
selected = next(item for item in result.cdsl["geometry"]["sketches"] if item["id"] == revolve["sketch_id"])
|
|
self.assertEqual(len(selected["profile"]["contours"]), 1)
|
|
x_coordinates = {point[0] for segment in selected["profile"]["contours"][0]["segments"] for point in (segment["start"], segment["end"])}
|
|
self.assertEqual(x_coordinates, {11.68, 12.05})
|
|
|
|
def test_line_point_plane_uses_the_reference_line_as_its_normal(self):
|
|
root = Path(__file__).parents[2] / "data/cadfs-sample/CADFS_test"
|
|
feature = root / "featurescript_rp/0003/00035682.txt"
|
|
if not feature.exists(): self.skipTest("CADFS sample is not installed")
|
|
result = lower_model(parse_featurescript(feature.read_text(), "00035682"), {})
|
|
self.assertEqual(result.status, "converted_complete")
|
|
features = {item["id"]: item for item in result.cdsl["features"]}
|
|
self.assertEqual(features["f_F5"]["atomic_id"], "reference_plane")
|
|
self.assertEqual(features["f_F8"]["atomic_id"], "reference_plane")
|
|
self.assertEqual(features["f_F7"]["atomic_id"], "extrude_cut_blind")
|
|
self.assertEqual(features["f_F10"]["atomic_id"], "extrude_cut_blind")
|
|
sketches = {item["id"]: item for item in result.cdsl["geometry"]["sketches"]}
|
|
length = math.hypot(10.44, 6.03)
|
|
for actual, expected in zip(sketches["sketch_F6"]["workplane"]["normal"], [-10.44 / length, 6.03 / length, 0.0]):
|
|
self.assertAlmostEqual(actual, expected)
|
|
for actual, expected in zip(sketches["sketch_F6"]["workplane"]["x_dir"], [-6.03 / length, -10.44 / length, 0.0]):
|
|
self.assertAlmostEqual(actual, expected)
|
|
for actual, expected in zip(sketches["sketch_F9"]["workplane"]["normal"], [10.44 / length, 6.03 / length, 0.0]):
|
|
self.assertAlmostEqual(actual, expected)
|
|
for actual, expected in zip(sketches["sketch_F9"]["workplane"]["x_dir"], [-6.03 / length, 10.44 / length, 0.0]):
|
|
self.assertAlmostEqual(actual, expected)
|
|
|
|
def test_revolved_swept_face_lowers_to_an_annular_profile(self):
|
|
root = Path(__file__).parents[2] / "data/cadfs-sample/CADFS_test"
|
|
feature = root / "featurescript_rp/0005/00054089.txt"
|
|
if not feature.exists(): self.skipTest("CADFS sample is not installed")
|
|
result = lower_model(parse_featurescript(feature.read_text(), "00054089"), {})
|
|
self.assertEqual(result.status, "converted_complete")
|
|
features = {item["id"]: item for item in result.cdsl["features"]}
|
|
self.assertEqual(features["f_F5"]["atomic_id"], "extrude_add_blind")
|
|
sketches = {item["id"]: item for item in result.cdsl["geometry"]["sketches"]}
|
|
profile = sketches["sketch_F4"]["profile"]
|
|
self.assertEqual(profile["type"], "analytic_contours")
|
|
radii = {contour["role"]: contour["segments"][0]["radius_mm"] for contour in profile["contours"]}
|
|
self.assertEqual(radii, {"outer": 18.0, "inner": 14.0})
|
|
|
|
def test_full_revolve_planar_swept_face_lowers_as_a_mirror_plane(self):
|
|
root = Path(__file__).parents[2] / "data/cadfs-sample/CADFS_test"
|
|
feature = root / "featurescript_rp/0000/00000385.txt"
|
|
if not feature.exists(): self.skipTest("CADFS sample is not installed")
|
|
source = feature.read_text(encoding="utf-8")
|
|
result = lower_model(parse_featurescript(source, "00000385"), {})
|
|
features = {item["id"]: item for item in result.cdsl["features"]}
|
|
|
|
self.assertEqual(features["f_F5"]["atomic_id"], "pattern_mirror")
|
|
mirror_plane = features["f_F5_plane"]["params"]["plane"]
|
|
self.assertEqual(mirror_plane["origin_mm"], [0.0, 0.0, 0.0])
|
|
self.assertEqual(mirror_plane["x_dir"], [1.0, 0.0, 0.0])
|
|
self.assertEqual(mirror_plane["normal"], [0.0, 0.0, 1.0])
|
|
self.assertFalse([item for item in result.diagnostics if item.get("feature_id") == "F5"])
|
|
boolean = features["f_F6"]
|
|
self.assertEqual(boolean["atomic_id"], "boolean_bodies")
|
|
self.assertEqual(boolean["params"], {
|
|
"operation": "union",
|
|
"target_feature_ids": ["f_F1"],
|
|
"keep_tools": False,
|
|
"tool_pattern_instance_refs": [{
|
|
"pattern_feature_id": "f_F5",
|
|
"source_feature_id": "f_F1",
|
|
"instance_index": 1,
|
|
}],
|
|
})
|
|
self.assertFalse([item for item in result.diagnostics if item.get("feature_id") == "F6"])
|
|
|
|
with tempfile.TemporaryDirectory() as directory:
|
|
rebuilt = rebuild_candidate(result.cdsl, Path(directory) / "rebuild.step")
|
|
self.assertEqual(rebuilt["status"], "rebuilt")
|
|
mirror = next(item for item in rebuilt["result"]["feature_results"] if item["feature_id"] == "f_F5")
|
|
self.assertEqual(mirror["status"], "executed")
|
|
boolean_result = next(item for item in rebuilt["result"]["feature_results"] if item["feature_id"] == "f_F6")
|
|
self.assertEqual(boolean_result["status"], "executed")
|
|
|
|
partial = source.replace("RevolveType.FULL", "RevolveType.PARTIAL", 1)
|
|
rejected = lower_model(parse_featurescript(partial, "partial-revolve-mirror-plane"), {})
|
|
self.assertNotIn("f_F5", {item["id"] for item in rejected.cdsl["features"]})
|
|
self.assertEqual(
|
|
[item for item in rejected.diagnostics if item.get("feature_id") == "F5"],
|
|
[{
|
|
"code": "feature_deferred",
|
|
"feature_id": "F5",
|
|
"operation": "mirror",
|
|
"message": "mirror plane is not a default or reference plane",
|
|
}],
|
|
)
|
|
|
|
def test_targetless_union_partitions_direct_body_queries_in_source_order(self):
|
|
root = Path(__file__).parents[2] / "data/cadfs-sample/CADFS_test"
|
|
feature = root / "featurescript_rp/0029/00293508.txt"
|
|
if not feature.exists(): self.skipTest("CADFS sample is not installed")
|
|
result = lower_model(parse_featurescript(feature.read_text(encoding="utf-8"), "00293508"), {})
|
|
self.assertEqual(result.status, "converted_complete")
|
|
boolean = next(item for item in result.cdsl["features"] if item["id"] == "f_F4")
|
|
self.assertEqual(boolean["atomic_id"], "boolean_bodies")
|
|
self.assertEqual(boolean["params"], {
|
|
"operation": "union",
|
|
"target_feature_ids": ["f_F1"],
|
|
"tool_feature_ids": ["f_F3"],
|
|
"keep_tools": False,
|
|
})
|
|
with tempfile.TemporaryDirectory() as directory:
|
|
rebuilt = rebuild_candidate(result.cdsl, Path(directory) / "rebuild.step")
|
|
self.assertEqual(rebuilt["status"], "rebuilt")
|
|
execution = next(item for item in rebuilt["result"]["feature_results"] if item["feature_id"] == "f_F4")
|
|
self.assertEqual(execution["status"], "executed")
|
|
|
|
def test_intersect_partition_profile_retains_exact_planar_imprint_evidence(self):
|
|
root = Path(__file__).parents[2] / "data/cadfs-sample/CADFS_test"
|
|
feature = root / "featurescript_rp/0083/00835610.txt"
|
|
if not feature.exists(): self.skipTest("CADFS sample is not installed")
|
|
result = lower_model(parse_featurescript(feature.read_text(), "00835610"), {})
|
|
self.assertEqual(result.status, "converted_complete")
|
|
self.assertFalse([item for item in result.diagnostics if item.get("feature_id") == "F5"])
|
|
features = {item["id"]: item for item in result.cdsl["features"]}
|
|
self.assertEqual(features["f_F5"]["atomic_id"], "extrude_from_face")
|
|
sketches = {item["id"]: item for item in result.cdsl["geometry"]["sketches"]}
|
|
first = sketches[features["f_F15"]["sketch_id"]]["profile"]
|
|
second = sketches[features["f_F16"]["sketch_id"]]["profile"]
|
|
self.assertEqual(first["type"], "planar_imprint")
|
|
self.assertEqual(second["type"], "planar_imprint")
|
|
self.assertEqual(
|
|
first["selections"],
|
|
[
|
|
{"source_entity_id": "E11", "face_side": 1.0,
|
|
"fragment": {"anchor_entity_id": "E15", "side": -1.0, "intersection_index": 0}},
|
|
{"source_entity_id": "E11", "face_side": -1.0,
|
|
"fragment": {"anchor_entity_id": "E15", "side": -1.0, "intersection_index": 0}},
|
|
],
|
|
)
|
|
self.assertEqual({item["id"] for item in first["source_entities"]}, {"E11", "E13", "E14", "E15"})
|
|
self.assertEqual(
|
|
[selection["fragment"]["anchor_entity_id"] for selection in second["selections"]],
|
|
["E14", "E14"],
|
|
)
|
|
|
|
def test_direct_imprint_profile_preserves_selector_intent_and_f1_checkpoint(self):
|
|
root = Path(__file__).parents[2] / "data/cadfs-sample/CADFS_test"
|
|
feature = root / "featurescript_rp/0035/00354246.txt"
|
|
if not feature.exists(): self.skipTest("CADFS sample is not installed")
|
|
|
|
result = lower_model(parse_featurescript(feature.read_text(), "00354246"), {})
|
|
self.assertEqual(result.status, "converted_complete")
|
|
features = {item["id"]: item for item in result.cdsl["features"]}
|
|
sketches = {item["id"]: item for item in result.cdsl["geometry"]["sketches"]}
|
|
profile = sketches[features["f_F1"]["sketch_id"]]["profile"]
|
|
self.assertEqual(profile["type"], "planar_imprint")
|
|
self.assertEqual(profile["selections"], [
|
|
{"source_entity_id": "E6.MirrorCS", "face_side": -1.0},
|
|
{"source_entity_id": "E0.MirrorCS", "face_side": 1.0},
|
|
])
|
|
|
|
selectors = features["f_F2"]["selectors"]
|
|
self.assertEqual(len(selectors), 7)
|
|
self.assertTrue(all(
|
|
selector["selector_intent"]["query_family"] == "SWEPT_FACE"
|
|
and selector["selector_intent"]["derivation_policy"] == {
|
|
"allowed": ["continuation"], "multiplicity": "none",
|
|
}
|
|
for selector in selectors
|
|
))
|
|
self.assertTrue(any("geometry" not in selector for selector in selectors))
|
|
|
|
with tempfile.TemporaryDirectory() as directory:
|
|
rebuilt = Path(directory) / "rebuild.step"
|
|
outcome = rebuild_candidate(result.cdsl, rebuilt)
|
|
self.assertEqual(outcome["status"], "rebuild_failed")
|
|
self.assertEqual(outcome["error"]["message"], "f_F2: selector_query_unsupported during incremental replay")
|
|
self.assertTrue(rebuilt.exists())
|
|
self.assertEqual(outcome["last_executable_prefix"]["last_feature_id"], "f_F1")
|
|
|
|
def test_direct_translation_transform_updates_the_source_revolve(self):
|
|
root = Path(__file__).parents[2] / "data/cadfs-sample/CADFS_test"
|
|
feature = root / "featurescript_rp/0011/00111611.txt"
|
|
if not feature.exists(): self.skipTest("CADFS sample is not installed")
|
|
result = lower_model(parse_featurescript(feature.read_text(), "00111611"), {})
|
|
self.assertNotIn("F10", {item.get("feature_id") for item in result.diagnostics})
|
|
features = {item["id"]: item for item in result.cdsl["features"]}
|
|
sketches = {item["id"]: item for item in result.cdsl["geometry"]["sketches"]}
|
|
self.assertEqual(features["f_F9"]["params"]["result_mode"], "new_body")
|
|
self.assertEqual(sketches[features["f_F9"]["sketch_id"]]["workplane"]["origin_mm"], [77.16, -11.67, -63.0])
|
|
for actual, expected in zip(features["f_F9"]["params"]["axis"]["origin_mm"], [0.13, -11.67, 56.11]):
|
|
self.assertAlmostEqual(actual, expected)
|
|
|
|
def test_cap_face_workplane_uses_the_physical_cap_normal(self):
|
|
root = Path(__file__).parents[2] / "data/cadfs-sample/CADFS_test"
|
|
feature = root / "featurescript_rp/0011/00111611.txt"
|
|
if not feature.exists(): self.skipTest("CADFS sample is not installed")
|
|
result = lower_model(parse_featurescript(feature.read_text(), "00111611"), {})
|
|
sketches = {item["id"]: item for item in result.cdsl["geometry"]["sketches"]}
|
|
|
|
self.assertEqual(sketches["sketch_F2"]["workplane"]["origin_mm"], [0.0, 25.4, 0.0])
|
|
self.assertEqual(sketches["sketch_F2"]["workplane"]["normal"], [0.0, 1.0, 0.0])
|
|
self.assertEqual(sketches["sketch_F6"]["workplane"]["origin_mm"], [0.0, 0.0, 0.0])
|
|
self.assertEqual(sketches["sketch_F6"]["workplane"]["normal"], [0.0, -1.0, 0.0])
|
|
|
|
def test_nested_circle_imprint_selects_its_bounded_annulus(self):
|
|
root = Path(__file__).parents[2] / "data/cadfs-sample/CADFS_test"
|
|
feature = root / "featurescript_rp/0011/00111611.txt"
|
|
if not feature.exists(): self.skipTest("CADFS sample is not installed")
|
|
result = lower_model(parse_featurescript(feature.read_text(), "00111611"), {})
|
|
features = {item["id"]: item for item in result.cdsl["features"]}
|
|
sketches = {item["id"]: item for item in result.cdsl["geometry"]["sketches"]}
|
|
profile = sketches[features["f_F7"]["sketch_id"]]["profile"]
|
|
|
|
self.assertEqual(profile["type"], "analytic_contours")
|
|
self.assertEqual(
|
|
[(item["role"], item["segments"][0]["radius_mm"]) for item in profile["contours"]],
|
|
[("outer", 4.48), ("inner", 2.36)],
|
|
)
|
|
|
|
def test_ellipse_profiles_unblock_the_00287955_feature_chain(self):
|
|
root = Path(__file__).parents[2] / "data/cadfs-sample/CADFS_test"
|
|
feature = root / "featurescript_rp/0028/00287955.txt"
|
|
if not feature.exists(): self.skipTest("CADFS sample is not installed")
|
|
|
|
result = lower_model(parse_featurescript(feature.read_text(), "00287955"), {})
|
|
features = {item["id"] for item in result.cdsl["features"]}
|
|
feature_by_id = {item["id"]: item for item in result.cdsl["features"]}
|
|
sketches = {item["id"]: item for item in result.cdsl["geometry"]["sketches"]}
|
|
|
|
self.assertTrue({"f_F3", "f_F5", "f_F6", "f_F11"}.issubset(features))
|
|
self.assertEqual(feature_by_id["f_F9"]["atomic_id"], "extrude_add_blind")
|
|
self.assertNotIn("selectors", feature_by_id["f_F9"])
|
|
mid_plane = feature_by_id["f_F12"]["params"]["plane"]
|
|
self.assertAlmostEqual(mid_plane["origin_mm"][0], -18.67, places=5)
|
|
self.assertAlmostEqual(mid_plane["normal"][0], 1.0, places=5)
|
|
self.assertAlmostEqual(mid_plane["normal"][1], 0.0, places=3)
|
|
axis = feature_by_id["f_F14"]["params"]["axis"]
|
|
self.assertAlmostEqual(axis["origin_mm"][0], -18.67, delta=0.01)
|
|
self.assertAlmostEqual(axis["origin_mm"][1], 33.77, delta=0.01)
|
|
for sketch_id in ("sketch_F2", "sketch_F4", "sketch_F7", "sketch_F8"):
|
|
segment = sketches[sketch_id]["profile"]["contours"][0]["segments"][0]
|
|
self.assertEqual(segment["type"], "ellipse")
|
|
self.assertNotIn("sketch_deferred", {item["code"] for item in result.diagnostics})
|
|
|
|
def test_circular_pattern_lowers_to_existing_engine_contract(self):
|
|
root = Path(__file__).parents[2] / "data/cadfs-sample/CADFS_test"
|
|
feature = root / "featurescript_rp/0042/00423838.txt"
|
|
if not feature.exists(): self.skipTest("CADFS sample is not installed")
|
|
result = lower_model(parse_featurescript(feature.read_text(), "00423838"), {})
|
|
self.assertIsNotNone(result.cdsl)
|
|
features = {item["id"]: item for item in result.cdsl["features"]}
|
|
pattern = features["f_F4"]
|
|
self.assertEqual(pattern["atomic_id"], "pattern_circular")
|
|
self.assertEqual(pattern["params"]["source_feature_ids"], ["f_F1"])
|
|
self.assertEqual(pattern["params"]["pattern_count"], 6)
|
|
self.assertEqual(pattern["params"]["sweep_angle_deg"], 360.0)
|
|
self.assertEqual(pattern["params"]["axis"]["direction"], [0.0, 0.0, -1.0])
|
|
self.assertNotIn("F2", {item.get("feature_id") for item in result.diagnostics})
|
|
sketches = {item["id"]: item for item in result.cdsl["geometry"]["sketches"]}
|
|
self.assertNotEqual(sketches[features["f_F1"]["sketch_id"]]["workplane"]["normal"], [0.0, 0.0, 1.0])
|
|
self.assertNotIn("circularPattern", {item.get("operation") for item in result.diagnostics})
|
|
|
|
def test_static_integral_round_pattern_count_is_lowered_without_guessing_rounding_mode(self):
|
|
root = Path(__file__).parents[2] / "data/cadfs-sample/CADFS_test"
|
|
for sample_id, feature_id, count in (
|
|
("00003011", "f_F5", 8),
|
|
("00039410", "f_F6", 9),
|
|
):
|
|
with self.subTest(sample_id=sample_id):
|
|
feature = root / "featurescript_rp" / sample_id[:4] / f"{sample_id}.txt"
|
|
result = lower_model(parse_featurescript(feature.read_text(), sample_id), {})
|
|
features = {item["id"]: item for item in result.cdsl["features"]}
|
|
self.assertEqual(features[feature_id]["atomic_id"], "pattern_circular")
|
|
self.assertEqual(features[feature_id]["params"]["pattern_count"], count)
|
|
self.assertNotIn(feature_id.removeprefix("f_"), {
|
|
item.get("feature_id") for item in result.diagnostics
|
|
})
|
|
|
|
integral_round = Call("round", [8.0])
|
|
fractional_round = Call("round", [8.5])
|
|
self.assertEqual(_number(integral_round), 8.0)
|
|
with self.assertRaisesRegex(ValueError, "not a constant number"):
|
|
_number(fractional_round)
|
|
|
|
def test_two_point_fit_spline_requires_endpoint_derivatives_and_lowers_as_bspline(self):
|
|
root = Path(__file__).parents[2] / "data/cadfs-sample/CADFS_test"
|
|
source_path = root / "featurescript_rp/0003/00039410.txt"
|
|
source = source_path.read_text(encoding="utf-8")
|
|
result = lower_model(parse_featurescript(source, "00039410"), {})
|
|
sketches = {item["id"]: item for item in result.cdsl["geometry"]["sketches"]}
|
|
profile = sketches["sketch_F4"]["profile"]
|
|
splines = [
|
|
segment
|
|
for contour in profile["contours"]
|
|
for segment in contour["segments"]
|
|
if segment["type"] == "bspline"
|
|
]
|
|
self.assertEqual(len(splines), 2)
|
|
self.assertTrue(all(len(segment["points"]) == 2 for segment in splines))
|
|
self.assertTrue(all("start_tangent" in segment and "end_tangent" in segment for segment in splines))
|
|
features = {item["id"]: item for item in result.cdsl["features"]}
|
|
self.assertEqual(features["f_F6"]["params"]["pattern_count"], 9)
|
|
self.assertNotIn("F4", {item.get("feature_id") for item in result.diagnostics})
|
|
self.assertNotIn("F6", {item.get("feature_id") for item in result.diagnostics})
|
|
|
|
missing_tangent = source.replace(', "endDerivative": vector(4.02, 9.38) * mm', "", 1)
|
|
rejected = lower_model(parse_featurescript(missing_tangent, "two-point-spline-without-tangent"), {})
|
|
self.assertIn({
|
|
"code": "sketch_deferred",
|
|
"feature_id": "F4",
|
|
"message": "two-point fit spline requires both endpoint derivatives",
|
|
}, rejected.diagnostics)
|
|
|
|
coincident = source.replace('v(0, 30) * mm', 'v(-1, 19.97) * mm', 1)
|
|
rejected = lower_model(parse_featurescript(coincident, "two-point-spline-with-coincident-endpoints"), {})
|
|
self.assertIn({
|
|
"code": "sketch_deferred",
|
|
"feature_id": "F4",
|
|
"message": "two-point fit spline endpoints must be distinct",
|
|
}, rejected.diagnostics)
|
|
|
|
def test_opposed_circle_regions_lower_to_their_union_disk(self):
|
|
root = Path(__file__).parents[2] / "data/cadfs-sample/CADFS_test"
|
|
feature = root / "featurescript_rp/0042/00423838.txt"
|
|
if not feature.exists(): self.skipTest("CADFS sample is not installed")
|
|
result = lower_model(parse_featurescript(feature.read_text(), "00423838"), {})
|
|
features = {item["id"]: item for item in result.cdsl["features"]}
|
|
sketches = {item["id"]: item for item in result.cdsl["geometry"]["sketches"]}
|
|
profile = sketches[features["f_F6"]["sketch_id"]]["profile"]
|
|
self.assertEqual(profile["type"], "circle")
|
|
self.assertEqual(profile["radius_mm"], 30.0)
|
|
|
|
def test_reference_plane_variants_lower_to_explicit_frames(self):
|
|
root = Path(__file__).parents[2] / "data/cadfs-sample/CADFS_test"
|
|
cases = {
|
|
"00159804": {"F3", "F5"},
|
|
"00192744": {"F3"},
|
|
"00212904": {"F3"},
|
|
"00542223": {"F3"},
|
|
}
|
|
for sample_id, expected in cases.items():
|
|
with self.subTest(sample_id=sample_id):
|
|
feature = root / "featurescript_rp" / sample_id[:4] / f"{sample_id}.txt"
|
|
if not feature.exists(): self.skipTest("CADFS sample is not installed")
|
|
result = lower_model(parse_featurescript(feature.read_text(), sample_id), {})
|
|
features = {item["name"]: item for item in result.cdsl["features"]}
|
|
for feature_id in expected:
|
|
plane = features[feature_id]
|
|
self.assertEqual(plane["atomic_id"], "reference_plane")
|
|
self.assertEqual(set(plane["params"]["plane"]), {"origin_mm", "x_dir", "normal"})
|
|
diagnostics = [item for item in result.diagnostics if item.get("operation") == "cPlane"]
|
|
self.assertFalse(diagnostics)
|
|
|
|
def test_curve_point_plane_uses_an_explicit_bspline_endpoint_tangent(self):
|
|
root = Path(__file__).parents[2] / "data/cadfs-sample/CADFS_test"
|
|
feature = root / "featurescript_rp/0082/00827798.txt"
|
|
if not feature.exists(): self.skipTest("CADFS sample is not installed")
|
|
result = lower_model(parse_featurescript(feature.read_text(), "00827798"), {})
|
|
plane = next(item for item in result.cdsl["features"] if item["id"] == "f_F1")
|
|
self.assertEqual(plane["atomic_id"], "reference_plane")
|
|
self.assertFalse(any(
|
|
item.get("operation") == "cPlane" and item.get("feature_id") == "F1"
|
|
for item in result.diagnostics
|
|
))
|
|
expected = [107.86, 0.0, -176.04]
|
|
magnitude = math.sqrt(sum(value * value for value in expected))
|
|
for actual, value in zip(plane["params"]["plane"]["normal"], expected):
|
|
self.assertAlmostEqual(actual, value / magnitude)
|
|
|
|
second_feature = root / "featurescript_rp/0084/00845891.txt"
|
|
if second_feature.exists():
|
|
second = lower_model(parse_featurescript(second_feature.read_text(), "00845891"), {})
|
|
self.assertEqual(
|
|
next(item for item in second.cdsl["features"] if item["id"] == "f_F3")["atomic_id"],
|
|
"reference_plane",
|
|
)
|
|
self.assertFalse(any(
|
|
item.get("operation") == "cPlane" and item.get("feature_id") == "F3"
|
|
for item in second.diagnostics
|
|
))
|
|
|
|
without_end_derivative = feature.read_text().replace(
|
|
', "endDerivative": vector(107.86, -176.04) * mm', "", 1,
|
|
)
|
|
rejected = lower_model(parse_featurescript(without_end_derivative, "00827798-no-end-derivative"), {})
|
|
self.assertIn({
|
|
"code": "unsupported_engine_capability",
|
|
"capability": "reference_plane:curve_point",
|
|
"feature_id": "F1",
|
|
"operation": "cPlane",
|
|
"message": "CURVE_POINT B-spline endpoint has no exported tangent",
|
|
}, rejected.diagnostics)
|
|
|
|
def test_curve_endpoint_tangent_uses_arc_orientation_without_a_chord_fallback(self):
|
|
arc = {
|
|
"type": "arc", "start": [1.0, 0.0], "end": [0.0, 1.0],
|
|
"center": [0.0, 0.0], "clockwise": False,
|
|
}
|
|
self.assertEqual(_curve_endpoint_tangent(arc, "start"), [0.0, 1.0])
|
|
self.assertEqual(_curve_endpoint_tangent(arc, "end"), [-1.0, 0.0])
|
|
with self.assertRaisesRegex(UnsupportedCapability, "direct source-curve endpoint"):
|
|
_curve_endpoint_tangent(arc, "internal")
|
|
|
|
def test_curve_point_plane_uses_exact_bspline_interpolation_vertex_tangents(self):
|
|
root = Path(__file__).parents[2] / "data/cadfs-sample/CADFS_test"
|
|
cases = {
|
|
"00456498": ("f_F1", "F1", [141.23, 0.0, -13.99]),
|
|
"00812557": ("f_F2", "F2", [0.0, 191.15, -139.74]),
|
|
}
|
|
for sample_id, (cdsl_feature_id, source_feature_id, expected) in cases.items():
|
|
with self.subTest(sample_id=sample_id):
|
|
source = root / "featurescript_rp" / sample_id[:4] / f"{sample_id}.txt"
|
|
if not source.exists():
|
|
self.skipTest("CADFS sample is not installed")
|
|
result = lower_model(parse_featurescript(source.read_text(), sample_id), {})
|
|
plane = next(item for item in result.cdsl["features"] if item["id"] == cdsl_feature_id)
|
|
self.assertEqual(plane["atomic_id"], "reference_plane")
|
|
magnitude = math.sqrt(sum(value * value for value in expected))
|
|
for actual, value in zip(plane["params"]["plane"]["normal"], expected):
|
|
self.assertAlmostEqual(actual, value / magnitude, places=8)
|
|
self.assertFalse(any(
|
|
item.get("operation") == "cPlane" and item.get("feature_id") == source_feature_id
|
|
for item in result.diagnostics
|
|
))
|
|
|
|
no_derivatives = (root / "featurescript_rp/0045/00456498.txt").read_text().replace(
|
|
', "startDerivative": vector(0, 64.52) * mm, "endDerivative": vector(141.23, -13.99) * mm', "", 1,
|
|
)
|
|
rejected = lower_model(parse_featurescript(no_derivatives, "00456498-no-derivatives"), {})
|
|
self.assertIn({
|
|
"code": "unsupported_engine_capability",
|
|
"capability": "reference_plane:curve_point",
|
|
"feature_id": "F1",
|
|
"operation": "cPlane",
|
|
"message": "CURVE_POINT B-spline interpolation point has no complete source interpolation data",
|
|
}, rejected.diagnostics)
|
|
|
|
derived = (root / "featurescript_rp/0045/00456498.txt").read_text().replace(
|
|
'"E0.2.internal"', '"E0.2.endSnap0"', 1,
|
|
)
|
|
rejected_derived = lower_model(parse_featurescript(derived, "00456498-derived-vertex"), {})
|
|
self.assertIn({
|
|
"code": "unsupported_engine_capability",
|
|
"capability": "reference_plane:curve_point",
|
|
"feature_id": "F1",
|
|
"operation": "cPlane",
|
|
"message": "CURVE_POINT point must name a direct source-curve endpoint or B-spline interpolation vertex",
|
|
}, rejected_derived.diagnostics)
|
|
|
|
def test_curve_point_plane_uses_a_direct_arc_endpoint_tangent(self):
|
|
root = Path(__file__).parents[2] / "data/cadfs-sample/CADFS_test"
|
|
feature = root / "featurescript_rp/0005/00057273.txt"
|
|
if not feature.exists(): self.skipTest("CADFS sample is not installed")
|
|
source = feature.read_text().replace(
|
|
'EDGE,"E1"', 'EDGE,"E0"', 1,
|
|
).replace(
|
|
'VERTEX,"E1.end"', 'VERTEX,"E0.end"', 1,
|
|
)
|
|
result = lower_model(parse_featurescript(source, "00057273-arc-curve-point"), {})
|
|
plane = next(item for item in result.cdsl["features"] if item["id"] == "f_F1")
|
|
self.assertEqual(plane["atomic_id"], "reference_plane")
|
|
self.assertEqual(plane["params"]["plane"]["origin_mm"], [-24.6, 0.0, 0.0])
|
|
self.assertEqual(plane["params"]["plane"]["normal"], [0.0, -1.0, 0.0])
|
|
self.assertFalse(any(
|
|
item.get("operation") == "cPlane" and item.get("feature_id") == "F1"
|
|
for item in result.diagnostics
|
|
))
|
|
|
|
def test_offset_reference_plane_honors_opposite_direction_without_reversing_its_frame(self):
|
|
root = Path(__file__).parents[2] / "data/cadfs-sample/CADFS_test"
|
|
feature = root / "featurescript_rp/0077/00777619.txt"
|
|
if not feature.exists(): self.skipTest("CADFS sample is not installed")
|
|
source = feature.read_text()
|
|
|
|
opposite = lower_model(parse_featurescript(source, "00777619"), {})
|
|
opposite_plane = next(item for item in opposite.cdsl["features"] if item["id"] == "f_F2")["params"]["plane"]
|
|
self.assertEqual(opposite_plane, {
|
|
"origin_mm": [-76.2, 0.0, 0.0],
|
|
"x_dir": [0.0, 1.0, 0.0],
|
|
"normal": [1.0, 0.0, 0.0],
|
|
})
|
|
|
|
default = lower_model(parse_featurescript(source.replace('"oppositeDirection" : true, ', ""), "00777619-default"), {})
|
|
default_plane = next(item for item in default.cdsl["features"] if item["id"] == "f_F2")["params"]["plane"]
|
|
self.assertEqual(default_plane, {
|
|
"origin_mm": [76.2, 0.0, 0.0],
|
|
"x_dir": [0.0, 1.0, 0.0],
|
|
"normal": [1.0, 0.0, 0.0],
|
|
})
|
|
|
|
def test_shell_preserves_pattern_copy_cap_faces_and_offset_edge_fillet(self):
|
|
root = Path(__file__).parents[2] / "data/cadfs-sample/CADFS_test"
|
|
feature = root / "featurescript_rp/0054/00542223.txt"
|
|
if not feature.exists(): self.skipTest("CADFS sample is not installed")
|
|
|
|
result = lower_model(parse_featurescript(feature.read_text(), "00542223"), {})
|
|
features = {item["id"]: item for item in result.cdsl["features"]}
|
|
sketches = {item["id"]: item for item in result.cdsl["geometry"]["sketches"]}
|
|
shell = features["f_F7"]
|
|
fillet = features["f_F8"]
|
|
|
|
self.assertEqual(sketches["sketch_F4"]["workplane"]["origin_mm"], [0.0, 0.0, -50.0])
|
|
self.assertEqual(features["f_F5"]["params"]["path"]["segment"]["points"][0], [-40.0, -50.0])
|
|
self.assertEqual(features["f_F5"]["params"]["path"]["segment"]["start_tangent"], [27.94, 92.49])
|
|
self.assertEqual(shell["selectors"][1]["geometry"], {
|
|
"normal": [0.0, 0.0, 1.0], "plane_offset_mm": -50.0,
|
|
"center_mm": [0.0, -40.0, -50.0], "minimum_area_mm2": 481.0563750809371,
|
|
})
|
|
expected_centers = [[34.64101615137755, 20.0, -50.0], [0.0, -40.0, -50.0], [-34.64101615137754, 20.0, -50.0]]
|
|
for center, expected in zip([selector["geometry"]["center_mm"] for selector in shell["selectors"][:3]], expected_centers):
|
|
for value, target in zip(center, expected): self.assertAlmostEqual(value, target)
|
|
self.assertEqual(shell["selectors"][3]["geometry"]["center_mm"], [0.0, 0.0, 50.0])
|
|
self.assertEqual(shell["atomic_id"], "shell")
|
|
self.assertEqual(len(shell["selectors"]), 4)
|
|
self.assertEqual(
|
|
[selector["owner_feature_id"] for selector in shell["selectors"][:3]],
|
|
["f_F6.c1.f_F5", "f_F5", "f_F6.c2.f_F5"],
|
|
)
|
|
self.assertEqual(fillet["atomic_id"], "fillet")
|
|
self.assertEqual(fillet["selectors"][0]["geometry"]["source_circle_radius_mm"], 17.5)
|
|
self.assertEqual(shell["params"]["target_feature_id"], "f_F5")
|
|
self.assertFalse(any(
|
|
diagnostic.get("capability") == "shell_parts_body_source"
|
|
for diagnostic in result.diagnostics
|
|
))
|
|
self.assertNotIn("F8", {item.get("feature_id") for item in result.diagnostics})
|
|
|
|
def test_shell_resolves_direct_prism_swept_faces_through_kernel_lineage(self):
|
|
root = Path(__file__).parents[2] / "data/cadfs-sample/CADFS_test"
|
|
feature = root / "featurescript_rp/0059/00594348.txt"
|
|
if not feature.exists(): self.skipTest("CADFS sample is not installed")
|
|
|
|
result = lower_model(parse_featurescript(feature.read_text(), "00594348"), {})
|
|
self.assertEqual(result.status, "converted_complete")
|
|
shell_index = next(index for index, item in enumerate(result.cdsl["features"]) if item["id"] == "f_F2")
|
|
shell = result.cdsl["features"][shell_index]
|
|
self.assertEqual(shell["atomic_id"], "shell")
|
|
self.assertEqual([item["owner_feature_id"] for item in shell["selectors"]], ["f_F1", "f_F1"])
|
|
self.assertTrue(all("geometry" not in item and "stable_id" not in item for item in shell["selectors"]))
|
|
self.assertTrue(all(item["selector_intent"]["query_family"] == "SWEPT_FACE" for item in shell["selectors"]))
|
|
self.assertTrue(all(item["selector_intent"]["evidence"] == "kernel_history" for item in shell["selectors"]))
|
|
self.assertTrue(all(
|
|
item["selector_intent"]["derivation_policy"] == {"allowed": ["boundary"], "multiplicity": "one"}
|
|
for item in shell["selectors"]
|
|
))
|
|
with tempfile.TemporaryDirectory() as directory:
|
|
outcome = rebuild_candidate(result.cdsl, Path(directory) / "swept-face-shell.step")
|
|
self.assertEqual(outcome["status"], "rebuilt")
|
|
resolutions = [
|
|
item for item in outcome["result"]["selector_resolution"]
|
|
if item["feature_id"] == "f_F2"
|
|
]
|
|
self.assertEqual(len(resolutions), 2)
|
|
self.assertTrue(all(item["resolution_mode"] == "kernel_lineage" for item in resolutions))
|
|
self.assertTrue(all(
|
|
item["evidence"]["relations"][0]["source_kind"] == "edge"
|
|
and item["evidence"]["relations"][0]["result_kind"] == "face"
|
|
for item in resolutions
|
|
))
|
|
|
|
def test_shell_resolves_immediate_direct_prism_cap_faces_through_output_roles(self):
|
|
root = Path(__file__).parents[2] / "data/cadfs-sample/CADFS_test"
|
|
cases = (("00212904", "extrude.start"), ("00789939", "extrude.end"))
|
|
for sample_id, output_role in cases:
|
|
with self.subTest(sample_id=sample_id):
|
|
feature = root / "featurescript_rp" / sample_id[:4] / f"{sample_id}.txt"
|
|
if not feature.exists(): self.skipTest("CADFS sample is not installed")
|
|
result = lower_model(parse_featurescript(feature.read_text(encoding="utf-8"), sample_id), {})
|
|
self.assertEqual(result.status, "converted_complete")
|
|
shell_index = next(index for index, item in enumerate(result.cdsl["features"]) if item["id"] == "f_F2")
|
|
shell = result.cdsl["features"][shell_index]
|
|
self.assertEqual(shell["atomic_id"], "shell")
|
|
self.assertEqual(len(shell["selectors"]), 1)
|
|
selector = shell["selectors"][0]
|
|
self.assertEqual(selector["owner_feature_id"], "f_F1")
|
|
self.assertEqual(selector["output_role"], output_role)
|
|
self.assertEqual(selector["selector_intent"]["query_family"], "CAP_FACE")
|
|
self.assertEqual(selector["selector_intent"]["evidence"], "operation_role")
|
|
self.assertNotIn("stable_id", selector)
|
|
self.assertNotIn("binding_feature_id", selector)
|
|
self.assertNotIn("geometry", selector)
|
|
|
|
prefix = deepcopy(result.cdsl)
|
|
prefix["features"] = prefix["features"][:shell_index + 1]
|
|
with tempfile.TemporaryDirectory() as directory:
|
|
outcome = rebuild_candidate(prefix, Path(directory) / f"{sample_id}-cap-face-shell.step")
|
|
self.assertEqual(outcome["status"], "rebuilt")
|
|
resolution = next(
|
|
item for item in outcome["result"]["selector_resolution"]
|
|
if item["feature_id"] == "f_F2"
|
|
)
|
|
self.assertEqual(resolution["status"], "resolved")
|
|
self.assertEqual(resolution["resolution_mode"], "operation_role")
|
|
self.assertEqual(resolution["selected"]["output_roles"], [output_role])
|
|
|
|
def test_shell_direct_prism_swept_face_rejects_unregistered_source_version(self):
|
|
root = Path(__file__).parents[2] / "data/cadfs-sample/CADFS_test"
|
|
feature = root / "featurescript_rp/0059/00594348.txt"
|
|
if not feature.exists(): self.skipTest("CADFS sample is not installed")
|
|
|
|
source = feature.read_text(encoding="utf-8").replace("FeatureScript 1511;", "FeatureScript 1793;", 1)
|
|
result = lower_model(parse_featurescript(source, "00594348-version-1793"), {})
|
|
shell = next(item for item in result.cdsl["features"] if item["id"] == "f_F2")
|
|
self.assertTrue(all(
|
|
item["selector_intent"]["evidence"] == "feature_script_query"
|
|
and item["selector_intent"]["derivation_policy"]["multiplicity"] == "none"
|
|
for item in shell["selectors"]
|
|
))
|
|
with tempfile.TemporaryDirectory() as directory:
|
|
outcome = rebuild_candidate(result.cdsl, Path(directory) / "swept-face-shell-1793.step")
|
|
self.assertEqual(outcome["status"], "rebuild_failed")
|
|
self.assertEqual(outcome["error"]["message"], "f_F2: selector_query_unsupported during incremental replay")
|
|
self.assertEqual(outcome["last_executable_prefix"]["last_feature_id"], "f_F1")
|
|
|
|
def test_shell_direct_prism_swept_face_rejects_unregistered_standard_library_revision(self):
|
|
root = Path(__file__).parents[2] / "data/cadfs-sample/CADFS_test"
|
|
feature = root / "featurescript_rp/0059/00594348.txt"
|
|
if not feature.exists(): self.skipTest("CADFS sample is not installed")
|
|
|
|
source = feature.read_text(encoding="utf-8").replace(
|
|
'import(path : "onshape/std/geometry.fs", version : "1511.0");',
|
|
'import(path : "onshape/std/geometry.fs", version : "1512.0");',
|
|
1,
|
|
)
|
|
result = lower_model(parse_featurescript(source, "00594348-library-1512"), {})
|
|
shell = next(item for item in result.cdsl["features"] if item["id"] == "f_F2")
|
|
self.assertTrue(all(
|
|
item["selector_intent"]["source_query"]["featurescript_version"] == "1511"
|
|
and item["selector_intent"]["source_query"]["standard_library"] == "onshape/std/geometry.fs"
|
|
and item["selector_intent"]["source_query"]["standard_library_version"] == "1512.0"
|
|
for item in shell["selectors"]
|
|
))
|
|
with tempfile.TemporaryDirectory() as directory:
|
|
outcome = rebuild_candidate(result.cdsl, Path(directory) / "swept-face-shell-library-1512.step")
|
|
self.assertEqual(outcome["status"], "rebuild_failed")
|
|
self.assertEqual(outcome["error"]["message"], "f_F2: selector_query_unsupported during incremental replay")
|
|
self.assertEqual(outcome["last_executable_prefix"]["last_feature_id"], "f_F1")
|
|
|
|
def test_shell_offset_face_requires_true_dependency_cap_evidence(self):
|
|
root = Path(__file__).parents[2] / "data/cadfs-sample/CADFS_test"
|
|
feature = root / "featurescript_rp/0010/00107631.txt"
|
|
if not feature.exists(): self.skipTest("CADFS sample is not installed")
|
|
# Keep the same nested CAP_FACE outside a true-dependency relation.
|
|
# It is source-profile evidence only and must not select an OFFSET_FACE.
|
|
source = feature.read_text(encoding="utf-8").replace(
|
|
'TDD([makeQuery(id+"F1.opExtrude","CAP_FACE",FACE,{"disambiguationData":[OSD([subQ0])],"isStart":true})])',
|
|
'OSD([subQ0])',
|
|
)
|
|
result = lower_model(parse_featurescript(source, "00107631-without-tdd"), {})
|
|
|
|
diagnostic = next(item for item in result.diagnostics if item.get("feature_id") == "F3")
|
|
self.assertEqual(diagnostic["capability"], "shell_offset_face_selector")
|
|
self.assertIn("true dependency", diagnostic["message"])
|
|
|
|
def test_shell_runtime_failure_exports_its_bound_executable_prefix(self):
|
|
root = Path(__file__).parents[2] / "data/cadfs-sample/CADFS_test"
|
|
feature = root / "featurescript_rp/0024/00248377.txt"
|
|
if not feature.exists(): self.skipTest("CADFS sample is not installed")
|
|
|
|
result = lower_model(parse_featurescript(feature.read_text(), "00248377"), {})
|
|
self.assertEqual(result.status, "converted_complete")
|
|
with tempfile.TemporaryDirectory() as directory:
|
|
rebuilt = Path(directory) / "swept-face-shell-prefix.step"
|
|
outcome = rebuild_candidate(result.cdsl, rebuilt)
|
|
self.assertTrue(rebuilt.exists())
|
|
self.assertEqual(outcome["status"], "rebuild_failed")
|
|
self.assertEqual(outcome["error"]["type"], "ValueError")
|
|
self.assertEqual(outcome["error"]["message"], "f_F5: selector_query_unsupported during incremental replay")
|
|
self.assertIn("bound_cdsl", outcome)
|
|
self.assertEqual(outcome["last_executable_prefix"]["failed_feature_id"], "f_F5")
|
|
self.assertEqual(outcome["last_executable_prefix"]["last_feature_id"], "f_F4")
|
|
self.assertEqual(outcome["last_executable_prefix"]["result"]["solid_count"], 1)
|
|
|
|
def test_pattern_copy_intersection_query_preserves_its_prefix_without_instance_geometry_binding(self):
|
|
root = Path(__file__).parents[2] / "data/cadfs-sample/CADFS_test"
|
|
feature = root / "featurescript_rp/0042/00423838.txt"
|
|
if not feature.exists(): self.skipTest("CADFS sample is not installed")
|
|
|
|
result = lower_model(parse_featurescript(feature.read_text(), "00423838"), {})
|
|
with tempfile.TemporaryDirectory() as directory:
|
|
rebuilt = Path(directory) / "selector-prefix.step"
|
|
outcome = rebuild_candidate(result.cdsl, rebuilt)
|
|
self.assertTrue(rebuilt.exists())
|
|
self.assertEqual(outcome["status"], "rebuild_failed")
|
|
self.assertEqual(outcome["error"]["message"], "f_F7: selector_query_unsupported during incremental replay")
|
|
self.assertEqual(outcome["last_executable_prefix"]["last_feature_id"], "f_F6")
|
|
reference = next(item for item in result.cdsl["features"] if item["id"] == "f_F7")["params"]["end_condition"]["reference"]
|
|
self.assertEqual(reference["selector_intent"]["query_family"], "INTERSECT")
|
|
self.assertEqual(
|
|
[item["selector_intent"]["query_family"] for item in reference["intersection_of"][:2]],
|
|
["COPY", "COPY"],
|
|
)
|
|
|
|
def test_shell_rejects_swept_faces_without_direct_linear_extrude_ownership(self):
|
|
root = Path(__file__).parents[2] / "data/cadfs-sample/CADFS_test"
|
|
cases = (("00246716", "F7"), ("00051308", "F3"))
|
|
for sample_id, shell_id in cases:
|
|
with self.subTest(sample_id=sample_id):
|
|
feature = root / "featurescript_rp" / sample_id[:4] / f"{sample_id}.txt"
|
|
if not feature.exists(): self.skipTest("CADFS sample is not installed")
|
|
result = lower_model(parse_featurescript(feature.read_text(), sample_id), {})
|
|
diagnostic = next(item for item in result.diagnostics if item.get("feature_id") == shell_id)
|
|
self.assertEqual(diagnostic["code"], "unsupported_engine_capability")
|
|
self.assertEqual(diagnostic["capability"], "shell_face_selector")
|
|
self.assertIn("direct blind/two-sided linear extrusion", diagnostic["message"])
|
|
|
|
def test_curve_point_plane_uses_its_projected_attachment_origin(self):
|
|
root = Path(__file__).parents[2] / "data/cadfs-sample/CADFS_test"
|
|
feature = root / "featurescript_rp/0019/00192744.txt"
|
|
if not feature.exists(): self.skipTest("CADFS sample is not installed")
|
|
result = lower_model(parse_featurescript(feature.read_text(), "00192744"), {})
|
|
sketches = {item["id"]: item for item in result.cdsl["geometry"]["sketches"]}
|
|
plane = sketches["sketch_F4"]["workplane"]
|
|
self.assertEqual(plane["origin_mm"], [0.0, -2000.0, -4000.0])
|
|
self.assertAlmostEqual(_global(plane, [0.0, 8944.27])[1], -10000.0, places=2)
|
|
self.assertAlmostEqual(_global(plane, [0.0, 8944.27])[2], 0.0, places=2)
|
|
|
|
def test_delete_pattern_copies_lower_to_explicit_exclusions(self):
|
|
root = Path(__file__).parents[2] / "data/cadfs-sample/CADFS_test"
|
|
feature = root / "featurescript_rp/0019/00192744.txt"
|
|
if not feature.exists(): self.skipTest("CADFS sample is not installed")
|
|
result = lower_model(parse_featurescript(feature.read_text(), "00192744"), {})
|
|
features = {item["id"]: item for item in result.cdsl["features"]}
|
|
self.assertEqual(features["f_F6"]["params"]["excluded_instance_indices"], [2])
|
|
self.assertEqual(features["f_F11"]["params"]["excluded_instance_indices"], [2])
|
|
self.assertEqual(result.status, "converted_complete")
|
|
self.assertFalse(result.diagnostics)
|
|
self.assertEqual(features["f_F15"]["atomic_id"], "transform_bodies")
|
|
self.assertEqual(features["f_F15"]["params"]["source_feature_ids"], ["f_F1", "f_F5"])
|
|
self.assertEqual(features["f_F15"]["params"]["pattern_instance_refs"], [
|
|
{"pattern_feature_id": "f_F6", "source_feature_id": "f_F5", "instance_index": 1},
|
|
{"pattern_feature_id": "f_F6", "source_feature_id": "f_F5", "instance_index": 3},
|
|
])
|
|
|
|
def test_feature_face_profile_is_not_reused_as_original_sketch(self):
|
|
source = SOURCE.replace('qSketchRegion(id + "F0", true)', 'makeQuery(id+"F1.opExtrude","CAP_FACE",FACE,{"isStart":false})')
|
|
result = lower_model(parse_featurescript(source, "face-profile"), {})
|
|
self.assertIsNone(result.cdsl)
|
|
self.assertEqual(result.diagnostics[0]["code"], "unsupported_engine_capability")
|
|
self.assertIn("extrude_profile_topology:cap_face", result.diagnostics[0]["capability"])
|
|
|
|
def test_cap_face_selector_retains_versioned_provenance_intent(self):
|
|
source = SOURCE.replace(
|
|
"FeatureScript 1511;",
|
|
'FeatureScript 1511;\nimport(path : "onshape/std/geometry.fs", version : "1511.0");',
|
|
1,
|
|
).replace(
|
|
'\n});\n',
|
|
'\n extrude(context, id + "F2", {"entities":makeQuery(id + "F1.opExtrude", "CAP_FACE", FACE, {"isStart":false}), "depth":10 * mm});\n});\n',
|
|
)
|
|
result = lower_model(parse_featurescript(source, "cap-intent"), {})
|
|
self.assertEqual(result.status, "converted_complete")
|
|
selector = next(item for item in result.cdsl["features"] if item["id"] == "f_F2")["selectors"][0]
|
|
self.assertEqual(selector["selector_intent"]["query_family"], "CAP_FACE")
|
|
self.assertNotIn("selector_intent_version", selector)
|
|
self.assertEqual(selector["selector_intent"]["source_query"]["featurescript_version"], "1511")
|
|
self.assertEqual(selector["selector_intent"]["source_query"]["standard_library"], "onshape/std/geometry.fs")
|
|
self.assertEqual(selector["selector_intent"]["source_query"]["standard_library_version"], "1511.0")
|
|
self.assertEqual(selector["selector_intent"]["evidence"], "operation_role")
|
|
from engine.cdsl_engine.semantic_validation import validate_semantic_cdsl
|
|
self.assertTrue(validate_semantic_cdsl(result.cdsl)["future_rebuild_ready"])
|
|
|
|
def test_direct_boolean_intersection_lowering_keeps_two_source_contract(self):
|
|
base = lower_model(parse_featurescript(SOURCE, "intersection-intent"), {}).cdsl
|
|
sketch = base["geometry"]["sketches"][0]
|
|
direct = {**base["features"][0], "id": "f_F2", "name": "F2"}
|
|
feature_by_id = {
|
|
"f_F1": base["features"][0],
|
|
"f_F2": direct,
|
|
"f_F3": {
|
|
"id": "f_F3", "atomic_id": "boolean_bodies",
|
|
"params": {
|
|
"operation": "subtract", "target_feature_ids": ["f_F1"],
|
|
"tool_feature_ids": ["f_F2"], "keep_tools": False,
|
|
},
|
|
},
|
|
}
|
|
cap = Call("makeQuery", ["F1.opExtrude", "CAP_FACE", "EntityType.FACE", {"isStart": False}])
|
|
source_edge = Call("sQuery", ["F0.wireOp", "EntityType.EDGE", "E0"])
|
|
swept = Call("makeQuery", [
|
|
"F2.opExtrude", "SWEPT_FACE", "EntityType.FACE",
|
|
{"disambiguationData": [Call("OSD", [[source_edge]])]},
|
|
])
|
|
query = Call("makeQuery", [
|
|
"F3.boolean.opBoolean", "INTERSECT", "EntityType.EDGE", {"derivedFrom": [cap, swept]},
|
|
])
|
|
selector = _direct_boolean_intersection_selector(
|
|
query,
|
|
feature_by_id=feature_by_id,
|
|
feature_frames={"F2": {"profile_source": "F0"}},
|
|
sketch_by_source={"F0": sketch},
|
|
sketches_by_id={sketch["id"]: sketch},
|
|
entity_by_sketch={"F0": {"E0": {"type": "circle", "center": [0, 0], "radius_mm": 9.53}}},
|
|
featurescript_version="1511",
|
|
)
|
|
|
|
self.assertIsNotNone(selector)
|
|
self.assertNotIn("stable_id", selector)
|
|
intent = selector["selector_intent"]
|
|
self.assertEqual(intent["derivation_policy"], {"allowed": ["intersection"], "multiplicity": "one"})
|
|
self.assertEqual(intent["intersection_sources"], [
|
|
{"query_family": "CAP_FACE", "owner_feature_id": "f_F1", "output_role": "extrude.end"},
|
|
{"query_family": "SWEPT_FACE", "owner_feature_id": "f_F2", "source_entity": {"sketch_id": "F0", "entity_id": "E0"}},
|
|
])
|
|
|
|
def test_direct_primary_cut_intersection_requires_no_unverified_disambiguation(self):
|
|
base = lower_model(parse_featurescript(SOURCE, "primary-intersection-intent"), {}).cdsl
|
|
target = base["features"][0]
|
|
target_sketch = base["geometry"]["sketches"][0]
|
|
tool_sketch = deepcopy(target_sketch)
|
|
tool_sketch.update({"id": "sketch_F2", "source_sketch_id": "F2"})
|
|
if tool_sketch["profile"].get("type") == "circle":
|
|
tool_sketch["profile"]["source_entity_id"] = "E1"
|
|
else:
|
|
for contour in tool_sketch["profile"]["contours"]:
|
|
for segment in contour["segments"]:
|
|
segment["source_entity_id"] = "E1"
|
|
tool = {
|
|
"id": "f_F3", "atomic_id": "extrude_cut_blind", "sketch_id": "sketch_F2",
|
|
"params": {"distance_mm": 10, "end_condition": {"type": "blind"}},
|
|
}
|
|
cap = Call("makeQuery", ["F1.opExtrude", "CAP_FACE", "EntityType.FACE", {"isStart": False}])
|
|
tool_edge = Call("sQuery", ["F2.wireOp", "EntityType.EDGE", "E1"])
|
|
swept = Call("makeQuery", [
|
|
"F3.opExtrude", "SWEPT_FACE", "EntityType.FACE",
|
|
{"disambiguationData": [Call("OSD", [[tool_edge]])]},
|
|
])
|
|
query = Call("makeQuery", [
|
|
"F3.boolean.opBoolean", "INTERSECT", "EntityType.EDGE", {"derivedFrom": [cap, swept]},
|
|
])
|
|
kwargs = {
|
|
"feature_by_id": {"f_F1": target, "f_F3": tool},
|
|
"feature_frames": {"F3": {"profile_source": "F2"}},
|
|
"sketch_by_source": {"F2": tool_sketch},
|
|
"sketches_by_id": {tool_sketch["id"]: tool_sketch, target_sketch["id"]: target_sketch},
|
|
"entity_by_sketch": {"F2": {"E1": {"type": "circle", "center": [0, 0], "radius_mm": 9.53}}},
|
|
"previous": ["f_F1", "f_F3"],
|
|
"featurescript_version": "1511",
|
|
}
|
|
selector = _direct_primary_cut_intersection_selector(query, **kwargs)
|
|
|
|
self.assertIsNotNone(selector)
|
|
self.assertEqual(selector["owner_feature_id"], "f_F3")
|
|
self.assertEqual(selector["selector_intent"]["intersection_sources"][1], {
|
|
"query_family": "SWEPT_FACE", "owner_feature_id": "f_F3",
|
|
"source_entity": {"sketch_id": "F2", "entity_id": "E1"},
|
|
})
|
|
deferred = Call("makeQuery", [
|
|
"F3.boolean.opBoolean", "INTERSECT", "EntityType.EDGE",
|
|
{"derivedFrom": [cap, swept], "disambiguationData": [Call("OD", [0.0])]},
|
|
])
|
|
self.assertIsNone(_direct_primary_cut_intersection_selector(deferred, **kwargs))
|
|
|
|
def test_deferred_primary_intersect_keeps_the_convertible_f3_checkpoint(self):
|
|
root = Path(__file__).parents[2] / "data/cadfs-sample/CADFS_test"
|
|
feature = root / "featurescript_rp/0002/00020311.txt"
|
|
if not feature.exists(): self.skipTest("CADFS sample is not installed")
|
|
|
|
result = lower_model(parse_featurescript(feature.read_text(), "00020311"), {})
|
|
f4 = next(item for item in result.cdsl["features"] if item["id"] == "f_F4")
|
|
self.assertTrue(all(
|
|
selector["kind"] == "edge"
|
|
and selector["selector_intent"]["query_family"] == "INTERSECT"
|
|
and selector["selector_intent"]["derivation_policy"]["multiplicity"] == "none"
|
|
for selector in f4["selectors"]
|
|
))
|
|
from engine.cdsl_engine.semantic_validation import validate_semantic_cdsl
|
|
self.assertTrue(validate_semantic_cdsl(result.cdsl)["future_rebuild_ready"])
|
|
with tempfile.TemporaryDirectory() as directory:
|
|
outcome = rebuild_candidate(result.cdsl, Path(directory) / "00020311.step")
|
|
self.assertTrue((Path(directory) / "00020311.step").exists())
|
|
self.assertEqual(outcome["status"], "rebuild_failed")
|
|
self.assertEqual(outcome["error"]["message"], "f_F4: selector_query_unsupported during incremental replay")
|
|
self.assertEqual(outcome["last_executable_prefix"]["last_feature_id"], "f_F3")
|
|
|
|
def test_conversion_writes_status_and_sidecars(self):
|
|
with tempfile.TemporaryDirectory() as tmp:
|
|
root = Path(tmp); source = root / "00000173.txt"; source.write_text(SOURCE)
|
|
sample = Sample("00000173", {"featurescript": str(source)}, {"featurescript": "x"})
|
|
status = convert_one(sample, root / "out", force=True)
|
|
directory = root / "out/samples/00000173"
|
|
self.assertEqual(status["conversion_status"], "converted_complete")
|
|
for name in ("candidate.cdsl.json", "history.json", "diagnostics.json", "status.json"):
|
|
self.assertTrue((directory / name).exists(), name)
|
|
self.assertEqual(json.loads((directory / "candidate.cdsl.json").read_text())["part_id"], "00000173")
|
|
|
|
def test_force_rebuild_refreshes_the_candidate_from_source(self):
|
|
with tempfile.TemporaryDirectory() as tmp:
|
|
root = Path(tmp); source = root / "00000173.txt"; source.write_text(SOURCE)
|
|
sample = Sample("00000173", {"featurescript": str(source)}, {"featurescript": "x"})
|
|
directory = root / "out/samples/00000173"; directory.mkdir(parents=True)
|
|
(directory / "candidate.cdsl.json").write_text(json.dumps({"part_id": "stale"}), encoding="utf-8")
|
|
(directory / "status.json").write_text(json.dumps({"sample_id": sample.sample_id}), encoding="utf-8")
|
|
status = rebuild_one(sample, root / "out", force=True)
|
|
self.assertEqual(status["rebuild_status"], "rebuilt")
|
|
self.assertEqual(json.loads((directory / "candidate.cdsl.json").read_text())["part_id"], "00000173")
|
|
|
|
|
|
if __name__ == "__main__": unittest.main()
|