validator/common.py

"""RegalFire synthetic fixture serialization, group identity and schema. No label oracle."""
import hashlib
import json
from pathlib import Path

NAMES={'nav':'GameNav-CriticalEdits-25K','coord':'GameCoord-JointPlans-25K','reads':'BioRead-QC-Boundaries-20K','align':'BioAlign-EditDistance-HardCases-10K','intervals':'BioInterval-CoordinateQA-20K'}
FAMILIES={'nav':['gap_close','gap_open','weighted_gap_close','boundary_gap','two_gap_detour'],
 'coord':['adjacent_swap','crossing','bottleneck','separated','random_obstacles'],
 'reads':['clean','quality_boundary','length_boundary','ambiguous_bases','malformed_record'],
 'align':['homopolymer','tandem_repeat','clustered_indels','literal_N','reverse_complement'],
 'intervals':['touching_boundary','nested','overlapping_blocks','stranded','coordinate_conversion']}
def enc(x): return json.dumps(x,sort_keys=True,separators=(',',':'),ensure_ascii=False,allow_nan=False)
def sha(x): return hashlib.sha256(x.encode()).hexdigest()
def strict(s):
    def pairs(items):
        out={}
        for k,v in items:
            if k in out: raise ValueError('duplicate JSON key')
            out[k]=v
        return out
    return json.loads(s,object_pairs_hook=pairs,parse_constant=lambda v:(_ for _ in ()).throw(ValueError('nonfinite JSON')))
def write_json(path,value):
    path=Path(path); temp=path.with_suffix(path.suffix+'.tmp'); temp.write_text(enc(value)+'\n',encoding='utf-8'); temp.replace(path)
def rc(seq): return seq.translate(str.maketrans('ACGTN','TGCAN'))[::-1]
def transforms(grid, points=(), costs=None):
    g=list(grid); p=[tuple(x) for x in points]; c=[list(x) for x in costs] if costs else None
    variants=[]
    for _ in range(4):
        h,w=len(g),len(g[0]); variants.append((g,p,c))
        variants.append(([s[::-1] for s in g],[(y,w-1-x) for y,x in p],[r[::-1] for r in c] if c else None))
        g=[''.join(g[h-1-y][x] for y in range(h)) for x in range(w)]
        p=[(x,h-1-y) for y,x in p]
        if c: c=[[c[h-1-y][x] for y in range(h)] for x in range(w)]
    return variants
def semantic(kind,inp):
    if kind=='nav':
        candidates=[enc([g,p,c]) for g,p,c in transforms(inp['grid'],[inp['start'],inp['goal'],inp['edit']],inp['costs'])]
        group=min(enc(g) for g,_,_ in transforms(inp['grid']))
    elif kind=='coord':
        candidates=[]
        for g,p,_ in transforms(inp['grid'],inp['starts']+inp['goals']):
            candidates.extend([enc([g,p]),enc([g,[p[1],p[0],p[3],p[2]]])])
        group=min(enc(g) for g,_,_ in transforms(inp['grid']))
    elif kind=='reads':
        candidates=[enc([inp['fastq'].split('\n')[1:],inp['policy']])]
        seq=inp['fastq'].split('\n')[1]
        group=min(seq,rc(seq))
    elif kind=='align':
        a,b=inp['a'],inp['b']; candidates=[enc([a,b,inp['threshold']]),enc([b,a,inp['threshold']]),enc([rc(a),rc(b),inp['threshold']]),enc([rc(b),rc(a),inp['threshold']])]
        group=min(inp['source_sequence'],rc(inp['source_sequence']))
    else:
        def norm(feature):
            return [feature['contig'],feature['start']-(feature['basis']=='one_closed'),feature['end'],feature['strand']]
        features=[norm(f) for f in inp['features']]; query=norm(inp['query'])
        offsets={c:min(v[1] for v in features+[query] if v[0]==c) for c in inp['contigs']}
        normalized=[[v[0],v[1]-offsets[v[0]],v[2]-offsets[v[0]],v[3]] for v in features]
        q=[query[0],query[1]-offsets[query[0]],query[2]-offsets[query[0]],query[3]]
        candidates=[enc([sorted(normalized),q,inp['same_strand']])]; group=candidates[0]
    return sha(min(candidates)),sha(group)
def split(group): return 'train' if int(group[:8],16)%10<8 else 'validation' if int(group[:8],16)%10==8 else 'test'
def provenance(kind): return {'brand':'RegalFire','origin':'original_procedural_synthetic','external_records':False,'contains_personal_data':False,'license':'MIT','environment':'RegalFire '+kind+' computational fixture v1','label_source':'deterministic_computational_rules','llm_ground_truth':False}
def schema(kind):
    integer={'type':'integer','minimum':0}; text={'type':'string'}; point={'type':'array','items':integer,'minItems':2,'maxItems':2}
    def obj(props): return {'type':'object','properties':props,'required':list(props),'additionalProperties':False}
    if kind in ['nav','coord']:
        props={'grid':{'type':'array','items':{'type':'string','pattern':'^[.#]+$'},'minItems':3}}
        if kind=='nav': props.update(start=point,goal=point,edit=point,costs={'type':'array','items':{'type':'array','items':{'type':'integer','minimum':1,'maximum':5}}})
        else: props.update(starts={'type':'array','items':point,'minItems':2,'maxItems':2},goals={'type':'array','items':point,'minItems':2,'maxItems':2})
    elif kind=='reads': props={'fastq':text,'policy':obj({'min_length':integer,'max_n':integer,'mean_q_min':integer,'trim_q_min':integer})}
    elif kind=='align': props={'a':{'type':'string','pattern':'^[ACGTN]+$'},'b':{'type':'string','pattern':'^[ACGTN]+$'},'source_sequence':{'type':'string','pattern':'^[ACGTN]+$'},'threshold':integer}
    else:
        feature=obj({'contig':text,'start':integer,'end':integer,'strand':{'enum':['+','-']},'basis':{'enum':['zero_half_open','one_closed']}})
        props={'features':{'type':'array','items':feature,'minItems':3},'query':feature,'same_strand':{'type':'boolean'},'contigs':{'type':'object','additionalProperties':{'type':'integer','minimum':1}}}
    nullable_int={'type':['integer','null'],'minimum':0}
    boolean={'type':'boolean'}
    if kind=='nav':
        path_result=obj({'cost':nullable_int,'path':{'type':['array','null'],'items':point}})
        expected=obj({'before':path_result,'after':path_result,'reachability_changed':boolean})
    elif kind=='coord':expected=obj({'plan':{'type':['array','null'],'items':{'type':'array','items':point,'minItems':2,'maxItems':2}},'optimal_makespan':nullable_int,'independent_lower_bound':nullable_int,'coordination_overhead':nullable_int})
    elif kind=='reads':expected=obj({'valid_fastq':boolean,'errors':{'type':'array','items':{'enum':['header','separator','alphabet','quality_length','quality_ascii']}},'passed_filter':boolean,'trimmed_sequence':{'type':['string','null']},'trimmed_quality':{'type':['string','null']},'quality_sum':nullable_int,'length':nullable_int,'n_count':nullable_int,'gc_count':nullable_int})
    elif kind=='align':expected=obj({'edit_distance':integer,'within_threshold':boolean,'aligned_a':{'type':'string','pattern':'^[ACGTN-]+$'},'aligned_b':{'type':'string','pattern':'^[ACGTN-]+$'}})
    else:expected=obj({'query_bed':point,'matches':{'type':'array','items':obj({'feature_index':integer,'overlap_bases':{'type':'integer','minimum':1}})},'union_overlap_bases':integer,'query_length':integer})
    prov=provenance(kind)
    return {'$schema':'https://json-schema.org/draft/2020-12/schema',**obj({'id':text,'index':integer,'seed':integer,'family':{'enum':FAMILIES[kind]},'input':obj(props),'expected':expected,'fingerprint':{'type':'string','pattern':'^[a-f0-9]{64}$'},'group_id':{'type':'string','pattern':'^[a-f0-9]{64}$'},'split':{'enum':['train','validation','test']},'provenance':{'const':prov}})}