| """Resumable full census, train-only fitting, and verified lossless packing.""" |
| from collections import Counter, deque |
| from concurrent.futures import ThreadPoolExecutor |
| from pathlib import Path |
| import csv |
| import hashlib |
| import io |
| import json |
| import os |
| import shutil |
| import sqlite3 |
| import subprocess |
| import time |
| import numpy as np |
| from . import codec |
| from .core import (VERSION, BANDS, accumulate, canonical, empty_accumulator, |
| finish_stats, json_write, sample_moments, sha256_file) |
|
|
| PROJECT = Path(__file__).resolve().parents[1] |
| CHUNK = 512 |
|
|
| def safe_path(root, relative): |
| root = Path(root).resolve() |
| path = (root / relative).resolve() |
| if not path.is_relative_to(root): |
| raise ValueError(f'Path escapes source root: {relative}') |
| return path |
|
|
| def bounded_map(pool, fn, items, width): |
| it = iter(items) |
| pending = deque() |
| for _ in range(width): |
| try: pending.append(pool.submit(fn, next(it))) |
| except StopIteration: break |
| while pending: |
| yield pending.popleft().result() |
| try: pending.append(pool.submit(fn, next(it))) |
| except StopIteration: pass |
|
|
| def file_signature(path): |
| s = path.stat() |
| return {'size': s.st_size, 'mtime_ns': s.st_mtime_ns} |
|
|
| def create_index(project, name, out, limit=None): |
| index = out / 'source_index.jsonl' |
| if index.exists() and (out/'source_info.json').exists(): |
| info = json.loads((out/'source_info.json').read_text(encoding='utf-8')) |
| if info['limit'] != limit: |
| raise ValueError('Cannot change a partial/full build scope in an existing output') |
| for rel, digest in info['source_manifest_hashes'].items(): |
| if sha256_file(project/rel) != digest: |
| raise ValueError(f'Source manifest changed: {rel}') |
| if sha256_file(index) != info['index_sha256']: |
| raise ValueError('Source index changed') |
| return info |
| temp = index.with_suffix('.building') |
| hashes = {} |
| counts = Counter() |
| candidate = Counter() |
| count = 0 |
| if name == 'prithvi': |
| source = project/'prithvi_data' |
| if shutil.which('rg'): |
| paths = subprocess.check_output(['rg','--files','--hidden','--no-ignore',str(source)], text=True).splitlines() |
| rels = [Path(p).relative_to(source).as_posix() for p in paths] |
| else: |
| rels = [p.relative_to(source).as_posix() for p in source.rglob('*') if p.is_file()] |
| groups = {} |
| extra = [] |
| for rel in rels: |
| if rel.startswith(('train/','val/')): |
| parent, base = rel.rsplit('/', 1) |
| groups.setdefault(parent, set()).add(base) |
| else: |
| extra.append(rel) |
| with temp.open('w', encoding='utf-8', newline='\n') as f: |
| for key, members in sorted(groups.items()): |
| if set(codec.FILENAMES) != members: |
| raise ValueError(f'Unexpected/missing files at {key}: {members}') |
| split, tile, obs, patch = key.split('/') |
| int(obs.removeprefix('obs_')) |
| row, col = patch.split('_') |
| int(row[1:]); int(col[1:]) |
| record = {'id': count+1, 'key': key, 'split': split, 'tile': tile, |
| 'loc': {'path': key}} |
| f.write(json.dumps(record, separators=(',',':'))+'\n') |
| count += 1; counts[split] += 1 |
| candidate[f'{split}/hls'] += 1; candidate[f'{split}/lst_hr'] += 1 |
| if limit and count >= limit: break |
| aux = out/'original_aux' |
| aux.mkdir(exist_ok=True) |
| auxiliary = {} |
| for rel in extra: |
| src = safe_path(source, rel) |
| dst = safe_path(aux, rel) |
| dst.parent.mkdir(parents=True, exist_ok=True) |
| shutil.copy2(src, dst) |
| auxiliary[rel] = {'sha256': sha256_file(dst), **file_signature(src)} |
| root_rel = 'prithvi_data' |
| else: |
| root_rel = 'data_inspection/extracted_metadata/lstsr_tb_final_dataset_20260719' |
| source = project/root_rel |
| hls_rel = 'hls_l8_conditions_2019_2025_lc08' |
| manifests = [source/'phase4_dataset_manifest.csv', source/hls_rel/'hls_condition_manifest.csv'] |
| for p in manifests: hashes[p.relative_to(project).as_posix()] = sha256_file(p) |
| hls = {} |
| with manifests[1].open(encoding='utf-8', newline='') as f: |
| for r in csv.DictReader(f): |
| key = r['sequence_id'] |
| if key in hls: raise ValueError(f'Duplicate HLS key: {key}') |
| if r['reflectance_bands'] != 'B2,B3,B4,B5,B6,B7' or float(r['reflectance_scale']) != 0.0001: |
| raise ValueError(f'Unexpected HLS band/scale at {key}') |
| hls[key] = {k:r[k] for k in ['archive','split','mgrs_tile','hls_datetime_utc','hls_image_id']} |
| seen = set() |
| with manifests[0].open(encoding='utf-8', newline='') as src, temp.open('w', encoding='utf-8', newline='\n') as dst: |
| for r in csv.DictReader(src): |
| key = r['sequence_id'] |
| if key in seen: raise ValueError(f'Duplicate LST key: {key}') |
| seen.add(key) |
| h = hls[key] |
| if (r['split'],r['mgrs_tile']) != (h['split'],h['mgrs_tile']): |
| raise ValueError(f'LST/HLS membership mismatch at {key}') |
| if int(r['nodata_i16']) != -32768 or int(r['patch_size']) != 256: |
| raise ValueError(f'Unexpected source encoding at {key}') |
| months = [int(m)-1 for m in r['available_months'].split(',')] |
| if len(set(months)) != len(months) or any(m not in range(12) for m in months) or len(months)!=int(r['available_month_count']): |
| raise ValueError(f'Invalid availability at {key}') |
| loc = {'lst': r['archive'], 'hls': hls_rel+'/'+h['archive'], 'slots': sorted(months)} |
| safe_path(source, loc['lst']); safe_path(source, loc['hls']) |
| record = {'id':count+1,'key':key,'split':r['split'],'tile':r['mgrs_tile'],'loc':loc, |
| 'meta':{'sequence_id':key,'month_dates':json.loads(r['month_dates_json']), |
| 'hls_datetime':h['hls_datetime_utc'],'hls_image_id':h['hls_image_id'], |
| 'qa_version':r['qa_version'],'source_split':r['split']}} |
| dst.write(json.dumps(record, separators=(',',':'))+'\n') |
| count += 1; counts[r['split']] += 1 |
| candidate[f"{r['split']}/hls"] += 1 |
| candidate[f"{r['split']}/lst_hr"] += len(months) |
| if limit and count >= limit: break |
| if not limit and seen != set(hls): raise ValueError('LST and HLS manifest key sets differ') |
| auxiliary = {} |
| temp.replace(index) |
| info = {'dataset':name,'source_root':root_rel,'records':count,'record_counts':dict(counts), |
| 'candidate_samples':dict(candidate),'source_manifest_hashes':hashes, |
| 'index_sha256':sha256_file(index),'auxiliary':auxiliary,'limit':limit} |
| json_write(out/'source_info.json', info) |
| return info |
|
|
| def inspect_record(record, source, name, level): |
| """Each worker loads one complete source record; no validation fitting.""" |
| fit = record['split'] == 'train' |
| result = {'record':record,'samples':[], 'frame':None, 'raw_bytes':0} |
| if name == 'prithvi': |
| folder = safe_path(source, record['loc']['path']) |
| paths = [folder/n for n in codec.FILENAMES] |
| signatures = [file_signature(p) for p in paths] |
| parts = [p.read_bytes() for p in paths] |
| if [file_signature(p) for p in paths] != signatures: |
| raise ValueError(f'Source changed during read: {folder}') |
| meta = json.loads(parts[3]) |
| b, f, l = [np.load(io.BytesIO(p), allow_pickle=False) for p in parts[:3]] |
| split,tile,obs,patch = record['key'].split('/') |
| row,col = patch.split('_') |
| if (meta['split'],meta['tile'],meta['obs_idx'],meta['row'],meta['col']) != (split,tile,int(obs[4:]),int(row[1:]),int(col[1:])): |
| raise ValueError(f'Metadata/path mismatch: {record["key"]}') |
| if tuple(meta['bands']) != BANDS or meta['bands_scale'] != 10000 or meta['lst_scale'] != 100: |
| raise ValueError(f'Unexpected scale/bands: {record["key"]}') |
| result.update(meta=meta,digest=codec.original_digest(parts),frame=codec.encode(parts,level), |
| signatures=signatures,raw_bytes=sum(map(len,parts))) |
| arrays = [('hls',-1,*canonical(b,'hls',name,fmask=f)), |
| ('lst_hr',-1,*canonical(l,'lst_hr',name))] |
| else: |
| loc = record['loc'] |
| hp, lp = safe_path(source,loc['hls']), safe_path(source,loc['lst']) |
| signatures = {'hls':file_signature(hp),'lst':file_signature(lp)} |
| with np.load(hp,allow_pickle=False) as z: |
| b, f, v = z['hls_reflectance_i16'], z['hls_fmask'], z['hls_valid'] |
| with np.load(lp,allow_pickle=False) as z: |
| l, lv = z['hr_lst'], z['hr_valid'] |
| if l.shape != (12,256,256) or lv.shape != l.shape or l.dtype != np.int16: |
| raise ValueError(f'Invalid month bundle: {record["key"]}') |
| if {'hls':file_signature(hp),'lst':file_signature(lp)} != signatures: |
| raise ValueError(f'Source changed during read: {record["key"]}') |
| digest = hashlib.sha256() |
| for array in (b,f,v,l,lv): digest.update(array.tobytes(order='C')) |
| result.update(meta=record['meta'],digest=digest.hexdigest(),signatures=signatures, |
| raw_bytes=signatures['hls']['size']+signatures['lst']['size']) |
| arrays = [('hls',-1,*canonical(b,'hls',name,fmask=f,source_valid=v))] |
| for slot in loc['slots']: |
| arrays.append(('lst_hr',slot,*canonical(l[slot],'lst_hr',name,source_valid=lv[slot]))) |
| for modality,slot,image,mask in arrays: |
| n = int(mask.sum()) |
| result['samples'].append((modality,slot,n,sample_moments(image,mask) if fit and n else None)) |
| return result |
|
|
| def init_db(path): |
| db = sqlite3.connect(path) |
| db.execute('PRAGMA journal_mode=WAL') |
| db.executescript(''' |
| CREATE TABLE IF NOT EXISTS records(id INTEGER PRIMARY KEY, key TEXT UNIQUE, split TEXT, tile TEXT, meta TEXT, loc TEXT, digest TEXT); |
| CREATE TABLE IF NOT EXISTS samples(modality TEXT, split TEXT, record_id INTEGER, slot INTEGER, valid_pixels INTEGER, UNIQUE(modality,record_id,slot)); |
| CREATE TABLE IF NOT EXISTS rejected(record_id INTEGER, modality TEXT, slot INTEGER, reason TEXT); |
| CREATE TABLE IF NOT EXISTS settings(key TEXT PRIMARY KEY, value TEXT); |
| CREATE TABLE IF NOT EXISTS shards(name TEXT PRIMARY KEY, bytes INTEGER, sha256 TEXT, records INTEGER, verified INTEGER); |
| ''') |
| return db |
|
|
| def _read_setting(db, key): |
| row = db.execute('SELECT value FROM settings WHERE key=?',(key,)).fetchone() |
| return json.loads(row[0]) if row else None |
|
|
| def prepare_dataset(project, name, output, workers=4, level=3, limit=None): |
| from .locking import build_lock |
| with build_lock(Path(output)/name): |
| return _prepare_dataset(project,name,output,workers,level,limit) |
|
|
| def _prepare_dataset(project, name, output, workers=4, level=3, limit=None): |
| started = time.time() |
| out = output/name |
| out.mkdir(parents=True, exist_ok=True) |
| if (out/'bundle.json').exists(): |
| bundle = json.loads((out/'bundle.json').read_text(encoding='utf-8')) |
| if bundle['identity']['limit'] != limit or bundle['identity']['zstd_level'] != level: |
| raise ValueError('Completed output has a different build scope/configuration') |
| print(f'{name}: already complete; keeping frozen output',flush=True) |
| return bundle |
| info = create_index(project,name,out,limit) |
| source = project/info['source_root'] |
| db = init_db(out/'index.sqlite') |
| protocol = json.loads((project/'experiments/data/protocol.json').read_text(encoding='utf-8')) |
| if protocol['training_scope'] != 'independent_datasets': raise ValueError('This pipeline requires independent datasets') |
| identity = {'protocol_sha256':sha256_file(project/'experiments/data/protocol.json'), |
| 'pipeline_sha256':{p.name:sha256_file(p) for p in Path(__file__).parent.glob('*.py')}, |
| 'source_index_sha256':info['index_sha256'],'zstd_level':level,'limit':limit} |
| saved = _read_setting(db,'identity') |
| if saved and saved != identity: raise ValueError('Build identity changed; use a new output version') |
| if not saved: |
| db.execute('INSERT INTO settings VALUES (?,?)',('identity',json.dumps(identity))) |
| db.commit() |
| json_write(out/'protocol.json',protocol) |
| state = _read_setting(db,'progress') or {'completed_records':0,'raw_bytes':0,'packed_bytes':0, |
| 'train_accumulators':{'hls':empty_accumulator(6),'lst_hr':empty_accumulator(1)},'elapsed_seconds':0.0} |
| prior_time = state['elapsed_seconds'] |
| def records(): |
| with (out/'source_index.jsonl').open(encoding='utf-8') as f: |
| for line in f: |
| r=json.loads(line) |
| if r['id'] > state_start: yield r |
| state_start = state['completed_records'] |
| it = iter(records()) |
| packs = out/'packs' |
| if name == 'prithvi': packs.mkdir(exist_ok=True) |
| with ThreadPoolExecutor(max_workers=workers) as pool: |
| while True: |
| chunk=[] |
| for _ in range(CHUNK): |
| try: chunk.append(next(it)) |
| except StopIteration: break |
| if not chunk: break |
| part = f'part_{(chunk[0]["id"]-1)//CHUNK:06d}.eoz' |
| tmp = packs/(part+'.partial') |
| stream = tmp.open('wb') if name=='prithvi' else None |
| locations=[] |
| pending_state=json.loads(json.dumps(state)) |
| try: |
| results = bounded_map(pool,lambda r:inspect_record(r,source,name,level),chunk,max(2,workers*2)) |
| for result in results: |
| r=result['record']; loc=dict(r['loc']) |
| loc['source_signatures']=result['signatures'] |
| if stream: |
| offset=stream.tell(); frame=result['frame']; stream.write(frame) |
| loc.update(shard=part,offset=offset,length=len(frame)) |
| locations.append((offset,len(frame),result['digest'])) |
| pending_state['packed_bytes']+=len(frame) |
| for mod,slot,n,moments in result['samples']: |
| if n: |
| db.execute('INSERT INTO samples VALUES (?,?,?,?,?)',(mod,r['split'],r['id'],slot,n)) |
| if r['split']=='train': accumulate(pending_state['train_accumulators'][mod],moments) |
| else: |
| db.execute('INSERT INTO rejected VALUES (?,?,?,?)',(r['id'],mod,slot,'no_valid_reference_pixels')) |
| db.execute('INSERT INTO records VALUES (?,?,?,?,?,?,?)', |
| (r['id'],r['key'],r['split'],r['tile'],json.dumps(result['meta'],separators=(',',':')), |
| json.dumps(loc,separators=(',',':')),result['digest'])) |
| pending_state['completed_records']+=1 |
| pending_state['raw_bytes']+=result['raw_bytes'] |
| if stream: |
| stream.flush();os.fsync(stream.fileno());stream.close();stream=None |
| with tmp.open('rb') as check: |
| for offset,length,digest in locations: |
| check.seek(offset) |
| codec.decode(check.read(length),digest) |
| target = packs/part |
| tmp.replace(target) |
| db.execute('INSERT OR REPLACE INTO shards VALUES (?,?,?,?,?)', |
| (part,target.stat().st_size,sha256_file(target),len(locations),1)) |
| pending_state['elapsed_seconds']=prior_time+time.time()-started |
| db.execute('INSERT OR REPLACE INTO settings VALUES (?,?)',('progress',json.dumps(pending_state))) |
| db.commit() |
| except BaseException: |
| if stream:stream.close() |
| db.rollback() |
| raise |
| state=pending_state |
| progress={'dataset':name,'status':'running','phase':'full_preprocessing', |
| 'completed_records':state['completed_records'],'total_records':info['records'], |
| 'raw_GiB':state['raw_bytes']/2**30,'packed_GiB':state['packed_bytes']/2**30, |
| 'elapsed_seconds':state['elapsed_seconds']} |
| json_write(out/'progress.json',progress) |
| if state['completed_records']%(CHUNK*8)==0 or state['completed_records']==info['records']: |
| print(json.dumps(progress),flush=True) |
| if state['completed_records'] != info['records']:raise RuntimeError('Incomplete source census') |
| overlap=db.execute('SELECT tile FROM records GROUP BY tile HAVING COUNT(DISTINCT split)>1 LIMIT 1').fetchone() |
| if overlap:raise ValueError(f'Tile crosses splits within {name}: {overlap[0]}') |
| normalization={mod:finish_stats(acc,mod) for mod,acc in state['train_accumulators'].items()} |
| json_write(out/'normalization.json',normalization) |
| splits={} |
| (out/'indices').mkdir(exist_ok=True) |
| for mod,split,count in db.execute('SELECT modality,split,COUNT(*) FROM samples GROUP BY modality,split').fetchall(): |
| path=out/'indices'/f'{split}.{mod}.npy' |
| arr=np.lib.format.open_memmap(path,mode='w+',dtype=np.int64,shape=(count,3)) |
| cur=db.execute('SELECT record_id,slot,valid_pixels FROM samples WHERE modality=? AND split=? ORDER BY record_id,slot',(mod,split)) |
| pos=0 |
| while True: |
| batch=cur.fetchmany(10000) |
| if not batch:break |
| arr[pos:pos+len(batch)]=batch;pos+=len(batch) |
| arr.flush();del arr |
| splits[f'{split}/{mod}']={'samples':count,'index':path.relative_to(out).as_posix(),'sha256':sha256_file(path)} |
| rejected=db.execute('SELECT modality,COUNT(*) FROM rejected GROUP BY modality').fetchall() |
| shards=[dict(zip(['name','bytes','sha256','records','verified'],r)) for r in db.execute('SELECT * FROM shards ORDER BY name')] |
| db.execute('CREATE INDEX IF NOT EXISTS samples_lookup ON samples(modality,split,record_id,slot)') |
| db.commit();db.execute('PRAGMA wal_checkpoint(TRUNCATE)');db.close() |
| artifacts={'index.sqlite':sha256_file(out/'index.sqlite'),'normalization.json':sha256_file(out/'normalization.json'), |
| 'source_index.jsonl':info['index_sha256'],'source_info.json':sha256_file(out/'source_info.json'), |
| 'protocol.json':sha256_file(out/'protocol.json')} |
| bundle={'version':VERSION,'dataset':name,'status':'ready','scope':'development' if limit else 'full', |
| 'backend':'eoz' if name=='prithvi' else 'npz','source_root':info['source_root'], |
| 'records':info['records'],'samples':splits,'normalization':'normalization.json','artifacts':artifacts, |
| 'identity':identity,'source_manifest_hashes':info['source_manifest_hashes'], |
| 'source_bytes':state['raw_bytes'],'packed_bytes':state['packed_bytes'], |
| 'shards':shards,'all_packed_records_byte_verified':name=='prithvi', |
| 'rejected':dict(rejected),'auxiliary':info['auxiliary'],'elapsed_seconds':state['elapsed_seconds']} |
| json_write(out/'bundle.json',bundle) |
| json_write(out/'progress.json',{'dataset':name,'status':'complete','records':info['records'], |
| 'samples':{k:v['samples'] for k,v in splits.items()},'elapsed_seconds':state['elapsed_seconds']}) |
| print(f'{name}: COMPLETE {info["records"]} records; '+json.dumps({k:v['samples'] for k,v in splits.items()}),flush=True) |
| return bundle |
|
|
