| |
| |
| |
| """Export generation-only or evaluator-only inputs; never execute candidates.""" |
| import argparse |
| import hashlib |
| import json |
| import re |
| from pathlib import Path |
|
|
| import pyarrow.parquet as pq |
| from appworld_reconstruction import FAMILIES, appworld_backfill, gold_body |
|
|
| PACKAGE = Path(__file__).resolve().parents[1] |
|
|
|
|
| def sha(data): |
| return hashlib.sha256(data).hexdigest() |
|
|
|
|
| def rows(version, kind): |
| if version != 'paper' or kind not in ('tasks', 'evaluation'): |
| raise ValueError('This release provides only the frozen paper222 configurations.') |
| name = 'tasks' if kind == 'tasks' else 'candidates' |
| return pq.read_table(PACKAGE / 'data' / (name + '.parquet')).to_pylist() |
|
|
|
|
| def canonical(obj): |
| return json.dumps(obj, ensure_ascii=False, sort_keys=True, separators=(',', ':')).encode() |
|
|
|
|
| def reconstruct_task(row, manifest, appworld_root): |
| record = manifest[row['task_id']] |
| template = record['template_json'].encode() |
| assert sha(template) == row['task_spec_sha256'] == record['template_sha256'] |
| spec = appworld_backfill(json.loads(template), row['source_task_id'], root=str(appworld_root)) |
| if spec is None: |
| raise ValueError('Missing AppWorld official task data: ' + row['task_id']) |
| blob = canonical(spec) |
| if sha(blob) != row['effective_spec_sha256']: |
| raise ValueError('AppWorld effective task hash mismatch: ' + row['task_id']) |
| return blob |
|
|
|
|
| def reconstruct_candidate(row, appworld_root, cache): |
| source_id, _, suffix = row['source_candidate_id'].partition('::') |
| if source_id not in cache: |
| body = gold_body(source_id, str(appworld_root / 'data')) |
| if body is None: |
| raise ValueError('Missing AppWorld official compiled solution: ' + source_id) |
| recipes = [('gold', body), ('base_empty', 'def solution(apis, requester):\n pass')] |
| for _, operator in FAMILIES: |
| recipes.extend(operator(body)) |
| cache[source_id] = recipes |
| _, _, name = suffix.partition('_') |
| matches = [] |
| for recipe, solution in cache[source_id]: |
| if recipe != name: |
| continue |
| |
| |
| payload = json.loads(re.sub(r'v4v[ _\-]?[A-Za-z0-9_]*', 'alt', |
| json.dumps({'solution': solution}, ensure_ascii=False))) |
| obj = dict(candidate_id=row['candidate_id'], task_id=row['task_id'], schema_version='1.0', |
| verifier_form='tool_state_transition', payload=payload) |
| blob = json.dumps(obj, ensure_ascii=False, sort_keys=True, indent=1).encode() |
| if sha(blob) == row['candidate_view_sha256']: |
| matches.append(blob) |
| if not matches: |
| raise ValueError('No exact AppWorld reconstruction matched: ' + row['candidate_id']) |
| return matches[0] |
|
|
|
|
| def materialize(version, kind, output, appworld_root): |
| if version != 'paper' or kind not in ('generation', 'evaluation'): |
| raise ValueError('Use version=paper with kind=generation or evaluation.') |
| output = output.resolve() |
| if output == PACKAGE or PACKAGE in output.parents: |
| raise ValueError('Output must be outside the release package (AppWorld plaintext is local-only).') |
| if output.exists() and any(output.iterdir()): |
| raise ValueError('Output directory must be empty; existing files are never overwritten.') |
| if appworld_root is None: |
| raise ValueError('--appworld-root is required for the full pool; partial exports are refused.') |
| manifest = {r['task_id']: r for r in json.loads((PACKAGE / 'metadata/appworld_reconstruction.json').read_text())} |
| selected = rows(version, 'tasks' if kind == 'generation' else 'evaluation') |
| files, labels, cache = [], [], {} |
| for row in selected: |
| if kind == 'generation': |
| if row['task_spec_json'] is None: |
| blob = reconstruct_task(row, manifest, appworld_root) |
| else: |
| original = row['task_spec_json'].encode() |
| assert sha(original) == row['task_spec_sha256'] |
| blob = canonical(json.loads(original)) |
| assert sha(blob) == row['effective_spec_sha256'], row['task_id'] |
| files.append((Path(row['task_id']) / 'task_spec.public.json', blob)) |
| else: |
| blob = (row['candidate_view_json'].encode() if row['candidate_view_json'] is not None |
| else reconstruct_candidate(row, appworld_root, cache)) |
| assert sha(blob) == row['candidate_view_sha256'] |
| files.append((Path(row['task_id']) / 'candidates' / (row['candidate_id'] + '.json'), blob)) |
| labels.append({k: row[k] for k in ('task_id', 'candidate_id', 'label', 'candidate_class', 'candidate_view_sha256')}) |
| |
| for path, blob in files: |
| dest = output / path |
| dest.parent.mkdir(parents=True, exist_ok=True) |
| dest.write_bytes(blob) |
| if kind == 'evaluation': |
| (output / 'labels.jsonl').write_text(''.join(json.dumps(r, ensure_ascii=False) + '\n' for r in labels)) |
| return dict(version=version, kind=kind, verified_files=len(files)) |
|
|
|
|
| def main(): |
| p = argparse.ArgumentParser(description=__doc__) |
| p.add_argument('--version', choices=('paper',), default='paper') |
| p.add_argument('--kind', choices=('generation', 'evaluation'), required=True) |
| p.add_argument('--output', type=Path, required=True) |
| p.add_argument('--appworld-root', type=Path, required=True) |
| a = p.parse_args() |
| print(json.dumps(materialize(a.version, a.kind, a.output, a.appworld_root), indent=2)) |
|
|
|
|
| if __name__ == '__main__': |
| main() |
|
|
