#!/usr/bin/env python3 """Independent, read-only verification of generated CRITICS canonical and HF pair files. Returns nonzero on errors. Writes JSON and optionally text reports under data/reports. Never builds/replaces benchmark data; detects stale files and cross-view divergence. """ import argparse from collections import Counter from datetime import date import hashlib import json from pathlib import Path import re import sys LANGUAGES = ('es', 'eu') EXPECTED_TOPICS = ('artificial_intelligence', 'biology', 'chemistry', 'mathematics', 'physics') def read_jsonl(path, errors): if not path.is_file(): errors.append(f'Missing required file: {path}') return [] records = [] for line_no, line in enumerate(path.read_text(encoding='utf-8').splitlines(), 1): if not line.strip(): errors.append(f'{path}:{line_no}: blank JSONL line') continue try: entry = json.loads(line) except json.JSONDecodeError as ex: errors.append(f'{path}:{line_no}: JSON parse error: {ex}') continue if not isinstance(entry, dict): errors.append(f'{path}:{line_no}: expected an object') else: records.append(entry) return records def index_rows(rows, label, errors): indexed = {} for pos, row in enumerate(rows, 1): identifier = row.get('id') if not isinstance(identifier, str) or not identifier: errors.append(f'{label} record {pos}: missing/non-string id') elif identifier in indexed: errors.append(f'{label}: duplicate id {identifier}') else: indexed[identifier] = row return indexed def expected_pair(row, lang): src = row['source'] translation = row['translations'][lang] pe = translation['post_edit'] meta = translation['mt']['metadata'] return { 'id': row['id'], 'batch_id': row['batch_id'], 'topic': src['topic'], 'repository': src['repository'], 'source_document_key': src['source_document_key'], 'source_text': src['text'], 'source_sha256': src['source_sha256'], 'target_lang': lang, 'mt_text': translation['mt']['text'], 'reference_text': pe['text'] if pe is not None else None, 'reference_status': 'pending' if pe is None else 'human_post_edited', 'mt_system': meta['system'], 'mt_prompt_version': meta['prompt_version'], } def validate(data_dir, schema_path, config_path, strict_complete=False): errors, warnings = [], [] report = { 'validator': 'independent_cross_representation_v1', 'purpose': 'evaluation_only', 'schema_path': str(schema_path), 'config_path': str(config_path), } try: from jsonschema import Draft202012Validator, FormatChecker except ImportError: raise RuntimeError('Missing dependency: pip install -r requirements.txt') schema = json.loads(schema_path.read_text(encoding='utf-8')) Draft202012Validator.check_schema(schema) validator = Draft202012Validator(schema, format_checker=FormatChecker()) # Avoid a hard dependency on PyYAML: the configuration here contains simple scalar/list keys. try: import yaml except ImportError: raise RuntimeError('Missing dependency: pip install -r requirements.txt') cfg = yaml.safe_load(config_path.read_text(encoding='utf-8')) if not isinstance(cfg, dict): errors.append('Benchmark config must be a YAML mapping') cfg = {} for key, value in {'purpose': 'evaluation_only', 'hf_split': 'test', 'training_permitted': False}.items(): if cfg.get(key) != value: errors.append(f'Config mismatch: {key} must be {value!r}') if cfg.get('hf_configs') != ['en-es', 'en-eu']: errors.append('Config hf_configs must be [en-es, en-eu]') if cfg.get('source_language') != 'en' or cfg.get('target_languages') != ['es', 'eu']: errors.append('Config language settings must match en -> [es, eu]') if str(cfg.get('schema_version')) != schema.get('properties', {}).get('schema_version', {}).get('const'): errors.append('Config schema_version differs from JSON Schema') canonical_path = data_dir / 'canonical' / 'all_languages.jsonl' records = read_jsonl(canonical_path, errors) canonical = index_rows(records, canonical_path.name, errors) batch_members = {} topics = Counter() for row in records: identifier = row.get('id', '') for issue in validator.iter_errors(row): errors.append(f'Canonical id {identifier}: {"/".join(map(str, issue.absolute_path))}: {issue.message}') try: src = row['source'] checksum = hashlib.sha256(src['text'].encode('utf-8')).hexdigest() if src['source_sha256'] != checksum: errors.append(f'{identifier}: source_sha256 mismatch') if src['source_identifier'] != identifier: errors.append(f'{identifier}: source_identifier differs from id') batch = row['batch_id'] if not re.fullmatch(r'batch_\d{3}', batch): errors.append(f'{identifier}: malformed batch_id') batch_members.setdefault(batch, []).append(row) topics[src['topic']] += 1 except (KeyError, TypeError) as ex: errors.append(f'{identifier}: cannot check canonical fields ({ex})') # Confirm batch files are a complete, exact decomposition of all_languages.jsonl. batch_dir = data_dir / 'canonical' present = {p.stem: p for p in batch_dir.glob('batch_*.jsonl')} if set(present) != set(batch_members): errors.append(f'Canonical batch file set differs: expected {sorted(batch_members)}, actual {sorted(present)}') for batch, members in batch_members.items(): if batch not in present: continue actual_rows = read_jsonl(present[batch], errors) expected_index = index_rows(members, f'all_languages/{batch}', errors) actual_index = index_rows(actual_rows, f'{batch}.jsonl', errors) if list(actual_index) != list(expected_index): errors.append(f'{batch}: per-batch IDs/order differ from all_languages.jsonl') for identifier, expected in expected_index.items(): if identifier in actual_index and actual_index[identifier] != expected: errors.append(f'{batch}: canonical contents differ for id {identifier}') pair_counts = {} for lang in LANGUAGES: label = f'en-{lang}' path = data_dir / 'pairs' / label / 'test.jsonl' rows = read_jsonl(path, errors) pair_counts[label] = len(rows) pairs = index_rows(rows, f'{label}/test', errors) if list(pairs) != list(canonical): errors.append(f'{label}: IDs or order differ from canonical') for identifier, source in canonical.items(): if identifier not in pairs: errors.append(f'{label}: missing id {identifier}') continue try: target = expected_pair(source, lang) current = pairs[identifier] if target != current: for field in sorted(set(target) | set(current)): if target.get(field) != current.get(field) or field not in target or field not in current: errors.append(f'{label}: {identifier}: field {field} differs from canonical-derived value') except (TypeError, KeyError) as ex: errors.append(f'{label}: cannot derive canonical pair for id {identifier} ({ex})') for identifier in pairs.keys() - canonical.keys(): errors.append(f'{label}: unexpected id {identifier}') # No train or validation datasets are allowed in the release pair tree. pair_root = data_dir / 'pairs' expected_files = {pair_root / f'en-{lang}' / 'test.jsonl' for lang in LANGUAGES} for p in pair_root.rglob('*.jsonl'): if p not in expected_files: errors.append(f'Unexpected pair JSONL (potential training/dev split or stale data): {p}') expected_batches = cfg.get('expected_total_batches', 10) try: expected_batches = int(expected_batches) except (ValueError, TypeError): errors.append('Config expected_total_batches is invalid') expected_batches = 10 expected_instances = cfg.get('expected_instances_per_batch', 50) try: expected_instances = int(expected_instances) except (ValueError, TypeError): errors.append('Config expected_instances_per_batch is invalid') expected_instances = 50 if len(batch_members) > expected_batches: errors.append(f'Found {len(batch_members)} batches, exceeds configured {expected_batches}') for batch, members in batch_members.items(): if len(members) != expected_instances: errors.append(f'{batch}: {len(members)} records; expected {expected_instances}') if len(batch_members) < expected_batches: text = f'Partial dataset: {len(batch_members)}/{expected_batches} batches loaded; do not publish as complete' (errors if strict_complete else warnings).append(text) if set(topics) - set(EXPECTED_TOPICS): errors.append('Unexpected topic labels in canonical dataset') report.update({ 'status': 'FAIL' if errors else 'PASS', 'complete': len(batch_members) == expected_batches, 'canonical_records': len(records), 'batches': {k: len(v) for k,v in sorted(batch_members.items())}, 'pair_records': pair_counts, 'topic_counts': dict(sorted(topics.items())), 'schema_valid': not any('Canonical id ' in e for e in errors), 'cross_view_consistent': not any('en-es:' in e or 'en-eu:' in e for e in errors), 'error_count': len(errors), 'warning_count': len(warnings), 'errors': errors, 'warnings': warnings, }) return report def main(): parser = argparse.ArgumentParser(description=__doc__) parser.add_argument('--data-dir', type=Path, default=Path('data')) parser.add_argument('--schema', type=Path, default=Path('schema/benchmark.schema.json')) parser.add_argument('--config', type=Path, default=Path('config/benchmark.yaml')) parser.add_argument('--strict-complete', action='store_true', help='Fail unless all configured batches are present') parser.add_argument('--report', type=Path, default=None, help='Optional output JSON report; default data/reports/independent_validation.json') args = parser.parse_args() try: result = validate(args.data_dir, args.schema, args.config, args.strict_complete) except (ValueError, OSError, RuntimeError, json.JSONDecodeError) as error: print(f'VALIDATION FAILED: {error}', file=sys.stderr) return 2 output = args.report or args.data_dir / 'reports' / 'independent_validation.json' output.parent.mkdir(parents=True, exist_ok=True) output.write_text(json.dumps(result, ensure_ascii=False, indent=2) + '\n', encoding='utf-8') print(f'{result["status"]}: {result["canonical_records"]} canonical records; ' f'{len(result["batches"])} batches; {result["error_count"]} errors; ' f'{result["warning_count"]} warnings. Report: {output}') for message in result['errors'][:20]: print(f'ERROR: {message}', file=sys.stderr) for message in result['warnings']: print(f'WARNING: {message}', file=sys.stderr) return 0 if not result['errors'] else 1 if __name__ == '__main__': sys.exit(main())