188 lines
12 KiB
Python
188 lines
12 KiB
Python
"""General parameter families and quality evidence flow; no target-part fixtures."""
|
|
import base64
|
|
import io
|
|
import json
|
|
import math
|
|
import tempfile
|
|
import unittest
|
|
from pathlib import Path
|
|
from unittest.mock import patch
|
|
|
|
from build123d import Box, Cylinder, Pos, GeomType
|
|
from PIL import Image
|
|
from engine.agent_session import AgentSession
|
|
from engine.config import QualityConfig
|
|
from engine.job import QualityJob
|
|
from engine.quality_pipeline import QualityWorkflow, generate_quality
|
|
from engine.registry import load_registry
|
|
from test_api_loop import Client, response
|
|
from test_workflow import ROOT, OPS, brief, review
|
|
|
|
FRAME = dict(origin=[0, 0, 0], x_axis=[1, 0, 0], normal=[0, 0, 1])
|
|
|
|
|
|
class CompositeGeometryTests(unittest.TestCase):
|
|
@classmethod
|
|
def setUpClass(cls):
|
|
cls.registry = load_registry(ROOT / 'capabilities')
|
|
|
|
def apply(self, name, params):
|
|
session = AgentSession(self.registry)
|
|
result = session.apply_op(name, params)
|
|
self.assertTrue(result['ok'], result)
|
|
return session.context[result['id']]
|
|
|
|
def test_arc_profile_preserves_analytic_semicircle(self):
|
|
for radius in (2, 7, 15):
|
|
shape = self.apply('sketch_arc_profile', dict(points=[[-radius, 0], [radius, 0], [radius, 10], [-radius, 10]], bulges=[0, 0, 1, 0]))
|
|
self.assertAlmostEqual(shape.area, 20*radius + math.pi*radius**2/2, places=5)
|
|
self.assertTrue(any(e.geom_type == GeomType.CIRCLE for e in shape.edges()))
|
|
|
|
def test_annular_sectors_match_analytic_volume_and_rotations(self):
|
|
for radius, sweep, normal in ((12, 90, [0,0,1]), (19, 210, [0,1,0]), (31, 330, [0,-1,0])):
|
|
shape = self.apply('annular_sector_plate', {**FRAME, 'normal': normal, 'origin': [3,4,5],
|
|
'outer_radius': radius, 'inner_radius': radius-3, 'start_angle': -37, 'sweep_angle': sweep, 'thickness': 2})
|
|
self.assertEqual(len(shape.solids()), 1)
|
|
self.assertAlmostEqual(shape.volume, math.pi*(radius**2-(radius-3)**2)*sweep/360*2, places=5)
|
|
|
|
def test_tube_parameter_family_is_through_and_scales(self):
|
|
volumes = []
|
|
for scale in (0.7, 1, 1.8):
|
|
shape = self.apply('tube_with_lands', {**FRAME, 'outer_radius': 23*scale, 'inner_radius': 20*scale,
|
|
'height': 44*scale, 'land_width': 28*scale, 'length': 42*scale, 'shoulder_radius': scale})
|
|
self.assertEqual(len(shape.solids()), 1)
|
|
self.assertFalse(shape.is_inside((0,0,0)))
|
|
self.assertAlmostEqual(shape.bounding_box().size.Z, 42*scale, places=5)
|
|
volumes.append(shape.volume/scale**3)
|
|
self.assertAlmostEqual(min(volumes), max(volumes), places=4)
|
|
|
|
def test_batch_cut_exact_volume_and_limited_depth(self):
|
|
session = AgentSession(self.registry)
|
|
session.context['plate'] = Box(40, 30, 4)
|
|
result = session.apply_op('cut_openings', {**FRAME, 'openings': [dict(kind='circle', u=-10, diameter=4),
|
|
dict(kind='slot', u=8, length=12, width=4)]}, target='plate')
|
|
self.assertTrue(result['ok'], result)
|
|
self.assertAlmostEqual(session.context[result['id']].volume, 4800 - 4*(8*math.pi + 32), places=5)
|
|
# A connected hollow body: one-wall policy must leave the opposite wall intact.
|
|
session.context['shell'] = Box(30,30,20) - Box(24,24,16)
|
|
result = session.apply_op('cut_openings', {**FRAME, 'through_all': False, 'start_depth': 7, 'depth': 5,
|
|
'openings': [dict(kind='circle', diameter=6)]}, target='shell')
|
|
self.assertTrue(result['ok'], result)
|
|
shape = session.context[result['id']]
|
|
self.assertFalse(shape.is_inside((0,0,9)))
|
|
self.assertTrue(shape.is_inside((0,0,-9)))
|
|
|
|
def test_batch_failure_never_commits_partial_geometry(self):
|
|
for openings in ([dict(kind='circle', diameter=4), dict(kind='circle', u=100, diameter=4)],
|
|
[dict(kind='circle', diameter=8), dict(kind='circle', u=1, diameter=8)],
|
|
[dict(kind='rectangle', length=50, width=4)]):
|
|
session = AgentSession(self.registry)
|
|
session.context['part'] = Box(30,30,4)
|
|
result = session.apply_op('cut_openings', {**FRAME, 'openings': openings}, target='part')
|
|
self.assertFalse(result['ok'], result)
|
|
self.assertEqual(session.trace, [])
|
|
self.assertEqual(list(session.context), ['part'])
|
|
self.assertAlmostEqual(session.context['part'].volume, 3600)
|
|
|
|
def test_bad_frame_and_degenerate_arc_fail(self):
|
|
session = AgentSession(self.registry)
|
|
self.assertFalse(session.apply_op('sketch_arc_profile', dict(points=[[0,0],[0,0],[1,2]], bulges=[0,0,0]))['ok'])
|
|
session.context['part'] = Box(10,10,4)
|
|
self.assertFalse(session.apply_op('cut_openings', {**FRAME, 'normal':[1,0,0],
|
|
'openings':[dict(kind='circle', diameter=2)]}, target='part')['ok'])
|
|
|
|
|
|
class ExperienceFlowTests(unittest.TestCase):
|
|
def test_material_probes_are_resampled_on_submitted_candidate_and_sent_to_review(self):
|
|
with tempfile.TemporaryDirectory() as folder:
|
|
job=QualityJob(folder,'box',[],QualityConfig())
|
|
flow=QualityWorkflow(None,job,load_registry(ROOT/'capabilities'),brief(),'box',[])
|
|
flow.dispatch('rebuild_model',{'operations':OPS})
|
|
probe=flow.dispatch('inspect_geometry',{'id':'body','points':[[0,0,15]]})
|
|
self.assertTrue(probe['point_material'][0]['inside'])
|
|
flow.session.context['body']=Pos(0,50,0)*flow.session.context['body']
|
|
with patch('engine.quality_pipeline.render_shape_png',return_value=b'png'), patch('engine.quality_pipeline.structured_call',return_value=review()) as reviewer:
|
|
self.assertTrue(flow.submit({'output_id':'body'})['ok'])
|
|
content=reviewer.call_args.args[3]
|
|
measured=[json.loads(c['text']) for c in content if c['type']=='input_text' and c.get('text','').startswith('{')][0]
|
|
self.assertEqual(measured['geometry']['point_material'],[{'point':[0,0,15],'inside':False}])
|
|
self.assertTrue((job.path/'measurement_points.json').exists())
|
|
|
|
def test_future_requirements_are_visible_but_not_due_and_tool_prefix_is_normalized(self):
|
|
from engine.quality_models import Requirement
|
|
with tempfile.TemporaryDirectory() as folder:
|
|
task=brief()
|
|
task.requirements.append(Requirement(id='no_fillet',description='Keep sharp edges',stage='detail',source='explicit',evidence='User says no fillets',critical=True,envelope_dimension=None))
|
|
job=QualityJob(folder,'box',[],QualityConfig())
|
|
flow=QualityWorkflow(None,job,load_registry(ROOT/'capabilities'),task,'box',[])
|
|
operations=[{**op,'op':'op_'+op['op']} for op in OPS]
|
|
self.assertTrue(flow.dispatch('rebuild_model',{'operations':operations})['ok'])
|
|
with patch('engine.quality_pipeline.render_shape_png',return_value=b'png'), patch('engine.quality_pipeline.structured_call',return_value=review()) as reviewer:
|
|
self.assertTrue(flow.submit({'output_id':'body'})['ok'])
|
|
content=reviewer.call_args.args[3]
|
|
record=[json.loads(c['text']) for c in content if c['type']=='input_text' and c.get('text','').startswith('{')][0]
|
|
self.assertEqual([r['id'] for r in record['requirements']],['body'])
|
|
self.assertEqual([r['id'] for r in record['all_requirements']],['body','no_fillet'])
|
|
|
|
def test_automatic_regions_preserve_source_pixels_without_target_coordinates(self):
|
|
from PIL import ImageDraw
|
|
from engine.images import normalize_images, drawing_regions, crop_reference
|
|
source = Image.new('RGB', (900,650), 'white')
|
|
draw = ImageDraw.Draw(source)
|
|
draw.rectangle((5,5,895,645), outline='black', width=2)
|
|
for box in ((100,90,260,250), (550,320,740,520)):
|
|
draw.rectangle(box, outline='black', width=3)
|
|
buffer = io.BytesIO(); source.save(buffer, format='PNG')
|
|
images = normalize_images([base64.b64encode(buffer.getvalue()).decode()])
|
|
regions = drawing_regions(images)
|
|
self.assertEqual(len(regions), 2)
|
|
for region in regions:
|
|
metadata, png = crop_reference(images, **region)
|
|
actual = Image.open(io.BytesIO(png))
|
|
expected = source.crop(region['box'])
|
|
self.assertEqual(actual.tobytes(), expected.tobytes())
|
|
self.assertEqual(metadata['source_sha256'], images[0]['sha256'])
|
|
|
|
def test_image_audit_freezes_corrected_brief_and_reviews_candidate_ledger(self):
|
|
original = brief(); original.name = 'draft'
|
|
audited = brief(); audited.name = 'audited'
|
|
parameter = dict(name='width', value=10, source='explicit', evidence='test input', requirement_ids=['body'])
|
|
responses = [response(1, original.model_dump_json()), response(2, audited.model_dump_json()),
|
|
response(3, tool='rebuild_model', args={'operations': OPS})]
|
|
for i in range(3):
|
|
responses += [response(4+i*2, tool='submit_stage', args={'output_id':'body','parameters':[parameter]}),
|
|
response(5+i*2, review().model_dump_json())]
|
|
client = Client(responses)
|
|
png = io.BytesIO(); Image.new('RGB', (4,4)).save(png, format='PNG')
|
|
with tempfile.TemporaryDirectory() as folder:
|
|
base = Path(folder); (base/'capabilities').symlink_to(ROOT/'capabilities')
|
|
with patch('engine.quality_pipeline.render_shape_png', return_value=b'png'):
|
|
report = generate_quality('box', base, [base64.b64encode(png.getvalue()).decode()], QualityConfig(max_calls=9, read_model='teacher-test'), client)
|
|
self.assertEqual(report['quality_status'], 'passed')
|
|
self.assertEqual([client.requests[i]['model'] for i in (0,1)], ['teacher-test', 'teacher-test'])
|
|
self.assertEqual(client.requests[2]['model'], QualityConfig().model)
|
|
self.assertEqual(report['models']['read'], 'teacher-test')
|
|
self.assertEqual(report['display_name'], 'audited')
|
|
self.assertEqual(report['candidate_parameters'][0]['value'], 10)
|
|
self.assertEqual(json.loads((Path(report['step_file']).parent/'requirements_draft.json').read_text())['name'], 'draft')
|
|
for index in (4,6,8):
|
|
text = json.dumps(client.requests[index]['input'], ensure_ascii=False)
|
|
self.assertIn('candidate_parameters', text)
|
|
self.assertIn('test input', text)
|
|
|
|
def test_rejected_unchanged_submission_does_not_repeat_review(self):
|
|
with tempfile.TemporaryDirectory() as folder:
|
|
job = QualityJob(folder, 'box', [], QualityConfig())
|
|
flow = QualityWorkflow(None, job, load_registry(ROOT/'capabilities'), brief(), 'box', [])
|
|
flow.dispatch('rebuild_model', {'operations': OPS})
|
|
with patch('engine.quality_pipeline.render_shape_png', return_value=b'png'), patch('engine.quality_pipeline.structured_call', return_value=review('fail')) as reviewer:
|
|
flow.submit({'output_id':'body'})
|
|
for _ in range(2):
|
|
self.assertIn('UNCHANGED_CANDIDATE', flow.submit({'output_id':'body'})['error'])
|
|
with self.assertRaisesRegex(RuntimeError, 'NoProgress'):
|
|
flow.submit({'output_id':'body'})
|
|
self.assertEqual(reviewer.call_count, 1)
|
|
with self.assertRaises(ValueError):
|
|
flow.record_parameters([dict(name='bad', value=2, source='explicit', evidence='x', requirement_ids=['missing'])])
|
|
self.assertEqual(flow.parameters, {})
|