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.
123 lines
5.5 KiB
Python
123 lines
5.5 KiB
Python
"""Exercise production decoder, MicroBatcher and provenance with fake I/O."""
|
|
import asyncio
|
|
import logging
|
|
from pathlib import Path
|
|
import time
|
|
from types import SimpleNamespace
|
|
import unittest
|
|
from typing import Any, List, Optional, Tuple
|
|
from uuid import uuid4
|
|
|
|
import numpy as np
|
|
|
|
import test_handoff as fixture
|
|
from ptz_tracker_modular import inspection_handoff as wiring
|
|
|
|
|
|
class ServerPathTests(unittest.IsolatedAsyncioTestCase):
|
|
def setUp(self):
|
|
self.fx = fixture.HandoffTests()
|
|
self.fx.setUp()
|
|
self.addCleanup(self.fx.doCleanups)
|
|
self.state = self.fx.st
|
|
self.adapter = self.fx.adapter
|
|
self.adapter.detect = lambda frames: [None] * len(frames)
|
|
self.config = fixture.config
|
|
self.config.UNKNOWN_INSPECTION_ENABLE = True
|
|
self.config.CAMERA_CONFIG = {0: {}}
|
|
self.config.PTZ_CAM_IDS = (0,)
|
|
self.config.CPP_WS_URI = 'offline'
|
|
self.config.ADAPTIVE_BATCH_ENABLE = False
|
|
self.config.BATCH_MIN = self.config.BATCH_MAX = 1
|
|
self.config.BATCH_TARGET_MS = 1
|
|
self.config.SAHI_ENABLE = True # Forbidden for UNKNOWN provenance.
|
|
self.server_state = SimpleNamespace(ptz_states={0: self.state}, detected_cameras={0},
|
|
video_clients=set())
|
|
self.env = dict(
|
|
asyncio=asyncio, time=time, np=np, cv2=SimpleNamespace(IMREAD_COLOR=1,
|
|
imdecode=lambda data, mode: np.full((16, 16, 3), int(data[0]), dtype=np.uint8)),
|
|
logger=logging.getLogger('server-path'), config=self.config, state=self.server_state,
|
|
uuid4=uuid4, inspection_handoff=wiring, Optional=Optional,
|
|
Any=Any, Tuple=Tuple, List=List, InferenceItem=tuple,
|
|
_resolve_cpp_cam_id=int, _cpp_stream_map_logged=set(), ensure_runtime_state_for_camera=lambda cam: None,
|
|
_has_recent_video_client=lambda now: False, _frontend_raw_preview_due=lambda *args: False,
|
|
_target_predecode_fps=lambda *args: 0, _target_infer_fps=lambda *args: 0,
|
|
_select_inference_batch=lambda items, size, **kw: (items[:size], items[size:]),
|
|
visual_control=SimpleNamespace(enabled=lambda: True),
|
|
postprocess_control=lambda *args, **kw: self.fail('Legacy controller used in UNKNOWN'),
|
|
sahi_augment_batch=lambda *args: self.fail('SAHI used in UNKNOWN'),
|
|
yolo_forward=lambda *args: self.fail('Legacy detector used in UNKNOWN'),
|
|
)
|
|
self.state['proc_busy'] = False
|
|
self.load('cpp_ws_loop', 'MicroBatcher', '_refresh_inference_item',
|
|
'_prepare_visual_inference_item', '_postprocess_inference_item')
|
|
|
|
def load(self, *names):
|
|
import ast
|
|
path = Path(__file__).parent / 'ptz_tracker_modular/streaming.py'
|
|
tree = ast.parse(path.read_text(encoding='utf-8'))
|
|
definitions = [node for node in tree.body if getattr(node, 'name', None) in names]
|
|
exec(compile(ast.Module(body=definitions, type_ignores=[]), str(path), 'exec'), self.env)
|
|
|
|
async def test_decoder_batch_passes_exact_pixels_ticket_and_owner(self):
|
|
seen = asyncio.Event()
|
|
called = []
|
|
original = self.adapter.process_item
|
|
|
|
def capture(cam, pixels, result, is_ptz, seq, future):
|
|
ticket = future.inspection_ticket
|
|
called.append((cam, pixels, is_ptz, seq, ticket, self.adapter.current(ticket)))
|
|
loop.call_soon_threadsafe(seen.set)
|
|
return True
|
|
|
|
self.adapter.process_item = capture
|
|
loop = asyncio.get_running_loop()
|
|
batcher = self.env['MicroBatcher'](max_batch=1)
|
|
self.server_state.batcher = batcher
|
|
|
|
class Socket:
|
|
async def __aenter__(self):
|
|
return self
|
|
|
|
async def __aexit__(self, *args):
|
|
pass
|
|
|
|
async def __aiter__(self):
|
|
yield b'\x01\x00\x00\x17'
|
|
await asyncio.Future()
|
|
|
|
self.env['websockets'] = SimpleNamespace(connect=lambda *args, **kwargs: Socket())
|
|
ws = asyncio.create_task(self.env['cpp_ws_loop']())
|
|
try:
|
|
try:
|
|
await asyncio.wait_for(seen.wait(), 2)
|
|
except TimeoutError:
|
|
self.fail((self.state.get('last_source_seq'), self.state.get('inspection_decode_age_s'), self.state.get('proc_busy'), ws.done(), batcher._task.exception() if batcher._task.done() else batcher._task.get_stack()))
|
|
cam, pixels, ptz, seq, ticket, current = called.pop()
|
|
self.assertEqual((cam, ptz, seq, int(pixels[0, 0, 0])), (0, True, 1, 23))
|
|
self.assertTrue(current)
|
|
self.assertIs(ticket.pixels, pixels)
|
|
self.assertEqual(ticket.acquired_owner, self.adapter.bridge.owner(self.state))
|
|
finally:
|
|
ws.cancel()
|
|
batcher._task.cancel()
|
|
await asyncio.gather(ws, batcher._task, return_exceptions=True)
|
|
self.adapter.process_item = original
|
|
self.assertFalse(self.adapter.current(ticket))
|
|
self.assertFalse(self.state['inspection_authorized'])
|
|
|
|
async def test_mismatched_ticket_does_not_enter_batch(self):
|
|
batcher = self.env['MicroBatcher'](max_batch=1)
|
|
try:
|
|
ticket = self.fx.accepted()
|
|
await batcher.submit(0, ticket.pixels.copy(), True,
|
|
source_seq=ticket.stamp.source_seq, inspection_ticket=ticket)
|
|
self.assertEqual(batcher._buf, [])
|
|
finally:
|
|
batcher._task.cancel()
|
|
await asyncio.gather(batcher._task, return_exceptions=True)
|
|
|
|
|
|
if __name__ == '__main__':
|
|
unittest.main(verbosity=2)
|