"""New exact adapter + checkout handoff checks; no old suites or model imports.""" import ast from contextlib import nullcontext, contextmanager import hashlib import importlib.util import io import json from pathlib import Path import sys import threading from types import ModuleType, SimpleNamespace import unittest import numpy as np sys.dont_write_bytecode = True HERE = Path(__file__).resolve().parent package = ModuleType('ptz_tracker_modular'); package.__path__=[str(HERE/'ptz_tracker_modular')] sys.modules[package.__name__] = package config = ModuleType('ptz_tracker_modular.config'); config.UNKNOWN_INSPECTION_ENABLE=True sys.modules[config.__name__] = config from ptz_tracker_modular import inspection_handoff as wiring from ptz_tracker_modular.inspection_bridge import InspectionBridge from ptz_tracker_modular.unknown_inspection import Settings, Session from ptz_tracker_modular.model_class_contract import ModelContract from ptz_tracker_modular.inspection_runtime import CropContext, source_key from ptz_tracker_modular import alarm_boundary class Future: def __init__(self): self.finished=False; self.value='unset' def done(self): return self.finished def set_result(self,value): self.finished=True; self.value=value def checkout_functions(path, namespace): tree=ast.parse(path.read_text(encoding='utf8')) names={'_refresh_inference_item','_prepare_visual_inference_item','_postprocess_inference_item'} nodes=[n for n in tree.body if isinstance(n,ast.FunctionDef) and n.name in names] assert {n.name for n in nodes}==names tree=ast.Module(body=[ast.ImportFrom(module='__future__',names=[ast.alias(name='annotations')],level=0)]+nodes,type_ignores=[]) exec(compile(ast.fix_missing_locations(tree),str(path),'exec'),namespace) return namespace class HandoffTests(unittest.TestCase): def setUp(self): self.st=dict(generation=4,track_started_at=99.,mode='TRACK',tracking_active=True) self.states={0:self.st};self.epoch=1;self.now=50.;self.utc=100.;self.saved=None self.lock=threading.RLock();self.calls=[] self.owner=lambda st:(id(st),st['generation'],st['track_started_at'],0) cfg=Settings('a'*64,'b'*64,('airborne_object',),.25,.8,.2,16,10.,5.,enabled=True) proposal=ModelContract('a'*64,'.pt',('airborne_object',),'generic_detector','loaded_model.names','detect') semantic=ModelContract('b'*64,'.pt',('multirotor_uav','fixed_wing_uav','bird','manned_aircraft'),'semantic_classifier','loaded_model.names','classify') self.bridge=InspectionBridge(settings=cfg,cameras=(0,),proposal_contract=proposal, classifier_contract=semantic,owner=self.owner,control_lock=lambda c:self.lock, controller=lambda *a,**k:self.calls.append((a,k)),alarm_ready=lambda st:False, state_provider=lambda c:self.states[c],clock=lambda:self.now) self.adapter=wiring.Handoff(self.bridge,camera_epoch=lambda c:self.epoch, latest_visual=lambda c,now:self.saved,mono_ns=lambda:round(self.now*1e9),utc_ns=lambda:round(self.utc*1e9)) wiring.configure(self.adapter) self.addCleanup(setattr,wiring,'_configured',None) self.addCleanup(setattr,config,'UNKNOWN_INSPECTION_ENABLE',True) self.assertTrue(self.adapter.begin_source(0,'cpp_image','conn1',self.epoch)) self.hooks=checkout_functions(HERE/'ptz_tracker_modular/streaming.py',dict( inspection_handoff=wiring,state=SimpleNamespace(ptz_states=self.states), visual_control=SimpleNamespace(enabled=lambda:False), postprocess_control=lambda *a,**k:self.calls.append((a,k)))) def accepted(self,seq=1): image=np.random.default_rng(seq).integers(0,256,(64,64,3),dtype=np.uint8) return self.adapter.accepted(0,image,seq,self.epoch) def item(self,ticket): item=(0,ticket.pixels,True,ticket.stamp.source_seq,Future(),7.) self.assertTrue(self.adapter.bind_item(item,ticket));return item def advance(self,seconds): self.now+=seconds;self.utc+=seconds def test_accepted_keeps_decode_stamp_and_never_invents_capture_utc(self): t=self.accepted();self.assertEqual(t.stamp.decode_mono_ns,50_000_000_000) self.assertEqual(t.stamp.decode_utc_ns,100_000_000_000) self.assertIsNone(t.stamp.capture_utc_ns);self.assertIsNone(t.stamp.raw_pts) self.assertFalse(self.st['inspection_authorized']) self.assertEqual(t.acquired_owner,self.owner(self.st)) def test_exact_checkout_refresh_atomically_replaces_pixels_seq_stamp_owner(self): old=self.accepted();item=self.item(old);self.advance(.05);new=self.accepted(2) self.assertTrue(self.adapter.pending(new)) updated,changed=self.hooks['_refresh_inference_item'](item) self.assertTrue(changed);self.assertIs(updated[1],new.pixels) self.assertEqual(updated[3],2);self.assertIs(updated[4].inspection_ticket,new) self.assertIsNone(updated[4].visual_sample);self.assertNotIn('pending_frame',self.st) self.assertEqual(new.stamp.decode_mono_ns,50_050_000_000) def test_mismatched_pending_pixel_ticket_is_dropped_without_restamping(self): old=self.accepted();item=self.item(old);self.advance(.05);new=self.accepted(2) self.adapter.pending(new);self.st['pending_frame']=new.pixels.copy() updated,changed=self.hooks['_refresh_inference_item'](item) self.assertFalse(changed);self.assertIs(updated[4].inspection_ticket,old) self.assertNotIn('pending_frame',self.st) def test_stale_pending_and_expired_batch_are_dropped_before_inference(self): old=self.accepted();item=self.item(old);self.adapter.pending(old);self.advance(.651) self.hooks['_refresh_inference_item'](item) self.assertNotIn('pending_inspection_ticket',self.st) self.assertEqual(self.adapter.prune([item]),[]) self.assertTrue(item[4].done());self.assertIsNone(item[4].value) def test_pair_replaces_whole_ticket_with_exact_retained_image(self): old=self.accepted();item=self.item(old);self.advance(.05);new=self.accepted(2) sample=self.adapter.visual_sample(new,SimpleNamespace(source_seq=2,ok=True)) self.saved=(new.pixels,sample) paired=self.hooks['_prepare_visual_inference_item'](item) self.assertIs(paired[1],new.pixels);self.assertEqual(paired[3],2) self.assertIs(paired[4].inspection_ticket,new);self.assertIs(paired[4].visual_sample,sample) def test_pair_wrong_pixels_or_expired_visual_cannot_replace_packet(self): old=self.accepted();item=self.item(old) sample=self.adapter.visual_sample(old,SimpleNamespace(source_seq=1,ok=True)) self.saved=(old.pixels.copy(),sample) self.assertIs(self.hooks['_prepare_visual_inference_item'](item)[1],old.pixels) self.advance(.251);self.saved=(old.pixels,sample) self.assertIsNone(self.adapter.visual_sample(old,SimpleNamespace(source_seq=1))) self.assertIs(self.hooks['_prepare_visual_inference_item'](item)[4].inspection_ticket,old) def test_postprocess_over_650ms_or_old_owner_never_calls_controller(self): item=self.item(self.accepted());self.advance(.651) self.assertFalse(self.hooks['_postprocess_inference_item'](*item[:2],None,*item[2:5])) self.assertFalse(self.calls) self.st['generation']+=1 self.assertFalse(self.adapter.current(item[4].inspection_ticket)) def test_fullstop_and_manual_revoke_before_existing_transition_without_regrant(self): for reason in ('FULLSTOP','manual'): t=self.accepted(1 if reason=='FULLSTOP' else 2) self.st['inspection_authorized']=True self.st['zoom_no_effect_count']=3 session=Session(0,9,self.owner(self.st),49.,55.,phase='inspection') self.st['inspection_session']=session;self.adapter.pending(t) called=[] def existing(): called.append(True);self.assertFalse(self.st['inspection_authorized']) self.assertEqual(session.phase,'closed');self.st['mode']='MANUAL' self.assertTrue(self.adapter.transition(0,self.st,t.acquired_owner,reason,existing)) self.assertTrue(called);self.assertFalse(self.adapter.current(t)) self.assertEqual(session.deadline_mono,55.);self.assertEqual(self.st['zoom_no_effect_count'],3) self.assertNotIn('pending_frame',self.st) self.advance(.01) def test_same_owner_revoke_rebind_aba_cannot_revive_old_future(self): t=self.accepted();item=self.item(t);owner=t.acquired_owner self.assertTrue(self.adapter.transition(0,self.st,owner,'FULLSTOP',lambda:None)) self.st['inspection_authorized']=True # explicit external fresh grant for test self.assertEqual(self.owner(self.st),owner) self.advance(.01);new=self.accepted(2) self.assertTrue(self.adapter.current(new));self.assertFalse(self.adapter.current(t)) self.assertEqual(self.adapter.prune([item]),[]) def test_foreign_retired_state_transition_cannot_revoke_current_state(self): old=self.st.copy();self.st['inspection_authorized']=True self.assertFalse(self.adapter.transition(0,old,self.owner(old),'FULLSTOP',lambda:self.fail('transition called'))) self.assertTrue(self.st['inspection_authorized']) def test_reconnect_and_camera_lifecycle_epoch_drop_old_ticket(self): t=self.accepted();self.adapter.begin_source(0,'cpp_image','conn2',self.epoch) self.assertFalse(self.adapter.current(t));self.assertFalse(self.st['inspection_authorized']) new=self.accepted(1);self.epoch+=1 self.assertFalse(self.adapter.current(new));self.assertIsNone(self.adapter.accepted(0,new.pixels,2,self.epoch)) def test_source_utc_clock_jump_revokes_original_binding_without_retimestamp(self): old=self.accepted();self.advance(.1);self.utc+=2.;new=self.accepted(2) self.assertEqual(new.stamp.clock_epoch,1);self.assertFalse(self.adapter.current(old)) self.assertFalse(self.st['inspection_authorized']) def test_slow_recognition_does_not_block_exact_checkout_control_handoff(self): t=self.accepted();item=self.item(t);ctx=CropContext(0,1,t.acquired_owner,source_key(t.stamp),'b'*64) self.bridge.crops.bind(ctx) self.assertTrue(self.bridge.crops.submit(ctx,t.stamp,t.pixels,(8.,8.,48.,48.),now=self.now,occluded=False)) entered,release=threading.Event(),threading.Event() def classify(pixels): entered.set();release.wait(2) return (('multirotor_uav',.94),('fixed_wing_uav',.02),('bird',.02),('manned_aircraft',.02)) thread=threading.Thread(target=lambda:self.bridge.crops.run_one(classify,clock=lambda:self.now)) thread.start() try: self.assertTrue(entered.wait(1)) # This is the real copied checkout wrapper and actual bridge, not # classifier completion. No observation is supplied, so no grant. self.hooks['_postprocess_inference_item'](0,t.pixels,SimpleNamespace(names={0:'airborne_object'},boxes=None),True,1,item[4]) self.assertEqual(len(self.calls),1) finally: release.set();thread.join(2) self.assertFalse(thread.is_alive()) def test_disabled_checkout_handoff_calls_legacy_controller_unchanged(self): config.UNKNOWN_INSPECTION_ENABLE=False item=(0,np.zeros((4,4,3),dtype=np.uint8),True,8,Future(),7.) self.assertIs(self.hooks['_prepare_visual_inference_item'](item),item) self.assertEqual(self.hooks['_refresh_inference_item'](item),(item,False)) self.hooks['_postprocess_inference_item'](0,item[1],'legacy',True,8,item[4]) self.assertEqual(self.calls[-1][0][2],'legacy') def test_unknown_startup_and_unbound_alarm_fail_closed(self): wiring._configured=None with self.assertRaises(RuntimeError): wiring.require_configured() self.assertFalse(alarm_boundary.arm_allowed(0)) def test_recognition_diagnostics_are_original_decode_age_and_revoke_clears(self): t=self.accepted();ctx=CropContext(0,1,t.acquired_owner,source_key(t.stamp),'b'*64) self.bridge.crops.bind(ctx) self.bridge.crops.submit(ctx,t.stamp,t.pixels,(8.,8.,48.,48.),now=self.now,occluded=False) self.advance(.1) def classify(pixels): self.advance(.2) return (('multirotor_uav',.94),('fixed_wing_uav',.02),('bird',.02),('manned_aircraft',.02)) self.assertTrue(self.bridge.crops.run_one(classify,clock=lambda:self.now)) ages=self.bridge.crops.decode_ages()[0] self.assertAlmostEqual(ages['recognition_start'],.1) self.assertAlmostEqual(ages['recognition_complete'],.3) self.bridge.crops.revoke(0) self.assertEqual(self.bridge.crops.decode_ages(),{}) def test_transition_between_outer_check_and_bridge_admission_rejects_old_future(self): t=self.accepted();item=self.item(t);interposed=[False] @contextmanager def locked(camera): with self.lock: if not interposed[0]: interposed[0]=True def new_discovery(): self.st['inspection_authorized']=True self.st['inspection_session']=Session(0,2,self.owner(self.st),50.,55., phase='inspection',bbox=(8.,8.,48.,48.),shape=(64,64),contract=self.bridge.settings) self.adapter.transition(0,self.st,t.acquired_owner,'FULLSTOP',new_discovery) yield self.bridge.control_lock=locked result=SimpleNamespace(names={0:'airborne_object'},boxes=None) self.assertFalse(self.hooks['_postprocess_inference_item'](0,t.pixels,result,True,1,item[4])) self.assertTrue(interposed[0]);self.assertFalse(self.calls) self.assertTrue(self.st['inspection_authorized']) # old callback does not revoke new discovery def test_prepare_foreign_camera_future_cannot_consult_or_pair_other_camera(self): t=self.accepted();item=self.item(t) self.adapter.latest_visual=lambda *a:self.fail('foreign camera consulted retained image') foreign=(2,item[1],True,item[3],item[4],item[5]) self.assertIs(self.adapter.prepare(foreign),foreign) def test_decode_receipt_does_not_hide_800ms_control_lock_wait(self): @contextmanager def delayed(camera): self.advance(.8) with self.lock: yield self.bridge.control_lock=delayed self.assertIsNone(self.accepted()) def test_decode_receipt_preserves_original_clock_across_short_lock_wait(self): @contextmanager def delayed(camera): self.advance(.2) with self.lock: yield self.bridge.control_lock=delayed ticket=self.accepted() self.assertEqual(ticket.stamp.decode_mono_ns,50_000_000_000) self.assertEqual(ticket.stamp.decode_utc_ns,100_000_000_000) self.assertAlmostEqual(self.now-ticket.stamp.decode_mono_ns/1e9,.2) def test_decode_receipt_cannot_bless_owner_changed_while_waiting(self): @contextmanager def changed(camera): self.advance(.1);self.st['generation']+=1 with self.lock: yield self.bridge.control_lock=changed self.assertIsNone(self.accepted()) if __name__ == '__main__': unittest.main(verbosity=2)