code/exp/analysis/pool/frames_decode.py

#!/usr/bin/env python3
"""frames_decode.py — frame cache for steps 2 and 3.

Cache location: bench_exp/work/pool_frames/<video_id>/frame_<k>.jpg + frames.json
(video_id = content_hash). Decision (2026-09-06): the cluster runs
job_container/tmpfs (per-job private /tmp, destroyed at job end) and the MIG node
reports TmpDisk=0, so node-local storage cannot be shared between the CPU decode array
and the GPU array. /vast is the shared NVMe-backed (VAST) filesystem every node mounts;
it is the only cache that the decode array and all GPU tasks can read and write, and
it survives job boundaries for incremental re-runs. GPU tasks decode any video still
missing from the cache on the fly (same function) so steps 2-3 never block on the array.

Frames = the stage_p1_runner v_32 grid: 32 time-uniform targets over meta
frame_timestamps, nearest frame index each, duplicates (short videos) collapsed to the
first grid position. frame_<k>.jpg is named by grid position k (0..31); frames.json
lists the positions that exist (`keys`), the single-frame position `mid_k` (grid
position 16 = v_1), and the frame size after resizing to a 448 px long side (never
upscaled), JPEG q85.

  frames_decode.py [--shard i/k] [--workers 8] [--limit N] [--video-ids FILE]
                   [--all-videos]   (default: videos of items still in the pool)
  frames_decode.py --stats
"""
import argparse
import hashlib
import io
import json
import os
import shutil
import sys
import time
from concurrent.futures import ProcessPoolExecutor, as_completed

sys.path.insert(0, os.path.dirname(os.path.abspath(__file__)))
import pool_common as pc  # noqa: E402
from pool_common import log  # noqa: E402


def frames_json_path(video_id):
    return os.path.join(pc.FRAMES_DIR, video_id, "frames.json")


def load_frames_json(video_id):
    p = frames_json_path(video_id)
    if not os.path.exists(p):
        return None
    try:
        d = json.load(open(p))
        return d if d.get("ok") else None
    except Exception:
        return None


def grid_positions(meta):
    """-> (grid of 32 frame indices, ordered unique positions k, mid_k)."""
    from stage_p1_runner import _nearest_indices, _uniform_times
    n = int(meta["n_frames"])
    ts = meta.get("frame_timestamps") or []
    if len(ts) != n or n == 0:
        ts = list(range(max(n, 1)))
    grid = _nearest_indices(ts, _uniform_times(ts[0], ts[-1], pc.N_FRAMES_V32))
    first = {}
    keys = []
    for k, idx in enumerate(grid):
        if idx not in first:
            first[idx] = k
            keys.append(k)
    mid_k = first[grid[pc.MID_POS]]
    return grid, keys, mid_k


def ensure_frames(video_id, video_path, meta=None, long_side=pc.FRAME_LONG_SIDE):
    """Decode + cache if missing; returns the frames.json dict (or raises)."""
    d = load_frames_json(video_id)
    if d is not None:
        return d
    from PIL import Image
    from extract_frames import _decode
    if meta is None:
        meta = pc.meta_of(video_id)
    if not meta:
        raise RuntimeError("meta.json missing")
    grid, keys, mid_k = grid_positions(meta)
    idxs = [grid[k] for k in keys]
    decoded = _decode(video_path, idxs)                 # {idx: PIL}
    avail = max(decoded)
    out_dir = os.path.join(pc.FRAMES_DIR, video_id)
    tmp_dir = f"{out_dir}.tmp{os.getpid()}"
    os.makedirs(tmp_dir, exist_ok=True)
    w = h = None
    for k, idx in zip(keys, idxs):
        im = decoded[min(idx, avail)].convert("RGB")
        W, H = im.size
        s = long_side / max(W, H)
        if s < 1.0:
            im = im.resize((max(1, round(W * s)), max(1, round(H * s))), Image.LANCZOS)
        w, h = im.size
        im.save(os.path.join(tmp_dir, f"frame_{k}.jpg"), format="JPEG", quality=pc.JPEG_QUALITY)
    info = dict(video_id=video_id, n_frames_video=int(meta.get("n_frames", 0)), grid=grid, keys=keys,
                mid_k=mid_k, w=w, h=h, long_side=long_side, jpeg_quality=pc.JPEG_QUALITY,
                too_short=bool(meta.get("too_short")), ok=True, ts=time.strftime("%F %T"))
    json.dump(info, open(os.path.join(tmp_dir, "frames.json"), "w"))
    try:
        os.rename(tmp_dir, out_dir)
    except OSError:
        # another worker finished first: keep theirs
        shutil.rmtree(tmp_dir, ignore_errors=True)
        d = load_frames_json(video_id)
        if d is None:
            raise
        return d
    return info


def frame_bytes(video_id, k):
    with open(os.path.join(pc.FRAMES_DIR, video_id, f"frame_{k}.jpg"), "rb") as f:
        return f.read()


# ------------------------------------------------------------------ selection
def pool_videos(all_videos=False):
    """(video_id, video_path) of videos whose items are still in the pool: base items
    that are mcq, kept by step 0 (if run) and not removed by step 1 (if run)."""
    import pyarrow.parquet as pq
    df = pq.read_table(pc.BASE_PARQUET, columns=["benchmark", "item_id", "video_key", "video_id",
                                                 "video_path", "format"]).to_pandas()
    hashes = pc.manifest_hashes()
    pend = df["video_id"].str.startswith("k:")
    new = df.loc[pend, "video_key"].map(hashes)
    got = new.notna()
    df.loc[new[got].index, "video_id"] = new[got].values
    df.loc[new[got].index, "video_path"] = [pc.normalized_path(x) for x in new[got].values]
    df = df[df["video_path"].notna()]
    if not all_videos:
        df = df[df["format"] == "mcq"]
        if os.path.exists(pc.STEP0_KEPT):
            kept = pq.read_table(pc.STEP0_KEPT, columns=["item_id", "kept"]).to_pandas()
            keep_ids = set(kept.loc[kept["kept"], "item_id"])
            df = df[df["item_id"].isin(keep_ids)]
        ok1, _ = pc.load_step_rows(1)
        if ok1:
            removed = {i for i, r in ok1.items() if r.get("remove")}
            df = df[~df["item_id"].isin(removed)]
    vids = df.drop_duplicates("video_id")[["video_id", "video_path"]]
    return list(vids.itertuples(index=False, name=None))


def shard_of(video_id, n):
    return int(hashlib.sha1(video_id.encode()).hexdigest()[:8], 16) % n


def work_one(video_id, video_path):
    t0 = time.time()
    try:
        info = ensure_frames(video_id, video_path)
        return video_id, None, len(info["keys"]), round(time.time() - t0, 2)
    except Exception as e:
        return video_id, f"{type(e).__name__}: {str(e)[:200]}", 0, round(time.time() - t0, 2)


def main():
    ap = argparse.ArgumentParser(description=__doc__.split("\n\n")[0])
    ap.add_argument("--shard", default=None, help="i/k (default: Slurm array env or 0/1)")
    ap.add_argument("--workers", type=int, default=max(1, int(os.environ.get("SLURM_CPUS_PER_TASK", 16)) // 2))
    ap.add_argument("--limit", type=int, default=None)
    ap.add_argument("--video-ids", default=None, help="file with one video_id per line (smoke tests)")
    ap.add_argument("--all-videos", action="store_true", help="every normalized video of the base items")
    ap.add_argument("--stats", action="store_true")
    a = ap.parse_args()
    pc.ensure_dirs()
    vids = pool_videos(a.all_videos)
    if a.video_ids:
        want = {l.strip() for l in open(a.video_ids) if l.strip()}
        vids = [v for v in vids if v[0] in want]
    cached = [v for v in vids if load_frames_json(v[0]) is not None]
    if a.stats:
        print(f"pool videos with a normalized file: {len(vids)}; frames cached: {len(cached)}; "
              f"missing: {len(vids) - len(cached)}")
        return
    if a.shard:
        tid, n = (int(x) for x in a.shard.split("/"))
    else:
        tid, n = pc.slurm_task()
    todo = [v for v in vids if load_frames_json(v[0]) is None and shard_of(v[0], n) == tid]
    if a.limit:
        todo = todo[:a.limit]
    log(f"frames shard {tid}/{n}: {len(todo)} video(s) to decode of {len(vids)} "
        f"({len(cached)} already cached); workers={a.workers}", "frames")
    if not todo:
        return
    t0 = time.time()
    n_ok = n_err = n_frames = 0
    errs = []
    with ProcessPoolExecutor(max_workers=a.workers) as ex:
        futs = [ex.submit(work_one, v, p) for v, p in todo]
        for i, f in enumerate(as_completed(futs), 1):
            vid, err, nf, dt = f.result()
            if err:
                n_err += 1
                errs.append(dict(video_id=vid, error=err))
            else:
                n_ok += 1
                n_frames += nf
            if i % 200 == 0 or i == len(todo):
                el = time.time() - t0
                log(f"{i}/{len(todo)} ok={n_ok} err={n_err} {i / el:.2f} videos/s", "frames")
    el = time.time() - t0
    if errs:
        with open(os.path.join(pc.LOG_DIR, "pool_frames_errors.jsonl"), "a") as f:
            for e in errs:
                f.write(json.dumps(dict(ts=time.strftime("%F %T"), **e)) + "\n")
    with open(os.path.join(pc.LOG_DIR, "pool_timing.jsonl"), "a") as f:
        f.write(json.dumps(dict(ts=time.strftime("%F %T"), stage="frames", shard=f"{tid}/{n}", n_videos=len(todo),
                                n_ok=n_ok, n_err=n_err, n_frames=n_frames, wall_s=round(el, 1),
                                videos_per_s=round(len(todo) / max(el, 1e-9), 3), workers=a.workers)) + "\n")
    log(f"done: ok={n_ok} err={n_err} frames={n_frames} in {el / 60:.1f} min "
        f"({len(todo) / max(el, 1e-9):.2f} videos/s)", "frames")


if __name__ == "__main__":
    main()