| |
| """Re-read every serialized Kanripo record and verify it against raw sources.""" |
| import argparse |
| from collections import Counter, defaultdict |
| import hashlib |
| import json |
| from pathlib import Path |
|
|
| from kanripo_clean import RULES, RESIDUAL, clean, load_inputs, sha, source_path |
| from kanripo_profile import dump |
|
|
|
|
| def records(path): |
| with path.open(encoding='utf-8') as f: |
| for line in f: |
| yield json.loads(line) |
|
|
|
|
| def file_hash(path): |
| h = hashlib.sha256() |
| with path.open('rb') as f: |
| for block in iter(lambda: f.read(1024*1024), b''): |
| h.update(block) |
| return h.hexdigest() |
|
|
|
|
| def check(condition, message): |
| if not condition: |
| raise ValueError(message) |
|
|
|
|
| def verify(output): |
| output = output.resolve() |
| manifest = json.loads((output / 'manifest.json').read_text()) |
| check(manifest['complete'], 'incomplete build') |
| check(manifest['rules'] == RULES, 'rules changed') |
| check(manifest['script_sha256'] == file_hash(Path(__file__).with_name('kanripo_clean.py')), 'implementation changed') |
| root, audit = Path(manifest['root']), Path(manifest['audit']) |
| catalog, inventory, metadata, inventory_data = load_inputs(root, audit) |
| check(sha(metadata) == manifest['source_manifest_sha256'], 'metadata mismatch') |
| check(sha(inventory_data) == manifest['inventory_sha256'], 'inventory changed') |
| for name, digest in manifest['output_hashes'].items(): |
| check(file_hash(output / name) == digest, f'output changed: {name}') |
| file_rows = list(records(output / 'files.jsonl')) |
| check(len(file_rows) == len(inventory), 'file coverage mismatch') |
| docs = iter(records(output / 'documents.jsonl')) |
| review = {r['id']: r for r in records(output / 'review.jsonl')} |
| edits = {r['id']: r for r in records(output / 'edits.jsonl')} |
| totals, removed, dynasties = Counter(), Counter(), Counter() |
| exact = defaultdict(list) |
| works, review_works = set(), set() |
| for i, (entry, f) in enumerate(zip(inventory, file_rows)): |
| rid = entry['id'] |
| check(f['raw_path'] == entry['raw_path'], 'file order/coverage mismatch') |
| row = catalog[rid] |
| check(row['status'] == 'complete' and row['dynasty'] not in {'清', '淸'}, 'ineligible work') |
| raw = source_path(root, entry).read_bytes() |
| check(sha(raw) == entry['raw_sha256'] == f['raw_sha256'], 'raw hash mismatch') |
| original = raw.decode('utf-8') |
| text, counts, issues = clean(original) |
| digest = sha(text.encode('utf-8')) |
| expected_status = 'review' if issues else ('included' if text.strip() else 'empty') |
| check(f['status'] == expected_status, 'status mismatch') |
| check(f['original_chars'] == len(original) and f['clean_chars'] == len(text), 'length mismatch') |
| check(f['removed'] == counts and f['clean_sha256'] == digest, 'edit audit mismatch') |
| check((f['id'] in edits) == bool(counts), 'edit coverage mismatch') |
| if counts: |
| check(edits[f['id']] == f, 'edit record mismatch') |
| totals['input_files'] += 1 |
| totals['original_chars'] += len(original) |
| totals[expected_status + '_files'] += 1 |
| removed.update(counts) |
| if issues: |
| check(f['id'] in review and review[f['id']]['issues'] == issues, 'review mismatch') |
| review_works.add(rid) |
| elif expected_status == 'included': |
| doc = next(docs, None) |
| check(doc is not None and doc['id'] == f['id'], 'document order/coverage mismatch') |
| check(doc['text'] == text and doc['chars'] == len(text) and doc['clean_sha256'] == digest, 'serialized text mismatch') |
| for key in ['raw_path', 'raw_sha256', 'dynasty', 'label', 'source', 'work_id', 'classification_source', 'dynasty_raw']: |
| check(doc[key] == f[key], 'document provenance mismatch') |
| check(not RESIDUAL.search(doc['text']) and '¶' not in doc['text'], 'management syntax survived') |
| exact[digest].append(doc['id']) |
| works.add(rid) |
| totals['clean_chars'] += len(text) |
| dynasties[row['dynasty']] += len(text) |
| if (i+1) % 10000 == 0: |
| print(f'verified {i+1}/{len(inventory)}', flush=True) |
| check(next(docs, None) is None, 'extra documents') |
| check(set(review) == {r['id'] for r in file_rows if r['status'] == 'review'}, 'review coverage') |
| check(set(edits) == {r['id'] for r in file_rows if r['removed']}, 'edits coverage') |
| body_works = {r['id'] for r in inventory} |
| expected_excluded = {} |
| for row in catalog.values(): |
| reasons = [] |
| if row['dynasty'] in {'清', '淸'}: |
| reasons.append('qing_user_excluded') |
| totals['qing_catalog_works'] += 1 |
| if row['status'] == 'complete': |
| totals['qing_complete_works'] += 1 |
| if row['status'] != 'complete': |
| reasons.append('download_not_complete') |
| totals['incomplete_catalog_works'] += 1 |
| elif row['dynasty'] not in {'清', '淸'} and row['id'] not in body_works: |
| reasons.append('no_body_files') |
| totals['no_body_works'] += 1 |
| if reasons: |
| expected_excluded[row['id']] = reasons |
| exclusions = list(records(output / 'excluded.jsonl')) |
| check(len(exclusions) == len(expected_excluded), 'exclusion coverage') |
| check({r['id']: r['reasons'] for r in exclusions} == expected_excluded, 'exclusion reasons') |
| totals['excluded_catalog_works'] = len(exclusions) |
| expected_duplicates = [dict(sha256=h, ids=ids) for h, ids in exact.items() if len(ids) > 1] |
| check(list(records(output / 'duplicates.jsonl')) == expected_duplicates, 'duplicate group mismatch') |
| totals.update(included_works=len(works), review_works=len(review_works), duplicate_groups=len(expected_duplicates)) |
| report = json.loads((output / 'report.json').read_text()) |
| check(totals == Counter(report['totals']), 'total mismatch') |
| check(removed == Counter(report['removed']), 'removal count mismatch') |
| check(dynasties == Counter(report['chars_by_dynasty']), 'dynasty character counts mismatch') |
| result = dict(verified=True, verified_files=len(inventory), included_files=totals['included_files'], |
| clean_chars=totals['clean_chars'], documents_sha256=file_hash(output / 'documents.jsonl'), |
| checks=['raw hashes', 'full serialized text and provenance', 'Qing exclusion and file coverage', |
| 'management marker absence', 'review and empty statuses', 'totals and duplicates']) |
| dump(output / 'verification.json', result) |
| print(json.dumps(result, ensure_ascii=False), flush=True) |
| return result |
|
|
|
|
| if __name__ == '__main__': |
| p = argparse.ArgumentParser(description=__doc__) |
| p.add_argument('output', type=Path) |
| a = p.parse_args() |
| verify(a.output) |
|
|
