"""Pure metadata validation; this module does not load/deserialize model files.""" import ast from dataclasses import dataclass from pathlib import PurePath from .alarm_eligibility import NAMES, sha @dataclass(frozen=True) class ModelContract: sha256: str suffix: str names: tuple role: str metadata_source: str task: str = '' def normalize_names(raw): if isinstance(raw, str): if len(raw) > 4096: raise ValueError('Excessive names metadata') try: tree = ast.parse(raw, mode='eval') if isinstance(tree.body, ast.Dict): keys = [ast.literal_eval(k) for k in tree.body.keys] if len(set(keys)) != len(keys): raise ValueError('Duplicate literal class IDs') raw = ast.literal_eval(tree) except (ValueError, SyntaxError, MemoryError, RecursionError) as exc: raise ValueError('Invalid literal names metadata') from exc if type(raw) in (list, tuple): pairs = list(enumerate(raw)) elif type(raw) is dict: pairs = [] for key, value in raw.items(): if type(key) is int: index = key elif type(key) is str and key.isdecimal() and str(int(key)) == key: index = int(key) else: raise ValueError('Ambiguous class ID') pairs.append((index, value)) else: raise ValueError('Missing names metadata') ids = [i for i, _ in pairs] if (not pairs or len(set(ids)) != len(ids) or set(ids) != set(range(len(ids))) or any(type(v) is not str or not v.strip() or v != v.strip() for _, v in pairs)): raise ValueError('Non-contiguous/duplicate IDs or invalid labels') names = tuple(v for _, v in sorted(pairs)) if len(set(names)) != len(names): raise ValueError('Duplicate class labels') return names def validate_contract(path, actual_sha, expected_sha, raw_names, *, role, metadata_source, actual_task=None): suffix = PurePath(path).suffix.lower() supported = {'.pt': {'loaded_model.names', 'result.names'}, '.pth': {'loaded_model.names', 'result.names'}, '.onnx': {'onnx.metadata.names', 'result.names'}, '.engine': {'result.names'}} if suffix not in supported or metadata_source not in supported[suffix]: raise ValueError('Unsupported format or unverified metadata source') if not sha(actual_sha) or actual_sha != expected_sha: raise ValueError('Loaded artifact hash is not pinned') expected_task = 'classify' if role == 'semantic_classifier' else 'detect' if actual_task != expected_task: raise ValueError('Model task must be independently verified, not inferred from class names') names = normalize_names(raw_names) if role == 'generic_detector' and names != ('airborne_object',): raise ValueError('Generic detector must expose airborne_object only') elif role == 'semantic_classifier' and set(names) != NAMES: raise ValueError('Classifier must expose exactly the four reviewed semantic labels') elif role not in ('generic_detector', 'semantic_classifier', 'legacy_display'): raise ValueError('Unsupported model role') # legacy_display preserves Fighter/drone numeric names; never upgrades their # meaning to fixedwing_uav or to permission for unknown-object alarms. return ModelContract(actual_sha, suffix, names, role, metadata_source, actual_task)