dataprocessing/common/video_id.py

"""Canonical video ID normalization and source-law loading.

Every prompt in the pipeline gets a single canonical vid of the form
``{dataset}_{original_key}`` (no domain prefix, no file extension).
This module is the single source of truth for that mapping.

The canonical vid is computed at runtime — it is NOT stored in source JSONs.
"""

from __future__ import annotations

import json
import logging
from dataclasses import dataclass, field
from pathlib import Path
from typing import TypedDict

logger = logging.getLogger(__name__)

ROOT = Path(__file__).resolve().parents[2]

# Ordered: first match wins for overlapping prompts (video_phy_2 before video_phy_2).
PROMPT_SOURCES: list[tuple[str, Path]] = [
    ("wmb", ROOT / "data/prompts/wmb/wmb.json"),
    ("physics_iq", ROOT / "data/prompts/physics_iq/physics_iq.json"),
    ("video_phy_2", ROOT / "data/prompts/video_phy_2/video_phy_2.json"),
    ("openvid", ROOT / "data/prompts/openvid/openvid.json"),
]


class SourceEntry(TypedDict):
    laws: list[str]
    dataset: str
    prompt: str
    source_key: str


# ---------------------------------------------------------------------------
# normalize_vid: the single rule for canonical IDs
# ---------------------------------------------------------------------------

def normalize_vid(dataset: str, key: str) -> str:
    """Pure function.  ``(dataset, key) -> canonical vid``.

    Rules:
    - Strip ``.mp4`` suffix from key
    - Prefix with ``{dataset}_``
    - For physics_iq perspectives, key is the full generated_video_name (without .mp4)

    Examples::

        normalize_vid("wmb", "195")                          -> "wmb_195"
        normalize_vid("video_phy_2", "119")                       -> "video_phy_2_119"
        normalize_vid("openvid", "abc.mp4")                  -> "openvid_abc"
        normalize_vid("physics_iq", "0052_...-double-cradle") -> "physics_iq_0052_...-double-cradle"
    """
    key = key.removesuffix(".mp4")
    return f"{dataset}_{key}"


# ---------------------------------------------------------------------------
# resolve_eval_vid: map eval-side video names back to canonical vids
# ---------------------------------------------------------------------------

def resolve_eval_vid(
    eval_video: str,
    eval_dataset_suffix: str,
    reverse_map: dict[str, str],
) -> str | None:
    """Map an eval-side video name to its canonical vid.

    ``reverse_map`` is built by :func:`load_source_laws` — it maps every
    legacy identifier (first_frame_image stem, generated_video_name, numeric
    key) to the canonical vid.

    Falls back to numeric-suffix extraction for video_phy_2/video_phy_2 domain-prefix
    mismatches (e.g. ``buoyancy_119`` -> key ``119``).
    """
    # Direct hit (covers physics_iq perspective names, openvid, exact wmb stems)
    if eval_video in reverse_map:
        return reverse_map[eval_video]

    # Fallback: strip domain prefix, try numeric key
    if "_" in eval_video:
        numeric = eval_video.rsplit("_", 1)[-1]
        if numeric in reverse_map:
            return reverse_map[numeric]

    return None


# ---------------------------------------------------------------------------
# load_source_laws: single loader for all source datasets
# ---------------------------------------------------------------------------

@dataclass
class SourceLawsResult:
    """Result of loading all source prompt JSONs."""
    entries: dict[str, SourceEntry]           # canonical_vid -> SourceEntry
    reverse_map: dict[str, str]               # legacy_id -> canonical_vid
    stats: dict[str, int] = field(default_factory=dict)

    def get(self, canonical_vid: str) -> SourceEntry | None:
        return self.entries.get(canonical_vid)

    def resolve_eval(self, eval_video: str, eval_ds_suffix: str) -> tuple[str, SourceEntry] | None:
        """Resolve eval-side video name -> (canonical_vid, entry)."""
        cvid = resolve_eval_vid(eval_video, eval_ds_suffix, self.reverse_map)
        if cvid and cvid in self.entries:
            return cvid, self.entries[cvid]
        return None

    @property
    def cvid_to_legacies(self) -> dict[str, set[str]]:
        """Inverse of reverse_map: canonical_vid -> set of legacy IDs."""
        if not hasattr(self, "_cvid_to_legacies"):
            inv: dict[str, set[str]] = {}
            for lid, cvid in self.reverse_map.items():
                inv.setdefault(cvid, set()).add(lid)
            self._cvid_to_legacies = inv
        return self._cvid_to_legacies


def load_source_laws(
    sources: list[tuple[str, Path]] | None = None,
) -> SourceLawsResult:
    """Load physical_laws from all canonical prompt JSONs.

    Returns a :class:`SourceLawsResult` with:
    - ``entries``: canonical_vid -> SourceEntry
    - ``reverse_map``: legacy identifiers -> canonical_vid (for eval matching)
    """
    if sources is None:
        sources = PROMPT_SOURCES

    entries: dict[str, SourceEntry] = {}
    reverse_map: dict[str, str] = {}
    stats: dict[str, int] = {}

    def _register(cvid: str, legacy_ids: list[str],
                  laws: list[str], dataset: str,
                  prompt: str, source_key: str) -> None:
        """Register a canonical vid + its legacy aliases (first-match-wins)."""
        if cvid in entries:
            return
        entries[cvid] = SourceEntry(
            laws=laws, dataset=dataset, prompt=prompt, source_key=source_key,
        )
        # Register all legacy identifiers for reverse lookup
        for lid in legacy_ids:
            if lid and lid not in reverse_map:
                reverse_map[lid] = cvid

    for ds_name, path in sources:
        if not path.exists():
            logger.warning("Source not found: %s", path)
            continue
        with open(path) as f:
            data = json.load(f)

        prompts = data.get("prompts", data)
        if not isinstance(prompts, dict):
            continue

        count = 0
        for key, item in prompts.items():
            if not isinstance(item, dict):
                continue
            if item.get("status") != "kept":
                continue

            laws = item.get("physical_laws", [])
            if not laws:
                continue

            prompt_text = item.get("prompt", item.get("description", ""))

            if ds_name == "physics_iq":
                # Each perspective is a separate vid
                for persp in item.get("perspectives", []):
                    gvn = persp.get("generated_video_name", "")
                    gvn_bare = gvn.removesuffix(".mp4")
                    if not gvn_bare:
                        continue
                    cvid = normalize_vid(ds_name, gvn_bare)
                    _register(
                        cvid,
                        legacy_ids=[gvn_bare],
                        laws=laws, dataset=ds_name,
                        prompt=prompt_text, source_key=key,
                    )
                    count += 1
            elif ds_name == "openvid":
                key_bare = key.removesuffix(".mp4")
                cvid = normalize_vid(ds_name, key_bare)
                _register(
                    cvid,
                    legacy_ids=[key_bare],
                    laws=laws, dataset=ds_name,
                    prompt=prompt_text, source_key=key,
                )
                count += 1
            else:
                # wmb, video_phy_2: first_frame_image stem is the legacy ID
                # video_phy_2 entries with subset=video_phy_2 get dataset="video_phy_2"
                effective_ds = item.get("subset", ds_name)
                ff = item.get("first_frame_image", "")
                ff_stem = Path(ff).stem if ff else key
                cvid = normalize_vid(effective_ds, key)
                _register(
                    cvid,
                    legacy_ids=[ff_stem, key],  # both stem and numeric key
                    laws=laws, dataset=effective_ds,
                    prompt=prompt_text, source_key=key,
                )
                count += 1

        stats[ds_name] = count
        logger.info("Loaded %d prompts from %s", count, path.name)

    return SourceLawsResult(entries=entries, reverse_map=reverse_map, stats=stats)