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_server_path.py

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)