Files
make-cad/test/test_drawing_evidence_contracts.py
NiJingzhe 8971279494 feat: the geometry engine is C++ on OpenCASCADE, one package, prebuilt wheels
The modeling API (shapes, operators, sketches, products, queries, the reactive graph) is implemented in
C++20 on OpenCASCADE (src/cpp) and ships inside the wheel as simplecadapi._cpp.  The Python layers that stay
Python (runtime, build, artifacts, editor, inspect, exporter, translators, scene) run on it unchanged; the
previous Python test suite passes on the new engine.

Layout: src/cpp and src/simplecadapi side by side, one distribution built by scikit-build-core.
simplecadapi.core, .operators.*, .ql, .std.* and the other legacy modules are real forwarding modules; the
Python adapter layer is simplecadapi/_glue.  OCP is no longer a dependency and nothing imports it.

Release: .github/workflows/release.yml builds wheels for Linux x86_64 and aarch64, macOS arm64 and Windows
x86_64 (Python 3.10-3.13) against one static OCCT, runs the test suite on the Linux wheels and publishes to
GitHub and PyPI; ci.yml caches the static OCCT for the test jobs.

Errors: every message the library writes is English; the tag-validation and semantic-query errors render in
full with possible causes and fixes.

Co-Authored-By: Claude Sonnet 5.5 <noreply@anthropic.com>
2026-10-24 02:55:35 +08:00

398 lines
13 KiB
Python

"""Independent regressions for semantic, visual-artifact and display bindings."""
from copy import deepcopy
import importlib.util
import json
from pathlib import Path
import sys
import pytest
from simplecadapi._cpp.occt.BRepPrimAPI import BRepPrimAPI_MakeBox
from simplecadapi.inspect import drawing
from simplecadapi.inspect.drawing._provenance import file_hash
# The pytest console entry point need not put the repository root on sys.path.
# Load the standalone verifier by its actual file, as the other tool tests do.
_VERIFIER_PATH = (
Path(__file__).resolve().parents[1] / "tools/verify_drawing_evidence.py"
)
_VERIFIER_SPEC = importlib.util.spec_from_file_location(
"drawing_evidence_verifier", _VERIFIER_PATH
)
assert _VERIFIER_SPEC is not None and _VERIFIER_SPEC.loader is not None
_VERIFIER = importlib.util.module_from_spec(_VERIFIER_SPEC)
sys.modules[_VERIFIER_SPEC.name] = _VERIFIER
_VERIFIER_SPEC.loader.exec_module(_VERIFIER)
verify = _VERIFIER.verify
PLANE = {"origin": [0, 0, 1], "normal": [0, 0, 1]}
def contract(kind, direction, definition="axis_aligned_extent", point=None):
return {
"kind": kind,
"direction": direction,
"definition": definition,
"point": point,
"units": "mm",
"coordinate_space": "section_local",
}
def fixture(width=20, height=10):
# Local x = global -Y, local y = global X.
model = BRepPrimAPI_MakeBox(height, width, 2).Shape()
result = drawing.measure_model_section_rdimensions(
model, PLANE, section_checks=box_checks(width, height)
)
return model, {m["kind"]: m for m in result.measurements}
def box_checks(width=20, height=10):
return {
"expected_origin": [0, 0, 1],
"expected_normal": [0, 0, 1],
"expected_x_direction": [0, -1, 0],
"expected_y_direction": [1, 0, 0],
"expected_solid_count": 1,
"expected_face_count": 1,
"expected_hole_count": 0,
"material_points": [{"id": "material", "point": [-width / 2, height / 2]}],
"void_points": [],
"point_tolerance_mm": 1e-7,
"tolerance_basis": "fixture point classification precision",
"evidence": "box drawing fixture",
}
def ledger_for(record, expected_contract, nominal):
return {
"dim_id": "DIM-W",
"feature_id": "outline",
"view": "section",
"source_id": "fixture-source",
"raw_word_ids": [1],
"association_evidence": ["independent dimension line review"],
"datum": "local axes",
"tolerance_basis": "explicit fixture band",
"tolerance_min": nominal - 0.01,
"tolerance_max": nominal + 0.01,
"nominal": nominal,
"coordinate_status": "verified",
"value_status": "verified",
"association_status": "verified",
"target_geometry": deepcopy(record["target_geometry"]),
"section_checks": deepcopy(record["configuration"]["section_checks"]),
"measurement_contract": deepcopy(expected_contract),
}
def uncertainty(record):
return {
"measurement_id": record["measurement_id"],
"bound_mm": 1e-6,
"basis": "independently assessed fixture",
"evidence": "fixture proof",
}
def annotate(record, ledger):
return drawing.build_section_annotation_rrecord(
record, ledger, error_assessment=uncertainty(record), anchor=[0, 0]
)
def reviewed_evidence(model, ledger, annotation, tmp_path):
png = drawing.render_model_section_rpath(
model,
PLANE,
dimensions=[annotation],
validation_ledger=[ledger],
out_dir=tmp_path,
dpi=72,
)
sidecar = png.with_suffix(".json")
review = {
"dim_id": ledger["dim_id"],
"layout_status": "reviewed",
"association_status": "verified",
"evidence": "independent reviewer",
**{k: annotation[k] for k in ("measurement_id", "model_hash", "section_id")},
"render_artifact": {
"image_path": str(png.resolve()),
"image_sha256": file_hash(png),
"sidecar_path": str(sidecar.resolve()),
"sidecar_sha256": file_hash(sidecar),
},
}
return {
"plane": PLANE,
"ledger": [ledger],
"annotations": [annotation],
"output_reviews": {ledger["dim_id"]: review},
}
def test_wrong_axis_rejected_by_assessor_and_builder():
_, records = fixture()
height = records["extent_height"]
row = ledger_for(height, contract("extent_width", [1, 0]), 10)
verdict = drawing.assess_dimension_rverdict(
row, height, error_assessment=uncertainty(height)
)
assert verdict["model_measurement"]["status"] != "passed"
with pytest.raises(ValueError, match="contract"):
annotate(height, row)
@pytest.mark.parametrize(
"field,wrong",
[
("kind", "extent_height"),
("direction", [0, 1]),
("definition", "minimum_boundary_gap"),
("point", [1, 0]),
],
)
def test_independent_ledger_contract_cannot_be_changed(field, wrong, tmp_path):
model, records = fixture()
width = records["extent_width"]
row = ledger_for(width, contract("extent_width", [1, 0]), 20)
ann = annotate(width, row)
evidence = reviewed_evidence(model, row, ann, tmp_path)
assert verify(model, evidence)["status"] == "passed"
row["measurement_contract"][field] = wrong
assert verify(model, evidence)["status"] != "passed"
def test_height_cannot_satisfy_width_in_complete_verify(tmp_path):
model, records = fixture()
height = records["extent_height"]
row = ledger_for(height, contract("extent_height", [0, 1]), 10)
ann = annotate(height, row)
evidence = reviewed_evidence(model, row, ann, tmp_path)
assert verify(model, evidence)["status"] == "passed"
row["measurement_contract"] = contract("extent_width", [1, 0])
assert verify(model, evidence)["status"] != "passed"
@pytest.mark.parametrize(
"fields",
[
["measurement_id"],
["model_hash"],
["section_id"],
["measurement_id", "model_hash", "section_id"],
],
)
def test_old_visual_review_ids_are_preserved_and_rejected(fields, tmp_path):
model, records = fixture()
row = ledger_for(records["extent_width"], contract("extent_width", [1, 0]), 20)
ann = annotate(records["extent_width"], row)
evidence = reviewed_evidence(model, row, ann, tmp_path)
review = evidence["output_reviews"]["DIM-W"]
for field in fields:
review[field] = "OLD"
snapshot = deepcopy(evidence)
report = verify(model, evidence)
assert report["status"] != "passed"
assert evidence == snapshot
for field in fields:
assert report["dimensions"][0]["output_expression"]["evidence"][field] == "OLD"
@pytest.mark.parametrize("decimals", [0, 1])
def test_display_precision_follows_tolerance_at_builder_and_validator(decimals):
model, records = fixture(width=10.4)
record = records["extent_width"]
row = ledger_for(record, contract("extent_width", [1, 0]), 10.4)
with pytest.raises(ValueError, match="display precision"):
drawing.build_section_annotation_rrecord(
record,
row,
error_assessment=uncertainty(record),
anchor=[0, 0],
display_decimals=decimals,
)
ann = annotate(record, row)
ann["display_decimals"] = decimals
assert (
drawing.validate_section_annotations_rreport(model, PLANE, [ann], [row])[
"status"
]
== "rejected"
)
@pytest.mark.parametrize("target", ["image_path", "sidecar_path"])
def test_modified_reviewed_artifact_is_rejected(target, tmp_path):
from pathlib import Path
model, records = fixture()
row = ledger_for(records["extent_width"], contract("extent_width", [1, 0]), 20)
ann = annotate(records["extent_width"], row)
evidence = reviewed_evidence(model, row, ann, tmp_path)
assert verify(model, evidence)["status"] == "passed"
path = Path(evidence["output_reviews"]["DIM-W"]["render_artifact"][target])
path.write_bytes(path.read_bytes() + b" ")
assert verify(model, evidence)["status"] != "passed"
def test_reviewed_render_must_match_current_annotation_not_just_model(tmp_path):
model, records = fixture()
row = ledger_for(records["extent_width"], contract("extent_width", [1, 0]), 20)
ann = annotate(records["extent_width"], row)
evidence = reviewed_evidence(model, row, ann, tmp_path)
ann["anchor"] = [-20, 0] # Also on the contour; old layout was not reviewed.
assert (
drawing.validate_section_annotations_rreport(model, PLANE, [ann], [row])[
"status"
]
== "verified"
)
assert verify(model, evidence)["status"] != "passed"
@pytest.mark.parametrize(
"missing",
[
"measurement_contract",
"kind",
"definition",
"direction",
"point",
"units",
"coordinate_space",
],
)
def test_missing_semantic_contract_is_not_inferred(missing):
_, records = fixture()
record = records["extent_width"]
row = ledger_for(record, contract("extent_width", [1, 0]), 20)
if missing == "measurement_contract":
row.pop(missing)
else:
row["measurement_contract"].pop(missing)
assert (
drawing.assess_dimension_rverdict(
row, record, error_assessment=uncertainty(record)
)["model_measurement"]["status"]
!= "passed"
)
def test_directional_thickness_binds_line_point_even_when_values_match():
model, _ = fixture()
def probe(point):
result = drawing.measure_model_section_rdimensions(
model,
PLANE,
section_checks=box_checks(),
directional_thickness=[
{"id": "probe", "point": point, "direction": [1, 0]}
],
)
return next(
m for m in result.measurements if m["kind"] == "thickness_directional"
)
first, second = probe([-10, 1]), probe([-10, 2])
assert first["value"] == pytest.approx(second["value"])
row = ledger_for(
first,
contract("thickness_directional", [1, 0], "material_length_on_line", [-10, 1]),
20,
)
assert (
drawing.assess_dimension_rverdict(
row, first, error_assessment=uncertainty(first)
)["model_measurement"]["status"]
== "passed"
)
assert (
drawing.assess_dimension_rverdict(
row, second, error_assessment=uncertainty(second)
)["model_measurement"]["status"]
!= "passed"
)
def test_sufficient_display_precision_and_live_review_pass(tmp_path):
model, records = fixture(width=10.4)
record = records["extent_width"]
row = ledger_for(record, contract("extent_width", [1, 0]), 10.4)
annotation = drawing.build_section_annotation_rrecord(
record,
row,
error_assessment=uncertainty(record),
anchor=[0, 0],
display_decimals=2,
)
evidence = reviewed_evidence(model, row, annotation, tmp_path)
assert verify(model, evidence)["status"] == "passed"
assert json.loads((tmp_path / "section.json").read_text())["dimensions"][0][
"display_text"
][0].endswith("10.40")
annotation["display_decimals"] = 0
result = drawing.validate_section_annotations_rreport(
model, PLANE, [annotation], [row]
)
assert any(
"display precision" in error for error in result["dimensions"][0]["errors"]
)
assert verify(model, evidence)["status"] != "passed"
with pytest.raises(ValueError, match="display precision"):
drawing.render_model_section_rpath(
model,
PLANE,
dimensions=[annotation],
validation_ledger=[row],
out_dir=tmp_path,
)
@pytest.mark.parametrize(
"missing", ["measurement_id", "model_hash", "section_id", "render_artifact"]
)
def test_missing_visual_identity_cannot_pass_or_count_as_reviewed(missing, tmp_path):
model, records = fixture()
row = ledger_for(records["extent_width"], contract("extent_width", [1, 0]), 20)
ann = annotate(records["extent_width"], row)
evidence = reviewed_evidence(model, row, ann, tmp_path)
evidence["output_reviews"]["DIM-W"].pop(missing)
report = verify(model, evidence)
assert report["status"] != "passed"
assert report["coverage"]["layout_reviewed"]["count"] == 0
def test_layout_review_counts_separately_when_association_is_pending(tmp_path):
model, records = fixture()
row = ledger_for(records["extent_width"], contract("extent_width", [1, 0]), 20)
ann = annotate(records["extent_width"], row)
evidence = reviewed_evidence(model, row, ann, tmp_path)
evidence["output_reviews"]["DIM-W"]["association_status"] = "pending"
report = verify(model, evidence)
assert report["status"] != "passed"
assert report["coverage"]["layout_reviewed"]["count"] == 1
@pytest.mark.parametrize(
"value,band,decimals,expected",
[
(10.408, [10.389, 10.409], 2, "rejected"),
(-10.408, [-10.409, -10.389], 2, "rejected"),
(10, [10, 10], 0, "verified"),
(10.123, [10.123, 10.123], 2, "rejected"),
(10.123, [10.123, 10.123], 3, "verified"),
],
)
def test_display_rounding_boundary_cases(value, band, decimals, expected):
from simplecadapi.inspect.drawing._measurement_contract import display_precision
result = display_precision(
value, decimals, {"tolerance_min": band[0], "tolerance_max": band[1]}
)
assert result["status"] == expected