| |
| """Restore the trusted SimLingo bucket snapshot for a new data location (Python >=3.8).""" |
| import argparse |
| import gzip |
| import hashlib |
| import json |
| import os |
| import pickle |
| import shutil |
| import tarfile |
| import tempfile |
| from pathlib import Path |
|
|
| TOKEN = '__SIMLINGO_DATA_ROOT__' |
| CACHE = 'BUCKET2DATA_remove_missing_dream_jianing.pkl' |
| INDEX = 'bucketsv2_simlingo/buckets_paths.pkl' |
| FIELDS = ('images', 'boxes', 'measurements', 'alternative_trajectories') |
|
|
|
|
| def sha256(path): |
| h = hashlib.sha256() |
| with Path(path).open('rb') as f: |
| for block in iter(lambda: f.read(8 * 1024 * 1024), b''): |
| h.update(block) |
| return h.hexdigest() |
|
|
|
|
| def rewrite_cache(cache, old, new): |
| """Rewrite path leaves only; keep scalar values, container types and aliasing.""" |
| memo = {} |
| count = 0 |
|
|
| def walk(value): |
| nonlocal count |
| ident = id(value) |
| if ident in memo: |
| return memo[ident][1] |
| if type(value) is str: |
| if not value.startswith(old + '/'): |
| raise ValueError('Unexpected cache path prefix; refusing a partial rewrite') |
| out = new + value[len(old):] |
| count += 1 |
| elif type(value) is list: |
| out = [] |
| memo[ident] = (value, out) |
| out.extend(walk(x) for x in value) |
| elif type(value) is tuple: |
| out = tuple(walk(x) for x in value) |
| else: |
| raise TypeError('Unexpected path container: ' + type(value).__name__) |
| memo[ident] = (value, out) |
| return out |
|
|
| for buckets in cache.values(): |
| for bucket in buckets.values(): |
| for field in FIELDS: |
| if field in bucket: |
| bucket[field] = walk(bucket[field]) |
| return count |
|
|
|
|
| def check_data(root, probes): |
| from PIL import Image |
| for item in probes: |
| path = root / item['path'] |
| if not path.is_file(): |
| raise FileNotFoundError(str(path)) |
| if item['kind'] == 'image': |
| with Image.open(str(path)) as im: |
| im.verify() |
| else: |
| with gzip.open(str(path), 'rt') as f: |
| data = json.load(f) |
| if item['kind'] == 'commentary': |
| assert 'commentary' in data |
| elif item['kind'] == 'vqa': |
| assert data.get('QA') |
| elif item['kind'] == 'dreamer': |
| assert any(v for k, v in data.items() if 'factor' not in k) |
| return len(probes) |
|
|
|
|
| def main(): |
| parser = argparse.ArgumentParser(description=__doc__) |
| parser.add_argument('--database-root', type=Path, required=True, |
| help='Resource directory containing simlingo_v2_2025_01_10/') |
| parser.add_argument('--bundle-dir', type=Path, default=Path(__file__).resolve().parent) |
| parser.add_argument('--check-data', action='store_true', help='Decode representative real samples before writing') |
| args = parser.parse_args() |
| bundle = args.bundle_dir.resolve() |
| db = args.database_root.resolve() |
| data = (db / 'simlingo_v2_2025_01_10').resolve() |
| if args.check_data: |
| probes = json.loads((bundle / 'sample-probes.json').read_text()) |
| print('Verified real data files:', check_data(data, probes), flush=True) |
| targets = (db / CACHE, db / INDEX) |
| for target in targets: |
| if target.exists() or target.is_symlink(): |
| raise FileExistsError('Refusing to overwrite ' + str(target)) |
| manifest = json.loads((bundle / 'manifest.json').read_text()) |
| archive = bundle / manifest['archive']['path'] |
| assert archive.stat().st_size == manifest['archive']['bytes'] |
| assert sha256(archive) == manifest['archive']['sha256'], 'Archive checksum mismatch' |
| db.mkdir(parents=True, exist_ok=True) |
| with tempfile.TemporaryDirectory(prefix='.restore-buckets-', dir=str(db)) as temp: |
| temp = Path(temp) |
| expected = {x['path']: x for x in manifest['payload']} |
| with tarfile.open(str(archive), 'r:gz') as tar: |
| members = tar.getmembers() |
| assert len(members) == len(expected) |
| assert {x.name for x in members} == set(expected) |
| for member in members: |
| assert member.isfile() and member.size == expected[member.name]['bytes'] |
| target = temp / member.name |
| target.parent.mkdir(parents=True, exist_ok=True) |
| with tar.extractfile(member) as src, target.open('wb') as dst: |
| shutil.copyfileobj(src, dst, 8 * 1024 * 1024) |
| assert sha256(target) == expected[member.name]['sha256'] |
| print('Loading portable cache; this may take a few minutes.', flush=True) |
| with (temp / 'BUCKET2DATA.portable.pkl').open('rb') as f: |
| cache = pickle.load(f) |
| rewritten = rewrite_cache(cache, TOKEN, str(data)) |
| staged_cache = temp / CACHE |
| with staged_cache.open('wb') as f: |
| pickle.dump(cache, f, protocol=4) |
| targets[1].parent.mkdir(parents=True, exist_ok=True) |
| |
| os.link(str(staged_cache), str(targets[0])) |
| try: |
| os.link(str(temp / INDEX), str(targets[1])) |
| except BaseException: |
| targets[0].unlink() |
| raise |
| report = {'ok': True, 'data_root': str(data), 'rewritten_unique_path_objects': rewritten, |
| 'cache': str(targets[0]), 'bucket_index': str(targets[1]), |
| 'sample_counts': manifest['sample_counts'], 'real_samples_checked': args.check_data} |
| print(json.dumps(report, indent=2)) |
|
|
|
|
| if __name__ == '__main__': |
| main() |
|
|
