220 lines
13 KiB
Python
220 lines
13 KiB
Python
"""Real threaded solids, interrupted walls, and saved failure recovery."""
|
|
import json
|
|
import math
|
|
import tempfile
|
|
import unittest
|
|
from pathlib import Path
|
|
from unittest.mock import patch
|
|
|
|
from build123d import Box
|
|
from engine.agent_session import AgentSession
|
|
from engine.registry import load_registry
|
|
from engine.cad_export import export_verified
|
|
from engine.worker_resources import memory_exceeded
|
|
|
|
ROOT = Path(__file__).resolve().parents[2]
|
|
|
|
|
|
class ThreadReliabilityTests(unittest.TestCase):
|
|
@classmethod
|
|
def setUpClass(cls):
|
|
cls.registry = load_registry(ROOT/'capabilities')
|
|
|
|
def test_measurement_does_not_alias_a_twenty_turn_helix(self):
|
|
from build123d import Helix
|
|
from engine.inspection import z_helical_measurements
|
|
result=z_helical_measurements(Helix(2,40,10))
|
|
self.assertEqual(result['signed_lead_mm_range'],[2,2])
|
|
self.assertEqual(result['hand'],'right')
|
|
self.assertEqual(result['measured_flank_faces'],0)
|
|
|
|
def test_round_wire_rejects_touching_and_overlapping_turns(self):
|
|
for radius in (1, 1.25, 2.5):
|
|
s = AgentSession(self.registry)
|
|
result = s.apply_op('helical_sweep', dict(pitch=2, height=15, coil_radius=29,
|
|
profile_radius=radius, lefthand=False))
|
|
self.assertFalse(result['ok'])
|
|
self.assertIn('SELF_INTERSECTION', result['error'])
|
|
self.assertEqual(s.trace, [])
|
|
|
|
def test_metric_threads_remain_real_and_valid_after_four_radial_windows(self):
|
|
for diameter, pitch, length, bore, hand in [(12, 1.5, 6, 6, "right"), (60, 2, 15, 52, "right"), (20, 1.5, 6, 12, "left")]:
|
|
with self.subTest(diameter=diameter):
|
|
s = AgentSession(self.registry)
|
|
result = s.apply_op('metric_thread', dict(major_diameter=diameter, pitch=pitch,
|
|
length=length, inner_diameter=bore, hand=hand, end_finish='square'), op_id='thread')
|
|
self.assertTrue(result['ok'], result)
|
|
original = s.context['thread']
|
|
self.assertEqual(len(original.solids()), 1)
|
|
root=diameter/2-.5412658773652742*pitch
|
|
self.assertGreater(original.volume,math.pi*(root*root-bore*bore/4)*length)
|
|
self.assertTrue(original.is_inside(((root+bore/2)/2,0,length/2)))
|
|
self.assertFalse(original.is_inside((0,0,length/2)))
|
|
self.assertAlmostEqual(original.bounding_box().size.Z, length, places=4)
|
|
# A point near the crest alternates solid/air across one pitch.
|
|
samples=[original.is_inside((diameter/2-pitch*.12,0,length/2+i*pitch/16)) for i in range(17)]
|
|
self.assertTrue(any(samples))
|
|
self.assertFalse(all(samples))
|
|
target='thread'
|
|
for i in range(4):
|
|
a=i*math.pi/2
|
|
r=s.apply_op('cut_openings', dict(origin=[0,0,length/2],
|
|
normal=[math.cos(a),math.sin(a),0], x_axis=[-math.sin(a),math.cos(a),0],
|
|
through_all=False,start_depth=bore/2-.3,depth=(diameter-bore)/2+1,
|
|
openings=[dict(kind='rectangle',length=pitch*2,width=pitch*1.5)]), target=target,op_id=f'window{i}')
|
|
self.assertTrue(r['ok'],r)
|
|
target=r['id']
|
|
final=s.context[target]
|
|
self.assertTrue(final.is_valid)
|
|
self.assertEqual(len(final.solids()),1)
|
|
self.assertLess(final.volume,original.volume)
|
|
from engine.inspection import inspect_geometry
|
|
measured=inspect_geometry(final)
|
|
helix=measured['helical_measurements']
|
|
self.assertEqual(helix['hand'],hand)
|
|
for lead in helix['signed_lead_mm_range']:
|
|
self.assertAlmostEqual(lead,pitch if hand=='right' else -pitch,places=3)
|
|
for angle in helix['symmetric_axial_profile_angle_deg_range']:
|
|
self.assertAlmostEqual(angle,60,delta=.05)
|
|
self.assertTrue(measured['planar_faces'])
|
|
for i in range(4):
|
|
a=i*math.pi/2
|
|
self.assertFalse(final.is_inside(((bore/2+.15)*math.cos(a),(bore/2+.15)*math.sin(a),length/2)))
|
|
with tempfile.TemporaryDirectory() as tmp:
|
|
check=export_verified(final,Path(tmp)/'model.step',Path(tmp)/'model.stl')
|
|
self.assertTrue(check['step_roundtrip_valid'])
|
|
|
|
def test_union_keeps_core_when_other_contains_multiple_solids(self):
|
|
from build123d import Compound, Pos
|
|
s=AgentSession(self.registry)
|
|
s.context['core']=Box(10,10,10)
|
|
s.context['details']=Compound(children=[Pos(5,0,0)*Box(4,4,4),Pos(-5,0,0)*Box(4,4,4)])
|
|
r=s.apply_op('boolean_combine',dict(with_id='details',operation='union'),target='core')
|
|
self.assertTrue(r['ok'],r)
|
|
result=s.context[r['id']]
|
|
self.assertAlmostEqual(result.volume,1064,places=5)
|
|
self.assertTrue(result.is_inside((0,0,0)))
|
|
self.assertEqual(len(result.solids()),1)
|
|
|
|
def test_missing_candidate_measurements_are_not_external_source_blockers(self):
|
|
from types import SimpleNamespace as S
|
|
from engine.quality_models import review_information_blockers, ReviewFinding
|
|
item=S(status='unverified',requirement_id='thread')
|
|
brief=S(due=lambda stage:[S(id='thread',critical=True,envelope_dimension=None)])
|
|
finding=ReviewFinding(category='measurement',requirement_id='thread',message='measure pitch',evidence='not measured')
|
|
review=S(items=[item],findings=[finding])
|
|
self.assertEqual(review_information_blockers(brief,'base',review),[])
|
|
finding.category='information'
|
|
self.assertEqual(review_information_blockers(brief,'base',review),[item])
|
|
|
|
def test_memory_guard_checks_descendants_without_counting_address_reservations(self):
|
|
with patch('engine.worker_resources.psutil.Process') as process, patch('engine.worker_resources.process_footprint', return_value=600):
|
|
root=process.return_value
|
|
root.children.return_value=[root]
|
|
self.assertIn('CADMemoryLimit',memory_exceeded(123,1000))
|
|
self.assertIsNone(memory_exceeded(123,2000))
|
|
|
|
def test_partial_batch_exports_checkpoint_without_claiming_review_pass(self):
|
|
from engine.quality_pipeline import QualityWorkflow
|
|
from engine.quality_models import Brief
|
|
from types import SimpleNamespace
|
|
from engine.job import write_json
|
|
import time
|
|
with tempfile.TemporaryDirectory() as tmp:
|
|
job=SimpleNamespace(path=Path(tmp),started=time.monotonic(),
|
|
config=SimpleNamespace(max_elapsed_seconds=600),write=lambda name,data:write_json(Path(tmp)/name,data),
|
|
event=lambda *a,**k:None,state=lambda *a,**k:None)
|
|
brief=Brief(name='test',coordinate_system='Z up',body_interpretation='one',requirements=[dict(id='body',description='one solid',stage='base',source='explicit',evidence='request',critical=True,envelope_dimension=None)],assumptions=[],unresolved=[],stage_plan=[])
|
|
w=QualityWorkflow(None,job,self.registry,brief,'',[])
|
|
w.session.context['seed']=Box(20,20,10)
|
|
result=w.batch({'mode':'append','operations':[
|
|
{'op':'cut_openings','id':'hole','target':'seed','params':dict(origin=[0,0,0],normal=[0,0,1],x_axis=[1,0,0],openings=[dict(kind='circle',diameter=2)])},
|
|
{'op':'missing','id':'bad','params':{}}]})
|
|
self.assertFalse(result['ok'])
|
|
saved=list(Path(tmp).glob('checkpoint_[0-9]*'))
|
|
self.assertEqual(len(saved),1)
|
|
self.assertTrue((saved[0]/'model.step').exists())
|
|
self.assertEqual(json.loads((saved[0]/'model.json').read_text())['output'],'hole')
|
|
self.assertIsNone(w.last_candidate)
|
|
|
|
class ClaimContractTests(unittest.TestCase):
|
|
def test_submission_contract_rejects_invented_types_and_wrong_axis_fields(self):
|
|
from engine.claims import claim_schema, check_claims
|
|
variants={v["properties"]["type"]["enum"][0]:v for v in claim_schema()["items"]["anyOf"]}
|
|
for claim in [dict(type='helix',target='body',pitch=2),
|
|
dict(type='axis_direction',target='body',axis='Z',expected='Z')]:
|
|
self.assertTrue(check_claims([claim],{},[]))
|
|
variant=variants.get(claim["type"])
|
|
self.assertTrue(variant is None or set(variant["required"]) - set(claim))
|
|
self.assertFalse(check_claims([dict(type="dimension",target="body",axis="Z",expected_mm=35)],{"body":Box(10,10,35)},[]))
|
|
self.assertFalse(check_claims([],{},[]))
|
|
registry=load_registry(ROOT/'capabilities')
|
|
from engine.quality_tools import quality_tools
|
|
tools={t['name']:t for t in quality_tools(registry)}
|
|
for tool in ('submit_stage','execute_batch'):
|
|
self.assertEqual(tools[tool]['parameters']['properties']['claims'],claim_schema())
|
|
|
|
class LocalChamferTests(unittest.TestCase):
|
|
def test_local_chamfer_uses_explicit_target_not_stale_edge_parent(self):
|
|
s=AgentSession(load_registry(ROOT/'capabilities'))
|
|
shape=Box(10,10,10);s.context['body']=shape
|
|
edges=shape.edges()
|
|
edges[0].topo_parent=Box(2,2,2)
|
|
with patch.object(shape,'edges',return_value=edges):
|
|
result=s.apply_op('chamfer_edge',dict(radius=.3,edge_selector='by_index',edge_indices=[0]),target='body')
|
|
self.assertTrue(result['ok'],result)
|
|
self.assertAlmostEqual(s.context[result['id']].bounding_box().size.X,10)
|
|
|
|
def test_thread_lead_in_is_on_external_crest_not_inner_bore(self):
|
|
from engine.inspection import conical_boundaries
|
|
s=AgentSession(load_registry(ROOT/'capabilities'))
|
|
result=s.apply_op('metric_thread',dict(major_diameter=60,pitch=2,length=15,inner_diameter=52,end_chamfer=.5),op_id='thread')
|
|
self.assertTrue(result['ok'],result)
|
|
cones=conical_boundaries(s.context['thread'])
|
|
self.assertEqual(len(cones),2)
|
|
for cone in cones:
|
|
self.assertAlmostEqual(cone['radius_range_mm'][0],29.5,places=4)
|
|
self.assertAlmostEqual(cone['radius_range_mm'][1],30,places=4)
|
|
self.assertAlmostEqual(cone['axial_extent_mm'],.5,places=4)
|
|
self.assertAlmostEqual(cone['half_angle_deg'],45,places=4)
|
|
self.assertTrue(s.context['thread'].is_inside((26.1,0,.1)))
|
|
self.assertFalse(s.context['thread'].is_inside((25.9,0,.1)))
|
|
# Tiny planar thread-end slivers must be meshed, not silently skipped.
|
|
from engine.render import render_shape_png
|
|
import struct
|
|
from collections import Counter
|
|
with tempfile.TemporaryDirectory() as tmp:
|
|
export_verified(s.context['thread'],Path(tmp)/'model.step',Path(tmp)/'model.stl')
|
|
self.assertTrue(render_shape_png(s.context['thread'],size=160).startswith(b'\x89PNG'))
|
|
data=(Path(tmp)/'model.stl').read_bytes()
|
|
edges=Counter()
|
|
for i in range(struct.unpack_from('<I',data,80)[0]):
|
|
values=struct.unpack_from('<12fH',data,84+50*i)[3:12]
|
|
pts=[tuple(round(v,5) for v in values[j:j+3]) for j in (0,3,6)]
|
|
if len(set(pts))<3: continue
|
|
for a,b in ((0,1),(1,2),(2,0)): edges[tuple(sorted((pts[a],pts[b])))]+=1
|
|
self.assertTrue(edges)
|
|
self.assertTrue(all(count==2 for count in edges.values()),'STL contains open or non-manifold mesh edges')
|
|
|
|
def test_local_hole_rim_chamfer_and_independent_cone_measurement(self):
|
|
from build123d import Cylinder, GeomType
|
|
from engine.inspection import inspect_geometry
|
|
s=AgentSession(load_registry(ROOT/'capabilities'))
|
|
shape=Cylinder(5,10)-Cylinder(2,10)
|
|
s.context['ring']=shape
|
|
index=next(i for i,e in enumerate(shape.edges()) if e.geom_type==GeomType.CIRCLE and abs(e.radius-2)<1e-6 and abs(e.center().Z-5)<1e-6)
|
|
evidence=inspect_geometry(shape,include_edges=True)
|
|
self.assertEqual(evidence['edges']['items'][index]['index'],index)
|
|
for indices in ([9999],[index,index]):
|
|
self.assertFalse(s.apply_op('chamfer_edge',dict(radius=.3,edge_selector='by_index',edge_indices=indices),target='ring')['ok'])
|
|
result=s.apply_op('chamfer_edge',dict(radius=.3,edge_selector='by_index',edge_indices=[index]),target='ring',op_id='finished')
|
|
self.assertTrue(result['ok'],result)
|
|
final=s.context['finished']
|
|
self.assertLess(final.volume,shape.volume)
|
|
measured=inspect_geometry(final)
|
|
self.assertEqual(len(measured['conical_faces']),1)
|
|
cone=measured['conical_faces'][0]
|
|
self.assertAlmostEqual(cone['half_angle_deg'],45,places=4)
|
|
self.assertAlmostEqual(cone['axial_extent_mm'],.3,places=4)
|
|
self.assertAlmostEqual(cone['radial_extent_mm'],.3,places=4)
|