You cannot select more than 25 topics Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
Chameleon/integration/unknown_r3/tests/test_handoff.py

279 lines
15 KiB
Python

"""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)