4be52a66c4
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.
861 lines
30 KiB
Python
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)
|