from __future__ import annotations import json, math, tempfile, unittest from pathlib import Path from cadfs_to_cdsl.featurescript_parser import parse_featurescript from cadfs_to_cdsl.lowering import _arc, _contours, _global, lower_model from cadfs_to_cdsl.pipeline import compare_one, convert_one, rebuild_one 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 class LoweringTests(unittest.TestCase): 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"}), 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") 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_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_remains_an_explicit_engine_capability_gap(self): source = TRANSFORM_SOURCE.replace('"makeCopy":false', '"makeCopy":true') result = lower_model(parse_featurescript(source, "transform-copy"), {}) self.assertEqual(result.status, "converted_partial") self.assertEqual(result.diagnostics[-1]["code"], "unsupported_engine_capability") self.assertEqual(result.diagnostics[-1]["capability"], "transform") 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") 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"]["geometry"]["plane_offset_mm"], 0.0) swept = next(item for item in result.cdsl["features"] if item["id"] == "f_F6") self.assertEqual(swept["params"]["end_condition"]["reference"]["geometry"]["radius_mm"], 24.3) 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_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_circular_pattern_replays_the_fused_swept_body_history(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_F1", "f_F5"]) 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_rebuilds_surface_limited_chamfer_history(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"], "rebuilt") chamfer = next(item for item in rebuilt["result"]["feature_results"] if item["feature_id"] == "f_F10") self.assertIn("chamfer_surface_limited", [item["code"] for item in chamfer["diagnostics"]]) self.assertAlmostEqual(rebuilt["result"]["volume_mm3"], 72577.33528261917, places=6) 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_cap_face_profile_preserves_the_selected_circular_output_region(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"]} sketches = {item["id"]: item for item in result.cdsl["geometry"]["sketches"]} cap_profile = sketches[features["f_F5"]["sketch_id"]]["profile"] self.assertEqual(features["f_F5"]["sketch_id"], "sketch_F3__f_F5") self.assertEqual(cap_profile["type"], "analytic_contours") self.assertEqual([ contour["segments"][0]["radius_mm"] for contour in cap_profile["contours"] ], [34.0, 32.0]) 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_intersect_partition_profile_lowers_to_its_bounded_circular_region(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_partial") self.assertEqual({item["feature_id"] for item in result.diagnostics}, {"F7", "F12"}) features = {item["id"]: item for item in result.cdsl["features"]} 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"], "analytic_contours") self.assertEqual( {contour["role"]: contour["segments"][0]["radius_mm"] for contour in first["contours"]}, {"outer": 2.75, "inner": 2.25}, ) self.assertEqual(second, {"type": "circle", "center": [-50.8, 0.0], "radius_mm": 2.25}) 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_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_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}) 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.assertNotIn("F7", {item.get("feature_id") for item in result.diagnostics}) self.assertNotIn("F8", {item.get("feature_id") for item in result.diagnostics}) 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_partial") self.assertEqual( [(item["feature_id"], item["capability"]) for item in result.diagnostics if item.get("code") == "unsupported_engine_capability"], [("F15", "transform")], ) 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_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()