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.
279 lines
15 KiB
Python
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)
|