"""Opt-in server entry point for UNKNOWN using locally pinned PyTorch weights.""" import asyncio import hashlib from pathlib import Path import time from . import config, state, visual_control from .inspection_bridge import InspectionBridge from .inspection_handoff import Handoff, configure from .model_class_contract import normalize_names, validate_contract from .unknown_inspection import Settings def _file_sha(path): with path.open('rb') as file: return hashlib.file_digest(file, 'sha256').hexdigest() def _load_model(yolo, path, expected, role): path = Path(path) if not path.is_absolute() or path.suffix.lower() != '.pt' or not path.is_file(): raise ValueError(f'{role} requires an absolute local .pt checkpoint') digest = _file_sha(path) if digest != expected: raise ValueError(f'{role} checkpoint SHA mismatch') model = yolo(str(path)) # Read task from the checkpoint, never force it. if _file_sha(path) != digest: raise ValueError(f'{role} checkpoint changed while loading') return model, validate_contract(path, digest, expected, model.names, role=role, metadata_source='loaded_model.names', actual_task=model.task) class ServerInspection(Handoff): def __init__(self, bridge, detector, classifier, *, authorize): super().__init__(bridge, camera_epoch=lambda camera: id(config.CAMERA_CONFIG.get(camera)), latest_visual=visual_control.latest, authorize=authorize) self.detector = detector self.classifier = classifier def detect(self, frames): return self.detector(frames, verbose=False, conf=self.bridge.settings.proposal_min, imgsz=int(config.INFER_IMGSZ), max_det=64) def classify(self, crop): result, = self.classifier(crop, verbose=False) names = normalize_names(result.names) if names != self.bridge.classifier.names: raise ValueError('Classifier output labels differ from the loaded checkpoint') scores = result.probs.data.detach().cpu().tolist() if len(scores) != len(names): raise ValueError('Classifier output count differs from the loaded checkpoint') return tuple(zip(names, scores)) async def recognition_loop(self): while True: if not await asyncio.to_thread(self.bridge.crops.run_one, self.classify, clock=time.monotonic): await asyncio.sleep(.01) def configure_runtime(): from ultralytics import YOLO from .postprocess import _inspection_alarm_ready, postprocess_control settings = getattr(config, 'UNKNOWN_INSPECTION_SETTINGS', None) cameras = tuple(getattr(config, 'UNKNOWN_INSPECTION_CAMERAS', ())) authorize = getattr(config, 'UNKNOWN_INSPECTION_AUTHORIZE', None) quality = getattr(config, 'UNKNOWN_INSPECTION_OCCLUDED', None) if (not isinstance(settings, Settings) or not settings.enabled or not visual_control.enabled() or not cameras or len(set(cameras)) != len(cameras) or not set(cameras) <= set(config.PTZ_CAM_IDS) or not callable(authorize) or not callable(quality)): raise RuntimeError('UNKNOWN requires calibrated settings, PTZ allowlist, authorization and quality providers') detector, proposal = _load_model(YOLO, config.UNKNOWN_INSPECTION_PROPOSAL_PATH, settings.proposal_sha, 'generic_detector') classifier, semantics = _load_model(YOLO, config.UNKNOWN_INSPECTION_CLASSIFIER_PATH, settings.classifier_sha, 'semantic_classifier') bridge = InspectionBridge(settings=settings, cameras=cameras, proposal_contract=proposal, classifier_contract=semantics, owner=visual_control.owner, control_lock=visual_control.control_lock, controller=postprocess_control, alarm_ready=_inspection_alarm_ready, state_provider=lambda camera: state.ptz_states.get(camera, {}), clock=time.monotonic, quality=quality) handoff = ServerInspection(bridge, detector, classifier, authorize=authorize) configure(handoff) return handoff