| """Validate an independent, checksummed closed-loop evaluation package. |
| |
| The legacy v1/10k loaders stay separate. A published package records its actual |
| Git commit, rather than inheriting the legacy v1 commit or trusting a label. |
| """ |
| from collections import Counter |
| from dataclasses import dataclass |
| import hashlib |
| import json |
| from pathlib import Path, PurePosixPath |
| import re |
| import subprocess |
|
|
|
|
| def sha256(path): |
| return hashlib.sha256(Path(path).read_bytes()).hexdigest() |
|
|
|
|
| def _read(path): |
| return json.loads(Path(path).read_text()) |
|
|
|
|
| def _package_files(root): |
| files = {} |
| for path in root.rglob('*'): |
| relative = path.relative_to(root) |
| if '__pycache__' in relative.parts or path.suffix == '.pyc': |
| continue |
| if path.is_symlink(): |
| raise ValueError('Package files must not be symlinks: ' + str(relative)) |
| if path.is_file(): |
| files[relative.as_posix()] = path |
| return files |
|
|
|
|
| def verify_checksums(directory): |
| root = Path(directory).resolve() |
| files = _package_files(root) |
| if 'SHA256SUMS' not in files: |
| raise ValueError('Frozen package requires SHA256SUMS') |
| expected = {} |
| for line in files['SHA256SUMS'].read_text().splitlines(): |
| match = re.fullmatch(r'([0-9a-f]{64}) [ *](.+)', line) |
| if not match: |
| raise ValueError('Malformed SHA256SUMS line') |
| digest, name = match.groups() |
| path = PurePosixPath(name) |
| if path.is_absolute() or '..' in path.parts or path.as_posix() != name or name == 'SHA256SUMS': |
| raise ValueError('Unsafe or recursive checksum path: ' + name) |
| if name in expected: |
| raise ValueError('Duplicate checksum path: ' + name) |
| expected[name] = digest |
| if set(expected) != set(files) - {'SHA256SUMS'}: |
| raise ValueError('SHA256SUMS must cover every package file exactly') |
| for name, digest in expected.items(): |
| if sha256(files[name]) != digest: |
| raise ValueError('Package checksum mismatch: ' + name) |
| return root, files, expected |
|
|
|
|
| def _published_commit(root, files): |
| def git(*args, cwd=root): |
| try: |
| return subprocess.run(['git', '-C', str(cwd), *args], check=True, |
| stdout=subprocess.PIPE, stderr=subprocess.PIPE).stdout |
| except subprocess.CalledProcessError as error: |
| raise ValueError('Package must be in a published Git checkout') from error |
| top = Path(git('rev-parse', '--show-toplevel').decode().strip()).resolve() |
| prefix = root.relative_to(top).as_posix() |
| commit = git('log', '-1', '--format=%H', '--', '.').decode().strip() |
| if not re.fullmatch('[0-9a-f]{40}', commit): |
| raise ValueError('Package has no committed publication') |
| |
| |
| |
| |
| tree = git('ls-tree', '-r', '-z', '--full-tree', commit, '--', prefix, cwd=top) |
| tracked = {} |
| for item in tree.split(b'\0'): |
| if not item: |
| continue |
| metadata, raw_name = item.split(b'\t', 1) |
| mode, kind, digest = metadata.decode().split() |
| name = raw_name.decode() |
| relative = str(PurePosixPath(name).relative_to(prefix)) if prefix != '.' else name |
| if '__pycache__' in PurePosixPath(relative).parts or relative.endswith('.pyc'): |
| continue |
| if kind != 'blob' or mode not in ('100644', '100755'): |
| raise ValueError('Publication contains nonregular package files') |
| tracked[relative] = digest |
| if set(tracked) != set(files): |
| raise ValueError('Package file set differs from its Git publication') |
| for name, path in files.items(): |
| raw = path.read_bytes() |
| blob = hashlib.sha1(b'blob ' + str(len(raw)).encode() + b'\0' + raw).hexdigest() |
| if blob != tracked[name]: |
| raise ValueError('Package differs from its Git publication: ' + name) |
| return commit |
|
|
|
|
| @dataclass(frozen=True) |
| class FrozenSubset: |
| directory: Path |
| protocol: dict |
| plan: list |
| commit: str | None |
| checksums_sha256: str |
| protocol_sha256: str |
|
|
| @property |
| def manifest_dir(self): |
| return self.directory / 'seed_manifests' |
|
|
| @property |
| def identity(self): |
| return {'subset_id': self.protocol['subset_id'], |
| 'runtime_protocol': self.protocol['runtime_protocol'], |
| 'subset_commit': self.commit, |
| 'count': self.protocol['count'], |
| 'checksums_sha256': self.checksums_sha256, |
| 'protocol_sha256': self.protocol_sha256, |
| 'episodes_sha256': self.protocol['episodes_sha256']} |
|
|
|
|
| def load_subset(directory, *, require_published=True): |
| root, files, checksums = verify_checksums(directory) |
| for required in ('protocol.json', 'episodes.jsonl'): |
| if required not in files: |
| raise ValueError('Missing package identity: ' + required) |
| protocol = _read(files['protocol.json']) |
| if not re.fullmatch(r'[a-z0-9][a-z0-9_-]+', protocol.get('subset_id', '')): |
| raise ValueError('Invalid subset_id') |
| if not re.fullmatch(r'hybrid_[a-z0-9_]+_rt', protocol.get('runtime_protocol', '')): |
| raise ValueError('Invalid RT runtime protocol') |
| dimensions = [protocol.get(key) for key in ('count', 'tasks', 'episodes_per_task_setting')] |
| if any(type(value) is not int or value <= 0 for value in dimensions): |
| raise ValueError('Protocol must declare positive integer quotas') |
| count, task_count, quota = dimensions |
| settings = protocol.get('settings') |
| if (not isinstance(settings, list) or not settings or len(set(settings)) != len(settings) |
| or not set(settings) <= {'clean', 'randomized'} |
| or count != task_count * len(settings) * quota): |
| raise ValueError('Invalid setting quota or total count') |
| instruction_types = protocol.get('instruction_types') |
| if (not isinstance(instruction_types, dict) or set(instruction_types) != set(settings) |
| or not set(instruction_types.values()) <= {'seen', 'unseen'}): |
| raise ValueError('Protocol must declare an instruction type for each setting') |
| if protocol.get('episodes_sha256') != checksums['episodes.jsonl']: |
| raise ValueError('Protocol episodes SHA256 does not match package') |
| rows = [json.loads(line) for line in files['episodes.jsonl'].read_text().splitlines()] |
| expected = {} |
| for row in rows: |
| if (not re.fullmatch(r'[a-z][a-z0-9_]*', row.get('task', '')) |
| or row.get('setting') not in settings or type(row.get('index')) is not int |
| or not 0 <= row['index'] < quota |
| or any(type(row.get(key)) is not int or row[key] < 0 for key in ('seed', 'policy_seed')) |
| or not isinstance(row.get('instruction'), str) or not row['instruction'].strip() |
| or not isinstance(row.get('scene_info'), dict) |
| or row.get('instruction_type') != instruction_types[row['setting']]): |
| raise ValueError('Invalid episode identity') |
| if 'scene_sequence_index' in row and (type(row['scene_sequence_index']) is not int |
| or not 0 <= row['scene_sequence_index'] < 10): |
| raise ValueError('Invalid explicit scene sequence index') |
| key = (row['task'], row['setting'], row['index']) |
| if key in expected: |
| raise ValueError('Duplicate episode identity') |
| expected[key] = row |
| cells = Counter((r['task'], r['setting']) for r in rows) |
| tasks = {r['task'] for r in rows} |
| if (len(rows) != count or len(tasks) != task_count |
| or set(cells) != {(task, setting) for task in tasks for setting in settings} |
| or set(cells.values()) != {quota} |
| or len({r['seed'] for r in rows}) != count): |
| raise ValueError('Episode task/setting quotas or unique seeds do not match protocol') |
| names = {f'seed_manifests/{task}__{setting}.json' for task, setting in cells} |
| if names != {name for name in files if name.startswith('seed_manifests/')}: |
| raise ValueError('Seed manifest cell inventory does not match protocol') |
| plan = [] |
| for name in sorted(names): |
| manifest = _read(files[name]) |
| episodes = manifest.get('episodes', []) |
| if manifest.get('status') != 'ready' or len(episodes) != quota: |
| raise ValueError('Cell manifest must be ready with the declared quota: ' + name) |
| seen = set() |
| for row in episodes: |
| key = (row['task'], row['setting'], row['index']) |
| if (key in seen or expected.get(key) != row |
| or name != f"seed_manifests/{row['task']}__{row['setting']}.json" |
| or (manifest.get('task'), manifest.get('setting')) != key[:2]): |
| raise ValueError('Episode and seed manifest identities differ: ' + name) |
| if row.get('instruction_type') != manifest.get('instruction_type'): |
| raise ValueError('Episode and manifest instruction types differ: ' + name) |
| seen.add(key) |
| plan.append({**row, 'manifest_sha256': checksums[name]}) |
| commit = _published_commit(root, files) if require_published else None |
| return FrozenSubset(root, protocol, |
| sorted(plan, key=lambda r: (r['index'], r['task'], r['setting'])), |
| commit, sha256(files['SHA256SUMS']), checksums['protocol.json']) |
|
|
