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