| import asyncio |
| from collections import Counter |
| from concurrent.futures import ThreadPoolExecutor |
| from copy import deepcopy |
| from dataclasses import dataclass |
| import fcntl |
| import hashlib |
| import json |
| from pathlib import Path |
| import random |
| import textwrap |
| import time |
| import ast |
|
|
| import httpx |
| from openai import AsyncOpenAI,DefaultAioHttpClient,RateLimitError |
| from omegaconf import OmegaConf |
| from pydantic import BaseModel |
| from rich import print |
| from tqdm import tqdm |
|
|
| from functional_rl import v2 |
| from hinted_rl.teacher_programs import canonical |
| from refined_v4.data import load_rows,write_rows,atomic_json,signature |
| from refined_v4.fast_generate import Limiter |
|
|
| from . import ROOT,TASKS |
| from .data import annotate,documents,gold_passes |
| from .envs import Pool,available_hints |
|
|
|
|
| SPLITS=('sft','rl','calibration','dev','test') |
|
|
|
|
| @dataclass |
| class Config: |
| action: str='generate' |
| source: str=str(ROOT) |
| teacher: str=str(ROOT/'variants/diverse-completion-v2') |
| root: str=str(ROOT/'variants/clear-reference-v1') |
| model: str='gpt-6-luna' |
| concurrency: int=96 |
| rpm: int=6000 |
| tpm: int=3000000 |
| limit: int=0 |
| tokens: int=2097152 |
| seed: int=6719 |
| workers: int=8 |
|
|
|
|
| class Body(BaseModel): |
| body: str |
|
|
|
|
| def jobs_for(config: Config): |
| jobs=[] |
| for family in ('mbpp','humaneval'): |
| for split in SPLITS: |
| for row in load_rows(Path(config.source),family,split): |
| jobs.append(dict(family=family,split=split,identity=row['source_id'],row=row)) |
| if not config.limit or len(jobs)<config.limit: |
| for row in load_rows(Path(config.teacher),'mbpp','sft'): |
| if row['source_id'].startswith('diverse-contract/'): |
| jobs.append(dict(family='teacher',split='sft',identity=row['source_id'],row=row)) |
| if config.limit and len(jobs)>=config.limit:break |
| if config.limit:jobs=jobs[:config.limit] |
| for job in jobs: |
| row=job['row'] |
| payload=dict(revision='clear-implementations-v1',model=config.model, |
| family=job['family'],identity=job['identity'],question=row['question'],reference=row['reference']) |
| job['key']=hashlib.sha256(json.dumps(payload,sort_keys=True).encode()).hexdigest() |
| assert len({j['key'] for j in jobs})==len(jobs) |
| return jobs |
|
|
|
|
| def cached(root: Path): |
| path=root/'rewrites.jsonl' |
| result={} |
| if path.exists(): |
| for line in path.read_text().splitlines(): |
| try: |
| record=json.loads(line) |
| except json.JSONDecodeError: |
| continue |
| if record.get('body'): |
| result[record['key']]=record |
| return result |
|
|
|
|
| def prompt(job: dict): |
| row=job['row'] |
| return ('Rewrite the implementation of this existing Python exercise in clear, ordinary, idiomatic Python. ' |
| 'Preserve the exact contract, signature and behavior on every valid input. ' |
| 'Use natural short local names and direct returns when an intermediate variable is unnecessary. ' |
| 'Prefer a simple builtin or comprehension when that is the clearest correct solution. ' |
| 'Keep loops when they make the algorithm clearer. Do not golf code or compress multiple statements onto a line. ' |
| 'Do not add padding, aliases, artificial final statements, redundant return variables, or comments chosen to make the ending predictable. ' |
| 'Return only the implementation body, with relative indentation, without the function signature, docstring, tests or Markdown. ' |
| 'Any newly needed standard-library import must be inside the function. Nested helpers are allowed when needed. ' |
| 'The existing instruction and signature prefix will be preserved verbatim.\n'+ |
| json.dumps(dict(question=row['question'],original_program=row['reference'],tests=row['tests']),ensure_ascii=False)) |
|
|
|
|
| async def generate(config: Config): |
| root=Path(config.root) |
| root.mkdir(parents=True,exist_ok=True) |
| jobs=jobs_for(config) |
| if config.limit:jobs=jobs[:config.limit] |
| done=cached(root) |
| pending=[j for j in jobs if j['key'] not in done] |
| limiter=Limiter(config.rpm,config.tpm) |
| stats=Counter() |
| lock=(root/'generation.lock').open('a') |
| fcntl.flock(lock,fcntl.LOCK_EX|fcntl.LOCK_NB) |
| stream=(root/'rewrites.jsonl').open('a',buffering=1024*1024) |
| semaphore=asyncio.Semaphore(config.concurrency) |
| progress=tqdm(total=len(pending),desc='Clear benchmark and SFT implementations',colour='cyan',mininterval=5) |
| limits=httpx.Limits(max_connections=config.concurrency+8,max_keepalive_connections=config.concurrency) |
| transport=DefaultAioHttpClient(limits=limits,timeout=60.) |
| try: |
| async with AsyncOpenAI(http_client=transport,max_retries=0,timeout=60.) as client: |
| async def one(job): |
| async with semaphore: |
| text=prompt(job) |
| body_tokens=len(v2.ENC.encode_ordinary(job['row']['reference'][len(job['row']['protected_prefix']):])) |
| output=max(256,min(1400,int(body_tokens*1.5)+128)) |
| for attempt in range(3): |
| ticket=await limiter.acquire(len(v2.ENC.encode_ordinary(text))+min(output,body_tokens+64)) |
| try: |
| response=await client.responses.parse(model=config.model,input=text,text_format=Body, |
| reasoning={'effort':'none'},max_output_tokens=output,store=False) |
| usage=response.usage.model_dump() if response.usage else {} |
| await limiter.settle(ticket,usage.get('total_tokens',0)) |
| if response.output_parsed is None: |
| raise ValueError('No structured implementation body') |
| record=dict(key=job['key'],family=job['family'],source_id=job['row']['source_id'], |
| body=response.output_parsed.body,response_id=response.id,model=config.model,usage=usage) |
| stream.write(json.dumps(record,ensure_ascii=False)+'\n') |
| stats['success']+=1 |
| stats['input_tokens']+=usage.get('input_tokens',0) |
| stats['output_tokens']+=usage.get('output_tokens',0) |
| break |
| except Exception as error: |
| await limiter.settle(ticket,0) |
| stats[type(error).__name__]+=1 |
| if isinstance(error,RateLimitError):limiter.backoff(2.+attempt*2.) |
| if attempt<2:await asyncio.sleep(1.+attempt) |
| progress.update() |
| if stats['success']%50==0: |
| stream.flush() |
| atomic_json(root/'generation-progress.json',dict(stats=stats,requested=len(pending),updated=time.time())) |
| await asyncio.gather(*(one(job) for job in pending)) |
| finally: |
| stream.close() |
| progress.close() |
| lock.close() |
| atomic_json(root/'generation-progress.json',dict(stats=stats,requested=len(pending),updated=time.time())) |
| if stats['success']<.9*len(pending): |
| raise RuntimeError('Too many API failures; resume missing cached bodies before building') |
| print('[green]Implementation rewrites cached[/green]',dict(stats),flush=True) |
|
|
|
|
| def proposed(row: dict,body: str): |
| code=row['protected_prefix']+textwrap.indent(textwrap.dedent(body).strip(),' ') |
| ast.parse(code) |
| if len(v2.ENC.encode_ordinary(v2.header(row)+code))>1000: |
| raise ValueError('Rewritten function exceeds context') |
| return annotate(dict(row,reference=code,answer=code,provenance=dict(row['provenance'], |
| reference_style='clear-implementations-v1',original_reference_sha256=hashlib.sha256(row['reference'].encode()).hexdigest()))) |
|
|
|
|
| def build(config: Config): |
| if config.limit: |
| raise ValueError('A smoke-generation limit cannot build a completed task dataset') |
| root=Path(config.root) |
| if (root/'dataset.json').exists():return json.loads((root/'dataset.json').read_text()) |
| records=cached(root) |
| jobs=jobs_for(config) |
| if sum(j['key'] in records for j in jobs)<.9*len(jobs): |
| raise ValueError('Generate the complete implementation cache before building') |
| accepted={} |
| stats=Counter() |
| candidates=[] |
| for job in tqdm(jobs,desc='Parse rewritten native functions',colour='cyan',mininterval=5): |
| try: |
| row=proposed(job['row'],records[job['key']]['body']) |
| if job['family']=='teacher':accepted[(job['family'],canonical(job['row']['reference']))]=records[job['key']] |
| else:candidates.append((job,row)) |
| except (KeyError,SyntaxError,ValueError):stats['format_fallback']+=1 |
| with ThreadPoolExecutor(max_workers=config.workers) as pool: |
| passed=list(tqdm(pool.map(gold_passes,[r for j,r in candidates]),total=len(candidates), |
| desc='Check unchanged benchmark tests once',colour='green',mininterval=5)) |
| for (job,row),ok in zip(candidates,passed,strict=True): |
| if ok: |
| accepted[(job['family'],job['identity'])]=records[job['key']] |
| stats['benchmark_rewrites']+=1 |
| else:stats['benchmark_test_fallback']+=1 |
| report=dict(source=str(config.source),teacher=str(config.teacher),sft_tokens=config.tokens,seed=config.seed, |
| revision='clear-implementations-v1',tasks={},rewrites=dict(stats), |
| reference_policy='Original questions, protected signatures/instructions, tests and source split groups are preserved. Rewrite implementation bodies only; unchanged-test failures retain the original reference. No padding or artificial endings.', |
| sft_validation='Teacher SFT implementations receive syntax/context checks only; benchmark full programs execute unchanged tests once.') |
| for task in TASKS: |
| family='mbpp' if task.startswith('mbpp') else 'humaneval' |
| pools={split:load_rows(Path(config.source),task,split) for split in SPLITS} |
| pools['sft']+=[r for r in load_rows(Path(config.teacher),task,'sft') if r['source_id'].startswith('diverse-contract/')] |
| for split,rows in pools.items(): |
| cleaned=[] |
| for row in rows: |
| origin='teacher' if row['source_id'].startswith('diverse-contract/') else family |
| identity=canonical(row['reference']) if origin=='teacher' else row['source_id'] |
| record=accepted.get((origin,identity)) |
| try: |
| value=proposed(row,record['body']) if record is not None else annotate(dict(row)) |
| except (SyntaxError,ValueError):value=annotate(dict(row)) |
| if record is not None: |
| value['provenance'].update(reference_teacher_model=record.get('model',config.model), |
| reference_response_id=record.get('response_id'),reference_rewrite_key=record['key']) |
| value.pop('demonstrations',None) |
| cleaned.append(value) |
| pools[split]=cleaned |
| heldout={canonical(r['reference']) for split in ('calibration','dev','test') for r in pools[split]} |
| pools['rl']=[r for r in pools['rl'] if canonical(r['reference']) not in heldout] |
| blocked=heldout|{canonical(r['reference']) for r in pools['rl']} |
| seen=set(blocked) |
| unique=[] |
| for row in pools['sft']: |
| identity=canonical(row['reference']) |
| if identity not in seen: |
| seen.add(identity) |
| unique.append(row) |
| pools['sft']=unique |
| short=sorted(unique,key=lambda r:len(v2.ENC.encode_ordinary(v2.render(r)))) |
| for split in SPLITS: |
| if split!='sft': |
| for row in pools[split]: |
| groups={row['group']} |
| row['demonstrations']=[] |
| for demo in short: |
| if demo['group'] not in groups: |
| row['demonstrations'].append(demo) |
| groups.add(demo['group']) |
| if len(row['demonstrations'])==2:break |
| row['hint_levels']=available_hints(row) |
| if not row['hint_levels']: |
| raise ValueError('A rewritten benchmark source cannot fit its protected prefix and two demonstrations') |
| Pool(pools[split]) |
| write_rows(root/'data'/task/(split+'.jsonl.gz'),pools[split]) |
| corpus=documents(unique,config.tokens,random.Random(config.seed)) |
| path=root/'sft'/task/'train.jsonl.gz' |
| write_rows(path,corpus) |
| report['tasks'][task]=dict(rows={s:len(r) for s,r in pools.items()},documents=len(corpus), |
| source_groups=len({r['group'] for r in unique}),sft_sha256=signature(path), |
| assets={str(p.relative_to(root)):signature(p) for p in sorted((root/'data'/task).glob('*.gz'))}) |
| atomic_json(root/'data-build-progress.json',report) |
| atomic_json(root/'dataset.json',report) |
| print('[green]Clear-reference task control ready[/green]',dict(stats),flush=True) |
| return report |
|
|
|
|
| def main(config: Config): |
| if config.action in ('generate','all'):asyncio.run(generate(config)) |
| if config.action in ('build','all'):build(config) |
|
|
|
|
| if __name__=='__main__': |
| main(OmegaConf.to_object(OmegaConf.merge(OmegaConf.structured(Config),OmegaConf.from_cli()))) |
|
|
