| """RegalFire original procedural fixture generators. Independent validation lives in check.py.""" |
| import argparse |
| from collections import deque |
| import heapq |
| import json |
| from pathlib import Path |
| import random |
| import sys |
| from common import * |
|
|
| def astar(grid,costs,start,goal): |
| h,w=len(grid),len(grid[0]); start=tuple(start); goal=tuple(goal) |
| distance={start:0}; parent={}; queue=[(0,0,start)] |
| while queue: |
| _,cost,cell=heapq.heappop(queue) |
| if distance[cell]!=cost: continue |
| if cell==goal: |
| path=[list(cell)] |
| while cell!=start: cell=parent[cell]; path.append(list(cell)) |
| return {'cost':cost,'path':path[::-1]} |
| y,x=cell |
| for dy,dx in [(1,0),(-1,0),(0,1),(0,-1)]: |
| b=(y+dy,x+dx) |
| if 0<=b[0]<h and 0<=b[1]<w and grid[b[0]][b[1]]=='.': |
| d=cost+costs[b[0]][b[1]] |
| if d<distance.get(b,10**9): |
| distance[b]=d; parent[b]=cell |
| heapq.heappush(queue,(d+abs(b[0]-goal[0])+abs(b[1]-goal[1]),d,b)) |
| return {'cost':None,'path':None} |
| def nav(r,family): |
| h,w=r.randint(6,10),r.randint(6,10); wall=r.randint(2,w-3) |
| gap=0 if family=='boundary_gap' else r.randint(1,h-2) |
| if family=='two_gap_detour': gap=1 |
| g=[['#' if r.random()<.22 else '.' for _ in range(w)] for _ in range(h)] |
| for y in range(h): g[y][wall]='#' |
| rows=[gap,h-2] if family=='two_gap_detour' else [gap] |
| for y in rows: |
| for x in range(w): g[y][x]='.' |
| start=[r.randrange(h),r.randrange(wall)]; goal=[r.randrange(h),r.randint(wall+1,w-1)] |
| if family=='two_gap_detour': start[0]=goal[0]=1 |
| for p in [start,goal]: |
| for row in rows: |
| for y in range(min(p[0],row),max(p[0],row)+1): g[y][p[1]]='.' |
| if family=='gap_open': g[gap][wall]='#' |
| grid=[''.join(row) for row in g] |
| costs=[[r.randint(1,5) if family=='weighted_gap_close' else 1 for x in range(w)] for y in range(h)] |
| before=astar(grid,costs,start,goal) |
| changed=[list(row) for row in grid]; changed[gap][wall]='.' if changed[gap][wall]=='#' else '#' |
| after=astar([''.join(row) for row in changed],costs,start,goal) |
| if before['cost']==after['cost']: raise ValueError('edit not critical') |
| return {'grid':grid,'costs':costs,'start':start,'goal':goal,'edit':[gap,wall]}, {'before':before,'after':after,'reachability_changed':(before['cost'] is None)!=(after['cost'] is None)} |
|
|
| def neighbors(grid,p,goal=None): |
| y,x=p; options=[] |
| for dy,dx in [(0,0),(1,0),(-1,0),(0,1),(0,-1)]: |
| yy,xx=y+dy,x+dx |
| if 0<=yy<len(grid) and 0<=xx<len(grid[0]) and grid[yy][xx]=='.': options.append((yy,xx)) |
| return [p] if goal is not None and p==goal else options |
| def single(grid,start,goal): |
| q=deque([(tuple(start),0)]); seen={tuple(start)} |
| while q: |
| p,d=q.popleft() |
| if p==tuple(goal): return d |
| for b in neighbors(grid,p): |
| if b not in seen: seen.add(b);q.append((b,d+1)) |
| return None |
| def joint_bfs(grid,starts,goals): |
| start=tuple(map(tuple,starts)); target=tuple(map(tuple,goals)); q=deque([start]); parent={start:None} |
| moves={tuple([y,x]):neighbors(grid,(y,x)) for y in range(len(grid)) for x in range(len(grid[0])) if grid[y][x]=='.'} |
| while q: |
| p=q.popleft() |
| if p==target: |
| plan=[] |
| while p is not None: plan.append([list(p[0]),list(p[1])]);p=parent[p] |
| return plan[::-1] |
| for a in ([p[0]] if p[0]==target[0] else moves[p[0]]): |
| for b in ([p[1]] if p[1]==target[1] else moves[p[1]]): |
| state=(a,b) |
| if a==b or (a==p[1] and b==p[0]) or state in parent: continue |
| parent[state]=p;q.append(state) |
| return None |
| def coord(r,family): |
| h,w=r.choice([4,5,6]),r.choice([4,5,6]) |
| grid=[['#' if r.random()<.28 else '.' for _ in range(w)] for _ in range(h)] |
| if family in ['bottleneck','separated']: |
| wall=w//2 |
| for y in range(h): grid[y][wall]='#' |
| if family=='bottleneck': grid[r.randrange(h)][wall]='.' |
| free=[[y,x] for y in range(h) for x in range(w) if grid[y][x]=='.'] |
| if len(free)<8: raise ValueError('too few cells') |
| starts=r.sample(free,2) |
| if family=='adjacent_swap': |
| adjacent=[p for p in free if abs(p[0]-starts[0][0])+abs(p[1]-starts[0][1])==1] |
| if not adjacent: raise ValueError('no neighbor') |
| starts[1]=r.choice(adjacent);goals=starts[::-1] |
| elif family in ['bottleneck','separated']: |
| left=[p for p in free if p[1]<w//2];right=[p for p in free if p[1]>w//2] |
| if not left or not right: raise ValueError('empty region') |
| starts=[r.choice(left),r.choice(right)];goals=starts[::-1] |
| elif family=='crossing': |
| rows=[[p for p in free if p[0]==y] for y in range(h)] |
| candidates=[row for row in rows if len(row)>=2 and row[-1][1]-row[0][1]>=2] |
| if not candidates:raise ValueError('no crossing row') |
| row=r.choice(candidates);starts=[row[0],row[-1]];goals=starts[::-1] |
| else: goals=r.sample([p for p in free if p not in starts],2) |
| grid=[''.join(row) for row in grid] |
| lower=[single(grid,s,g) for s,g in zip(starts,goals)] |
| plan=joint_bfs(grid,starts,goals) if all(x is not None for x in lower) else None |
| lb=max(lower) if all(x is not None for x in lower) else None |
| cost=len(plan)-1 if plan else None |
| return {'grid':grid,'starts':starts,'goals':goals}, {'plan':plan,'optimal_makespan':cost,'independent_lower_bound':lb,'coordination_overhead':cost-lb if cost is not None else None} |
|
|
| def read_label(fastq,policy): |
| header,seq,sep,qual=fastq.split('\n'); errors=[] |
| if not header.startswith('@'): errors.append('header') |
| if sep!='+': errors.append('separator') |
| if any(x not in 'ACGTN' for x in seq): errors.append('alphabet') |
| if len(seq)!=len(qual): errors.append('quality_length') |
| if any(not 33<=ord(q)<=74 for q in qual): errors.append('quality_ascii') |
| if errors: return {'valid_fastq':False,'errors':sorted(errors),'passed_filter':False,'trimmed_sequence':None,'trimmed_quality':None,'quality_sum':None,'length':None,'n_count':None,'gc_count':None} |
| end=len(seq) |
| while end>0 and ord(qual[end-1])-33<policy['trim_q_min']: end-=1 |
| seq=seq[:end];qual=qual[:end];total=sum(ord(x)-33 for x in qual) |
| return {'valid_fastq':True,'errors':[],'passed_filter':len(seq)>=policy['min_length'] and seq.count('N')<=policy['max_n'] and total>=policy['mean_q_min']*len(seq), |
| 'trimmed_sequence':seq,'trimmed_quality':qual,'quality_sum':total,'length':len(seq),'n_count':seq.count('N'),'gc_count':seq.count('G')+seq.count('C')} |
| def reads(r,family): |
| policy={'min_length':r.randint(20,50),'max_n':r.randint(0,3),'mean_q_min':r.randint(18,28),'trim_q_min':r.randint(4,15)} |
| length=r.randint(24,90) |
| if family=='length_boundary': length=policy['min_length']+r.choice([-1,0,1]) |
| seq=''.join(r.choices('ACGT',k=length));q=[r.randint(30,41) for _ in seq] |
| if family=='quality_boundary': |
| level=policy['mean_q_min']+r.choice([-1,0,1]);q=[level for _ in seq] |
| if family=='ambiguous_bases': |
| count=policy['max_n']+r.choice([0,1]);idx=r.sample(range(length),count);s=list(seq) |
| for i in idx:s[i]='N' |
| seq=''.join(s) |
| if family=='clean': |
| tail=r.randint(1,8);q[-tail:]=[2]*tail |
| qual=''.join(chr(x+33) for x in q);header='@synthetic_read';sep='+' |
| if family=='malformed_record': |
| error=r.choice(['header','separator','alphabet','quality_length','quality_ascii']) |
| if error=='header':header='synthetic_read' |
| elif error=='separator':sep='-' |
| elif error=='alphabet':seq=seq[:-1]+'X' |
| elif error=='quality_length':qual=qual[:-1] |
| else:qual=qual[:-1]+chr(32) |
| fastq='\n'.join([header,seq,sep,qual]) |
| return {'fastq':fastq,'policy':policy},read_label(fastq,policy) |
|
|
| def alignment(a,b): |
| n,m=len(a),len(b);d=[[0]*(m+1) for _ in range(n+1)] |
| for i in range(n+1):d[i][0]=i |
| for j in range(m+1):d[0][j]=j |
| for i in range(1,n+1): |
| for j in range(1,m+1):d[i][j]=min(d[i-1][j]+1,d[i][j-1]+1,d[i-1][j-1]+(a[i-1]!=b[j-1])) |
| aa=[];bb=[];i=n;j=m |
| while i or j: |
| if i and j and d[i][j]==d[i-1][j-1]+(a[i-1]!=b[j-1]):aa.append(a[i-1]);bb.append(b[j-1]);i-=1;j-=1 |
| elif i and d[i][j]==d[i-1][j]+1:aa.append(a[i-1]);bb.append('-');i-=1 |
| else:aa.append('-');bb.append(b[j-1]);j-=1 |
| return d[n][m],''.join(aa[::-1]),''.join(bb[::-1]) |
| def align(r,family): |
| rand=lambda n:''.join(r.choices('ACGT',k=n)) |
| if family=='homopolymer':a=rand(10)+r.choice('ACGT')*r.randint(8,16)+rand(10) |
| elif family=='tandem_repeat':a=rand(9)+rand(3)*r.randint(3,7)+rand(9) |
| else:a=rand(r.randint(24,50)) |
| if family=='literal_N':a=a[:10]+'NN'+a[12:] |
| source=a |
| if family=='reverse_complement':b=rc(a) |
| else: |
| b=list(a) |
| for _ in range(r.randint(1,5)): |
| pos=r.randrange(len(b));operation=r.choice(['sub','ins','del']) |
| if operation=='sub':b[pos]=r.choice('ACGTN' if family=='literal_N' else 'ACGT') |
| elif operation=='ins':b.insert(pos,r.choice('ACGT')) |
| else:b.pop(pos) |
| b=''.join(b) |
| distance,aa,bb=alignment(a,b);threshold=max(0,distance+r.choice([-1,0,1])) |
| return {'a':a,'b':b,'source_sequence':source,'threshold':threshold},{'edit_distance':distance,'within_threshold':distance<=threshold,'aligned_a':aa,'aligned_b':bb} |
|
|
| def interval_label(inp): |
| def bed(v):return v['start']-(v['basis']=='one_closed'),v['end'] |
| q=inp['query'];a,b=bed(q);matches=[];segments=[] |
| for i,f in enumerate(inp['features']): |
| if f['contig']!=q['contig'] or (inp['same_strand'] and f['strand']!=q['strand']):continue |
| c,d=bed(f);lo,hi=max(a,c),min(b,d) |
| if lo<hi:matches.append({'feature_index':i,'overlap_bases':hi-lo});segments.append((lo,hi)) |
| covered=0;end=-1 |
| for lo,hi in sorted(segments):covered+=max(0,hi-max(lo,end));end=max(end,hi) |
| return {'query_bed':[a,b],'matches':matches,'union_overlap_bases':covered,'query_length':b-a} |
| def intervals(r,family): |
| contigs={'synthetic_A':r.randint(600,1800),'synthetic_B':r.randint(600,1800)} |
| c=r.choice(list(contigs));a=r.randint(20,contigs[c]-200);b=a+r.randint(5,80) |
| q={'contig':c,'start':a,'end':b,'strand':r.choice(['+','-']),'basis':'zero_half_open'} |
| features=[] |
| for _ in range(r.randint(5,12)): |
| cc=r.choice(list(contigs));x=r.randint(0,contigs[cc]-120);features.append({'contig':cc,'start':x,'end':x+r.randint(1,120),'strand':r.choice(['+','-']),'basis':'zero_half_open'}) |
| def feature(start,end,strand=None):return {'contig':c,'start':start,'end':end,'strand':strand or q['strand'],'basis':'zero_half_open'} |
| if family=='touching_boundary':features[:2]=[feature(max(0,a-r.randint(1,20)),a),feature(b,b+r.randint(1,40))] |
| elif family=='nested':features[:2]=[feature(a-5,b+5),feature(a+1,b-1)] |
| elif family=='overlapping_blocks':features[:3]=[feature(a-3,a+3),feature(a+1,b),feature(b-2,b+3)] |
| elif family=='stranded':features[:2]=[feature(a,b,'+'),feature(a,b,'-')] |
| else:features[0]=feature(a,b) |
| for f in features+[q]: |
| if r.random()<.5 or family=='coordinate_conversion':f['start']+=1;f['basis']='one_closed' |
| inp={'contigs':contigs,'features':features,'query':q,'same_strand':family=='stranded' or r.choice([True,False])} |
| return inp,interval_label(inp) |
|
|
| MAKERS={'nav':nav,'coord':coord,'reads':reads,'align':align,'intervals':intervals} |
| def generate(kind,out,count,seed,resume=False): |
| out=Path(out) |
| if out.exists() and not resume:raise ValueError('output exists; use --resume') |
| out.mkdir(parents=True,exist_ok=True);chunks=out/'chunks';chunks.mkdir(exist_ok=True) |
| binding={'kind':kind,'count':count,'seed':seed,'source_sha256':sha(Path(__file__).read_text(encoding='utf-8')),'common_sha256':sha(Path(__file__).with_name('common.py').read_text(encoding='utf-8'))} |
| if (out/'config.json').exists() and strict((out/'config.json').read_text())!=binding:raise ValueError('resume parameters/source mismatch') |
| write_json(out/'config.json',binding) |
| seen=set();total=0 |
| for file in sorted(chunks.glob('*.jsonl')): |
| for line in file.read_text(encoding='utf-8').splitlines(): |
| row=strict(line) |
| if row['index']!=total or row['fingerprint'] in seen:raise ValueError('invalid checkpoint shard') |
| seen.add(row['fingerprint']);total+=1 |
| if total>count:raise ValueError('count below checkpoint size') |
| attempts=0 |
| while total<count: |
| batch=[];start=total |
| while len(batch)<min(500,count-start): |
| i=total;family=FAMILIES[kind][i%5] |
| for retry in range(1000): |
| try: |
| inp,expected=MAKERS[kind](random.Random(seed+i*1009+retry*100000003),family) |
| fp,group=semantic(kind,inp) |
| if fp in seen:continue |
| seen.add(fp);break |
| except ValueError:continue |
| else:raise ValueError('cannot produce unique record') |
| attempts+=retry |
| batch.append({'id':kind.upper()+f'-{i:07d}','index':i,'seed':seed,'family':family,'input':inp,'expected':expected,'fingerprint':fp,'group_id':group,'split':split(group),'provenance':provenance(kind)}) |
| total+=1 |
| temp=chunks/f'{start:07d}.jsonl.tmp';temp.write_text(''.join(enc(x)+'\n' for x in batch),encoding='utf-8');temp.replace(chunks/f'{start:07d}.jsonl') |
| write_json(out/'checkpoint.json',{'committed_records':total,'target':count,'attempt_retries_this_run':attempts}) |
| print(f'{kind}: generated {total}/{count}',flush=True) |
| with (out/'dataset.jsonl.tmp').open('w',encoding='utf-8',newline='\n') as dest: |
| for file in sorted(chunks.glob('*.jsonl')):dest.write(file.read_text(encoding='utf-8')) |
| (out/'dataset.jsonl.tmp').replace(out/'dataset.jsonl') |
| return total |
| def main(): |
| p=argparse.ArgumentParser();p.add_argument('--kind',choices=NAMES,required=True);p.add_argument('--out',type=Path,required=True);p.add_argument('--count',type=int,required=True);p.add_argument('--seed',type=int,default=20261001);p.add_argument('--resume',action='store_true');a=p.parse_args() |
| if not 100<=a.count<=100000:raise ValueError('count must be 100-100000') |
| generate(a.kind,a.out,a.count,a.seed,a.resume) |
| if __name__=='__main__':main() |
|
|
