"""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