"""Synthetic mathematical/custody/queue checks; no real dataset decode or solve.""" import io import json from pathlib import Path import tempfile import unittest from unittest.mock import patch from zipfile import ZipFile import numpy as np from freeze_g1_components import sha from s2_custody_common import read_json from naive_ordering_math import cdf_interval,pps_cdf,training_clock,squared_wall_distance,volume_clock_curve import run_naive_ordering_part as part import run_naive_ordering_queue as queue import run_naive_ordering_analysis as analysis from s2_models.features import R2_COLUMNS class Checks(unittest.TestCase): def test_CDF_strict_and_right_ties_mass_counted_once(self): left,right=cdf_interval([3,1,3],[2,1,1]) np.testing.assert_array_equal(left,[.25,0,.25]);np.testing.assert_array_equal(right,[1,.25,1]) a,b=pps_cdf([3,1,3],[2,1,1]);np.testing.assert_array_equal(a,left) expanded=np.repeat([3,1,3],[2,1,1]);el,_=pps_cdf(expanded,np.ones(4)) np.testing.assert_array_equal(el,[.25,.25,0,.25]) def test_invalid_PPS_or_empty_CDF_rejected(self): for s,w in [([],[]),([1],[0]),([np.nan],[1]),([1],[np.inf])]: with self.assertRaises(ValueError):cdf_interval(s,w) with self.assertRaises(ValueError):pps_cdf([1,2],[.2,.8]) def test_conditional_CDF_differs_under_full_constant_flow(self): full,_=cdf_interval([1,2,3,4],[1,1,1,1]);masked,_=pps_cdf([1,2],[1,1]) np.testing.assert_array_equal(full[:2],[0,.25]);np.testing.assert_array_equal(masked,[0,.5]) alpha=.5 self.assertTrue(np.all((full[:2]>=alpha*masked)&(full[:2]<=alpha*masked+1-alpha))) # K/2000 alone is not total-cavity eligible mass when M+ is only0.4. self.assertEqual(.4*1000/2000,.2) def test_c_is_component_part_equal_learning_only(self): def row(k,g,role):return dict(case=k,component_id=g,included=True,assignments=[dict(role=role,learning_pools=['100'])],preparation=dict(t_set=2.)) rows=[row('a','A','learning'),row('b','A','learning'),row('c','C','learning'),row('v','V','validation'),row('t','T','test')] c,access=training_clock(rows,0,100,dict(a=2.,b=6.,c=10.)) self.assertEqual(c,3.5);self.assertEqual({r['case'] for r in access},set('abc')) with self.assertRaises(KeyError):training_clock(rows,0,100,dict(a=2.,b=6.)) def test_Dw2_is_square_of_midpoint_not_mean_of_squares(self): out,source,excluded=squared_wall_distance([[0,0,0],[1,0,0],[2,0,0]],[[0,1],[1,2]],[0,2,4],[0,0,0]) np.testing.assert_allclose(out,[0,1,1+1/9]);self.assertEqual(source,0);self.assertEqual(excluded,0) with self.assertRaisesRegex(ValueError,'Unreachable'): squared_wall_distance([[0,0,0],[1,0,0],[2,0,0]],[[0,1],[1,2]],[0,0,2],[0,0,0]) def test_order_and_final_ties_preserved(self): s=np.array([-3.,1.,1.,9.]);ids=np.array([4,2,1,7]);left,_=pps_cdf(s,[1,2,3,1]);mapped=3.7*left self.assertEqual(ids[s==s.max()].min(),ids[mapped==mapped.max()].min()) np.testing.assert_array_equal(np.sign(s[:,None]-s),np.sign(mapped[:,None]-mapped)) def test_curve_records_full_end_distinct_from_tet_max(self): d=volume_clock_curve([0,.4,.8],[1,1,1],1.2,2.) self.assertEqual(d['tet_end'],.8);self.assertEqual(d['full_VTU_end'],1.2) self.assertEqual(d['seconds'][-1],.8);self.assertAlmostEqual(d['over_full_end'][-1],2/3) def test_one_full_decode_cache_identity_and_no_duplicate_attempt(self): with tempfile.TemporaryDirectory() as temp: root=Path(temp);source=root/'source';source.mkdir();(root/'parts/part-000').mkdir(parents=True) x=np.array([[0,0,0],[1,0,0],[0,1,0],[0,0,1.]]) edges=np.array([[0,1],[0,2],[0,3],[1,2],[1,3],[2,3]]) np.savez(source/'geometry.npz',points_raw=x,edges=edges,node_volume_raw=np.ones(4),raw_node_ids=np.arange(4),gate_location_raw=x[0]) features=np.zeros((4,20));features[:,8]=[0,1,1,1] np.savez(source/'r2.npz',features=features,Df=[0,2,2,2],Vf=[0,.25,.25,.25]) np.savez(source/'queries.npz',eligible_s2=[True]*3,anchor_ids=[1,2,3],raw_node_ids=[1,2,3],multiplicity=[1,2,1]) (source/'result.json').write_text(json.dumps(dict(r2=dict(columns=list(R2_COLUMNS)),draw_slots=4))) full=np.array([0.,.2,.4,.8,1.2]);old=root/'old.npz';np.savez(old,seconds=full[[1,2,3]],raw_ids=[1,2,3],counts=[1,2,1]) labels=root/'labels.json';labels.write_text(json.dumps([dict(case='case',path=str(old),sha256=sha(old))])) archive=root/'archive.zip' with ZipFile(archive,'w') as z:z.writestr('case_sim.vtu','x') st=archive.stat();(root/'contract.json').write_text('{}') c=dict(archive=str(archive),archive_stat=dict(bytes=st.st_size,mtime_ns=st.st_mtime_ns,inode=st.st_ino),label_index=str(labels),label_index_sha256=sha(labels),latest_ruling='synthetic') prep=dict(preparation_root=str(source),t_set=1.,output_sha256={n:sha(source/n) for n in ['geometry.npz','r2.npz','queries.npz']},result_sha256=sha(source/'result.json')) row=dict(case='case',component_id='A',preparation=prep) with patch.object(part,'contract',return_value=c),patch.object(part,'rows',return_value=[row]),patch.object(part,'decode_array',return_value=full) as decode: self.assertEqual(part.run(root,0),0) with self.assertRaises(FileExistsError):part.run(root,0) self.assertEqual(decode.call_count,1) r=read_json(root/'parts/part-000/output/result.json') self.assertEqual(r['full_VTU_T_end'],1.2);self.assertEqual(r['full_tet_T_end'],.8);self.assertEqual(r['query_T_max'],.8) self.assertEqual(r['baseline_Dw_Vf_max_abs_difference'],0.) self.assertEqual(r['raw_nodes'],5);self.assertEqual(r['tet_nodes'],4) def test_neural_route_keeps_three_seeds_and_original_missing_mask(self): roster=[dict(case='a',component_id='A',included=True,nodes=10,exposure=dict(development_exposed=False),assignments=[dict(fold=0,role='test')])] def row(arm,seed):return dict(case='a',arm=arm,pool=100,seed=seed,**{k:dict(value=.2,reason=None) for k in ['relative_l2','near_wall','kendall_tau_b','last_location']}) data=[row('R2',None),row('REORDER_N',0),row('REORDER_N',1)] tables,contrasts,_=analysis.reports(data,roster,{'a'}) r=next(x for x in contrasts if x['subset']=='all' and x['pool']==100 and x['candidate']=='REORDER_N') self.assertEqual(r['components'],0) data.append(row('REORDER_N',2));_,contrasts,_=analysis.reports(data,roster,{'a'}) r=next(x for x in contrasts if x['subset']=='all' and x['pool']==100 and x['candidate']=='REORDER_N') self.assertEqual(r['components'],1) def test_synthetic_mapping_scoring_and_exact_manifest_end_to_end(self): from s2_custody_common import prediction_path from s2_custody_statistics import part_metrics with tempfile.TemporaryDirectory() as temp: root=Path(temp);old=root/'old';old.mkdir();case='00000001_case' (root/'contract.json').write_text('{}');(root/'code-freeze.json').write_text('{}');(root/'batch-complete.json').write_text('{}') s2=old/'contract.json';s2.write_text('{}') row=dict(case=case,component_id='A',included=True,nodes=3,exposure=dict(development_exposed=False), assignments=[dict(fold=f,role='test' if f==0 else 'learning',learning_pools=['25','50','100']) for f in range(5)]) roster=root/'roster.json';roster.write_text(json.dumps(dict(parts=[row]))) truth=np.array([1.,2.,4.]);raw=np.arange(3);counts=np.array([1,2,1]);left=np.array([0.,1/3,2/3]);right=left+1/3 d=dict(ids=raw,raw_ids=raw,counts=counts,t_set=4.,near_wall=np.array([True,False,True]),coordinates_over_Rg=np.array([[0,0,0],[1,0,0],[2,0,0]])) prepared=root/'part';prepared.mkdir() np.savez(prepared/'full-domain-maps.npz',raw_ids=raw,truth_left=left,truth_right=right,df1_left=left,df1_right=right,df2_left=left,df2_right=right) np.savez(prepared/'full-node-labels.npz',seconds=truth) (prepared/'volume-clock-curve.json').write_text(json.dumps(volume_clock_curve(truth,np.ones(3),4.,4.))) models=[] for pool in [25,50,100]: for arm in ['R2','N','E']: for seed in ([None] if arm=='R2' else [0,1,2]): models.append(dict(fold=0,pool=pool,arm=arm,seed=seed,name=f'{arm}-{pool}-{seed}')) models.append(dict(fold=0,pool=None,arm='B0',seed=None,name='B0')) index={};scores=[] for m in models: pred=4*left if m['arm']=='B0' else np.array([.9,2.2,3.7]) p=prediction_path(old,m,case);p.parent.mkdir(parents=True,exist_ok=True);np.savez(p,seconds=pred,raw_ids=raw,counts=counts) index[str(p)]=sha(p) scores.append(dict(case=case,component_id='A',fold=0,pool=m['pool'],arm=m['arm'],seed=m['seed'], **part_metrics(pred,truth,counts,d['near_wall'],raw,d['coordinates_over_Rg'],1))) pi=old/'index.json';pi.write_text(json.dumps(index));sp=old/'scores.json';sp.write_text(json.dumps(scores)) lp=old/'labels.npz';np.savez(lp,seconds=truth,raw_ids=raw,counts=counts) li=old/'labels.json';li.write_text(json.dumps([dict(case=case,path=str(lp),sha256=sha(lp))])) ex=root/'exposure.json';ex.write_text(json.dumps([dict(parts=[case])])) c=dict(roster=str(roster),S2_contract=str(s2),S2_contract_sha256=sha(s2),prediction_index=str(pi),prediction_index_sha256=sha(pi),S2_root=str(old), original_part_scores=str(sp),original_part_scores_sha256=sha(sp),label_index=str(li),label_index_sha256=sha(li),exposure_membership=str(ex),exposure_membership_sha256=sha(ex)) prep={case:(dict(full_VTU_T_end=4.,estimated_alpha=.6),prepared)} with patch.object(analysis,'contract',return_value=c),patch.object(analysis,'prepared',return_value=prep),patch.object(analysis,'rows',return_value=[row]),patch.object(analysis,'prediction_inputs',return_value=d),patch.object(analysis,'expected_models',return_value=models),patch.object(analysis,'training_clock',return_value=(1.1,[])): self.assertEqual(analysis.make_maps(root),0) self.assertEqual(analysis.score_maps(root),0) result=read_json(root/'scores/result.json');self.assertEqual(result['prediction_rows'],39);self.assertEqual(result['reorder_invariant_rows'],24) mapped=read_json(root/'prediction-index.json');mapped.pop(next(iter(mapped))) with self.assertRaisesRegex(ValueError,'Missing/extra'):analysis.validate_manifest(c,mapped) def simulated_queue(self,root,fail_first=False,missing=False): c=dict(cases=['a','b','c'],coordinator_cpus=[28,29],limits=dict(workers=4,part_cpu_seconds=180,preparation_cpu_seconds=28800,disk_bytes=2**30)) (root/'contract.json').write_text('{}');(root/'code-freeze.json').write_text('{}');spawned=[] class Process: def __init__(self,index):self.index=index;self.pid=800000+index;self.polls=0 def poll(self): self.polls+=1 if self.polls<2:return None if missing:return 1 failed=fail_first and self.index==0;dest=root/'parts'/f'part-{self.index:03d}' (dest/'guard-result.json').write_text(json.dumps(dict(index=self.index,case=c['cases'][self.index],worker=dict(status='STOPPED_OR_FAILED' if failed else 'PASS',cpu_seconds=.1),guard_CPU_s=.01,result_path=None,result_sha256=None))) return 1 if failed else 0 def wait(self):self.polls=2;return self.poll() def spawn(command,**kwargs): i=int(command[-3]);p=Process(i);spawned.append(p);return p with patch.object(queue,'contract',return_value=c),patch.object(queue.os,'sched_setaffinity'),patch.object(queue.subprocess,'Popen',spawn),patch.object(queue,'tree_usage',return_value=(0,1,1)),patch.object(queue.time,'sleep'),patch.object(queue,'terminate'),patch('builtins.print'): result=queue.run(root) return result,spawned def test_independent_part_queue_once_only_and_no_redecode_restart(self): with tempfile.TemporaryDirectory() as temp: root=Path(temp);code,spawned=self.simulated_queue(root) self.assertEqual(code,0);self.assertEqual(len(spawned),3) self.assertEqual(read_json(root/'batch-complete.json')['passed'],3) self.assertTrue(read_json(root/'first-part-cost-check.json')['continue_within_cap']) with patch.object(queue,'contract',return_value=dict(cases=[],limits={})),patch.object(queue.subprocess,'Popen') as spawn: with self.assertRaises(FileExistsError):queue.run(root) spawn.assert_not_called() def test_failed_first_part_and_infrastructure_receipt_stop(self): for missing in [False,True]: with tempfile.TemporaryDirectory() as temp: root=Path(temp);code,spawned=self.simulated_queue(root,fail_first=not missing,missing=missing) self.assertEqual(code,1);self.assertEqual(len(spawned),1) r=read_json(root/'batch-complete.json');self.assertEqual(r['status'],'NAIVE_PREPARATION_INCOMPLETE') if missing:self.assertFalse(r['accounting_complete']) def test_global_monitor_failure_prevents_any_dispatch(self): with tempfile.TemporaryDirectory() as temp: root=Path(temp) with patch.object(queue.Monitor,'sample',side_effect=lambda op,fn,previous:(previous,False)): code,spawned=self.simulated_queue(root) self.assertEqual(code,1);self.assertEqual(len(spawned),0) self.assertEqual(read_json(root/'batch-complete.json')['stop_reason'],'GLOBAL_MONITOR_ACCOUNTING_ERROR') if __name__=='__main__':unittest.main(verbosity=2)