Files
2026-09-24 10:40:57 +08:00

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, {})