publish portable stage runner + frozen sources

pear15/dataset_archive.py

@@ -0,0 +1,163 @@
+"""Bounded flat tar transport for a verified BPE corpus; no model dependencies."""
+import argparse
+import hashlib
+import json
+from pathlib import Path
+import shutil
+import tarfile
+import tempfile
+
+from .scratch_data import manifest_fingerprint, verify_dataset
+
+MAX_BYTES = 3_000_000_000
+
+
+def digest(path):
+    value = hashlib.sha256()
+    with Path(path).open('rb') as stream:
+        for block in iter(lambda: stream.read(8 * 1024**2), b''):
+            value.update(block)
+    return value.hexdigest()
+
+
+def flat_name(name):
+    if (not isinstance(name, str) or not name or name in {'.', '..'}
+            or '/' in name or '\\' in name or ':' in name):
+        raise ValueError('Archive members must be flat safe filenames')
+    return name
+
+
+def members(manifest):
+    entries = [*manifest['files']]
+    for field in ('document_index', 'candidate_ledger', 'split_registry'):
+        if manifest.get(field):
+            entries.append(manifest[field])
+    names = [flat_name(entry['path']) for entry in entries]
+    if len(names) != len(set(names)) or {'manifest.json', 'report.json'} & set(names):
+        raise ValueError('Duplicate or reserved member names')
+    if len(names) > 20000 or sum(e['bytes'] for e in entries) > MAX_BYTES:
+        raise ValueError('Dataset exceeds transport bound')
+    return entries
+
+
+def pack(source, report_path, output, *, expected_fingerprint=None):
+    source, report_path, output = Path(source), Path(report_path), Path(output)
+    if output.exists() or Path(str(output) + '.json').exists():
+        raise FileExistsError('Choose a new archive output')
+    manifest = verify_dataset(source)
+    fingerprint = manifest_fingerprint(manifest)
+    report = json.loads(report_path.read_text(encoding='utf-8'))
+    if (report.get('success') is not True or report['dataset_fingerprint'] != fingerprint
+            or (expected_fingerprint and fingerprint != expected_fingerprint)
+            or report['manifest_sha256'] != digest(source / 'manifest.json')):
+        raise ValueError('Dataset/report/expected identity mismatch')
+    for split in ('train', 'validation'):
+        if sum(e['tokens'] for e in manifest['files'] if e['split'] == split) != report[split + '_tokens']:
+            raise ValueError('Reported token count mismatch')
+    entries = members(manifest)
+    for entry in entries:
+        path = source / entry['path']
+        if path.stat().st_size != entry['bytes'] or digest(path) != entry['sha256']:
+            raise ValueError('Archive member changed or failed checksum')
+    if report_path.stat().st_size > 2 * 1024**2:
+        raise ValueError('Unexpectedly large source report')
+    ordered = [('manifest.json', source / 'manifest.json')]
+    ordered.extend((entry['path'], source / entry['path']) for entry in entries)
+    ordered.append(('report.json', report_path))
+    temporary = output.with_name(output.name + '.partial')
+    try:
+        with tarfile.open(temporary, 'x:', format=tarfile.USTAR_FORMAT) as archive:
+            for name, path in ordered:
+                info = tarfile.TarInfo(flat_name(name))
+                info.size, info.mtime, info.mode = path.stat().st_size, 0, 0o644
+                with path.open('rb') as stream:
+                    archive.addfile(info, stream)
+        if temporary.stat().st_size > MAX_BYTES:
+            raise ValueError('Archive exceeds 3GB transport bound')
+        temporary.rename(output)
+    finally:
+        if temporary.exists():
+            temporary.unlink()
+    result = {'format': 'pear15-bpe-tar-transport-v1', 'success': True,
+              'archive': output.name, 'archive_bytes': output.stat().st_size,
+              'archive_sha256': digest(output), 'dataset_fingerprint': fingerprint,
+              'manifest_sha256': digest(source / 'manifest.json'),
+              'report_bytes': report_path.stat().st_size, 'report_sha256': digest(report_path),
+              'train_tokens': report['train_tokens'], 'validation_tokens': report['validation_tokens'],
+              'member_count': len(ordered), 'source_sha256': digest(__file__)}
+    Path(str(output) + '.json').write_text(json.dumps(result, indent=2) + '\n', encoding='utf-8')
+    return result
+
+
+def unpack(archive_path, transport, destination):
+    archive_path, destination = Path(archive_path), Path(destination)
+    if destination.exists():
+        raise FileExistsError('Extraction requires a fresh destination')
+    if (transport.get('format') != 'pear15-bpe-tar-transport-v1'
+            or transport.get('success') is not True
+            or not 0 < transport['archive_bytes'] <= MAX_BYTES
+            or archive_path.stat().st_size != transport['archive_bytes']
+            or digest(archive_path) != transport['archive_sha256']):
+        raise ValueError('Archive transport checksum/size mismatch')
+    stage = Path(tempfile.mkdtemp(prefix='.' + destination.name + '-', dir=destination.parent))
+    seen, expected, manifest = set(), {}, None
+    try:
+        with tarfile.open(archive_path, 'r:') as archive:
+            for index, member in enumerate(archive):
+                name = flat_name(member.name)
+                if not member.isfile() or member.linkname or name in seen:
+                    raise ValueError('Non-file/link/duplicate tar member')
+                seen.add(name)
+                stream = archive.extractfile(member)
+                if index == 0:
+                    if name != 'manifest.json' or member.size > 16 * 1024**2:
+                        raise ValueError('First member must be a bounded manifest')
+                    raw = stream.read(16 * 1024**2 + 1)
+                    if hashlib.sha256(raw).hexdigest() != transport['manifest_sha256']:
+                        raise ValueError('Archived manifest checksum mismatch')
+                    manifest = json.loads(raw)
+                    if manifest_fingerprint(manifest) != transport['dataset_fingerprint']:
+                        raise ValueError('Archived dataset fingerprint mismatch')
+                    expected = {entry['path']: entry for entry in members(manifest)}
+                    expected['report.json'] = {'bytes': transport['report_bytes'],
+                                               'sha256': transport['report_sha256']}
+                    if sum(e['bytes'] for e in expected.values()) + len(raw) > MAX_BYTES:
+                        raise ValueError('Extracted data exceeds cap')
+                    (stage / name).write_bytes(raw)
+                    continue
+                entry = expected.get(name)
+                if entry is None or type(entry['bytes']) is not int or member.size != entry['bytes']:
+                    raise ValueError('Unexpected tar member or byte count')
+                sha, count = hashlib.sha256(), 0
+                with (stage / name).open('xb') as target:
+                    for block in iter(lambda: stream.read(1024 * 1024), b''):
+                        count += len(block)
+                        if count > entry['bytes']:
+                            raise ValueError('Member exceeded declared bound')
+                        sha.update(block)
+                        target.write(block)
+                if count != entry['bytes'] or sha.hexdigest() != entry['sha256']:
+                    raise ValueError('Extracted member checksum mismatch')
+        if manifest is None or seen != {'manifest.json', *expected}:
+            raise ValueError('Incomplete archive')
+        verify_dataset(stage)
+        stage.rename(destination)
+    finally:
+        if stage.exists():
+            shutil.rmtree(stage)
+    return manifest
+
+
+def main():
+    parser = argparse.ArgumentParser(description=__doc__)
+    parser.add_argument('--source', type=Path, required=True)
+    parser.add_argument('--report', type=Path, required=True)
+    parser.add_argument('--output', type=Path, required=True)
+    parser.add_argument('--expected-fingerprint')
+    args = parser.parse_args()
+    print(json.dumps(pack(args.source, args.report, args.output,
+                          expected_fingerprint=args.expected_fingerprint), indent=2), flush=True)
+
+
+if __name__ == '__main__':
+    main()