3dd8c77b8d
A SimpleCAD model is now a marimo notebook: a PEP 723 header with a [tool.simplecadapi] table (id, revision, tolerance_profile, inputs), one FTC block per cell, and the product is the top-level value whose id is the notebook id. The notebook file is the only source of truth; .scadpkg is only for exchange and publishing. Runtime (simplecadapi.runtime): - run_notebook(path, *, id=None, overrides=None, cache=True) and sca run <notebook.py> [--id] [--set NAME=VALUE] [--no-cache] [--out] - use(path, id=..., **overrides) composes child notebooks; notebook_id() lets one notebook serve a part family under per-use ids - each cell records into its own session; cells are the unit of caching, keyed by the notebook dependency digest (deps.json) - marimo cell executor entry point, so marimo edit runs the same way - shapes and read-only definition mappings pickle for the cell cache Removed: the content-addressed part cache (simplecadapi.cache, CachePolicy, CacheReport, sca cache ...), the incremental assembly solver and its dependency/state modules, and part-interface diffs with latest- state persistence. Part and assembly builds and the notebook projection now share one definition writer (build/definition.py). Co-Authored-By: Claude Code <noreply@anthropic.com>
841 lines
31 KiB
Python
841 lines
31 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 _build_nested_gear_train():
|
|
@scad.part(id="train_base")
|
|
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")
|
|
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()
|
|
|
|
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() -> None:
|
|
_base, _gear, train, _pair = _build_nested_gear_train()
|
|
|
|
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() -> None:
|
|
@scad.part(id="durable_nested_ring")
|
|
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,),
|
|
)
|
|
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),
|
|
)
|
|
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()
|
|
rebuilt_fixture = build_fixture()
|
|
assert rebuilt_fixture.value is not fixture.value
|
|
assert rebuilt_fixture.definition.content_hash == fixture.definition.content_hash
|
|
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,
|
|
rebuilt_fixture.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() -> None:
|
|
@scad.part(id="declared_part")
|
|
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() -> None:
|
|
_base, _gear, train, _pair = _build_nested_gear_train()
|
|
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() -> None:
|
|
@scad.part(id="profile_part", 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_resolves_every_call_and_follows_child_connector_edits() -> None:
|
|
@scad.part(id="pair_base")
|
|
def build_base() -> scad.Part:
|
|
part = scad.make_part_rpart(
|
|
"pair_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="pair_tool_a")
|
|
def build_tool_a(connector_x: float) -> scad.Part:
|
|
part = scad.make_part_rpart(
|
|
"pair_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="pair_tool_b")
|
|
def build_tool_b() -> scad.Part:
|
|
part = scad.make_part_rpart(
|
|
"pair_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="pair_assembly",
|
|
definitions=(base, tool_a, tool_b),
|
|
)
|
|
def build_pair() -> scad.Assembly:
|
|
assembly = scad.make_assembly_rassembly("pair_assembly")
|
|
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))
|
|
first = initial_builder()
|
|
again = initial_builder()
|
|
changed = assembly_builder(build_tool_a(2.0))()
|
|
|
|
def origin(result: scad.AssemblyBuildResult, component_id: str):
|
|
return tuple(result.value.get_component(component_id).placement.origin)
|
|
|
|
# Nothing is reused: every call solves again and yields the same definition.
|
|
assert again.value is not first.value
|
|
assert again.definition.content_hash == first.definition.content_hash
|
|
|
|
# Moving tool_a's connector moves tool_a and changes the definition;
|
|
# the independent tool_b pair solves to the same place.
|
|
assert changed.definition.content_hash != first.definition.content_hash
|
|
assert origin(first, "tool_a") == pytest.approx((0.0, 0.0, 0.0))
|
|
assert origin(changed, "tool_a") == pytest.approx((-2.0, 0.0, 0.0))
|
|
assert origin(changed, "tool_b") == pytest.approx(origin(first, "tool_b"))
|
|
assert scad.inspect_assembly_constraints_rconstraintreport(changed.value).solved
|
|
|
|
|
|
def test_nested_public_connector_change_reaches_the_parent_definition() -> None:
|
|
@scad.part(id="nested_connector_part")
|
|
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,),
|
|
)
|
|
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,),
|
|
)
|
|
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)
|
|
first = initial_parent_builder()
|
|
again = initial_parent_builder()
|
|
changed_stage = build_stage(build_child(3.0))
|
|
changed = parent_builder(changed_stage)()
|
|
|
|
assert again.definition.content_hash == first.definition.content_hash
|
|
# A connector edit two levels down changes the parent through its
|
|
# reference to the rebuilt stage definition.
|
|
assert changed.definition.content_hash != first.definition.content_hash
|
|
(stage_ref,) = changed.definition.definition_refs
|
|
assert stage_ref.content_hash == changed_stage.definition.content_hash
|
|
assert scad.inspect_assembly_constraints_rconstraintreport(changed.value).solved
|
|
|
|
|
|
def test_assemble_owns_replayable_deterministic_feature_graph() -> None:
|
|
@scad.part(id="graph_child")
|
|
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,))
|
|
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(),
|
|
)
|
|
|
|
first = build_parent()
|
|
again = build_parent()
|
|
nodes = list(first.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 first.feature_graph.owner_definition_kind == "assembly"
|
|
assert first.feature_graph.owner_definition_id == "graph_parent"
|
|
assert first.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 first.feature_graph.result_node_ids == (terminal_nodes[0]["node_id"],)
|
|
assert first.feature_graph.canonical_bytes == again.feature_graph.canonical_bytes
|
|
|
|
archived = scad.load_feature_graph_artifact(
|
|
first.definition.blobs[first.definition.feature_graph_ref.path]
|
|
)
|
|
assert archived.canonical_bytes == first.feature_graph.canonical_bytes
|
|
replayed = first.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() -> None:
|
|
_base, _gear, train, _pair = _build_nested_gear_train()
|
|
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)
|
|
|
|
|
|
def test_assemble_runs_in_its_own_session_when_called_inside_a_recording() -> None:
|
|
@scad.part(id="hosted_child")
|
|
def build_child() -> scad.Solid:
|
|
return scad.make_box_rsolid(width=1.0, height=1.0, depth=1.0)
|
|
|
|
child = build_child()
|
|
|
|
@scad.assemble(id="hosted_parent", definitions=(child,))
|
|
def build_parent() -> scad.Assembly:
|
|
assembly = scad.make_assembly_rassembly(assembly_id="hosted_parent")
|
|
return scad.add_component_rassembly(
|
|
assembly=assembly,
|
|
item=child.value,
|
|
component_id="child",
|
|
placement=scad.identity_placement_rplacement(),
|
|
)
|
|
|
|
standalone = build_parent()
|
|
outer = scad.GraphSession(graph_id="host", allow_external_definitions=True)
|
|
with outer:
|
|
nodes_before = len(outer.graph.nodes)
|
|
with scad.SimpleWorkplane(origin=(0.0, 0.0, 7.0)):
|
|
hosted = build_parent()
|
|
# The build neither recorded into the caller nor inherited its frame.
|
|
assert scad.get_active_session() is outer
|
|
assert len(outer.graph.nodes) == nodes_before
|
|
|
|
assert hosted.definition.content_hash == standalone.definition.content_hash
|