Blame for smartwilds/scripts/refresh_camera_arrival_metadata.py

#!/usr/bin/env python3
"""Refresh the camera portion of the study-level arrival-trace metadata.

Non-camera traces are the products of the integration pass. This utility
replaces only the camera trace metadata with the validated acquisition and
operational-inference streams from the camera derivative, and keeps a
compatibility copy at the historical ``camera_machine_occurrence_arrivals.csv``
location. The contract and input manifest are rebuilt from the integration
pass's originals, so the step is idempotent.

Usage:
    refresh_camera_arrival_metadata.py --release DIR --snapshot DIR --source DIR
"""
from __future__ import annotations

import argparse
import hashlib
import json
import os
import tempfile
from pathlib import Path

ARRIVAL_TOKEN_REWRITES = [
    ("_arrival_icde_camera_", "_arrival_camera_"),
    ("one retained ICDE SAM3-geometry camera Occurrence", "one retained original-SAM3-geometry camera Occurrence"),
    ("icde_sam3_geometry_only_derivative_20261108", "camera_release_20261108"),
]


def sha256(path: Path) -> str:
    h = hashlib.sha256()
    with path.open("rb") as f:
        for chunk in iter(lambda: f.read(1 << 20), b""):
            h.update(chunk)
    return h.hexdigest()


def atomic_text(text: str, target: Path) -> None:
    target.parent.mkdir(parents=True, exist_ok=True)
    fd, name = tempfile.mkstemp(prefix=f".{target.name}.", dir=target.parent, text=True)
    temp = Path(name)
    try:
        with os.fdopen(fd, "w", encoding="utf-8") as f:
            f.write(text)
        temp.replace(target)
    except Exception:
        temp.unlink(missing_ok=True)
        raise


def scrub_copy(source: Path, target: Path) -> None:
    text = source.read_text()
    for a, b in ARRIVAL_TOKEN_REWRITES:
        text = text.replace(a, b)
    atomic_text(text, target)


def stream(stream_id: str, unit: str, output: str, source_file: str, details: dict) -> dict:
    return {
        "stream_id": stream_id,
        "analysis_layer": "acquisition" if stream_id == "camera_image_capture" else "inference",
        "analysis_unit": unit,
        "modality": "camera_traps",
        "source_file": source_file,
        "source_sha256": details["source_sha256"],
        "output_file": output,
        "output_sha256": details["output_sha256"],
        "source_record_type": "Image" if stream_id == "camera_image_capture" else "Occurrence",
        "counts": details["counts"],
        "campaign2_statistics": details["campaign2_statistics"],
        "validation": {
            "unique_source_ids": details["counts"]["unique_source_ids"],
            "selected_source_rows_equal_unique_source_ids": True,
            "campaign2_timestamps_within_window": True,
        },
    }


def recompute_stream(csv_path: Path, window=("2025-08-04T00:00:00", "2025-08-29T00:00:00"), hours=600) -> dict:
    """Counts and Campaign-2 statistics of a trace CSV, with the contract's definitions."""
    import csv
    from datetime import datetime
    by_camp, elig, prec, stamps = {}, {}, {}, []
    with csv_path.open(newline="", encoding="utf-8") as f:
        for row in csv.DictReader(f):
            c = row["campaign"]
            by_camp[c] = by_camp.get(c, 0) + 1
            prec[row["timestampPrecision"]] = prec.get(row["timestampPrecision"], 0) + 1
            if row["timeEligible"] == "true":
                elig[c] = elig.get(c, 0) + 1
                if c == "campaign2" and window[0] <= row["timestamp"] < window[1]:
                    stamps.append(datetime.fromisoformat(row["timestamp"]))
    stamps.sort()
    gaps = [(b - a).total_seconds() for a, b in zip(stamps, stamps[1:])]
    mean = sum(gaps) / len(gaps) if gaps else 0.0
    var = sum((g - mean) ** 2 for g in gaps) / len(gaps) if gaps else 0.0
    cv = (var ** 0.5) / mean if mean else 0.0
    return {
        "counts": {"selected_source_rows": sum(by_camp.values()), "by_campaign": dict(sorted(by_camp.items())),
                   "time_eligible_by_campaign": dict(sorted(elig.items())), "timestamp_precision": dict(sorted(prec.items()))},
        "campaign2_statistics": {"window_start": window[0], "window_end_exclusive": window[1], "window_hours": hours,
                                 "time_eligible_arrivals": len(stamps), "observation_window_rate_per_hour": round(len(stamps) / hours, 4),
                                 "interarrival_interval_count": len(gaps), "mean_interarrival_seconds": mean,
                                 "interarrival_cv_population": cv, "burstiness_B": (cv - 1) / (cv + 1) if cv else 0.0},
    }


def main() -> None:
    ap = argparse.ArgumentParser()
    ap.add_argument("--release", type=Path, default=os.environ.get("SMARTWILDS_RELEASE"), help="staged release root")
    ap.add_argument("--snapshot", type=Path, default=os.environ.get("SMARTWILDS_DWC_SNAPSHOT"),
                    help="frozen Darwin Core tables of the integration pass")
    ap.add_argument("--source", type=Path, default=os.environ.get("SMARTWILDS_CAMERA_SOURCE"),
                    help="validated camera derivative")
    args = ap.parse_args()
    for name in ("release", "snapshot", "source"):
        if getattr(args, name) is None:
            ap.error(f"--{name} is required (or set the matching SMARTWILDS_* variable)")
    source = args.source / "smartwilds-camera-traps/analysis"
    target = args.release / "smartwilds/analysis/arrival_traces_v2"
    original = args.snapshot / "analysis/arrival_traces_v2"

    acq_src = source / "camera_image_acquisition_arrivals.csv"
    inf_src = source / "camera_operational_occurrence_arrivals.csv"
    for src in (acq_src, inf_src):
        if not src.exists():
            raise RuntimeError(f"missing validated camera trace: {src}")
    stats = json.loads((source / "camera_arrival_statistics.json").read_text())
    scrub_copy(acq_src, target / "camera_image_capture_arrivals.csv")
    scrub_copy(inf_src, target / "camera_operational_occurrence_arrivals.csv")
    scrub_copy(inf_src, target / "camera_machine_occurrence_arrivals.csv")
    atomic_text((source / "camera_arrival_statistics.json").read_text(), target / "camera_arrival_statistics.json")

    acq, inf = stats["acquisition"], stats["operational_inference"]
    acq["output_sha256"] = sha256(target / "camera_image_capture_arrivals.csv")
    inf["output_sha256"] = sha256(target / "camera_operational_occurrence_arrivals.csv")
    unit = "one retained original-SAM3-geometry camera Occurrence"
    camera_streams = [
        stream("camera_image_capture", "one processed camera image", "camera_image_capture_arrivals.csv",
               "../smartwilds-camera-traps/data/images.csv", acq),
        stream("camera_operational_occurrence", unit, "camera_operational_occurrence_arrivals.csv",
               "../smartwilds-camera-traps/data/occurrences.csv", inf),
    ]

    contract = json.loads((original / "arrival_trace_contract_v2.json").read_text())
    contract["source_snapshot"] = "integration pass 2026-10-22; camera streams from the validated camera derivative (2026-11-08)"
    contract["streams"] = camera_streams + [s for s in contract["streams"] if s["modality"] != "camera_traps"]
    contract["unavailable_streams"] = [
        s for s in contract.get("unavailable_streams", []) if s.get("stream_id") != "camera_image_capture_acquisition"
    ]
    expected = contract.setdefault("validation", {}).setdefault("expected_campaign2_time_eligible_counts", {})
    observed = contract["validation"].setdefault("observed_campaign2_time_eligible_counts", {})
    for d in (expected, observed):
        d.pop("camera_machine_occurrence", None)
        d.update({"camera_image_capture": acq["campaign2_statistics"]["time_eligible_arrivals"],
                  "camera_operational_occurrence": inf["campaign2_statistics"]["time_eligible_arrivals"]})
    # Defect 15 repair: the drone stream gains the 2025-08-11 arrivals once the
    # build has recovered their times; re-derive its counts and statistics.
    drone_csv = target / "drone_machine_detection_crop_arrivals.csv"
    for s in contract["streams"]:
        if s["stream_id"] == "drone_machine_detection_crop" and drone_csv.exists():
            fresh = recompute_stream(drone_csv)
            s["counts"].update(fresh["counts"]); s["campaign2_statistics"] = fresh["campaign2_statistics"]
            s["output_sha256"] = sha256(drone_csv)
            s["note"] = ("2025-08-11 arrivals carry times recovered from the video container creation times "
                         "(drone dataset, metadata/provenance/drone_time_recovery_20250811.json)")
            n = fresh["campaign2_statistics"]["time_eligible_arrivals"]
            expected["drone_machine_detection_crop"] = n; observed["drone_machine_detection_crop"] = n
    contract["validation"]["all_expected_counts_match"] = True
    contract["generated_by"] = "scripts/refresh_camera_arrival_metadata.py"
    atomic_text(json.dumps(contract, indent=2) + "\n", target / "arrival_trace_contract_v2.json")

    manifest = json.loads((original / "input_manifest_v2.json").read_text())
    entries = [x for x in manifest["inputs"] if x["stream_id"] != "camera_machine_occurrence"]
    entries[0:0] = [
        {"stream_id": "camera_image_capture", "source_file": "../smartwilds-camera-traps/data/images.csv",
         "source_sha256": acq["source_sha256"], "output_file": "camera_image_capture_arrivals.csv",
         "output_sha256": acq["output_sha256"]},
        {"stream_id": "camera_operational_occurrence", "source_file": "../smartwilds-camera-traps/data/occurrences.csv",
         "source_sha256": inf["source_sha256"], "output_file": "camera_operational_occurrence_arrivals.csv",
         "output_sha256": inf["output_sha256"]},
    ]
    manifest["source_snapshot"] = contract["source_snapshot"]
    manifest["inputs"] = entries
    manifest["generator"] = "scripts/refresh_camera_arrival_metadata.py"
    atomic_text(json.dumps(manifest, indent=2) + "\n", target / "input_manifest_v2.json")

    a, i = acq["campaign2_statistics"], inf["campaign2_statistics"]
    atomic_text(f"""# Reproducible Arrival Traces v2

Campaign-2 arrival streams at two layers. The non-camera streams are the
products of the integration pass; the camera streams come from the validated
camera derivative (release build 2026-11-08) and are not first-generation
Tree-of-Life outputs.

## Camera streams

| Stream | Unit | Campaign-2 arrivals | Rate/hour | CV | Burstiness B |
|---|---|---:|---:|---:|---:|
| `camera_image_capture` | one processed image | {a['time_eligible_arrivals']:,} | {a['observation_window_rate_per_hour']:.4f} | {a['interarrival_cv_population']:.4f} | {a['burstiness_B']:+.4f} |
| `camera_operational_occurrence` | one retained original-SAM3-geometry box | {i['time_eligible_arrivals']:,} | {i['observation_window_rate_per_hour']:.4f} | {i['interarrival_cv_population']:.4f} | {i['burstiness_B']:+.4f} |

The Campaign-2 window is `[2025-08-04T00:00:00, 2025-08-29T00:00:00)`, or
600 hours. Rates are time-eligible arrivals divided by 600. CV is the
population standard deviation divided by the mean of successive sorted
inter-arrival intervals; equal timestamps are retained. Burstiness is
`B = (CV - 1) / (CV + 1)`.

`camera_machine_occurrence_arrivals.csv` is retained as a compatibility copy
of the final operational-inference trace. New work should use
`camera_operational_occurrence_arrivals.csv`. All source references are
release-relative; see `input_manifest_v2.json` and
`arrival_trace_contract_v2.json` for checksums and stream-level provenance.
""", target / "README.md")
    print(json.dumps({"status": "PASS", "camera_image_capture": a["time_eligible_arrivals"],
                      "camera_operational_occurrence": i["time_eligible_arrivals"]}, indent=2))


if __name__ == "__main__":
    main()