| |
| """Validate packaged data only. Never train, dock, download, or unpickle objects. |
| |
| Default exit status: 0 when available required-core data pass, 1 on corruption. |
| With --require-complete, exit 2 when acquisition inputs remain incomplete. |
| """ |
| import argparse |
| import array |
| import ast |
| import csv |
| import hashlib |
| import json |
| import math |
| from pathlib import Path |
| import pickletools |
| import struct |
| import sys |
| import zipfile |
|
|
| ALGORITHMS = ['surfdock', 'unimol', 'diffdock', 'diffdock_l', 'gnina', 'autodock', 'smina'] |
|
|
|
|
| def table(path): |
| with path.open(newline='', encoding='utf-8-sig') as handle: |
| reader = csv.reader(handle) |
| header = next(reader) |
| rows = list(reader) |
| assert len(header) == len(set(header)), f'Duplicate columns: {path}' |
| assert all(len(row) == len(header) for row in rows), f'Ragged rows: {path}' |
| return header, rows |
|
|
|
|
| def finite(value): |
| number = float(value) |
| assert math.isfinite(number), f'Nonfinite numeric value: {value}' |
| return number |
|
|
|
|
| def score(rmsd, pb): |
| z = 3.0 * (rmsd - 2.0) |
| return ((1.0 + math.exp(-6.0)) / (1.0 + math.exp(z)) if z < 700 else 0.0) * (pb == 1.0) |
|
|
|
|
| def matching_id_column(header, rows, expected): |
| candidates = [i for i in range(len(header)) |
| if len({row[i] for row in rows}) == len(rows) |
| and {row[i] for row in rows} == set(expected)] |
| assert len(candidates) == 1, f'Expected exactly one ID column; found {candidates}' |
| return candidates[0] |
|
|
|
|
| def npy_metadata(path): |
| with path.open('rb') as handle: |
| assert handle.read(6) == b'\x93NUMPY', 'Not an NPY file' |
| major, minor = handle.read(2) |
| assert major in (1, 2, 3), f'Unsupported NPY version: {major}.{minor}' |
| size = struct.unpack('<H' if major == 1 else '<I', handle.read(2 if major == 1 else 4))[0] |
| header = ast.literal_eval(handle.read(size).decode('utf-8' if major == 3 else 'latin1')) |
| dtype = header['descr'] |
| assert dtype in ('<f4', '<f8', '>f4', '>f8'), f'Unsupported numeric dtype: {dtype}' |
| values = array.array('f' if dtype.endswith('4') else 'd') |
| values.frombytes(handle.read()) |
| if (dtype[0] == '<') != (sys.byteorder == 'little'): |
| values.byteswap() |
| assert len(values) == math.prod(header['shape']), 'NPY payload size mismatch' |
| assert all(math.isfinite(x) for x in values), 'NPY contains nonfinite values' |
| return header |
|
|
|
|
| def validate(root): |
| report = {'scope': 'file integrity and existing-data consistency; no scientific experiments', |
| 'checks': {}, 'errors': [], 'warnings': [], 'missing_acquisition_inputs': []} |
| checks = report['checks'] |
| try: |
| matrices = {} |
| ids = None |
| for stem, suffix in [('rmsd', '_rmsd'), ('pb_ratio', '_pb_ratio'), ('runtime', '_runtime')]: |
| path = root / 'data/raw' / f'moad_{stem}_trimmed.csv' |
| h, rows = table(path) |
| assert h == ['PDB_CCD_ID'] + [a + suffix for a in ALGORITHMS], f'Unexpected schema: {path}' |
| current = [row[0] for row in rows] |
| assert len(current) == 3179 and len(set(current)) == 3179, f'Invalid ID coverage: {path}' |
| if ids is not None: |
| assert ids == current, f'Row order differs: {path}' |
| ids = current |
| vals = [[finite(x) for x in row[1:]] for row in rows] |
| assert all(x >= 0 for row in vals for x in row), f'Negative value: {path}' |
| if stem == 'runtime': |
| assert all(x > 0 for row in vals for x in row), 'Runtime must be positive' |
| if stem == 'pb_ratio': |
| assert all(x <= 1 for row in vals for x in row), 'PB ratio exceeds 1' |
| matrices[stem] = vals |
| checks[stem] = {'rows': len(rows), 'algorithm_columns': 7, 'finite_values': 22253, |
| 'minimum': min(map(min, vals)), 'maximum': max(map(max, vals))} |
| if stem == 'rmsd' and max(map(max, vals)) > 1000: |
| extreme_count = sum(x > 1000 for row in vals for x in row) |
| checks['rmsd']['values_above_1000_angstrom'] = extreme_count |
| report['warnings'].append(f'Raw RMSD contains {extreme_count} values above 1000 Angstrom; preserved unchanged. Failure/sentinel semantics are not established.') |
| h, rows = table(root / 'data/ordered_complex_ids.csv') |
| assert h == ['PDB_CCD_ID'] and [r[0] for r in rows] == ids, 'Raw ID index mismatch' |
| checks['raw_matrix_id_order'] = 'identical across all three matrices and raw ID index' |
| target = root / 'data/targets/strict_score_matrix.csv' |
| h, rows = table(target) |
| assert h == ['PDB_CCD_ID'] + ALGORITHMS and [r[0] for r in rows] == ids, 'Target alignment mismatch' |
| max_error = 0.0 |
| for i, row in enumerate(rows): |
| for j, value in enumerate(row[1:]): |
| observed = finite(value) |
| assert 0 <= observed <= 1, 'Strict score outside [0,1]' |
| max_error = max(max_error, abs(observed - score(matrices['rmsd'][i][j], matrices['pb_ratio'][i][j]))) |
| assert max_error <= 1e-12, f'Strict-score formula mismatch: {max_error}' |
| checks['strict_score'] = {'maximum_absolute_formula_error': max_error, 'tolerance': 1e-12, |
| 'lambda': 3.0, 'pb_valid': 'pb_ratio == 1.0'} |
| original_target = root / 'data/targets/full_strict_score_matrix.csv' |
| if original_target.exists(): |
| h, rows = table(original_target) |
| assert h == ['PDB_CCD_ID'] + [a + '_strict_score' for a in ALGORITHMS], 'Original target schema mismatch' |
| assert [r[0] for r in rows] == ids, 'Original target ID order mismatch' |
| max_error = max(abs(finite(row[j + 1]) - score(matrices['rmsd'][i][j], matrices['pb_ratio'][i][j])) |
| for i, row in enumerate(rows) for j in range(7)) |
| assert max_error <= 1e-12, f'Original target formula mismatch: {max_error}' |
| checks['original_strict_score'] = {'maximum_absolute_formula_error': max_error, 'tolerance': 1e-12} |
| native_target = root / 'data/targets/moad_score_native_reconstructed.csv' |
| if native_target.exists(): |
| h, rows = table(native_target) |
| assert h == ['PDB_CCD_ID'] + ALGORITHMS and [r[0] for r in rows] == ids, 'Native evaluation target alignment mismatch' |
| max_error = 0.0 |
| for i, row in enumerate(rows): |
| for j in range(7): |
| rmsd = matrices['rmsd'][i][j] |
| expected = 0.0 if rmsd > 5 or rmsd < 0 else score(rmsd, matrices['pb_ratio'][i][j]) |
| max_error = max(max_error, abs(finite(row[j + 1]) - expected)) |
| assert max_error <= 1e-12, f'Native evaluation formula mismatch: {max_error}' |
| native_provenance = json.loads((root / 'data/provenance/native_evaluation_target.json').read_text()) |
| assert hashlib.sha256(native_target.read_bytes()).hexdigest() == native_provenance['sha256'], 'Native target provenance hash mismatch' |
| validation = native_provenance['saved_downstream_validation'] |
| assert validation['complete_unique_complexes'] == 3179 and validation['engine_score_values_checked'] == 22253 and validation['mismatches'] == 0 |
| checks['native_evaluation_target'] = {'status': 'reconstructed, not recovered original CSV', |
| 'maximum_absolute_formula_error': max_error, |
| 'saved_engine_values_independently_checked': 22253, |
| 'maximum_saved_engine_value_difference': validation['maximum_absolute_difference'], |
| 'distinct_from_acquisition_target': True} |
|
|
| original_split = root / 'data/splits/moad_5fold_split_seed42.csv' |
| recovered_split = root / 'data/splits/recovered_heldout_folds_from_downstream.csv' |
| memberships = {} |
| for path in [original_split, recovered_split]: |
| if not path.exists(): |
| continue |
| h, rows = table(path) |
| id_col = matching_id_column(h, rows, ids) |
| fold_cols = [i for i, name in enumerate(h) if 'fold' in name.lower() and i != id_col] |
| assert len(fold_cols) == 1, f'Ambiguous fold column: {path}' |
| col = fold_cols[0] |
| raw_folds = [finite(row[col]) for row in rows] |
| assert all(v == int(v) for v in raw_folds), 'Noninteger fold label' |
| offset = 1 if set(raw_folds) == {1, 2, 3, 4, 5} else 0 |
| assignment = {row[id_col]: int(v) - offset for row, v in zip(rows, raw_folds)} |
| assert set(assignment.values()) == set(range(5)), 'Expected five folds' |
| counts = {str(k): sum(v == k for v in assignment.values()) for k in range(5)} |
| assert sorted(counts.values()) == [635, 636, 636, 636, 636], 'Unexpected fold sizes' |
| memberships[path.name] = assignment |
| checks[path.name] = {'id_column': h[id_col], 'fold_column': h[col], 'counts': counts, |
| 'normalization_offset': offset} |
| if len(memberships) == 2: |
| assert memberships[original_split.name] == memberships[recovered_split.name], 'Original/recovered fold mismatch' |
| checks['original_recovered_folds_agree'] = True |
| if not original_split.exists(): |
| report['warnings'].append('Original seed42 split file unavailable; recovered file records existing downstream membership, not a new random split.') |
| if not memberships: |
| report['missing_acquisition_inputs'].append('original or validated recovered outer-fold assignments') |
|
|
| descriptor = root / 'data/descriptors/moad_physical_descriptors_filtered.csv' |
| if descriptor.exists(): |
| h, rows = table(descriptor) |
| id_col = matching_id_column(h, rows, ids) |
| numeric = [] |
| for j in range(len(h)): |
| if j == id_col: |
| continue |
| try: |
| [finite(row[j]) for row in rows] |
| numeric.append(h[j]) |
| except (ValueError, AssertionError): |
| pass |
| assert len(numeric) == 4, f'Expected four finite numeric descriptors, found {numeric}' |
| checks['physical_descriptors'] = {'id_column': h[id_col], 'numeric_columns': numeric, 'rows': len(rows)} |
| else: |
| report['missing_acquisition_inputs'].append(str(descriptor.relative_to(root))) |
|
|
| feature = root / 'data/features/complex_features_ligand_protein_d256_seed0.npy' |
| feature_ids = root / 'data/features/complex_feature_ids.csv' |
| if feature.exists(): |
| metadata = npy_metadata(feature) |
| assert tuple(metadata['shape']) == (3179, 256), 'Combined feature shape mismatch' |
| checks['combined_feature_numeric_payload'] = metadata |
| else: |
| report['missing_acquisition_inputs'].append(str(feature.relative_to(root))) |
| if feature_ids.exists(): |
| h, rows = table(feature_ids) |
| assert len(h) == 1 and [x[0] for x in rows] == ids, 'Combined feature ID order mismatch' |
| provenance = root / 'data/provenance/combined_feature_alignment.json' |
| assert provenance.exists(), 'Producer-verified combined-feature alignment evidence is required' |
| evidence = json.loads(provenance.read_text()) |
| assert evidence.get('producer_verified') is True and evidence.get('evidence'), 'Incomplete feature alignment evidence' |
| assert hashlib.sha256(feature.read_bytes()).hexdigest() == evidence['cache_sha256'], 'Feature alignment evidence refers to a different cache' |
| assert hashlib.sha256(feature_ids.read_bytes()).hexdigest() == evidence['feature_ids_sha256'], 'Feature alignment evidence refers to different IDs' |
| comparison = json.loads((root / evidence['evidence']).read_text()) |
| assert comparison['passed'] and comparison['matching_rows'] == 3179 and comparison['matching_values'] == 813824, 'Incomplete cache-value comparison' |
| checks['combined_feature_ids'] = {'ordered_ids': 3179, 'independently_compared_cache_values': 813824, |
| 'maximum_absolute_difference': comparison['maximum_absolute_difference'], |
| 'absolute_tolerance': comparison['absolute_tolerance'], |
| 'relative_tolerance': comparison['relative_tolerance']} |
| else: |
| report['missing_acquisition_inputs'].append('producer-verified data/features/complex_feature_ids.csv and alignment evidence') |
|
|
| ligand = root / 'data/features/ligand_chemberta_moad3179.pt' |
| if ligand.exists(): |
| with zipfile.ZipFile(ligand) as archive: |
| prefix = archive.namelist()[0].split('/')[0] |
| ops = pickletools.genops(archive.read(prefix + '/data.pkl')) |
| strings = [arg for op, arg, _ in ops if op.name in ('BINUNICODE', 'SHORT_BINUNICODE', 'UNICODE')] |
| id_set = set(ids) |
| embedded_ids = [s for s in strings if s in id_set] |
| assert embedded_ids == ids, 'Embedded ligand IDs do not match raw ID order' |
| values = array.array('f') |
| values.frombytes(archive.read(prefix + '/data/0')) |
| if archive.read(prefix + '/byteorder').decode().strip() != sys.byteorder: |
| values.byteswap() |
| assert len(values) == 3179 * 384 and all(math.isfinite(x) for x in values), 'Ligand numeric payload invalid' |
| h, rows = table(root / 'data/features/ligand_feature_ids.csv') |
| assert h == ['PDB_CCD_ID'] and [x[0] for x in rows] == embedded_ids, 'Ligand index mismatch' |
| checks['ligand_embeddings'] = {'embedded_ordered_ids': 3179, 'finite_float_values': len(values), |
| 'inspection': 'ZIP/pickle opcodes only; no object deserialization'} |
|
|
| graph_dir = root / 'data/external/protein_graphs_esmc_600m' |
| if graph_dir.exists(): |
| files = list(graph_dir.glob('pyg_graph_*_esmc_600m.pt')) |
| graph_ids = [p.name.removeprefix('pyg_graph_').removesuffix('_esmc_600m.pt') for p in files] |
| assert len(files) == 3179 and set(graph_ids) == set(ids), 'External protein graph ID coverage mismatch' |
| stats = [p.stat() for p in files] |
| placeholders = sum(bool(getattr(s, 'st_flags', 0) & 0x40000000) for s in stats) |
| assert placeholders == 0, 'External protein graph directory contains cloud placeholders' |
| checks['external_protein_graphs'] = {'files': len(files), 'logical_bytes': sum(s.st_size for s in stats), |
| 'cloud_placeholders': placeholders, |
| 'check_scope': 'filenames and filesystem metadata, not payload deserialization'} |
|
|
| historical_audit = root / 'data/provenance/original_input_audit.json' |
| if historical_audit.exists(): |
| audit = json.loads(historical_audit.read_text()) |
| current_files = {p.name: p for p in [*(root / 'data/raw').glob('*.csv'), original_split, |
| descriptor, feature] if p.exists()} |
| matched = 0 |
| for original_path, expected_hash in audit['sha256'].items(): |
| filename = Path(original_path).name |
| assert filename in current_files, f'Historical audited input missing: {filename}' |
| assert hashlib.sha256(current_files[filename].read_bytes()).hexdigest() == expected_hash, f'Historical input hash mismatch: {filename}' |
| matched += 1 |
| checks['original_input_audit_hashes'] = {'matching_inputs': matched, |
| 'note': 'Comparison to preserved historical hashes; historical experiments were not rerun.'} |
|
|
| checksum_file = root / 'data/CHECKSUMS.sha256' |
| if checksum_file.exists(): |
| count = 0 |
| for line in checksum_file.read_text().splitlines(): |
| digest, rel = line.split(' ', 1) |
| path = root / rel |
| assert path.is_relative_to(root) and path.is_file(), f'Missing checksum target: {rel}' |
| assert hashlib.sha256(path.read_bytes()).hexdigest() == digest, f'Checksum mismatch: {rel}' |
| count += 1 |
| checks['checksums'] = {'verified_files': count} |
| except (AssertionError, ValueError, KeyError, OSError, csv.Error, zipfile.BadZipFile) as error: |
| report['errors'].append(str(error)) |
| report['available_data_integrity_passed'] = not report['errors'] |
| report['acquisition_inputs_complete'] = not report['errors'] and not report['missing_acquisition_inputs'] |
| report['full_downstream_reproduction_verified'] = False |
| report['license_clearance_verified'] = False |
| return report |
|
|
|
|
| def main(): |
| parser = argparse.ArgumentParser(description=__doc__) |
| parser.add_argument('--root', type=Path, default=Path(__file__).resolve().parents[1]) |
| parser.add_argument('--report', type=Path, help='Optional path for a JSON integrity report') |
| parser.add_argument('--require-complete', action='store_true') |
| args = parser.parse_args() |
| result = validate(args.root.resolve()) |
| text = json.dumps(result, indent=2, allow_nan=False) + '\n' |
| print(text, end='') |
| if args.report: |
| args.report.parent.mkdir(parents=True, exist_ok=True) |
| args.report.write_text(text) |
| if result['errors']: |
| return 1 |
| if args.require_complete and not result['acquisition_inputs_complete']: |
| return 2 |
| return 0 |
|
|
|
|
| if __name__ == '__main__': |
| raise SystemExit(main()) |
|
|
