| """Independent source + product verifier. Never imports the product builder.""" |
| import argparse,hashlib,importlib.util,json,re |
| from collections import Counter |
| from datetime import datetime |
| from html.parser import HTMLParser |
| from pathlib import Path |
| from jsonschema import Draft202012Validator |
| ROOT=Path(__file__).resolve().parents[1] |
| KINDS={'Scientific-Statistics-QA':'statistics_qa','Scientific-Code-and-Analysis-QA':'code_qa','Scientific-Answer-Ranking':'ranking','Scientific-Citation-Graph':'citations','Scientific-RAG-HardCases':'rag'} |
| CACHE={} |
| def read(p):return json.loads(p.read_text('utf-8')) |
| def rows(p):return [json.loads(x) for x in p.read_text('utf-8').splitlines() if x.strip()] |
| def h(s):return hashlib.sha256(s.encode()).hexdigest() |
| def normal(s):return re.sub(r'[^\w]+',' ',s.lower()).strip() |
| class CodeOracle(HTMLParser): |
| def __init__(self):super().__init__(convert_charrefs=True);self.inside=False;self.parts=[];self.blocks=[] |
| def handle_starttag(self,tag,attrs): |
| if tag=='pre':self.inside=True;self.parts=[] |
| elif self.inside and tag=='br':self.parts.append('\n') |
| def handle_endtag(self,tag): |
| if tag=='pre' and self.inside:self.blocks.append(''.join(self.parts));self.inside=False |
| def handle_data(self,s): |
| if self.inside:self.parts.append(s) |
| def sources(root): |
| if str(root) in CACHE:return CACHE[str(root)] |
| result={};reports={};edges={} |
| for site in ['stats','scicomp','biology']: |
| source=root/'sources'/site;file=source/'codex'/'validate_scientific_forum_dataset.py' |
| spec=importlib.util.spec_from_file_location('independent_source_'+site,file);module=importlib.util.module_from_spec(spec);spec.loader.exec_module(module) |
| report=module.validate(source/'release'/'source-corpus',source) |
| if report['status']!='PASS':raise ValueError('Source validator failed: '+site+' '+str(report['errors'][:5])) |
| reports[site]=report;result[site]={r['thread_id']:r for r in rows(source/'release'/'source-corpus'/'dataset.jsonl')};edges[site]=rows(source/'release'/'source-corpus'/'citation_graph.jsonl') |
| CACHE[str(root)]=(result,reports,edges);return result,reports,edges |
| def validate(folder,root=ROOT,name=None): |
| name=name or folder.name;kind=KINDS[name];source,source_reports,edges=sources(root) |
| errors=[];assertions=0 |
| def check(ok,msg): |
| nonlocal assertions |
| assertions+=1 |
| if not ok:errors.append(msg) |
| data=rows(folder/'dataset.jsonl');schema=Draft202012Validator(read(folder/'schema.json'));ids=set();threads={};primary={};code_total=0 |
| corpus={t['thread_id']:t for t in rows(root/'normalized'/'corpus.jsonl')} |
| qaeligible=set();rankeligible=set();rageligible={};codeeligible={};citeseligible={} |
| def selected(t): |
| accepted=[a for a in t['answers'] if a['is_accepted']] |
| if accepted:return accepted[0] |
| scored=sorted([a for a in t['answers'] if a['score']>=1],key=lambda a:(-a['score'],a['answer_id']));return scored[0] if scored else None |
| def signals(t): |
| answers=t['answers'];sc=[a['score'] for a in answers];ac=next((a for a in answers if a['is_accepted']),None);ss=[] |
| if len(answers)>1:ss.append('multiple_answers') |
| if len(t['external_links'])>1:ss.append('multiple_external_references') |
| if ac is None:ss.append('no_accepted_answer') |
| if ac and max(sc)>ac['score']:ss.append('accepted_not_highest_score') |
| if len(sc)>1 and max(sc)-min(sc)>=5:ss.append('community_score_spread_ge_5') |
| if len(answers)>1: |
| dates=[datetime.fromisoformat(a['created_at']) for a in answers] |
| if (max(dates)-min(dates)).days>=365:ss.append('answer_age_span_ge_365_days') |
| return ss |
| def code(t): |
| pp=[(t['question_id'],t['question_html'],t['source_url'])]+[(a['answer_id'],a['answer_html'],a['answer_url']) for a in t['answers']];rr=[] |
| for pid,body,url in pp: |
| oracle=CodeOracle();oracle.feed(body) |
| for i,block in enumerate(oracle.blocks): |
| if len(block.strip())<20:continue |
| if not re.search(r'\b(import|def|return|while|function|library|numpy|printf|NDSolve|Table|Plot|double|void)\b|<-|np\.|\bfor\s|print\(|lm\(',block):continue |
| rr.append((pid,i,block,url,h(block))) |
| return rr |
| for tid,t in corpus.items(): |
| if t['source_site']=='stats' and selected(t):qaeligible.add(tid) |
| if len(t['answers'])>=2:rankeligible.add(tid) |
| if signals(t):rageligible[tid]=signals(t) |
| cb=code(t) |
| if cb and selected(t):codeeligible[tid]=cb |
| cc=[c for c in edges[t['source_site']] if c['thread_id']==t['question_id']] |
| if cc:citeseligible[tid]=cc |
| seen_citations=set() |
| for r in data: |
| se=list(schema.iter_errors(r));check(not se,'schema '+r.get('record_id','?')+': '+str([e.message for e in se[:2]])) |
| if se:continue |
| rid=r['record_id'];check(rid not in ids,'duplicate primary ID '+rid);ids.add(rid) |
| t=r['thread'];tid=t['thread_id'];threads[tid]=t;site=t['source_site'];q=source[site].get(t['question_id']);check(q is not None,'orphan source thread '+tid) |
| if q is None:continue |
| check(tid==site+':'+str(t['question_id']),'qualified thread identity') |
| check(t['source_url']==q['thread_url'] and t['domain']=={'stats':'statistics','scicomp':'computational_science','biology':'biology'}[site],'source URL/domain') |
| for key in ['title','question_text','question_html','question_author','question_author_url','question_author_user_type','question_created_at','question_score','tags','question_license','accepted_answer_id','provenance','revision_attribution','medical_sensitive']: |
| check(t[key]==q[key],'source question field '+tid+'/'+key) |
| check(tid in corpus and t==corpus.get(tid),'canonical membership/equality '+tid) |
| check(r['split']==t['split'],'record/thread split consistency') |
| bucket=int(t['split_group'][:8],16)%100;expected='train' if bucket<70 else 'validation' if bucket<80 else 'test' if bucket<90 else 'holdout';check(t['split']==expected,'deterministic split bucket') |
| rawanswers={a['answer_id']:a for a in q['answers']};seen_answers=set() |
| for a in t['answers']: |
| aid=a['answer_id'];check(aid not in seen_answers,'duplicate answer');seen_answers.add(aid);original=rawanswers.get(aid);check(bool(original),'orphan answer') |
| if not original:continue |
| check(a['question_id']==t['question_id'],'answer question relationship') |
| for key in ['answer_text','answer_html','created_at','updated_at','score','is_accepted','content_license','answer_url','provenance','revision_attribution']: |
| check(a[key]==original[key],'source answer field '+tid+'/'+str(aid)+'/'+key) |
| check(a['author']==original['author_display_name'] and a['author_url']==original['author_profile_url'],'answer attribution') |
| check(seen_answers==set(rawanswers),'complete source answer coverage') |
| accepted=[a['answer_id'] for a in t['answers'] if a['is_accepted']];check(accepted==([t['accepted_answer_id']] if t['accepted_answer_id'] else []),'accepted consistency') |
| content='\n'.join([t['question_text']]+[a['answer_text'] for a in t['answers']]);check(not re.search(r'[\w.+-]+@[\w.-]+\.[A-Za-z]{2,}',content),'identifiable email heuristic') |
| check(not re.search(r'\b(my|I have|I am|my friend|my mother|my father)\b.{0,100}\b(symptom\w*|diagnos\w*|medication|disease|infection|pain|sick)\b',content,re.I|re.S),'patient history heuristic') |
| check(not re.search(r'\b(should I take|what (?:drug|medicine|treatment) should|how (?:can|should) I treat)\b',content,re.I),'clinical request heuristic') |
| if kind in ('statistics_qa','code_qa'): |
| s=selected(t);check(s is not None and r['selected_answer']==s and r['question']==t['question_text'],'QA selected answer') |
| check(r['accepted_answer']==(s if s and s['is_accepted'] else None),'QA accepted vs score fallback') |
| check(r['other_answers']==[a for a in t['answers'] if s and a['answer_id']!=s['answer_id']],'QA other candidates') |
| if kind=='code_qa': |
| actual=[(b['post_id'],b['block_index'],b['code_text'],b['source_url'],b['sha256']) for b in r['code_blocks']];check(actual==codeeligible.get(tid),'exact code extraction');code_total+=len(actual) |
| if kind=='ranking':check(r['candidate_answers']==t['answers'] and r['scores']==[a['score'] for a in t['answers']] and r['accepted_status']==[a['is_accepted'] for a in t['answers']] and r['question']==t['question_text'],'ranking source arrays') |
| if kind=='rag':check(r['hardness_signals']==signals(t),'deterministic hardness signals') |
| if kind=='citations': |
| key=(tid,r['post_id'],r['external_url'],r['doi']);check(key not in seen_citations,'duplicate citation');seen_citations.add(key) |
| allowed=citeseligible.get(tid,[]);c=next((c for c in allowed if (c['post_id'],c['target_url'],c['doi'])==key[1:]),None);check(c is not None,'literal source citation') |
| if c: |
| check(r['post_url']==c['source_post_url'] and r['kind']==c['kind'] and r['content_license']==c['content_license'] and r['correctness_verified'] is False,'citation metadata') |
| plain=t['question_text'] if r['post_id']==t['question_id'] else next(a['answer_text'] for a in t['answers'] if a['answer_id']==r['post_id']);needle=r['external_url'] or r['doi'];at=plain.find(needle);context=plain[max(0,at-100):at+len(needle)+100] if at>=0 else None;check(r['citation_context']==context,'citation literal context') |
| expected={'statistics_qa':qaeligible,'code_qa':set(codeeligible),'ranking':rankeligible,'rag':set(rageligible),'citations':set(citeseligible)}[kind];check(set(threads)==expected,'product eligible thread coverage') |
| if kind!='citations':check(len(data)==len(threads),'one record per thread') |
| else:check(seen_citations=={(tid,c['post_id'],c['target_url'],c['doi']) for tid,cc in citeseligible.items() for c in cc},'citation complete edge coverage') |
| allsplit=[] |
| for split in ['train','validation','test','holdout']: |
| ss=rows(folder/(split+'.jsonl'));check(ss==[r for r in data if r['split']==split],'exact '+split+' split');allsplit+=ss |
| check(len(allsplit)==len(data),'split coverage') |
| textmap={};near=0;normalized_duplicates=0;tts=list(threads.values());grams=[] |
| for t in tts: |
| for value in [normal(t['title']),normal(t['question_text'])]+[normal(a['answer_text']) for a in t['answers']]: |
| if value in textmap: |
| normalized_duplicates+=1;check(textmap[value]==t['split'],'exact question/title/answer leakage') |
| else:textmap[value]=t['split'] |
| w=normal(t['question_text']).split();grams.append(set(tuple(w[j:j+3]) for j in range(len(w)-2))) |
| for i,a in enumerate(grams): |
| for j in range(i): |
| b=grams[j] |
| if len(a)>=5 and len(b)>=5 and min(len(a),len(b))>=.8*max(len(a),len(b)) and len(a&b)/len(a|b)>=.8:near+=1;check(tts[i]['split']==tts[j]['split'],'near duplicate leakage') |
| stats=read(folder/'stats.json');check(stats['records']==len(data) and stats['unique_threads']==len(threads) and stats['answers']==sum(len(t['answers']) for t in threads.values()),'stats counts') |
| check(stats['splits']==dict(Counter(r['split'] for r in data)),'split counts') |
| rejected=rows(folder/'rejected.jsonl');check(len(rejected)==stats['rejected_records'] and all(r['reasons'] and r['thread_id'] not in threads for r in rejected),'rejections disjoint/reasoned') |
| check(len(data)>0 and all(any(r['split']==s for r in data) for s in ['train','validation','test','holdout']),'nonempty data and four splits') |
| report={'status':'PASS' if not errors else 'FAIL','name':name,'records':len(data),'unique_threads':len(threads),'answers':sum(len(t['answers']) for t in threads.values()),'assertions':assertions,'near_duplicate_pairs':near,'duplicate_text_occurrences':normalized_duplicates,'code_blocks_verified':code_total,'source_validation':{s:{'status':v['status'],'assertions':v['assertions'],'raw_files_verified':v['raw_files_verified']} for s,v in source_reports.items()},'errors':errors,'independent':'No import of builder; independent per-source raw/HTML/revision verifiers plus product selection and split checks. Same engine is used by five product-specific entry points.','holdout_note':'Source-thread lexical group holdout; public, not a contamination-free private test set.'} |
| (folder/'validation_report.json').write_text(json.dumps(report,indent=2)+'\n',encoding='utf-8');return report |
| if __name__=='__main__': |
| p=argparse.ArgumentParser();p.add_argument('--source-root',type=Path,default=ROOT);p.add_argument('--release',type=Path);p.add_argument('--product',choices=KINDS);a=p.parse_args() |
| names=[a.product] if a.product else list(KINDS);result={name:validate(a.release or a.source_root/'release'/name,a.source_root,name) for name in names} |
| print(json.dumps(result,indent=2));raise SystemExit(0 if all(r['status']=='PASS' for r in result.values()) else 1) |
|
|
