218 lines
12 KiB
Python
218 lines
12 KiB
Python
import base64
|
|
import copy
|
|
import io
|
|
import json
|
|
import tempfile
|
|
import unittest
|
|
from pathlib import Path
|
|
from unittest.mock import patch
|
|
|
|
from build123d import Box, Circle, Cylinder, Plane, Pos, fillet
|
|
from PIL import Image
|
|
from engine.agent_session import AgentSession
|
|
from engine.claims import check_claims
|
|
from engine.config import QualityConfig
|
|
from engine.executor import run_ir, IRError
|
|
from engine.images import normalize_images, crop_reference
|
|
from engine.job import QualityJob, BudgetExceeded
|
|
from engine.postcondition import check_postcondition, PostconditionError
|
|
from engine.quality_models import Brief, Review, assess_review, dimension_errors
|
|
from engine.quality_pipeline import QualityWorkflow
|
|
from engine.registry import load_registry
|
|
from engine.validation import safe_name, solid_errors
|
|
|
|
ROOT = Path(__file__).resolve().parents[2]
|
|
REGISTRY = load_registry(ROOT / 'capabilities')
|
|
OPS = [dict(op='sketch_rect', id='s', target=None, params=dict(width=10,height=20,x_offset=-5,y_offset=-10)),
|
|
dict(op='extrude', id='body', target='s', params=dict(amount=30))]
|
|
|
|
|
|
def brief():
|
|
return Brief.model_validate(dict(name='plate',coordinate_system='XYZ',body_interpretation='rectangular body',
|
|
requirements=[dict(id='body',description='10 mm wide body',stage='base',source='explicit',
|
|
evidence='user says 10 mm',critical=True,
|
|
envelope_dimension=dict(axis='X',expected_mm=10,tolerance_mm=.1))],
|
|
assumptions=[],unresolved=[],stage_plan=['base','features','detail']))
|
|
|
|
|
|
def review(status='pass'):
|
|
return Review.model_validate(dict(items=[dict(requirement_id='body',status=status,evidence='Measured X=10',repair='')],additional_issues=[]))
|
|
|
|
|
|
class GeometryTests(unittest.TestCase):
|
|
def test_invalid_params_and_duplicate_ids_preserve_state(self):
|
|
session=AgentSession(REGISTRY)
|
|
for params in ({}, {'radius':float('nan')}, {'radius':'inf'}, {'radius':2,'unknown':3}, []):
|
|
self.assertFalse(session.apply_op('sketch_circle',params)['ok'])
|
|
self.assertTrue(session.apply_op('sketch_circle',{'radius':2},op_id='s')['ok'])
|
|
self.assertFalse(session.apply_op('sketch_circle',{'radius':3},op_id='s')['ok'])
|
|
self.assertEqual(len(session.trace),1)
|
|
|
|
def test_empty_target_legacy_reports_still_replay(self):
|
|
ops=copy.deepcopy(OPS);ops[0]['target']=''
|
|
with tempfile.TemporaryDirectory() as d:
|
|
r=run_ir({'name':'legacy','operations':ops,'output':'body'},REGISTRY,d)
|
|
self.assertAlmostEqual(r['volume_mm3'],6000)
|
|
|
|
def test_final_sketch_rejected(self):
|
|
self.assertTrue(solid_errors(Circle(3)))
|
|
with tempfile.TemporaryDirectory() as d:
|
|
with self.assertRaises(IRError):
|
|
run_ir({'name':'bad','operations':OPS[:1],'output':'s'},REGISTRY,d)
|
|
|
|
def test_hole_rejects_empty_space_wrong_diameter_and_blocked(self):
|
|
shape=Box(20,20,10)-Cylinder(2,12)
|
|
claim=dict(type='hole',target='part',axis='Z',diameter=4,x=0,y=0,z=0)
|
|
self.assertEqual(check_claims([claim],{'part':shape},[]),[])
|
|
for changed in ({'x':30},{'diameter':3}):
|
|
self.assertTrue(check_claims([{**claim,**changed}],{'part':shape},[]))
|
|
self.assertTrue(check_claims([claim],{'part':shape+Box(2,2,1)},[]))
|
|
|
|
def test_small_cut_and_face_contact(self):
|
|
session=AgentSession(REGISTRY)
|
|
session.context.update(a=Box(10,10,10),b=Pos(4.99,0,0)*Box(.02,1,1))
|
|
r=session.apply_op('boolean_combine',{'with_id':'b','operation':'cut'},target='a')
|
|
self.assertTrue(r['ok'],r)
|
|
self.assertLess(session.context[r['id']].volume,1000)
|
|
session.context['b']=Pos(10,0,0)*Box(10,10,10)
|
|
r=session.apply_op('boolean_combine',{'with_id':'b','operation':'union'},target='a')
|
|
self.assertTrue(r['ok'],r)
|
|
self.assertEqual(r['solids'],1)
|
|
|
|
def test_sketch_boolean_cut_uses_area(self):
|
|
with tempfile.TemporaryDirectory() as d:
|
|
r=run_ir(json.loads((ROOT/'examples/demo_sketch_offset.json').read_text()),REGISTRY,d)
|
|
self.assertGreater(r['volume_mm3'],1000)
|
|
|
|
def test_snapshot_depth_hides_back_surfaces_and_preserves_hole(self):
|
|
from engine.render import render_shape_png
|
|
shape=Box(20,20,10)-Cylinder(5,15)
|
|
png=render_shape_png(shape,'top',size=160)
|
|
img=Image.open(io.BytesIO(png))
|
|
self.assertEqual(img.getpixel((80,85)),(245,246,248))
|
|
self.assertNotEqual(img.getpixel((30,85)),(245,246,248))
|
|
|
|
def test_offline_comparison_handles_axis_rotation_without_scaling(self):
|
|
from build123d import export_step, Rot
|
|
from scripts.compare_geometry import compare_step_files, orthogonal_rotations
|
|
self.assertEqual(len(list(orthogonal_rotations())),24)
|
|
shape=Box(20,13,7)-Pos(8,5,0)*Box(6,5,20)
|
|
with tempfile.TemporaryDirectory() as d:
|
|
reference=Path(d)/'reference.step'; candidate=Path(d)/'candidate.step'
|
|
export_step(shape,str(reference))
|
|
export_step(Pos(30,-10,5)*Rot(90,0,0)*shape,str(candidate))
|
|
result=compare_step_files(reference,candidate)
|
|
self.assertGreater(result['best_axis_aligned_volume_iou'],.99999)
|
|
self.assertLess(result['volume_relative_error'],1e-5)
|
|
|
|
def test_local_plane_axis(self):
|
|
s=AgentSession(REGISTRY)
|
|
s.apply_op('sketch_circle',{'radius':2},op_id='s')
|
|
r=s.apply_op('place_on_plane',{'origin':[0,-10,0],'x_axis':[1,0,0],'normal':[0,1,0]},target='s',op_id='p')
|
|
self.assertTrue(r['ok'],r)
|
|
r=s.apply_op('extrude',{'amount':20},target='p')
|
|
self.assertTrue(r['ok'],r)
|
|
self.assertAlmostEqual(s.context[r['id']].bounding_box().size.Y,20)
|
|
self.assertFalse(s.apply_op('place_on_plane',{'origin':[0,0,0],'x_axis':[1,0,0],'normal':[1,0,0]},target='s')['ok'])
|
|
|
|
def test_concave_fillet_can_add_material(self):
|
|
shape=Box(20,20,10)-Pos(5,5,0)*Box(10,10,20)
|
|
edge=min(shape.edges(),key=lambda e: (e.center()-__import__('build123d').Vector(0,0,0)).length)
|
|
result=fillet(edge,1)
|
|
self.assertGreater(result.volume,shape.volume)
|
|
check_postcondition('fillet_edge','geometry_changed',shape,result)
|
|
with self.assertRaises(PostconditionError):
|
|
check_postcondition('fillet_edge','geometry_changed',shape,shape)
|
|
|
|
|
|
class WorkflowTests(unittest.TestCase):
|
|
def test_reference_crop_preserves_pixels_and_is_sent_to_review(self):
|
|
source=Image.new('RGB',(20,16),'blue');source.paste('red',(4,4,12,12))
|
|
buffer=io.BytesIO();source.save(buffer,format='PNG')
|
|
images=normalize_images(base64.b64encode(buffer.getvalue()).decode())
|
|
metadata,png=crop_reference(images,1,[4,4,12,12])
|
|
self.assertEqual(Image.open(io.BytesIO(png)).size,(8,8))
|
|
self.assertEqual(Image.open(io.BytesIO(png)).getpixel((0,0)),(255,0,0))
|
|
self.assertEqual(metadata['source_sha256'],images[0]['sha256'])
|
|
with self.assertRaises(ValueError):crop_reference(images,1,[-1,0,8,8])
|
|
with tempfile.TemporaryDirectory() as d:
|
|
job=QualityJob(d,'test',images,QualityConfig())
|
|
w=QualityWorkflow(None,job,REGISTRY,brief(),'test',images)
|
|
w.dispatch('rebuild_model',{'operations':copy.deepcopy(OPS)})
|
|
w.crop({'image_index':1,'box':[4,4,12,12]})
|
|
with patch('engine.quality_pipeline.structured_call',return_value=review()) as call, patch('engine.quality_pipeline.render_shape_png',return_value=b'png'):
|
|
self.assertTrue(w.submit({'output_id':'body'})['ok'])
|
|
texts=[x.get('text','') for x in call.call_args.args[3]]
|
|
self.assertTrue(any(images[0]['sha256'] in t for t in texts))
|
|
self.assertEqual((job.path/'input_1.png').read_bytes(),buffer.getvalue())
|
|
|
|
def test_review_cannot_omit_or_duplicate_or_waive_critical(self):
|
|
self.assertFalse(assess_review(brief(),'base',review()))
|
|
self.assertTrue(assess_review(brief(),'base',review('unverified')))
|
|
r=review(); r.items=[]
|
|
self.assertTrue(assess_review(brief(),'base',r))
|
|
r=review(); r.items*=2
|
|
self.assertTrue(assess_review(brief(),'base',r))
|
|
self.assertTrue(dimension_errors(brief(),'detail',Box(12,20,30)))
|
|
|
|
def test_rebuild_is_atomic_and_stages_require_review(self):
|
|
with tempfile.TemporaryDirectory() as d:
|
|
job=QualityJob(d,'test',[],QualityConfig())
|
|
w=QualityWorkflow(None,job,REGISTRY,brief(),'test',[])
|
|
self.assertTrue(w.dispatch('rebuild_model',{'operations':copy.deepcopy(OPS)})['ok'])
|
|
before=w.session
|
|
bad=copy.deepcopy(OPS); bad[1]['params']['amount']=-1
|
|
self.assertFalse(w.dispatch('rebuild_model',{'operations':bad})['ok'])
|
|
self.assertIs(w.session,before)
|
|
with patch('engine.quality_pipeline.structured_call',return_value=review('fail')), patch('engine.quality_pipeline.render_shape_png',return_value=b'png'):
|
|
self.assertFalse(w.submit({'output_id':'body'})['ok'])
|
|
self.assertEqual(w.stage_index,0)
|
|
original_len=len(w.last_candidate[1]['operations'])
|
|
w.session.apply_op('sketch_circle',{'radius':2},op_id='extra')
|
|
self.assertEqual(len(w.last_candidate[1]['operations']),original_len)
|
|
partial=w.publish(True)
|
|
self.assertEqual(partial['quality_status'],'partial')
|
|
self.assertEqual(len(json.loads(Path(partial['published_model_file']).read_text())['operations']), original_len)
|
|
with patch('engine.quality_pipeline.structured_call',return_value=review()), patch('engine.quality_pipeline.render_shape_png',return_value=b'png'):
|
|
for i in range(3):
|
|
self.assertTrue(w.submit({'output_id':'body'})['ok'])
|
|
self.assertEqual(w.stage_index,i+1)
|
|
self.assertEqual(w.publish(True)['quality_status'],'passed')
|
|
|
|
def test_job_budget_and_original_image_are_durable(self):
|
|
b=io.BytesIO();Image.new('RGB',(8,8)).save(b,format='PNG')
|
|
images=normalize_images(base64.b64encode(b.getvalue()).decode())
|
|
with tempfile.TemporaryDirectory() as d:
|
|
j=QualityJob(d,'original',images,QualityConfig(max_calls=1))
|
|
self.assertEqual((j.path/'input_1.png').read_bytes(),b.getvalue())
|
|
self.assertEqual(json.loads((j.path/'request.json').read_text())['text'],'original')
|
|
j.calls=1
|
|
with self.assertRaises(BudgetExceeded):j.call(None,'build')
|
|
for value in ['../model','a/b','', 'a.b']:
|
|
with self.assertRaises(ValueError):safe_name(value)
|
|
with self.assertRaises(ValueError):normalize_images(['invalid'])
|
|
with self.assertRaises(ValueError):normalize_images(['eA==']*6)
|
|
|
|
def test_resume_endpoint_validates_and_returns_new_candidate(self):
|
|
from web.app import app
|
|
client=app.test_client()
|
|
self.assertEqual(client.post('/api/resume',json={'part_name':'../x'}).status_code,400)
|
|
with patch('web.app.run_isolated',return_value={'part_name':'new_version','quality_mode':True,'quality_status':'partial'}) as call:
|
|
response=client.post('/api/resume',json={'part_name':'old_version'})
|
|
self.assertEqual(response.status_code,200)
|
|
self.assertEqual(response.json['part_name'],'new_version')
|
|
self.assertTrue(response.json['can_resume'])
|
|
self.assertEqual(call.call_args.args[0],'resume')
|
|
self.assertEqual(call.call_args.kwargs['part_name'],'old_version')
|
|
|
|
def test_api_does_not_label_legacy_or_partial_as_passed(self):
|
|
from web.app import _report_to_response, app
|
|
self.assertEqual(_report_to_response({'part_name':'old'})['quality_status'],'unverified')
|
|
self.assertEqual(_report_to_response({'part_name':'partial','quality_status':'partial'})['quality_status'],'partial')
|
|
client=app.test_client()
|
|
for payload in ([1],{'text':5},{'text':'part','images':'abc'}, {'text':'part','images':['a']*6}):
|
|
self.assertEqual(client.post('/api/generate',json=payload).status_code,400)
|
|
|
|
|
|
if __name__=='__main__': unittest.main()
|