"""Read a completed DISFOR Sentinel-1 companion release from local files. The reader uses Parquet indexes and byte ranges in uncompressed TAR shards. It does not extract archive members, contact Earth Engine/Hugging Face, interpolate dates, assign disturbance labels, or combine different radar tracks implicitly. """ from __future__ import annotations import hashlib import io import json import re import tarfile from datetime import datetime, timezone from pathlib import Path, PurePosixPath from typing import Iterable, Iterator, Mapping, Sequence import numpy as np import pyarrow as pa import pyarrow.dataset as ds FLOAT_ARRAYS = ( "VV_sigma0_db", "VH_sigma0_db", "incidence_deg", "local_incidence_deg", ) BOOL_ARRAYS = ( "source_valid", "angle_ok", "terrain_known", "layover_risk", "shadow_risk", "terrain_ok", "recommended_valid", ) CUBE_ARRAYS = FLOAT_ARRAYS + ("source_scene_index",) + BOOL_ARRAYS DEFAULT_ARRAYS = ("VV_sigma0_db", "VH_sigma0_db", "recommended_valid") _TRACK = re.compile(r"R\d{3}_(ASCENDING|DESCENDING)\Z") _SHA256 = re.compile(r"[0-9a-f]{64}\Z") def _safe_relative(value: str) -> PurePosixPath: """Only accept canonical portable paths, never Windows or parent paths.""" if not isinstance(value, str) or not value or "\\" in value or ":" in value: raise ValueError(f"Invalid release-relative path: {value!r}") path = PurePosixPath(value) if path.is_absolute() or any(part in ("", ".", "..") for part in value.split("/")): raise ValueError(f"Invalid release-relative path: {value!r}") if path.as_posix() != value: raise ValueError(f"Noncanonical release-relative path: {value!r}") return path def _resolve_relative(root: Path, value: str) -> Path: relative = _safe_relative(value) path = root.joinpath(*relative.parts).resolve() try: path.relative_to(root) except ValueError as exc: raise ValueError(f"Release path leaves the release directory: {value!r}") from exc return path def _utc(value: str | datetime, *, name: str = "timestamp") -> datetime: """Parse an aware ISO time; an ISO date alone means midnight UTC.""" if isinstance(value, datetime): parsed = value elif isinstance(value, str): text = value.strip() if re.fullmatch(r"\d{4}-\d{2}-\d{2}", text): text += "T00:00:00+00:00" if text.endswith("Z"): text = text[:-1] + "+00:00" try: parsed = datetime.fromisoformat(text) except ValueError as exc: raise ValueError(f"Invalid {name}: {value!r}") from exc else: raise TypeError(f"{name} must be an ISO string or aware datetime.") if parsed.tzinfo is None or parsed.utcoffset() is None: raise ValueError(f"{name} needs a time zone, for example +00:00 or Z.") return parsed.astimezone(timezone.utc) def _integer(value, name: str, *, minimum: int = 0) -> int: if isinstance(value, bool) or not isinstance(value, (int, np.integer)): raise ValueError(f"{name} must be an integer.") result = int(value) if result < minimum: raise ValueError(f"{name} must be at least {minimum}.") return result def _json_object(path: Path) -> dict: try: value = json.loads(path.read_text(encoding="utf-8")) except (OSError, ValueError) as exc: raise ValueError(f"Cannot read release JSON: {path.name}: {exc}") from exc if not isinstance(value, dict): raise ValueError(f"Expected a JSON object in {path.name}.") return value class CompanionDataset: """A local, completed release with native irregular radar acquisition times. Completion metadata is required, but construction does not reread every dataset byte. ``load_block`` checks each requested payload's SHA-256 by default. Run the package's separate full verification command when all exported files need to be verified. """ def __init__(self, root: str | Path, *, max_block_bytes: int = 1 << 30, _build_validation: bool = False): self.root = Path(root).expanduser().resolve() if not self.root.is_dir(): raise ValueError(f"Release directory does not exist: {self.root}") marker = self.root / "RELEASE_COMPLETE.json" if not isinstance(_build_validation, bool): raise TypeError("_build_validation is a private boolean build option.") if not marker.is_file() and not _build_validation: raise ValueError("The release is incomplete: RELEASE_COMPLETE.json is missing.") self.release = _json_object(self.root / "release.json") self.completion = _json_object(marker) if marker.is_file() else None identity = self.release.get("release_id") if not isinstance(identity, str) or not identity: raise ValueError("release.json must declare a nonempty release_id.") if self.completion is not None and self.completion.get("release_id") != identity: raise ValueError("The completion marker belongs to a different release_id.") self.release_id = identity self.max_block_bytes = _integer(max_block_bytes, "max_block_bytes", minimum=1) self._blocks = None self._centres = None def _dataset(self, relative: str): path = _resolve_relative(self.root, relative) if not path.is_dir(): raise ValueError(f"Required Parquet catalogue is missing: {relative}") try: return ds.dataset(path, format="parquet", exclude_invalid_files=False) except (pa.ArrowException, OSError) as exc: raise ValueError(f"Cannot open Parquet catalogue {relative}: {exc}") from exc @staticmethod def _filter(sample_id: int | None, track: str | None): condition = None if sample_id is not None: sample_id = _integer(sample_id, "sample_id") condition = ds.field("sample_id") == sample_id if track is not None: if not isinstance(track, str) or not _TRACK.fullmatch(track): raise ValueError("track must be R###_ASCENDING or R###_DESCENDING.") track_condition = ds.field("track") == track condition = track_condition if condition is None else condition & track_condition return condition def iter_blocks( self, sample_id: int | None = None, track: str | None = None, *, batch_size: int = 4096, ) -> Iterator[dict]: """Yield index rows without loading the entire catalogue into memory.""" batch_size = _integer(batch_size, "batch_size", minimum=1) condition = self._filter(sample_id, track) if self._blocks is None: self._blocks = self._dataset("radar/blocks") for batch in self._blocks.to_batches(filter=condition, batch_size=batch_size): yield from batch.to_pylist() def tracks(self, sample_id: int) -> list[str]: """Return available relative-orbit/direction tracks for one location.""" return sorted({row["track"] for row in self.iter_blocks(sample_id=sample_id)}) def read_centre_rows( self, sample_id: int | None = None, track: str | None = None, *, columns: Sequence[str] | None = None, batch_size: int = 65536, ) -> Iterator[pa.RecordBatch]: """Yield Arrow batches of centre observations, with the original masks. No temporal or label filter is applied implicitly. For example, callers can select ``recommended_valid`` themselves while keeping the rejected records available for quality analysis. """ batch_size = _integer(batch_size, "batch_size", minimum=1) condition = self._filter(sample_id, track) if self._centres is None: self._centres = self._dataset("radar/pixel_data") if columns is not None: columns = list(columns) yield from self._centres.to_batches( filter=condition, columns=columns, batch_size=batch_size, ) def load_block(self, block: Mapping, *, verify_hash: bool = True) -> dict: """Decode one annual NPZ by its indexed TAR byte range. The result contains every NPZ array and a parsed ``metadata`` object. ``metadata_json`` is retained as its original scalar string array. Archive extraction is never used. Disabling the hash check is an explicit performance choice; path, TAR header and structure checks remain active. """ if not isinstance(block, Mapping): raise TypeError("block must be a row from iter_blocks().") required = { "sample_id", "track", "year", "archive_path", "member_path", "byte_offset", "byte_size", "payload_sha256", "n_frames", "grid_hash", } missing = required.difference(block) if missing: raise ValueError(f"Block index fields missing: {sorted(missing)}") sample_id = _integer(block["sample_id"], "sample_id") year = _integer(block["year"], "year", minimum=1) self._filter(sample_id, block["track"]) archive = _resolve_relative(self.root, block["archive_path"]) member = _safe_relative(block["member_path"]).as_posix() offset = _integer(block["byte_offset"], "byte_offset", minimum=512) size = _integer(block["byte_size"], "byte_size", minimum=1) frames = _integer(block["n_frames"], "n_frames", minimum=1) if offset % tarfile.BLOCKSIZE: raise ValueError("TAR data byte_offset must be aligned to 512 bytes.") if size > self.max_block_bytes: raise ValueError("Indexed NPZ exceeds max_block_bytes.") expected_hash = block["payload_sha256"] if not isinstance(expected_hash, str) or not _SHA256.fullmatch(expected_hash): raise ValueError("payload_sha256 must be a lowercase SHA-256 digest.") try: with archive.open("rb") as stream: stream.seek(0, 2) if offset + size > stream.tell(): raise ValueError("Indexed payload extends beyond the TAR archive.") stream.seek(offset - tarfile.BLOCKSIZE) header = stream.read(tarfile.BLOCKSIZE) try: entry = tarfile.TarInfo.frombuf(header, "utf-8", "strict") except (tarfile.TarError, UnicodeError, ValueError) as exc: raise ValueError("The indexed payload has an invalid TAR header.") from exc if not entry.isreg() or entry.name != member or entry.size != size: raise ValueError("TAR header does not match the indexed member/size.") payload = stream.read(size) if len(payload) != size: raise ValueError("Incomplete read of the indexed payload.") except OSError as exc: raise ValueError(f"Cannot read payload archive {block['archive_path']}: {exc}") from exc if verify_hash and hashlib.sha256(payload).hexdigest() != expected_hash: raise ValueError(f"Payload SHA-256 mismatch: {member}") try: with np.load(io.BytesIO(payload), allow_pickle=False) as stored: arrays = {name: stored[name] for name in stored.files} except (OSError, ValueError, EOFError) as exc: raise ValueError(f"Cannot decode NPZ payload {member}: {exc}") from exc expected_arrays = set(CUBE_ARRAYS) | {"utc", "pass_id", "metadata_json"} if set(arrays) != expected_arrays: raise ValueError("The NPZ array names do not match the native release schema.") for name in CUBE_ARRAYS: expected_dtype = np.dtype("float32" if name in FLOAT_ARRAYS else "bool" if name in BOOL_ARRAYS else "uint16") if arrays[name].shape != (frames, 32, 32) or arrays[name].dtype != expected_dtype: raise ValueError(f"Invalid shape or dtype for array {name}.") for name in ("utc", "pass_id"): if arrays[name].shape != (frames,) or arrays[name].dtype.kind not in "US": raise ValueError(f"Invalid frame strings in {name}.") scalar = arrays["metadata_json"] if scalar.shape != () or scalar.dtype.kind not in "US": raise ValueError("metadata_json must be a scalar string array.") try: metadata = json.loads(scalar.item()) except (TypeError, ValueError) as exc: raise ValueError("Invalid embedded metadata JSON.") from exc if not isinstance(metadata, dict): raise ValueError("Embedded metadata must be an object.") if (metadata.get("sample_id") != sample_id or metadata.get("track") != block["track"] or str(metadata.get("year")) != str(year)): raise ValueError("Embedded identity disagrees with the block index.") grid = metadata.get("grid") if not isinstance(grid, dict) or grid.get("grid_hash") != block["grid_hash"]: raise ValueError("Embedded grid identity disagrees with the block index.") if (grid.get("height"), grid.get("width"), grid.get("reference_row"), grid.get("reference_col")) != (32, 32, 16, 16): raise ValueError("Embedded grid is not the documented DISFOR reference grid.") passes = arrays["pass_id"].astype(str).tolist() acquisition_records = metadata.get("passes") if not isinstance(acquisition_records, list) or any( not isinstance(item, dict) for item in acquisition_records ) or [item.get("pass_id") for item in acquisition_records] != passes: raise ValueError("Metadata pass order disagrees with NPZ frame order.") if len(set(passes)) != frames: raise ValueError("Duplicate physical passes within one annual block.") times = [_utc(value, name="frame utc") for value in arrays["utc"].astype(str)] if any(a > b for a, b in zip(times, times[1:])): raise ValueError("Frame UTC order is not chronological.") if "first_utc" in block and _utc(block["first_utc"]) != min(times): raise ValueError("Block first_utc disagrees with NPZ frame UTCs.") if "last_utc" in block and _utc(block["last_utc"]) != max(times): raise ValueError("Block last_utc disagrees with NPZ frame UTCs.") if "n_valid_centres" in block and int(block["n_valid_centres"]) != int( arrays["recommended_valid"][:, 16, 16].sum() ): raise ValueError("Block n_valid_centres disagrees with the NPZ mask.") arrays["metadata"] = metadata return arrays def read_sequence( self, sample_id: int, track: str, *, valid_centres_only: bool = False, start: str | datetime | None = None, end: str | datetime | None = None, arrays: Sequence[str] = DEFAULT_ARRAYS, ) -> dict: """Read one location and one track, retaining native acquisition times. ``start`` is inclusive and ``end`` exclusive. Date-only boundaries are midnight UTC. ``valid_centres_only`` filters by the centre mask; it does not establish ecological health or valid weather conditions. The default retains every frame, including frames with rejected centre pixels. Selected cube arrays are returned under their own names, with ``utc``, ``pass_id``, ``block_ids`` and ``frame_indices`` aligned along axis zero. This method materializes one location/track sequence; use iter_blocks() and load_block() when an annual-block memory bound is required. """ sample_id = _integer(sample_id, "sample_id") self._filter(sample_id, track) names = tuple(arrays) if not names or len(set(names)) != len(names) or any(name not in CUBE_ARRAYS for name in names): raise ValueError("arrays must contain distinct native cube-array names.") lower = _utc(start, name="start") if start is not None else None upper = _utc(end, name="end") if end is not None else None if lower is not None and upper is not None and lower >= upper: raise ValueError("start must be earlier than end.") collected: dict[str, list[np.ndarray]] = {name: [] for name in names} utc_chunks, pass_chunks, block_chunks, frame_chunks = [], [], [], [] seen_passes: set[str] = set() grid_hash = None source_blocks = [] found = False for block in self.iter_blocks(sample_id=sample_id, track=track): found = True native = self.load_block(block) if grid_hash is None: grid_hash = block["grid_hash"] elif grid_hash != block["grid_hash"]: raise ValueError("A location/track sequence contains incompatible grids.") current_passes = native["pass_id"].astype(str) if seen_passes.intersection(current_passes.tolist()): raise ValueError("Duplicate physical pass across annual blocks.") seen_passes.update(current_passes.tolist()) times = [_utc(value) for value in native["utc"].astype(str)] keep = np.array([ (lower is None or moment >= lower) and (upper is None or moment < upper) for moment in times ], dtype=bool) if valid_centres_only: keep &= native["recommended_valid"][:, 16, 16] count = int(keep.sum()) block_id = str(block.get("block_id", block["member_path"])) source_blocks.append({"block_id": block_id, "frames_selected": count, "n_frames": len(times)}) if not count: continue for name in names: collected[name].append(native[name][keep]) utc_chunks.append(native["utc"][keep].astype(str)) pass_chunks.append(current_passes[keep]) block_chunks.append(np.full(count, block_id, dtype=f"U{len(block_id)}")) frame_chunks.append(np.flatnonzero(keep).astype(np.int64)) if not found: raise KeyError(f"No blocks for sample_id={sample_id}, track={track}.") result = { "sample_id": sample_id, "track": track, "grid_hash": grid_hash, "valid_centres_only": bool(valid_centres_only), "start": lower.isoformat() if lower is not None else None, "end": upper.isoformat() if upper is not None else None, "source_blocks": source_blocks, } if utc_chunks: utc_values = np.concatenate(utc_chunks) pass_values = np.concatenate(pass_chunks) order = np.asarray(sorted(range(len(utc_values)), key=lambda i: (_utc(str(utc_values[i])), str(pass_values[i]))), dtype=np.int64) result["utc"] = utc_values[order] result["pass_id"] = pass_values[order] result["block_ids"] = np.concatenate(block_chunks)[order] result["frame_indices"] = np.concatenate(frame_chunks)[order] for name in names: result[name] = np.concatenate(collected[name], axis=0)[order] else: result.update(utc=np.empty(0, dtype="U1"), pass_id=np.empty(0, dtype="U1"), block_ids=np.empty(0, dtype="U1"), frame_indices=np.empty(0, dtype=np.int64)) for name in names: dtype = "float32" if name in FLOAT_ARRAYS else "bool" if name in BOOL_ARRAYS else "uint16" result[name] = np.empty((0, 32, 32), dtype=dtype) return result