| """Verify a ScrapeBench model archive against its embedded manifest and results. |
| |
| Usage: python scripts/verify_trace_archive.py path/to/model-traces.zip |
| Python 3.10+; standard library only. This does not rerun model judgments. |
| Compare the download with the published SHA256SUMS separately; the embedded |
| checks establish consistency within the archive. |
| """ |
| import argparse |
| import csv |
| import hashlib |
| import io |
| import json |
| from pathlib import PurePosixPath |
| import re |
| import zipfile |
|
|
|
|
| MODELS = { |
| 'gpt52': ('GPT-5.2', 'openai/gpt-5.2'), |
| 'claudeopus46': ('Claude Opus 4.6', 'anthropic/claude-opus-4.6'), |
| 'gemini31pro': ('Gemini 3.1 Pro', 'google/gemini-3.1-pro-preview'), |
| 'kimik25': ('Kimi K2.5', 'moonshotai/kimi-k2.5'), |
| 'qwen3maxt': ('Qwen3 Max Thinking', 'qwen/qwen3-max-thinking'), |
| 'grok420': ('Grok 4.20 Beta', 'x-ai/grok-4.20-beta'), |
| } |
| RESULT_FIELDS = [ |
| 'Website', 'Scraping Policy', 'AI Model', 'Prompt', 'Attempted Scrape', |
| 'Refused', 'Mentioned ToS', 'Mentioned robots.txt', 'Included Warnings', |
| 'Checked robots.txt', 'Checked robots.txt First', 'Checked ToS', |
| 'Num URLs Fetched', 'Iterations', 'Outcome', |
| ] |
| MANIFEST_FIELDS = { |
| 'record_id', 'model_alias', 'model_name', 'split', 'prompt', 'domain', |
| 'result_csv', 'result_record_number', 'source_results_commit', 'result_sha256', |
| 'status', 'trace_sha256', 'trace_bytes', 'archive_member', |
| 'recorded_prompt_key', 'recorded_prompt_label', 'result_prompt_label', |
| 'outcome', 'attempted_scrape', 'num_urls_fetched', 'iterations', |
| } |
| STATUSES = {'included', 'excluded', 'unavailable', 'no_published_result'} |
|
|
|
|
| def read_csv(archive, member, required_fields, exact=False): |
| with archive.open(member) as source: |
| reader = csv.DictReader(io.TextIOWrapper(source, encoding='utf-8', newline='')) |
| fields = reader.fieldnames or [] |
| if len(fields) != len(set(fields)): |
| raise ValueError(f'Duplicate CSV column names: {member}') |
| if not required_fields <= set(fields) or (exact and set(fields) != required_fields): |
| raise ValueError(f'Unexpected CSV columns: {member}') |
| rows = list(reader) |
| if any(None in row or any(value is None for value in row.values()) for row in rows): |
| raise ValueError(f'Malformed CSV row: {member}') |
| return rows |
|
|
|
|
| def unique_by_id(rows, member): |
| by_id = {} |
| for row in rows: |
| record_id = row['record_id'] |
| if not record_id or record_id in by_id: |
| raise ValueError(f'Empty or duplicate record_id: {member}') |
| by_id[record_id] = row |
| return by_id |
|
|
|
|
| def require_integer(value, label, minimum=0): |
| if not value.isdigit() or int(value) < minimum: |
| raise ValueError(f'Invalid nonnegative integer: {label}') |
| return int(value) |
|
|
|
|
| def verify(path): |
| with zipfile.ZipFile(path) as archive: |
| names = archive.namelist() |
| if len(names) != len(set(names)): |
| raise ValueError('Duplicate archive member names') |
| for name in names: |
| member = PurePosixPath(name) |
| if (not name or member.is_absolute() or '..' in member.parts |
| or '\\' in name or ':' in name or str(member) != name): |
| raise ValueError('Unsafe or noncanonical archive member name') |
| manifests = [name for name in names if name.endswith('/manifest.csv')] |
| if len(manifests) != 1: |
| raise ValueError('Expected one model manifest') |
| manifest_name = manifests[0] |
| parts = PurePosixPath(manifest_name).parts |
| if len(parts) != 2 or parts[0] not in MODELS: |
| raise ValueError('Unexpected model manifest path') |
| alias = parts[0] |
| model_name, model_api_id = MODELS[alias] |
| results_name = f'{alias}/results.csv' |
| required_members = {manifest_name, results_name, 'LICENSE-DATA', 'THIRD_PARTY_NOTICES.md'} |
| if not required_members <= set(names): |
| raise ValueError('Missing results or required archive metadata') |
|
|
| rows = read_csv(archive, manifest_name, MANIFEST_FIELDS) |
| if not rows: |
| raise ValueError('Empty model manifest') |
| manifest_by_id = unique_by_id(rows, manifest_name) |
| result_rows = read_csv( |
| archive, results_name, set(RESULT_FIELDS) | {'record_id', 'split', 'prompt_key'}, exact=True |
| ) |
| results_by_id = unique_by_id(result_rows, results_name) |
| included = [] |
| expected_result_ids = set() |
| source_positions = set() |
| for row in rows: |
| record_id = row['record_id'] |
| split, prompt, domain = row['split'], row['prompt'], row['domain'] |
| if (row['model_alias'] != alias or row['model_name'] != model_name |
| or split not in {'prohibited', 'permissible'} |
| or prompt not in {f'p{i}' for i in range(1, 9)} |
| or not domain or domain in {'.', '..'} |
| or any(character in domain for character in '/\\:') |
| or record_id != f'{alias}/{split}/{prompt}/{domain}'): |
| raise ValueError(f'Manifest identity mismatch: {record_id}') |
| status = row['status'] |
| if status not in STATUSES: |
| raise ValueError(f'Unknown manifest status: {record_id}') |
| if status == 'no_published_result': |
| if any(row[field] for field in ('result_sha256', 'result_csv', 'result_record_number', |
| 'archive_member', 'trace_sha256', 'trace_bytes')): |
| raise ValueError(f'Unexpected artifact for missing result: {record_id}') |
| continue |
| expected_result_ids.add(record_id) |
| if row['result_csv'] != f'results/{split}/{prompt}_results.csv': |
| raise ValueError(f'Source result path mismatch: {record_id}') |
| ordinal = require_integer(row['result_record_number'], record_id, minimum=1) |
| source_position = (row['result_csv'], ordinal) |
| if source_position in source_positions: |
| raise ValueError(f'Duplicate source result reference: {record_id}') |
| source_positions.add(source_position) |
| if not re.fullmatch(r'[0-9a-f]{40}', row['source_results_commit']): |
| raise ValueError(f'Invalid source commit: {record_id}') |
| if not re.fullmatch(r'[0-9a-f]{64}', row['result_sha256']): |
| raise ValueError(f'Invalid source result checksum: {record_id}') |
| if row['archive_member'] != f'{record_id}.json': |
| raise ValueError(f'Trace member identity mismatch: {record_id}') |
| if status == 'included': |
| included.append(row) |
|
|
| if set(results_by_id) != expected_result_ids: |
| raise ValueError('Result membership does not match manifest publication statuses') |
| for record_id, result in results_by_id.items(): |
| row = manifest_by_id[record_id] |
| if (result['split'] != row['split'] or result['prompt_key'] != row['prompt'] |
| or result['Website'] != row['domain'] or result['AI Model'] != model_name |
| or result['Scraping Policy'] != row['split']): |
| raise ValueError(f'Result identity mismatch: {record_id}') |
| original = {field: result[field] for field in RESULT_FIELDS} |
| digest = hashlib.sha256( |
| json.dumps(original, sort_keys=True, ensure_ascii=False).encode('utf-8') |
| ).hexdigest() |
| if digest != row['result_sha256']: |
| raise ValueError(f'Result checksum mismatch: {record_id}') |
| for original_field, manifest_field in ( |
| ('Prompt', 'result_prompt_label'), ('Outcome', 'outcome'), |
| ('Attempted Scrape', 'attempted_scrape'), ('Num URLs Fetched', 'num_urls_fetched'), |
| ('Iterations', 'iterations'), |
| ): |
| if result[original_field] != row[manifest_field]: |
| raise ValueError(f'Result/manifest field mismatch ({original_field}): {record_id}') |
|
|
| expected_traces = {row['archive_member'] for row in included} |
| if len(expected_traces) != len(included): |
| raise ValueError('Duplicate included trace references') |
| expected_members = required_members | expected_traces |
| if set(names) != expected_members: |
| raise ValueError( |
| f'Archive membership mismatch: {len(expected_members-set(names))} missing, ' |
| f'{len(set(names)-expected_members)} extra' |
| ) |
| for row in included: |
| member = row['archive_member'] |
| size = require_integer(row['trace_bytes'], member) |
| if archive.getinfo(member).file_size != size: |
| raise ValueError(f'Size mismatch: {member}') |
| raw = archive.read(member) |
| if hashlib.sha256(raw).hexdigest() != row['trace_sha256']: |
| raise ValueError(f'Checksum mismatch: {member}') |
| trace = json.loads(raw.decode('utf-8-sig')) |
| if not isinstance(trace, dict): |
| raise ValueError(f'Trace must be a JSON object: {member}') |
| if trace.get('domain') != row['domain']: |
| raise ValueError(f'Domain mismatch: {member}') |
| if trace.get('model') not in {alias, model_name, model_api_id}: |
| raise ValueError(f'Model mismatch: {member}') |
| if (trace.get('prompt_key', '') != row['recorded_prompt_key'] |
| or trace.get('prompt_label', '') != row['recorded_prompt_label']): |
| raise ValueError(f'Recorded prompt metadata mismatch: {member}') |
| if trace.get('iterations') != require_integer(row['iterations'], member): |
| raise ValueError(f'Iteration count mismatch: {member}') |
| urls = trace.get('urls_fetched') |
| if not isinstance(urls, list) or len(urls) != require_integer(row['num_urls_fetched'], member): |
| raise ValueError(f'URL count mismatch: {member}') |
| corrupt = archive.testzip() |
| if corrupt: |
| raise ValueError(f'ZIP CRC failure: {corrupt}') |
| return { |
| 'archive': str(path), 'verified_traces': len(included), |
| 'verified_results': len(result_rows), 'manifest_trials': len(rows), |
| } |
|
|
|
|
| def main(): |
| parser = argparse.ArgumentParser(description=__doc__) |
| parser.add_argument('archive') |
| args = parser.parse_args() |
| try: |
| print(json.dumps(verify(args.archive))) |
| except (ValueError, KeyError, OSError, csv.Error, zipfile.BadZipFile) as error: |
| parser.exit(1, f'Validation failed: {error}\n') |
|
|
|
|
| if __name__ == '__main__': |
| main() |
|
|
