| """
|
| run_ingest.py — AtmosIQ Phase-2 orchestrator (checkpointed, never-skip build).
|
|
|
| GUARANTEE: no file is EVER skipped. Every source is resumable and asserts
|
| 100% file completeness before writing its output. If a download can't be
|
| recovered after retries, the run STOPS (raises) — it never drops data.
|
|
|
| Feeding modes:
|
| --local DIR : process files already on disk (use `hf download` for whole repos)
|
| (default) : stream each file from HF to scratch, process, delete (for MODIS)
|
|
|
| Env: ATMOS_OUT, ATMOS_GRID, ATMOS_SCRATCH, HF_TOKEN
|
| Commands: <source...> | --local DIR | --merge | --check | --no-merge | --force
|
| """
|
| from __future__ import annotations
|
| import os, sys, glob, math, pathlib, fnmatch, time
|
| os.environ.setdefault("HF_HUB_DISABLE_XET", "1")
|
| sys.path.insert(0, str(pathlib.Path(__file__).resolve().parent))
|
| sys.path.insert(0, str(pathlib.Path(__file__).resolve().parents[1] / "grid"))
|
|
|
| import numpy as np
|
| import pandas as pd
|
| import pyarrow as pa, pyarrow.parquet as pq
|
| from aggregation import SPECS, ingest, _to_date, _clean, _select_nearest_ist
|
| from grid_index import GridIndex
|
|
|
| OUT = pathlib.Path(os.environ.get("ATMOS_OUT", "data/ingest"))
|
| GRID = pathlib.Path(os.environ.get("ATMOS_GRID", "data/grid/grid_nodes.parquet"))
|
| SCRATCH = pathlib.Path(os.environ.get("ATMOS_SCRATCH", "scratch"))
|
| CHUNK = 500_000
|
| OUT.mkdir(parents=True, exist_ok=True); SCRATCH.mkdir(parents=True, exist_ok=True)
|
| CKPT = OUT / ".ckpt"; CKPT.mkdir(exist_ok=True)
|
|
|
| REG = {
|
| "s5p_no2": ("Atmos_Pollutants_Particles","data/NO2/*.csv","s5p_no2","stream"),
|
| "s5p_so2": ("Atmos_Pollutants_Particles","data/SO2/*.csv","s5p_so2","stream"),
|
| "s5p_co": ("Atmos_Pollutants_Particles","data/CO/*.csv","s5p_co","stream"),
|
| "s5p_o3": ("Atmos_Pollutants_Particles","data/O3/*.csv","s5p_o3","stream"),
|
| "s5p_hcho": ("Atmos_Pollutants_Particles","data/HCHO/*.csv","s5p_hcho","stream"),
|
| "s5p_aer_ai":("Atmos_Pollutants_Particles","data/AER_AI/*.csv","s5p_aer_ai","stream"),
|
| "s5p_ch4": ("Atmos_Pollutants_Particles","data/CH4/*.csv","s5p_ch4","stream"),
|
| "s5p_cloud":("Atmos_Pollutants_Particles","data/CLOUD/*.csv","s5p_cloud","stream"),
|
| "modis": ("Atmos_MODIS_AOD","data/*.csv","modis","stream"),
|
| "viirs": ("Atmos_VIIRS_AOD","data/*.csv","viirs","stream"),
|
| "era5_daily": ("Atmos_ERA5_Meteorology","data/*.csv","era5_daily","centroid"),
|
| "era5_wind_1330": ("Atmos_ERA5_Meteorology","data/*.csv","era5_wind_1330","centroid"),
|
| "firms": ("Atmos_FIRMS_Fire","data/*.csv","firms","stream"),
|
| "dem": ("Atmos_DEM_Copernicus","*.tif",None,"dem"),
|
| }
|
| HF_ORG = "AtmosIQ"
|
|
|
| def hf_list(repo, subpath):
|
| from huggingface_hub import HfApi
|
| api = HfApi(token=os.environ.get("HF_TOKEN"))
|
| return [f for f in api.list_repo_files(f"{HF_ORG}/{repo}", repo_type="dataset")
|
| if fnmatch.fnmatch(f, subpath)]
|
|
|
| def local_files(root, repo, subpath):
|
| return sorted(glob.glob(str(pathlib.Path(root) / repo / subpath)))
|
|
|
| def _dl_retry(repo, f, tries=10):
|
| """Download one file with exp backoff. NEVER skips: raises after `tries`
|
| so the run STOPS rather than dropping data."""
|
| from huggingface_hub import hf_hub_download
|
| for a in range(tries):
|
| try:
|
| return hf_hub_download(f"{HF_ORG}/{repo}", filename=f, repo_type="dataset",
|
| local_dir=str(SCRATCH), token=os.environ.get("HF_TOKEN"))
|
| except Exception as e:
|
| if a == tries - 1:
|
| raise RuntimeError(f"STOP: {f} failed after {tries} tries ({type(e).__name__}). "
|
| f"Nothing skipped — fix & re-run to resume.") from e
|
| w = min(120, 3 * 2 ** a); print(f" retry {a+1}/{tries} {f} in {w}s"); time.sleep(w)
|
|
|
|
|
| def _ckpt_load(name):
|
| ck = CKPT / f"{name}.ckpt.parquet"
|
| if ck.exists():
|
| t = pq.read_table(ck); done = set(t.schema.metadata[b"done"].decode().splitlines())
|
| return done, t.to_pandas().set_index(["node_id", "date"])
|
| man = CKPT / f"{name}.manifest.txt"; acc = CKPT / f"{name}.acc.parquet"
|
| if man.exists() and acc.exists():
|
| return set(man.read_text().splitlines()), pd.read_parquet(acc).set_index(["node_id", "date"])
|
| return set(), None
|
|
|
| def _ckpt_save(name, done, accdf):
|
| """ONE atomic parquet: accumulator + done-list in metadata. Crash-safe — the
|
| file is either fully the old checkpoint or fully the new one, never partial,
|
| so done and accumulator can never drift (no double-count on resume)."""
|
| ck = CKPT / f"{name}.ckpt.parquet"
|
| t = pa.Table.from_pandas(accdf.reset_index(), preserve_index=False)
|
| md = dict(t.schema.metadata or {}); md[b"done"] = ("\n".join(sorted(done))).encode()
|
| t = t.replace_schema_metadata(md)
|
| tmp = ck.with_suffix(".tmp"); pq.write_table(t, tmp); os.replace(tmp, ck)
|
|
|
|
|
| _WORKER_GI = None
|
| def _process_one(args):
|
| """Worker: one file -> partial groupby (sum_<col> + n_obs). If `repo` is set,
|
| the worker DOWNLOADS the file (with retry) to scratch, processes, deletes —
|
| enabling parallel HF streaming. Each worker lazy-loads its GridIndex once
|
| (Windows spawn-safe)."""
|
| path, speckey, grid_path, repo, scratch = args
|
| import os, time, pandas as pd, pathlib
|
| from aggregation import SPECS, _to_date, _clean
|
| from grid_index import GridIndex
|
| global _WORKER_GI
|
| if _WORKER_GI is None:
|
| _WORKER_GI = GridIndex.from_parquet(grid_path)
|
| spec = SPECS[speckey]; gi = _WORKER_GI
|
| local = path
|
| if repo is not None:
|
| from huggingface_hub import hf_hub_download
|
| for a in range(10):
|
| try:
|
| local = hf_hub_download(f"AtmosIQ/{repo}", filename=path, repo_type="dataset",
|
| local_dir=scratch, token=os.environ.get("HF_TOKEN")); break
|
| except Exception as e:
|
| if a == 9: raise RuntimeError(f"STOP: {path} failed after 10 tries ({type(e).__name__})") from e
|
| time.sleep(min(120, 3 * 2 ** a))
|
| try:
|
| reader = [pd.read_parquet(local)] if str(local).endswith(".parquet") else pd.read_csv(local, chunksize=500_000)
|
| acc = None
|
| for chunk in reader:
|
| df = _clean(_to_date(chunk, spec), spec)
|
| if not len(df): continue
|
| df["node_id"] = gi.assign_node_id(df[spec.lat_col].values, df[spec.lon_col].values)
|
| df = df[df["node_id"].notna()]
|
| if not len(df): continue
|
| g = df.groupby(["node_id","date"])
|
| part = g[spec.value_cols].sum().add_prefix("sum_"); part["n_obs"] = g.size()
|
| acc = part if acc is None else acc.add(part, fill_value=0)
|
| finally:
|
| if repo is not None:
|
| try: os.remove(local)
|
| except OSError: pass
|
| return pathlib.Path(path).name, acc
|
|
|
|
|
| class StreamAgg:
|
| def __init__(self, cols, acc=None): self.cols=cols; self.acc=acc
|
| def push(self, part): self.acc = part if self.acc is None else self.acc.add(part, fill_value=0)
|
| def finalize(self, agg):
|
| df=self.acc.reset_index()
|
| if agg=="mean":
|
| for c in self.cols: df[c]=df["sum_"+c]/df["n_obs"]
|
| df=df.drop(columns=["sum_"+c for c in self.cols])
|
| elif agg=="count":
|
| for c in self.cols: df[c]=df["sum_"+c]/df["n_obs"]; df=df.drop(columns=["sum_"+c])
|
| df=df.rename(columns={"n_obs":"count"})
|
| return df
|
|
|
| def run_stream(repo, files, use_hf, root, gi, spec):
|
| done, acc0 = _ckpt_load(spec.name)
|
| agg = StreamAgg(spec.value_cols, acc0)
|
| total = len(files); n = len(done)
|
| JOBS = int(os.environ.get("ATMOS_JOBS", "1"))
|
| BATCH = int(os.environ.get("ATMOS_BATCH", str(max(JOBS * 4, 32))))
|
| if JOBS > 1:
|
| from multiprocessing import Pool
|
| gp = str(GRID.resolve())
|
| todo = [f for f in files if pathlib.Path(f).name not in done]
|
|
|
|
|
| for bstart in range(0, len(todo), BATCH):
|
| batch = todo[bstart:bstart + BATCH]
|
| if use_hf:
|
| tasks = [(f, spec.name, gp, repo, str(SCRATCH)) for f in batch]
|
| else:
|
| tasks = [(f, spec.name, gp, None, None) for f in batch]
|
| with Pool(min(JOBS, len(batch))) as pool:
|
| for name, part in pool.imap_unordered(_process_one, tasks, chunksize=1):
|
| if part is not None: agg.push(part)
|
| done.add(name); n += 1
|
| print(f" [{spec.name}] {n}/{total}", end="\r")
|
| _ckpt_save(spec.name, done, agg.acc)
|
| if len(done) != total:
|
| raise RuntimeError(f"[{spec.name}] INCOMPLETE {len(done)}/{total}; refusing to write.")
|
| out = agg.finalize(spec.agg).rename(columns=spec.rename)
|
| return out.merge(gi.centroids(), on="node_id", how="left")
|
| for f in files:
|
| name = pathlib.Path(f).name
|
| if name in done:
|
| continue
|
| path = _dl_retry(repo, f) if use_hf else f
|
| try:
|
| reader = [pd.read_parquet(path)] if str(path).endswith(".parquet") else pd.read_csv(path, chunksize=CHUNK)
|
| for chunk in reader:
|
| df = _clean(_to_date(chunk, spec), spec)
|
| if not len(df): continue
|
| df["node_id"] = gi.assign_node_id(df[spec.lat_col].values, df[spec.lon_col].values)
|
| df = df[df["node_id"].notna()]
|
| if not len(df): continue
|
| g = df.groupby(["node_id","date"])
|
| part = g[spec.value_cols].sum().add_prefix("sum_"); part["n_obs"]=g.size()
|
| agg.push(part)
|
| finally:
|
| if use_hf:
|
| try: os.remove(path)
|
| except OSError: pass
|
| done.add(name); n += 1
|
| if n % 50 == 0: _ckpt_save(spec.name, done, agg.acc)
|
| print(f" [{spec.name}] {n}/{total}", end="\r")
|
| _ckpt_save(spec.name, done, agg.acc)
|
| if len(done) != total:
|
| raise RuntimeError(f"[{spec.name}] INCOMPLETE {len(done)}/{total}; refusing to write. Re-run to resume.")
|
| out = agg.finalize(spec.agg).rename(columns=spec.rename)
|
| return out.merge(gi.centroids(), on="node_id", how="left")
|
|
|
| def run_centroid(repo, files, use_hf, root, gi, spec):
|
| frames=[]; total=len(files)
|
| for i,f in enumerate(files):
|
| path=_dl_retry(repo,f) if use_hf else f
|
| try:
|
| df=pd.read_parquet(path) if str(path).endswith(".parquet") else pd.read_csv(path)
|
| frames.append(ingest(df,gi,spec))
|
| finally:
|
| if use_hf:
|
| try: os.remove(path)
|
| except OSError: pass
|
| print(f" [{spec.name}] {i+1}/{total}", end="\r")
|
| if len(frames)!=total:
|
| raise RuntimeError(f"[{spec.name}] INCOMPLETE {len(frames)}/{total}; refusing to write.")
|
| return pd.concat(frames, ignore_index=True)
|
|
|
| def run_dem(gi, use_hf, root):
|
| import rasterio
|
| nodes=gi.centroids().copy(); nodes["elevation_m"]=np.nan
|
| nodes["tlat"]=np.floor(nodes.centroid_lat).astype(int); nodes["tlon"]=np.floor(nodes.centroid_lon).astype(int)
|
| def tile(tlat,tlon):
|
| ns="N" if tlat>=0 else "S"; ew="E" if tlon>=0 else "W"
|
| fn=f"Copernicus_DSM_COG_10_{ns}{abs(tlat):02d}_00_{ew}{abs(tlon):03d}_00_DEM.tif"
|
| if use_hf:
|
| from huggingface_hub import hf_hub_download
|
| try: return hf_hub_download(f"{HF_ORG}/Atmos_DEM_Copernicus",filename=fn,repo_type="dataset",
|
| local_dir=str(SCRATCH),token=os.environ.get("HF_TOKEN"))
|
| except Exception: return None
|
| p=pathlib.Path(root)/"Atmos_DEM_Copernicus"/fn; return str(p) if p.exists() else None
|
| for (tlat,tlon),grp in nodes.groupby(["tlat","tlon"]):
|
| p=tile(tlat,tlon)
|
| if not p: continue
|
| with rasterio.open(p) as src:
|
| vals=[v[0] for v in src.sample(list(zip(grp.centroid_lon,grp.centroid_lat)))]
|
| nd=src.nodata; vals=[np.nan if (nd is not None and v==nd) else float(v) for v in vals]
|
| nodes.loc[grp.index,"elevation_m"]=vals
|
| if use_hf:
|
| try: os.remove(p)
|
| except OSError: pass
|
| return nodes[["node_id","elevation_m"]]
|
|
|
| def merge_master(gi):
|
| daily=[d for d in sorted(OUT.glob("*_daily.parquet"))]
|
| if not daily: print(" no *_daily.parquet"); return
|
| master=None
|
| for d in daily:
|
| df=pd.read_parquet(d); vc=[c for c in df.columns if c not in ("node_id","date","centroid_lat","centroid_lon","n_obs")]
|
| df=df[["node_id","date"]+vc]; master=df if master is None else master.merge(df,on=["node_id","date"],how="outer")
|
| master=master.merge(gi.centroids(),on="node_id",how="left"); master["_ym"]=master["date"].str.slice(0,7)
|
| mdir=OUT/"node_observations_daily"; mdir.mkdir(exist_ok=True)
|
| for ym,part in master.groupby("_ym"): part.drop(columns="_ym").to_parquet(mdir/f"{ym}.parquet",index=False)
|
| print(f" master: {len(master):,} node-days, {master.shape[1]-1} cols, {master['_ym'].nunique()} partitions -> {mdir}")
|
| dem=OUT/"dem_static.parquet"
|
| if dem.exists():
|
| gn=pd.read_parquet(GRID).drop(columns=["elevation_m"],errors="ignore").merge(pd.read_parquet(dem),on="node_id",how="left")
|
| gn.to_parquet(GRID,index=False); print(" grid_nodes.elevation_m filled")
|
|
|
| SANE={"s5p_no2_column":(-0.002,0.002),"s5p_so2_column":(-0.02,0.02),"s5p_co_column":(0,0.1),
|
| "s5p_o3_column":(0,0.25),"s5p_hcho_column":(-0.005,0.02),"s5p_aer_ai":(-30,35),
|
| "s5p_ch4_column":(1300,2400),"s5p_cloud_fraction":(0,1),"modis_aod":(0,5),"viirs_aod":(0,5),
|
| "era5_temperature":(230,325),"era5_boundary_layer_height":(0,5000),"u_1330ist":(-30,30),
|
| "v_1330ist":(-30,30),"fire_count":(0,1e6),"elevation_m":(-50,8850)}
|
| def check():
|
| print("=== range check ===")
|
| for d in sorted(OUT.glob("*_daily.parquet")):
|
| df=pd.read_parquet(d); print(f"\n{d.name}: {len(df):,} rows")
|
| for c in df.columns:
|
| if c not in SANE: continue
|
| s=df[c]; lo,hi=SANE[c]; bad=((s<lo)|(s>hi)).sum()
|
| print(f" {c}: min={s.min():.4g} max={s.max():.4g} null%={100*s.isna().mean():.1f}{' ⚠OUT-OF-RANGE' if bad else ''}")
|
|
|
| def main(argv):
|
| if "--check" in argv: check(); return
|
| use_hf = "--local" not in argv
|
| root = argv[argv.index("--local")+1] if "--local" in argv else None
|
| gi = GridIndex.from_parquet(str(GRID))
|
| print(f"grid: {len(gi)} cells | mode: {'HF-stream' if use_hf else 'local:'+str(root)}")
|
| if "--merge" in argv: merge_master(gi); return
|
| skip={"--local","--merge","--check","--no-merge","--force",root}
|
| only=[a for a in argv if a not in skip and not a.startswith("--")]
|
| for key,(repo,subpath,speckey,kind) in REG.items():
|
| if only and key not in only: continue
|
| outp=OUT/("dem_static.parquet" if kind=="dem" else f"{key}_daily.parquet")
|
| if outp.exists() and "--force" not in argv: print(f" skip {key} (exists)"); continue
|
| if "--force" in argv:
|
| for suf in (".manifest.txt",".acc.parquet",".ckpt.parquet"):
|
| fp=CKPT/f"{key}{suf}"
|
| if fp.exists(): fp.unlink()
|
| if kind=="dem":
|
| print(f" {key} [dem]"); out=run_dem(gi,use_hf,root)
|
| else:
|
| files=hf_list(repo,subpath) if use_hf else local_files(root,repo,subpath)
|
| if not files: print(f" ! {key}: 0 files ({repo}/{subpath})"); continue
|
| print(f" {key}: {len(files)} files [{kind}]")
|
| out=run_stream(repo,files,use_hf,root,gi,SPECS[speckey]) if kind=="stream" \
|
| else run_centroid(repo,files,use_hf,root,gi,SPECS[speckey])
|
| out.to_parquet(outp,index=False); print(f"\n -> {outp} ({len(out):,} rows)")
|
|
|
| for suf in (".manifest.txt",".acc.parquet",".ckpt.parquet"):
|
| fp=CKPT/f"{key}{suf}"
|
| if fp.exists(): fp.unlink()
|
| if "--no-merge" not in argv: merge_master(gi)
|
| print("done.")
|
|
|
| if __name__=="__main__": main(sys.argv[1:]) |
