| """Controller-only adapters to the existing independent domain oracles.""" |
| from copy import deepcopy |
| from pathlib import Path |
| import importlib.util |
| import sys |
| import json |
|
|
| def load(name,path): |
| spec=importlib.util.spec_from_file_location(name,path);m=importlib.util.module_from_spec(spec) |
| sys.modules[name]=m;spec.loader.exec_module(m);return m |
|
|
| class Bundle: |
| def __init__(self,path,slot): |
| self.path=Path(path);self.slot=slot;key=slot+'_'+str(abs(hash(str(self.path)))) |
| self.aws=slot=='aws_release_v1' |
| self.runtime=load('runtime_'+key,self.path/('environment/runtime.py' if self.aws else 'runtime.py')) |
| self.reference=load('reference_'+key,self.path/'private/reference.py') |
| self.oracle=load('oracle_'+key,self.path/'private/oracle.py') |
| self.task=json.loads((self.path/('public/task.json' if self.aws else 'public/public_task.json')).read_text()) |
| def transition(self,state,name,args): |
| if self.aws:return {'state':deepcopy(state),'observation':self.runtime.call_tool(deepcopy(state),name,deepcopy(args))} |
| return self.runtime.transition(self.path/'environment',state,name,args) |
| def solve(self,initial): |
| state=deepcopy(initial);events=[] |
| def call(name,args): |
| nonlocal state |
| step=self.transition(state,name,deepcopy(args));state=step['state'];obs=deepcopy(step['observation']) |
| events.append({'tool':name,'arguments':deepcopy(args),'observation':deepcopy(obs)}) |
| return obs |
| answer=self.reference.solve(call,self.task['context'] if self.aws else deepcopy(self.task)) |
| return answer,events,state |
| def grade(self,initial,answer,events,final_state): |
| |
| |
| state=deepcopy(initial) |
| for e in events: |
| actual=self.transition(state,e['tool'],e['arguments']);state=actual['state'] |
| if actual['observation']!=e['observation']:return {'passed':False,'errors':['forged_observation']} |
| if state!=final_state:return {'passed':False,'errors':['unreplayed_final_state']} |
| return self.oracle.grade(deepcopy(initial),deepcopy(answer),deepcopy(events),final_state=deepcopy(final_state)) |
|
|
| def public_report(answer): |
| return {k:deepcopy(v) for k,v in answer.items() if k not in ('status','decision')} |
|
|
| def restore_protocol(slot,report,protocol_key): |
| if not isinstance(report,dict) or 'status' in report or 'decision' in report:raise ValueError('Use the public report fields without benchmark decision labels') |
| result=deepcopy(report) |
| if slot=='aws_release_v1':outcome='blocked' if report.get('blocker') else 'reviewed' |
| elif slot=='slot_01':outcome='block' if report.get('blocking_reasons') else 'abstain' if report.get('unresolved_evidence') else 'approve' |
| elif slot=='slot_10':outcome='abstain' if report.get('unresolved_contenders') else 'complete' |
| else: |
| fields=('missing','missing_evidence','unresolved_evidence','unresolved_ids','unresolved_contenders','unresolved_plans') |
| missing=any(report.get(k) for k in fields) |
| if slot=='slot_03':missing=bool(report.get('unresolved')) |
| outcome='abstain' if missing else 'act' if protocol_key=='decision' else 'complete' |
| if not missing: |
| if slot=='slot_08':outcome='ready' if report.get('approval_usable') and all(r.get('check')=='match' for r in report.get('deliverables',[])) else 'needs_changes' |
| elif slot=='slot_09':outcome='choose' if report.get('selected') else 'no_match' |
| elif slot in {'slot_10','slot_11','slot_16','slot_17','slot_18'}:outcome='complete' |
| result[protocol_key]=outcome |
| return result |
|
|
| def public_schema(schema,root=True): |
| |
| |
| if not isinstance(schema,dict):return deepcopy(schema) |
| out={k:deepcopy(v) for k,v in schema.items() if k not in ('properties','oneOf','anyOf','allOf','items')} |
| if 'properties' in schema: |
| out['properties']={k:public_schema(v,False) for k,v in schema['properties'].items() if not(root and k in ('status','decision'))} |
| if root and 'required'in out:out['required']=[k for k in out['required'] if k not in ('status','decision')] |
| for kind in ('oneOf','anyOf','allOf'): |
| if kind in schema:out[kind]=[public_schema(v,root) for v in schema[kind]] |
| if 'items'in schema:out['items']=public_schema(schema['items'],False) |
| return out |
|
|
