Datasets:

nikhilr01
/

sen-bridge

# Copyright 2026 Nikhil Raghavendra
# SPDX-License-Identifier: Apache-2.0
"""Pilot build: stream a few shards, filter, write PNG pairs for auditing.
Usage::
    python build/pilot.py candidates.parquet OUT_DIR
        [--shards 20] [--workers 64] [--seed 0]
Unlike ``build_full.py``, this writes images of kept crops to
``OUT_DIR/{sar,optical}`` and up to 150 examples of each rejection reason to
``OUT_DIR/rejects/<reason>/``, which the audit tools read. It also writes
``pilot.parquet`` (kept rows) and ``rejects.parquet``.
"""

from __future__ import annotations

import argparse
import threading
import time
from collections import Counter
from concurrent.futures import ThreadPoolExecutor, as_completed
from pathlib import Path
from typing import TYPE_CHECKING, cast

import numpy as np
import pandas as pd
from PIL import Image

from build_full import open_shard
from sen_bridge_build import constants
from sen_bridge_build.sample import MODALITIES, compute

if TYPE_CHECKING:
    from numpy.typing import NDArray

    from sen_bridge_build.stream import Remote

    Opened = tuple[dict[str, Remote], dict[str, dict[str, tuple[int, int]]]]

#: Saved example images per rejection reason, for the audit.
REJECT_CAP = 150
_PROGRESS_EVERY = 200


def save_pair(
    out: Path,
    sub: str,
    sample_id: str,
    sar: NDArray[np.uint8],
    opt: NDArray[np.uint8],
) -> None:
    """Write the radar and optical PNGs of one crop.
    Args:
        out: Pilot directory.
        sub: Sub-directory (empty for kept crops, ``rejects/<reason>`` otherwise).
        sample_id: Example id used as the file name.
        sar: 8-bit radar image ``[3, 128, 128]``.
        opt: 8-bit optical image ``[3, 128, 128]``.
    """
    for name, arr in (("sar", sar), ("optical", opt)):
        directory = out / sub / name
        directory.mkdir(parents=True, exist_ok=True)
        Image.fromarray(arr.transpose(1, 2, 0)).save(directory / f"{sample_id}.png")


def select(path: Path, shards: int, seed: int) -> tuple[pd.DataFrame, list[str]]:
    """Choose the candidates of a random subset of shards.
    Args:
        path: Candidate table.
        shards: Number of shards to use.
        seed: Seed of the shard choice.
    Returns:
        The candidates of the chosen shards and the shard names.
    """
    candidates = pd.read_parquet(path)
    candidates = candidates[candidates["cloud_cover"] <= constants.CLOUD_MAX_FRAC]
    tars = list(
        np.random.default_rng(seed).permutation(sorted(candidates["tar"].unique()))
    )
    chosen = [str(t) for t in tars[:shards]]
    # pandas-stubs lose the DataFrame type through boolean indexing.
    subset = cast("pd.DataFrame", candidates[candidates["tar"].isin(chosen)])
    # pandas-stubs lose the DataFrame type through ``reset_index``.
    return cast("pd.DataFrame", subset.reset_index(drop=True)), chosen


def run_pilot(
    candidates: pd.DataFrame,
    opened: dict[str, Opened],
    out: Path,
    workers: int,
) -> tuple[list[dict[str, object]], list[dict[str, object]]]:
    """Process all candidates, save images, and split kept from rejected.
    Args:
        candidates: Candidates with ``id``, ``season``, ``zarr`` and ``tar``
            columns.
        opened: Opened shards by name.
        out: Pilot directory.
        workers: Number of samples processed concurrently.
    Returns:
        Records of kept crops and records (with a ``reason``) of rejected or failed
        ones.
    """
    saved: Counter[str] = Counter()
    lock = threading.Lock()

    def process(
        row: tuple[str, int, str, str],
    ) -> tuple[dict[str, object], str | None]:
        sample_id, season, zarr, tar = row
        remotes, index = opened[tar]
        done = compute(
            sample_id, season, remotes, {m: index[m][zarr] for m in MODALITIES}
        )
        if done.reason is None:
            save_pair(out, "", sample_id, done.sar, done.optical)
        else:
            with lock:
                saved[done.reason] += 1
                keep = saved[done.reason] <= REJECT_CAP
            if keep:
                save_pair(
                    out, f"rejects/{done.reason}", sample_id, done.sar, done.optical
                )
        return dict(done.record), done.reason

    rows = list(
        zip(
            candidates["id"],
            candidates["season"].astype(int),
            candidates["zarr"],
            candidates["tar"],
            strict=True,
        )
    )
    kept: list[dict[str, object]] = []
    rejects: list[dict[str, object]] = []
    start = time.time()
    with ThreadPoolExecutor(workers) as pool:
        futures = {pool.submit(process, r): r for r in rows}
        for i, future in enumerate(as_completed(futures), 1):
            try:
                record, reason = future.result()
            # Keep going; the failure is recorded as a reason.
            except Exception as exc:  # ruff: ignore[blind-except]
                record, reason = (
                    {"id": futures[future][0]},
                    f"error:{type(exc).__name__}",
                )
            if reason is None:
                kept.append(record)
            else:
                rejects.append({**record, "reason": reason})
            if i % _PROGRESS_EVERY == 0:
                rate = i / (time.time() - start)
                print(f"{i}/{len(rows)} kept={len(kept)} {rate:.1f}/s", flush=True)
    return kept, rejects


def main() -> None:
    """Run the pilot build."""
    parser = argparse.ArgumentParser(description=__doc__)
    parser.add_argument("candidates", type=Path)
    parser.add_argument("out", type=Path)
    parser.add_argument("--shards", type=int, default=20)
    parser.add_argument("--workers", type=int, default=64)
    parser.add_argument("--seed", type=int, default=0)
    args = parser.parse_args()
    out = Path(args.out)

    candidates, tars = select(Path(args.candidates), args.shards, args.seed)
    print(f"{len(candidates)} candidates in {len(tars)} shards", flush=True)
    start = time.time()
    with ThreadPoolExecutor(args.workers) as pool:
        opened = dict(
            zip(
                tars,
                pool.map(lambda t: open_shard(t, out / "index"), tars),
                strict=True,
            )
        )
    print(f"indexed in {time.time() - start:.0f}s", flush=True)

    kept, rejects = run_pilot(candidates, opened, out, args.workers)
    extra = candidates.drop(columns=["geometry"], errors="ignore")
    merged = pd.DataFrame(kept).merge(extra, on="id")
    merged.to_parquet(out / "pilot.parquet")
    rejected = pd.DataFrame(rejects)
    rejected.to_parquet(out / "rejects.parquet")
    print(
        rejected["reason"].value_counts().to_string()
        if len(rejected)
        else "no rejects"
    )
    print(f"kept {len(merged)} of {len(candidates)}")


if __name__ == "__main__":
    main()

	# Copyright 2026 Nikhil Raghavendra
	# SPDX-License-Identifier: Apache-2.0
	"""Pilot build: stream a few shards, filter, write PNG pairs for auditing.

	Usage::

	python build/pilot.py candidates.parquet OUT_DIR
	[--shards 20] [--workers 64] [--seed 0]

	Unlike ``build_full.py``, this writes images of kept crops to
	``OUT_DIR/{sar,optical}`` and up to 150 examples of each rejection reason to
	``OUT_DIR/rejects/<reason>/``, which the audit tools read. It also writes
	``pilot.parquet`` (kept rows) and ``rejects.parquet``.
	"""

	from __future__ import annotations

	import argparse
	import threading
	import time
	from collections import Counter
	from concurrent.futures import ThreadPoolExecutor, as_completed
	from pathlib import Path
	from typing import TYPE_CHECKING, cast

	import numpy as np
	import pandas as pd
	from PIL import Image

	from build_full import open_shard
	from sen_bridge_build import constants
	from sen_bridge_build.sample import MODALITIES, compute

	if TYPE_CHECKING:
	from numpy.typing import NDArray

	from sen_bridge_build.stream import Remote

	Opened = tuple[dict[str, Remote], dict[str, dict[str, tuple[int, int]]]]

	#: Saved example images per rejection reason, for the audit.
	REJECT_CAP = 150
	_PROGRESS_EVERY = 200


	def save_pair(
	out: Path,
	sub: str,
	sample_id: str,
	sar: NDArray[np.uint8],
	opt: NDArray[np.uint8],
	) -> None:
	"""Write the radar and optical PNGs of one crop.

	Args:
	out: Pilot directory.
	sub: Sub-directory (empty for kept crops, ``rejects/<reason>`` otherwise).
	sample_id: Example id used as the file name.
	sar: 8-bit radar image ``[3, 128, 128]``.
	opt: 8-bit optical image ``[3, 128, 128]``.
	"""
	for name, arr in (("sar", sar), ("optical", opt)):
	directory = out / sub / name
	directory.mkdir(parents=True, exist_ok=True)
	Image.fromarray(arr.transpose(1, 2, 0)).save(directory / f"{sample_id}.png")


	def select(path: Path, shards: int, seed: int) -> tuple[pd.DataFrame, list[str]]:
	"""Choose the candidates of a random subset of shards.

	Args:
	path: Candidate table.
	shards: Number of shards to use.
	seed: Seed of the shard choice.

	Returns:
	The candidates of the chosen shards and the shard names.
	"""
	candidates = pd.read_parquet(path)
	candidates = candidates[candidates["cloud_cover"] <= constants.CLOUD_MAX_FRAC]
	tars = list(
	np.random.default_rng(seed).permutation(sorted(candidates["tar"].unique()))
	)
	chosen = [str(t) for t in tars[:shards]]
	# pandas-stubs lose the DataFrame type through boolean indexing.
	subset = cast("pd.DataFrame", candidates[candidates["tar"].isin(chosen)])
	# pandas-stubs lose the DataFrame type through ``reset_index``.
	return cast("pd.DataFrame", subset.reset_index(drop=True)), chosen


	def run_pilot(
	candidates: pd.DataFrame,
	opened: dict[str, Opened],
	out: Path,
	workers: int,
	) -> tuple[list[dict[str, object]], list[dict[str, object]]]:
	"""Process all candidates, save images, and split kept from rejected.

	Args:
	candidates: Candidates with ``id``, ``season``, ``zarr`` and ``tar``
	columns.
	opened: Opened shards by name.
	out: Pilot directory.
	workers: Number of samples processed concurrently.

	Returns:
	Records of kept crops and records (with a ``reason``) of rejected or failed
	ones.
	"""
	saved: Counter[str] = Counter()
	lock = threading.Lock()

	def process(
	row: tuple[str, int, str, str],
	) -> tuple[dict[str, object], str \| None]:
	sample_id, season, zarr, tar = row
	remotes, index = opened[tar]
	done = compute(
	sample_id, season, remotes, {m: index[m][zarr] for m in MODALITIES}
	)
	if done.reason is None:
	save_pair(out, "", sample_id, done.sar, done.optical)
	else:
	with lock:
	saved[done.reason] += 1
	keep = saved[done.reason] <= REJECT_CAP
	if keep:
	save_pair(
	out, f"rejects/{done.reason}", sample_id, done.sar, done.optical
	)
	return dict(done.record), done.reason

	rows = list(
	zip(
	candidates["id"],
	candidates["season"].astype(int),
	candidates["zarr"],
	candidates["tar"],
	strict=True,
	)
	)
	kept: list[dict[str, object]] = []
	rejects: list[dict[str, object]] = []
	start = time.time()
	with ThreadPoolExecutor(workers) as pool:
	futures = {pool.submit(process, r): r for r in rows}
	for i, future in enumerate(as_completed(futures), 1):
	try:
	record, reason = future.result()
	# Keep going; the failure is recorded as a reason.
	except Exception as exc: # ruff: ignore[blind-except]
	record, reason = (
	{"id": futures[future][0]},
	f"error:{type(exc).__name__}",
	)
	if reason is None:
	kept.append(record)
	else:
	rejects.append({**record, "reason": reason})
	if i % _PROGRESS_EVERY == 0:
	rate = i / (time.time() - start)
	print(f"{i}/{len(rows)} kept={len(kept)} {rate:.1f}/s", flush=True)
	return kept, rejects


	def main() -> None:
	"""Run the pilot build."""
	parser = argparse.ArgumentParser(description=__doc__)
	parser.add_argument("candidates", type=Path)
	parser.add_argument("out", type=Path)
	parser.add_argument("--shards", type=int, default=20)
	parser.add_argument("--workers", type=int, default=64)
	parser.add_argument("--seed", type=int, default=0)
	args = parser.parse_args()
	out = Path(args.out)

	candidates, tars = select(Path(args.candidates), args.shards, args.seed)
	print(f"{len(candidates)} candidates in {len(tars)} shards", flush=True)
	start = time.time()
	with ThreadPoolExecutor(args.workers) as pool:
	opened = dict(
	zip(
	tars,
	pool.map(lambda t: open_shard(t, out / "index"), tars),
	strict=True,
	)
	)
	print(f"indexed in {time.time() - start:.0f}s", flush=True)

	kept, rejects = run_pilot(candidates, opened, out, args.workers)
	extra = candidates.drop(columns=["geometry"], errors="ignore")
	merged = pd.DataFrame(kept).merge(extra, on="id")
	merged.to_parquet(out / "pilot.parquet")
	rejected = pd.DataFrame(rejects)
	rejected.to_parquet(out / "rejects.parquet")
	print(
	rejected["reason"].value_counts().to_string()
	if len(rejected)
	else "no rejects"
	)
	print(f"kept {len(merged)} of {len(candidates)}")


	if __name__ == "__main__":
	main()