Files
make-cad/test/test_assembly_builder.py
T
NiJingzhe 4be52a66c4 fix(placement): integer-tick canonical identity for all hashed frames
Float frames re-normalized on every Placement reconstruction, so
canonical JSON bytes and content hashes drifted across save/load cycles
(connector interface_hash mismatch, unstable PartInstance placement
identity, spurious cache/dirty misses).

Store every hashed/persisted frame as exact integer ticks at 1e-9
resolution instead:

- placement.py: placement_ticks / validate_placement_ticks (pure integer
  unit-orthogonal-handedness checks) / placement_from_canonical with a
  from_exact_frame constructor that keeps durable components verbatim;
  tick frames short-circuit re-quantization; placement_frame_mm exports
  millimetre floats for translators
- ConnectorInterface.local_frame and PartInstance.placement store ticks;
  definition content hashes are byte-stable across round trips
- solved snapshots, authored placements, assembly state, solve keys and
  component cache payloads compare tick-to-tick; rebuilds reuse
  from_exact_frame so verification is exact instead of tolerance-based
- occurrence-graph transforms and scene product ingestion convert ticks
  at the runtime boundary only
- FreeCAD runtime and Fusion360/SolidWorks translators convert recorded
  tick frames back to millimetre floats when emitting target payloads

Derived z_axis is authoritative (computed once at write time) and is
never recomputed on read. BREP/zip/package integrity checks remain
strict byte hashes. Existing pre-tick packages must be recaptured;
examples/22_mecanum_wheel was rebuilt and revalidated.
2026-09-06 18:30:16 +08:00

861 lines
30 KiB
Python

from __future__ import annotations
from copy import deepcopy
from dataclasses import replace
from pathlib import Path
import pytest
from simplecadapi.product.placement import placement_ticks
import simplecadapi as scad
from simplecadapi.artifacts.canonical import (
ArtifactValidationError,
content_hash,
sha256_bytes,
)
from simplecadapi.artifacts.feature_graph import (
FEATURE_GRAPH_MEDIA_TYPE,
capture_feature_graph,
)
GENERATOR = {
"simplecadapi_version": "2.0.4b1",
"ocp_version": "7.9.3.1",
"python_abi": "cp313",
"platform_tag": "darwin-arm64",
"semantic_registry_version": "simplecad-operations-2.0",
}
def _policy(root: Path) -> scad.CachePolicy:
return scad.CachePolicy(root=root)
def _build_nested_gear_train(tmp_path: Path):
@scad.part(id="train_base", cache=_policy(tmp_path / "cache"))
def build_base() -> scad.Part:
body = scad.make_box_rsolid(width=30.0, height=8.0, depth=2.0)
part = scad.make_part_rpart(part_id="train_base", body=body)
left = scad.make_placement_connector_rconnector(
connector_id="left_axis",
placement=scad.make_placement_rplacement(origin=(5.0, 4.0, 2.0)),
)
right = scad.make_placement_connector_rconnector(
connector_id="right_axis",
placement=scad.make_placement_rplacement(origin=(25.0, 4.0, 2.0)),
)
part = scad.add_connector_rpart(part=part, connector=left)
return scad.add_connector_rpart(part=part, connector=right)
@scad.part(id="train_gear", cache=_policy(tmp_path / "cache"))
def build_gear() -> scad.Part:
body = scad.make_cylinder_rsolid(radius=4.0, height=3.0)
part = scad.make_part_rpart(part_id="train_gear", body=body)
axis = scad.make_placement_connector_rconnector(
connector_id="axis",
placement=scad.make_placement_rplacement(origin=(0.0, 0.0, 0.0)),
)
return scad.add_connector_rpart(part=part, connector=axis)
base = build_base()
gear = build_gear()
@scad.assemble(
id="gear_train",
definitions=(base, gear),
)
def build_train() -> scad.Assembly:
identity = scad.identity_placement_rplacement()
assembly = scad.make_assembly_rassembly(assembly_id="gear_train")
assembly = scad.add_component_rassembly(
assembly=assembly,
item=base.value,
component_id="base",
placement=identity,
)
assembly = scad.add_component_rassembly(
assembly=assembly,
item=gear.value,
component_id="gear_a",
placement=identity,
)
assembly = scad.add_component_rassembly(
assembly=assembly,
item=gear.value,
component_id="gear_b",
placement=identity,
)
assembly = scad.ground_component_rassembly(
assembly=assembly,
component_id="base",
)
base_left = scad.make_connector_ref_rconnectorref("base", "left_axis")
base_right = scad.make_connector_ref_rconnectorref("base", "right_axis")
gear_a = scad.make_connector_ref_rconnectorref("gear_a", "axis")
gear_b = scad.make_connector_ref_rconnectorref("gear_b", "axis")
assembly = scad.add_revolute_constraint_rassembly(
assembly=assembly,
constraint_id="support_a",
connector_a=base_left,
connector_b=gear_a,
drive_angle_degrees=30.0,
)
assembly = scad.add_revolute_constraint_rassembly(
assembly=assembly,
constraint_id="support_b",
connector_a=base_right,
connector_b=gear_b,
)
assembly = scad.add_gear_constraint_rassembly(
assembly=assembly,
constraint_id="mesh",
connector_a=gear_a,
connector_b=gear_b,
pitch_radius_a=4.0,
pitch_radius_b=8.0,
)
assembly = scad.solve_assembly_constraints_rassembly(assembly=assembly)
return scad.set_public_connector_rassembly(
assembly=assembly,
public_connector_id="output_axis",
source_component_id="gear_b",
source_connector_id="axis",
)
train = build_train()
@scad.assemble(
id="nested_train_pair",
definitions=(train,),
)
def build_pair() -> scad.Assembly:
assembly = scad.make_assembly_rassembly(assembly_id="nested_train_pair")
assembly = scad.add_component_rassembly(
assembly=assembly,
item=train.value,
component_id="train_left",
placement=scad.identity_placement_rplacement(),
)
assembly = scad.add_component_rassembly(
assembly=assembly,
item=train.value,
component_id="train_right",
placement=scad.make_placement_rplacement(origin=(50.0, 0.0, 0.0)),
)
return scad.set_public_connector_rassembly(
assembly=assembly,
public_connector_id="service_axis",
source_component_id="train_right",
source_connector_id="output_axis",
)
return base, gear, train, build_pair()
def test_assemble_external_reference_round_trip_preserves_hierarchy_and_coupling(
tmp_path: Path,
) -> None:
_base, gear, train, pair = _build_nested_gear_train(tmp_path)
assert len(train.definition.definition_refs) == 2
assert [item.definition_id for item in train.definition.instances].count(
"train_gear"
) == 2
assert [item.constraint_kind for item in train.value.constraints] == [
"revolute",
"revolute",
"gear",
]
assert scad.inspect_assembly_constraints_rconstraintreport(train.value).solved
output = scad.export_assembly_definition(
pair.definition,
tmp_path / "pair.assembly-definition.zip",
)
loaded = scad.load_assembly_definition(output)
rebuilt = scad.materialize_definition(loaded)
assert loaded.canonical_bytes == pair.definition.canonical_bytes
assert isinstance(rebuilt, scad.Assembly)
assert rebuilt.component_ids() == ("train_left", "train_right")
assert rebuilt.public_connector_ids() == ("service_axis",)
left = rebuilt.get_component("train_left").item
right = rebuilt.get_component("train_right").item
assert left is right
assert isinstance(left, scad.Assembly)
assert left.get_component("gear_a").item is left.get_component("gear_b").item
assert left.get_component("gear_a").item.part_id == gear.value.part_id
assert left.constraint_ids() == ("mesh", "support_a", "support_b")
assert scad.inspect_assembly_constraints_rconstraintreport(left).solved
written = {item.name for item in tmp_path.glob("*.zip")}
assert "pair.assembly-definition.zip" in written
assert any(name.endswith(".part-definition.zip") for name in written)
assert any(
name.endswith(".assembly-definition.zip")
and name != "pair.assembly-definition.zip"
for name in written
)
def test_assemble_keeps_authored_placements_separate_from_solved_snapshot(
tmp_path: Path,
) -> None:
_base, _gear, train, _pair = _build_nested_gear_train(tmp_path)
authored = {
instance.instance_id: instance.placement
for instance in train.definition.instances
}
solved = {
item["instance_id"]: item["placement"]
for item in train.definition.solved_snapshot["component_placements"]
}
identity = placement_ticks(scad.identity_placement_rplacement())
assert authored["gear_a"] == identity
assert solved["gear_a"]["origin"] == placement_ticks(
scad.make_placement_rplacement(origin=(5.0, 4.0, 2.0))
)["origin"]
assert solved["gear_b"]["origin"] == placement_ticks(
scad.make_placement_rplacement(origin=(25.0, 4.0, 2.0))
)["origin"]
assert train.definition.interface_hashes.geometry == content_hash(
{
"instances": [
{
"instance_id": instance.instance_id,
"definition_id": instance.definition_id,
"geometry_hash": train.definition.resolved_definitions[
instance.definition_id
].interface_hashes.geometry,
"placement": instance.placement,
}
for instance in train.definition.instances
]
}
)
rebuilt = scad.materialize_definition(train.definition)
assert isinstance(rebuilt, scad.Assembly)
assert placement_ticks(rebuilt.get_component("gear_a").placement) == solved["gear_a"]
assert placement_ticks(rebuilt.get_component("gear_b").placement) == solved["gear_b"]
def test_nested_occurrence_placements_survive_materialization_and_replay(
tmp_path: Path,
) -> None:
policy = _policy(tmp_path / "cache")
@scad.part(id="durable_nested_ring", cache=policy)
def build_ring() -> scad.Part:
part = scad.make_part_rpart(
part_id="durable_nested_ring",
body=scad.make_cylinder_rsolid(radius=2.0, height=1.0),
)
return scad.add_connector_rpart(
part=part,
connector=scad.make_placement_connector_rconnector(
connector_id="axis",
placement=scad.identity_placement_rplacement(),
),
)
ring = build_ring()
@scad.assemble(
id="durable_nested_bearing",
definitions=(ring,),
cache=policy,
)
def build_bearing() -> scad.Assembly:
assembly = scad.make_assembly_rassembly(assembly_id="durable_nested_bearing")
for component_id in ("outer_ring", "inner_ring"):
assembly = scad.add_component_rassembly(
assembly=assembly,
item=ring.value,
component_id=component_id,
placement=scad.identity_placement_rplacement(),
)
assembly = scad.ground_component_rassembly(
assembly=assembly,
component_id="outer_ring",
)
assembly = scad.add_revolute_constraint_rassembly(
assembly=assembly,
constraint_id="inner_outer_revolute",
connector_a=scad.make_connector_ref_rconnectorref(
component_id="outer_ring",
connector_id="axis",
),
connector_b=scad.make_connector_ref_rconnectorref(
component_id="inner_ring",
connector_id="axis",
),
drive_angle_degrees=90.0,
)
assembly = scad.solve_assembly_constraints_rassembly(assembly=assembly)
assembly = scad.set_public_connector_rassembly(
assembly=assembly,
public_connector_id="outer_axis",
source_component_id="outer_ring",
source_connector_id="axis",
)
return scad.set_public_connector_rassembly(
assembly=assembly,
public_connector_id="inner_axis",
source_component_id="inner_ring",
source_connector_id="axis",
)
bearing = build_bearing()
quarter_turn = scad.make_placement_rplacement(
origin=(0.0, 0.0, 0.0),
x_axis=(0.0, 1.0, 0.0),
y_axis=(-1.0, 0.0, 0.0),
)
@scad.assemble(
id="durable_nested_fixture",
definitions=(bearing, ring),
cache=policy,
)
def build_fixture() -> scad.Assembly:
assembly = scad.make_assembly_rassembly(assembly_id="durable_nested_fixture")
assembly = scad.add_component_rassembly(
assembly=assembly,
item=ring.value,
component_id="housing",
placement=scad.identity_placement_rplacement(),
)
assembly = scad.add_component_rassembly(
assembly=assembly,
item=ring.value,
component_id="shaft",
placement=quarter_turn,
)
assembly = scad.add_component_rassembly(
assembly=assembly,
item=bearing.value,
component_id="bearing",
placement=scad.identity_placement_rplacement(),
)
assembly = scad.ground_component_rassembly(
assembly=assembly,
component_id="housing",
)
assembly = scad.ground_component_rassembly(
assembly=assembly,
component_id="shaft",
)
assembly = scad.add_fixed_constraint_rassembly(
assembly=assembly,
constraint_id="outer_ring_to_housing",
connector_a=scad.make_connector_ref_rconnectorref(
component_id="housing",
connector_id="axis",
),
connector_b=scad.make_connector_ref_rconnectorref(
component_id="bearing",
connector_id="outer_axis",
),
)
return scad.add_fixed_constraint_rassembly(
assembly=assembly,
constraint_id="inner_ring_to_shaft",
connector_a=scad.make_connector_ref_rconnectorref(
component_id="shaft",
connector_id="axis",
),
connector_b=scad.make_connector_ref_rconnectorref(
component_id="bearing",
connector_id="inner_axis",
),
)
fixture = build_fixture()
warm = build_fixture()
assert (warm.solve_report.component_hits, warm.solve_report.component_misses) == (
1,
0,
)
occurrence_placements = {
tuple(record["component_path"]): record["placement"]
for record in fixture.definition.solved_snapshot["occurrence_placements"]
}
assert occurrence_placements[("bearing", "inner_ring")]["x_axis"] == [
round(value * 1.0e9) for value in quarter_turn.x_axis
]
for restored in (
fixture.value,
warm.value,
scad.materialize_definition(fixture.definition),
fixture.replay(),
):
assert isinstance(restored, scad.Assembly)
restored_bearing = restored.get_component("bearing").item
assert isinstance(restored_bearing, scad.Assembly)
assert restored_bearing.get_component(
"inner_ring"
).placement.x_axis == pytest.approx(quarter_turn.x_axis)
assert scad.inspect_assembly_constraints_rconstraintreport(restored).solved
def test_assemble_rejects_undeclared_and_wrong_runtime_definition_identity(
tmp_path: Path,
) -> None:
@scad.part(id="declared_part", cache=_policy(tmp_path / "cache"))
def declared(width: float = 1.0) -> scad.Part:
body = scad.make_box_rsolid(width=width, height=1.0, depth=1.0)
return scad.make_part_rpart(part_id="declared_part", body=body)
expected = declared(1.0)
wrong = declared(2.0)
@scad.assemble(id="wrong_identity", definitions=(expected,))
def build_wrong() -> scad.Assembly:
assembly = scad.make_assembly_rassembly("wrong_identity")
return scad.add_component_rassembly(
assembly,
wrong.value,
"part",
scad.identity_placement_rplacement(),
)
@scad.assemble(id="undeclared", definitions=())
def build_undeclared() -> scad.Assembly:
assembly = scad.make_assembly_rassembly("undeclared")
return scad.add_component_rassembly(
assembly,
expected.value,
"part",
scad.identity_placement_rplacement(),
)
with pytest.raises(ArtifactValidationError, match="reference_identity_mismatch"):
build_wrong()
with pytest.raises(ArtifactValidationError, match="reference_missing"):
build_undeclared()
def test_assembly_graph_validation_rejects_hash_and_connector_mismatches(
tmp_path: Path,
) -> None:
_base, _gear, train, _pair = _build_nested_gear_train(tmp_path)
definition = train.definition
first_ref = definition.definition_refs[0]
wrong_ref = replace(first_ref, content_hash="sha256:" + "0" * 64)
wrong_hash = replace(
definition,
definition_refs=(wrong_ref, *definition.definition_refs[1:]),
content_hash="",
)
with pytest.raises(ArtifactValidationError) as hash_error:
scad.validate_assembly_definition_graph(wrong_hash)
assert hash_error.value.reason == "reference_identity_mismatch"
assert hash_error.value.path == "/definition_refs/0"
relations = [dict(item) for item in definition.relations]
relations[0] = {
**relations[0],
"connector_b": {
**relations[0]["connector_b"],
"connector_id": "missing_axis",
},
}
missing_connector = replace(
definition,
relations=tuple(relations),
content_hash="",
)
with pytest.raises(ArtifactValidationError) as connector_error:
scad.validate_assembly_definition_graph(missing_connector)
assert connector_error.value.reason == "reference_missing"
assert connector_error.value.path == "/relations/0/connector_b/connector_id"
def test_assembly_loader_reports_cycle_with_instance_path(tmp_path: Path) -> None:
cycle_ref = scad.PartRef(
definition_id="cycle_child",
definition_kind="assembly",
path="cycle.assembly-definition.zip",
revision="r1",
content_hash="sha256:" + "1" * 64,
byte_length=0,
)
with scad.GraphSession(graph_id="cycle_root") as session:
root = scad.make_assembly_rassembly(assembly_id="cycle_root")
session.capture_result(value=root)
feature_graph = capture_feature_graph(
session=session,
owner_definition_kind="assembly",
owner_definition_id="cycle_root",
owner_revision="r1",
project_root=Path(__file__).resolve().parents[1],
external_definitions=(
{
"definition_kind": cycle_ref.definition_kind,
"definition_id": cycle_ref.definition_id,
"revision": cycle_ref.revision,
"content_hash": cycle_ref.content_hash,
},
),
)
feature_payload = scad.encode_feature_graph_artifact(feature_graph)
feature_path = (
"features/"
+ feature_graph.content_hash.removeprefix("sha256:")
+ ".feature-graph.zip"
)
definition = scad.AssemblyDefinition(
definition_id="cycle_root",
revision="r1",
tolerance_profile="simplecad-default",
generator=GENERATOR,
definition_refs=(cycle_ref,),
instances=(
scad.PartInstance(
instance_id="child",
definition_id="cycle_child",
name=None,
placement=scad.Placement((0.0, 0.0, 0.0)).to_dict(),
),
),
relations=(),
grounded_instance_ids=(),
public_connectors=(),
interface_hashes=scad.InterfaceHashes(
geometry=content_hash({"instances": []}),
connectors={},
bindings={},
material=None,
),
feature_graph_ref=scad.BlobRef(
path=feature_path,
sha256=sha256_bytes(feature_payload),
byte_length=len(feature_payload),
media_type=FEATURE_GRAPH_MEDIA_TYPE,
),
blobs={feature_path: feature_payload},
)
path = tmp_path / "cycle.assembly-definition.zip"
path.write_bytes(scad.encode_assembly_definition(definition))
with pytest.raises(ArtifactValidationError) as error:
scad.load_assembly_definition(path)
assert error.value.reason == "reference_cycle"
assert "child" in error.value.message
def test_assemble_rejects_dependency_tolerance_profile_conflict(tmp_path: Path) -> None:
@scad.part(
id="profile_part",
cache=_policy(tmp_path / "cache"),
tolerance_profile="alternate-profile",
)
def build_part() -> scad.Solid:
return scad.make_box_rsolid(width=1.0, height=1.0, depth=1.0)
part = build_part()
with pytest.raises(ArtifactValidationError, match="profile_incompatible"):
@scad.assemble(id="profile_conflict", definitions=(part,))
def build() -> scad.Assembly:
return scad.make_assembly_rassembly("profile_conflict")
def test_assemble_reuses_independent_constraint_components(tmp_path: Path) -> None:
policy = _policy(tmp_path / "cache")
@scad.part(id="incremental_base", cache=policy)
def build_base() -> scad.Part:
part = scad.make_part_rpart(
"incremental_base",
scad.make_box_rsolid(width=2.0, height=2.0, depth=2.0),
)
return scad.add_connector_rpart(
part,
scad.make_placement_connector_rconnector(
"mate",
scad.identity_placement_rplacement(),
),
)
@scad.part(id="incremental_tool_a", cache=policy)
def build_tool_a(connector_x: float) -> scad.Part:
part = scad.make_part_rpart(
"incremental_tool_a",
scad.make_box_rsolid(width=1.0, height=1.0, depth=1.0),
)
return scad.add_connector_rpart(
part,
scad.make_placement_connector_rconnector(
"mate",
scad.make_placement_rplacement(origin=(connector_x, 0.0, 0.0)),
),
)
@scad.part(id="incremental_tool_b", cache=policy)
def build_tool_b() -> scad.Part:
part = scad.make_part_rpart(
"incremental_tool_b",
scad.make_box_rsolid(width=1.0, height=1.0, depth=1.0),
)
return scad.add_connector_rpart(
part,
scad.make_placement_connector_rconnector(
"mate",
scad.identity_placement_rplacement(),
),
)
base = build_base()
tool_b = build_tool_b()
def assembly_builder(tool_a: scad.PartBuildResult):
@scad.assemble(
id="incremental_pair",
definitions=(base, tool_a, tool_b),
cache=policy,
)
def build_pair() -> scad.Assembly:
assembly = scad.make_assembly_rassembly("incremental_pair")
for component_id, item, origin in (
("base_a", base.value, (0.0, 0.0, 0.0)),
("tool_a", tool_a.value, (4.0, 0.0, 0.0)),
("base_b", base.value, (20.0, 0.0, 0.0)),
("tool_b", tool_b.value, (24.0, 0.0, 0.0)),
):
assembly = scad.add_component_rassembly(
assembly,
item,
component_id,
scad.make_placement_rplacement(origin=origin),
)
assembly = scad.ground_component_rassembly(assembly, "base_a")
assembly = scad.ground_component_rassembly(assembly, "base_b")
assembly = scad.add_fixed_constraint_rassembly(
assembly,
"constraint_a",
scad.make_connector_ref_rconnectorref("base_a", "mate"),
scad.make_connector_ref_rconnectorref("tool_a", "mate"),
)
return scad.add_fixed_constraint_rassembly(
assembly,
"constraint_b",
scad.make_connector_ref_rconnectorref("base_b", "mate"),
scad.make_connector_ref_rconnectorref("tool_b", "mate"),
)
return build_pair
initial_builder = assembly_builder(build_tool_a(0.0))
cold = initial_builder()
warm = initial_builder()
changed = assembly_builder(build_tool_a(2.0))()
assert (cold.solve_report.component_hits, cold.solve_report.component_misses) == (
0,
2,
)
assert (warm.solve_report.component_hits, warm.solve_report.component_misses) == (
2,
0,
)
assert warm.solve_report.hit
assert (
changed.solve_report.component_hits,
changed.solve_report.component_misses,
) == (1, 1)
assert changed.solve_report.dirty_connectors == ("tool_a.mate",)
assert changed.solve_report.dirty_relations == ("constraint_a",)
assert len(changed.solve_report.dirty_components) == 1
assert sum(item.cache_hit for item in changed.solve_report.component_results) == 1
assert scad.inspect_assembly_constraints_rconstraintreport(changed.value).solved
def test_nested_public_connector_change_invalidates_parent_component(
tmp_path: Path,
) -> None:
policy = _policy(tmp_path / "cache")
@scad.part(id="nested_connector_part", cache=policy)
def build_child(connector_x: float) -> scad.Part:
part = scad.make_part_rpart(
"nested_connector_part",
scad.make_box_rsolid(width=1.0, height=1.0, depth=1.0),
)
return scad.add_connector_rpart(
part,
scad.make_placement_connector_rconnector(
"mate",
scad.make_placement_rplacement(origin=(connector_x, 0.0, 0.0)),
),
)
def build_stage(child: scad.PartBuildResult) -> scad.AssemblyBuildResult:
@scad.assemble(
id="nested_connector_stage",
definitions=(child,),
cache=policy,
)
def stage() -> scad.Assembly:
assembly = scad.make_assembly_rassembly("nested_connector_stage")
assembly = scad.add_component_rassembly(
assembly,
child.value,
"child",
scad.identity_placement_rplacement(),
)
return scad.set_public_connector_rassembly(
assembly,
"output",
"child",
"mate",
)
return stage()
def parent_builder(stage: scad.AssemblyBuildResult):
@scad.assemble(
id="nested_connector_parent",
definitions=(stage,),
cache=policy,
)
def parent() -> scad.Assembly:
assembly = scad.make_assembly_rassembly("nested_connector_parent")
assembly = scad.add_component_rassembly(
assembly,
stage.value,
"grounded",
scad.identity_placement_rplacement(),
)
assembly = scad.add_component_rassembly(
assembly,
stage.value,
"moving",
scad.make_placement_rplacement(origin=(10.0, 0.0, 0.0)),
)
assembly = scad.ground_component_rassembly(assembly, "grounded")
return scad.add_fixed_constraint_rassembly(
assembly,
"nested_fixed",
scad.make_connector_ref_rconnectorref("grounded", "output"),
scad.make_connector_ref_rconnectorref("moving", "output"),
)
return parent
initial_stage = build_stage(build_child(0.0))
initial_parent_builder = parent_builder(initial_stage)
cold = initial_parent_builder()
warm = initial_parent_builder()
changed_stage = build_stage(build_child(3.0))
changed = parent_builder(changed_stage)()
assert (cold.solve_report.component_hits, cold.solve_report.component_misses) == (
0,
1,
)
assert (warm.solve_report.component_hits, warm.solve_report.component_misses) == (
1,
0,
)
assert (
changed.solve_report.component_hits,
changed.solve_report.component_misses,
) == (0, 1)
assert changed.solve_report.dirty_connectors == (
"grounded.output",
"moving.output",
)
assert changed.solve_report.dirty_relations == ("nested_fixed",)
assert scad.inspect_assembly_constraints_rconstraintreport(changed.value).solved
def test_assemble_owns_replayable_deterministic_feature_graph(tmp_path: Path) -> None:
policy = _policy(tmp_path / "cache")
@scad.part(id="graph_child", cache=policy)
def build_child() -> scad.Part:
return scad.make_part_rpart(
part_id="graph_child",
body=scad.make_box_rsolid(width=2.0, height=3.0, depth=4.0),
)
child = build_child()
@scad.assemble(id="graph_parent", definitions=(child,), cache=policy)
def build_parent() -> scad.Assembly:
assembly = scad.make_assembly_rassembly(assembly_id="graph_parent")
return scad.add_component_rassembly(
assembly=assembly,
item=child.value,
component_id="child",
placement=scad.identity_placement_rplacement(),
)
cold = build_parent()
warm = build_parent()
nodes = list(cold.feature_graph.graph["nodes"])
reference_nodes = [item for item in nodes if item["op"] == "reference_definition"]
terminal_nodes = [
item for item in nodes if item["op"] == "evaluate_assembly_definition"
]
assert cold.feature_graph.owner_definition_kind == "assembly"
assert cold.feature_graph.owner_definition_id == "graph_parent"
assert cold.feature_graph.external_definitions == (
{
"definition_kind": child.definition.definition_kind,
"definition_id": child.definition.definition_id,
"revision": child.definition.revision,
"content_hash": child.definition.content_hash,
},
)
assert len(reference_nodes) == 1
assert reference_nodes[0]["params"]["definition_id"] == "graph_child"
assert len(terminal_nodes) == 1
assert cold.feature_graph.result_node_ids == (terminal_nodes[0]["node_id"],)
assert cold.feature_graph.canonical_bytes == warm.feature_graph.canonical_bytes
archived = scad.load_feature_graph_artifact(
cold.definition.blobs[cold.definition.feature_graph_ref.path]
)
assert archived.canonical_bytes == cold.feature_graph.canonical_bytes
replayed = cold.replay()
assert replayed.component_ids() == ("child",)
assert replayed.get_component("child").item.part_id == "graph_child"
def test_assembly_feature_replay_tolerates_only_solver_scale_residual_drift(
tmp_path: Path,
) -> None:
_base, _gear, train, _pair = _build_nested_gear_train(tmp_path)
external_definitions = train.definition.resolved_definitions
def with_translation_drift(drift: float):
graph = deepcopy(dict(train.feature_graph.graph))
terminal = next(
node
for node in graph["nodes"]
if node["op"] == "evaluate_assembly_definition"
)
terminal["params"]["constraint_report"]["residuals"][0][
"translation_error"
] += drift
return replace(train.feature_graph, graph=graph, content_hash="")
replayed = with_translation_drift(5.0e-8).replay(
external_definitions=external_definitions
)
assert replayed[0].assembly_id == "gear_train"
with pytest.raises(ValueError, match="residual report differs"):
with_translation_drift(2.0e-7).replay(external_definitions=external_definitions)