grujdin's picture
Stage DISFOR S1 v1.0.0 batch 27
7eea874 verified
Raw History Blame Contribute Delete
19.8 kB
"""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