unrender 0.2.1__py3-none-any.whl

unrender/__init__.py

@@ -0,0 +1,15 @@
+"""Unrender timeline reconstruction pipeline."""
+
+from unrender.manifests import DialogueLineRecord, ManifestStore, ShotRecord, VoiceInput
+from unrender.project import RunPaths
+
+__version__ = "0.2.1"
+
+__all__ = [
+    "DialogueLineRecord",
+    "ManifestStore",
+    "RunPaths",
+    "ShotRecord",
+    "VoiceInput",
+    "__version__",
+]

unrender/__main__.py

@@ -0,0 +1,4 @@
+from unrender.cli import main
+
+if __name__ == "__main__":
+    raise SystemExit(main())

unrender/adapters/__init__.py

@@ -0,0 +1,33 @@
+from __future__ import annotations
+
+from unrender.adapters.artifacts import export_artifacts_to_paths
+from unrender.adapters.paths import (
+    ArtifactExportPaths,
+    ExternalProject,
+    ExternalShotPaths,
+    project_from_mapping,
+    write_project_config,
+)
+from unrender.adapters.rows import DEFAULT_ROW_ALIASES, rows_to_shots, smpte_to_seconds
+from unrender.adapters.stems import (
+    StemDestination,
+    StemDestinationPolicy,
+    media_dir_destination_policy,
+    plan_voice_promotions,
+)
+
+__all__ = [
+    "DEFAULT_ROW_ALIASES",
+    "ArtifactExportPaths",
+    "ExternalProject",
+    "ExternalShotPaths",
+    "StemDestination",
+    "StemDestinationPolicy",
+    "export_artifacts_to_paths",
+    "media_dir_destination_policy",
+    "plan_voice_promotions",
+    "project_from_mapping",
+    "rows_to_shots",
+    "smpte_to_seconds",
+    "write_project_config",
+]

unrender/adapters/artifacts.py

@@ -0,0 +1,32 @@
+from __future__ import annotations
+
+import shutil
+import tempfile
+from pathlib import Path
+
+from unrender.adapters.paths import ArtifactExportPaths
+from unrender.exports import export_artifacts
+from unrender.project import RunPaths
+
+
+def export_artifacts_to_paths(
+    run: RunPaths,
+    paths: ArtifactExportPaths,
+    *,
+    project_name: str = "unrender",
+) -> ArtifactExportPaths:
+    del project_name
+    with tempfile.TemporaryDirectory(prefix="unrender-exports-") as temp_dir:
+        export_dir = export_artifacts(run, Path(temp_dir))
+        copies = {
+            "face_speaker_detection.json": paths.face_speaker_detection,
+            "voice_speaker_detection.json": paths.voice_speaker_detection,
+            "speaker_resolution_plan.json": paths.speaker_resolution_plan,
+            "shot_stem_plan.json": paths.shot_stem_plan,
+        }
+        for name, destination in copies.items():
+            source = export_dir / name
+            destination.parent.mkdir(parents=True, exist_ok=True)
+            if source.exists():
+                shutil.copy2(source, destination)
+    return paths

unrender/adapters/paths.py

@@ -0,0 +1,105 @@
+from __future__ import annotations
+
+from collections.abc import Mapping, Sequence
+from dataclasses import dataclass
+from pathlib import Path
+from typing import Any
+
+from unrender.manifests import write_json
+
+
+@dataclass(frozen=True)
+class ExternalProject:
+    name: str
+    root_dir: Path
+    data_dir: Path
+    run_dir: Path
+    fps: float
+    speakers_config: Mapping[str, Any] | Sequence[str] | None = None
+    stem_map: Mapping[str, str] | None = None
+
+
+@dataclass(frozen=True)
+class ExternalShotPaths:
+    shot_id: str
+    shot_dir: Path
+    media_dir: Path
+    video_path: Path | None = None
+    target_face_box: tuple[int, int, int, int] | None = None
+
+
+@dataclass(frozen=True)
+class ArtifactExportPaths:
+    face_speaker_detection: Path
+    voice_speaker_detection: Path
+    speaker_resolution_plan: Path
+    shot_stem_plan: Path
+
+
+def project_from_mapping(
+    config: Mapping[str, Any],
+    *,
+    name: str | None = None,
+    root_key: str = "root_dir",
+    root_dir: Path | None = None,
+    data_dir: Path | None = None,
+    run_dir: Path | None = None,
+    fps: float | None = None,
+    speakers_config: Mapping[str, Any] | Sequence[str] | None = None,
+    stem_map: Mapping[str, str] | None = None,
+) -> ExternalProject:
+    root = root_dir or _path_value(config, root_key) or Path.cwd()
+    resolved_name = name or str(config.get("name") or config.get("project") or root.name)
+    resolved_data = data_dir or _path_value(config, "data_dir") or root / "_data"
+    resolved_run = run_dir or _path_value(config, "run_dir") or resolved_data / "unrender"
+    resolved_fps = fps if fps is not None else float(config.get("fps") or 24.0)
+    return ExternalProject(
+        name=resolved_name,
+        root_dir=root.expanduser(),
+        data_dir=resolved_data.expanduser(),
+        run_dir=resolved_run.expanduser(),
+        fps=resolved_fps,
+        speakers_config=speakers_config if speakers_config is not None else config.get("speakers"),
+        stem_map=stem_map if stem_map is not None else _string_mapping(config.get("stem_map")),
+    )
+
+
+def write_project_config(
+    project: ExternalProject,
+    *,
+    shots_path: Path,
+    config_path: Path | None = None,
+    extra_paths: Mapping[str, str] | None = None,
+) -> Path:
+    out_path = config_path or project.data_dir / f"{project.name}.json"
+    payload: dict[str, Any] = {
+        "speakers": project.speakers_config or {},
+        "paths": {
+            "run_dir": str(project.run_dir),
+            "shots": str(shots_path),
+            **dict(extra_paths or {}),
+        },
+    }
+    if project.stem_map:
+        payload["stem_map"] = dict(project.stem_map)
+    write_json(out_path, payload)
+    return out_path
+
+
+def media_dir_destination_policy(*args: Any, **kwargs: Any):
+    from unrender.adapters.stems import media_dir_destination_policy as _policy
+
+    return _policy(*args, **kwargs)
+
+
+def _path_value(config: Mapping[str, Any], key: str) -> Path | None:
+    value = config.get(key)
+    if value in (None, ""):
+        return None
+    return Path(str(value))
+
+
+def _string_mapping(value: Any) -> dict[str, str] | None:
+    if not isinstance(value, Mapping):
+        return None
+    return {str(key): str(path) for key, path in value.items() if path not in (None, "")}

unrender/adapters/rows.py

@@ -0,0 +1,96 @@
+from __future__ import annotations
+
+from collections.abc import Callable, Mapping, Sequence
+from pathlib import Path
+from typing import Any
+
+from unrender.adapters.paths import ExternalShotPaths
+from unrender.manifests import ShotRecord
+from unrender.media.timecode import smpte_to_seconds
+
+__all__ = ["DEFAULT_ROW_ALIASES", "rows_to_shots", "smpte_to_seconds"]
+
+DEFAULT_ROW_ALIASES: dict[str, tuple[str, ...]] = {
+    "shot_id": ("shot_id", "id", "number", "Shot ID"),
+    "start_sec": ("start_sec", "start_seconds"),
+    "end_sec": ("end_sec", "end_seconds"),
+    "start_tc": ("start_tc", "start", "start_timecode"),
+    "end_tc": ("end_tc", "end", "end_timecode"),
+    "speaker": ("speaker", "on_screen_speaker", "character"),
+    "video_path": ("video_path", "path", "file_path"),
+}
+
+
+def rows_to_shots(
+    rows: Sequence[Mapping[str, Any]],
+    *,
+    fps: float,
+    resolve_shot_paths: Callable[[Mapping[str, Any]], ExternalShotPaths | None],
+    aliases: Mapping[str, Sequence[str]] | None = None,
+    parse_timecode: Callable[[str, float], float | None] | None = None,
+) -> list[ShotRecord]:
+    merged_aliases = _merged_aliases(aliases)
+    parser = parse_timecode or smpte_to_seconds
+    shots: list[ShotRecord] = []
+    for row in rows:
+        shot_id = str(_value(row, merged_aliases["shot_id"]) or "").strip()
+        if not shot_id:
+            continue
+        paths = resolve_shot_paths(row)
+        if paths is None:
+            continue
+        start_sec = _seconds(row, merged_aliases, "start", fps=fps, parse_timecode=parser)
+        end_sec = _seconds(row, merged_aliases, "end", fps=fps, parse_timecode=parser)
+        video_path = paths.video_path or _path_from_row(row, merged_aliases["video_path"])
+        shots.append(
+            ShotRecord(
+                shot_id=shot_id,
+                video_path=video_path or paths.shot_dir,
+                existing_speaker=str(_value(row, merged_aliases["speaker"]) or "").strip(),
+                start_sec=start_sec,
+                end_sec=end_sec,
+                target_face_box=paths.target_face_box,
+            )
+        )
+    return shots
+
+
+def _seconds(
+    row: Mapping[str, Any],
+    aliases: Mapping[str, Sequence[str]],
+    prefix: str,
+    *,
+    fps: float,
+    parse_timecode: Callable[[str, float], float | None],
+) -> float | None:
+    seconds_value = _value(row, aliases[f"{prefix}_sec"])
+    if seconds_value not in (None, ""):
+        return float(seconds_value)
+    tc_value = _value(row, aliases[f"{prefix}_tc"])
+    if tc_value in (None, ""):
+        return None
+    return parse_timecode(str(tc_value), fps)
+
+
+def _path_from_row(row: Mapping[str, Any], aliases: Sequence[str]) -> Path | None:
+    value = _value(row, aliases)
+    if value in (None, ""):
+        return None
+    return Path(str(value)).expanduser()
+
+
+def _value(row: Mapping[str, Any], aliases: Sequence[str]) -> Any:
+    for key in aliases:
+        if key in row and row[key] not in (None, ""):
+            return row[key]
+    return None
+
+
+def _merged_aliases(
+    aliases: Mapping[str, Sequence[str]] | None,
+) -> dict[str, tuple[str, ...]]:
+    out = dict(DEFAULT_ROW_ALIASES)
+    for key, values in (aliases or {}).items():
+        defaults = out.get(key, ())
+        out[key] = tuple(dict.fromkeys((*values, *defaults)))
+    return out

unrender/adapters/stems.py

@@ -0,0 +1,143 @@
+from __future__ import annotations
+
+from collections.abc import Callable, Mapping, Sequence
+from dataclasses import dataclass
+from pathlib import Path
+from typing import Any
+
+from unrender.adapters.paths import ExternalShotPaths
+from unrender.manifests import ShotRecord, VoiceInput
+from unrender.media.names import safe_name
+from unrender.speakers import canonical_speaker_name, speaker_key
+
+
+@dataclass(frozen=True)
+class StemDestination:
+    path: Path
+    external_value: str | None = None
+
+
+StemDestinationPolicy = Callable[[ShotRecord, str, Mapping[str, Any]], StemDestination]
+
+
+def media_dir_destination_policy(
+    shot_paths_by_id: Mapping[str, ExternalShotPaths],
+    *,
+    filename_template: str = "{shot_dir_name}_{speaker_key}_stem.wav",
+) -> StemDestinationPolicy:
+    def destination(shot: ShotRecord, speaker: str, mapping: Mapping[str, Any]) -> StemDestination:
+        paths = shot_paths_by_id[shot.shot_id]
+        speaker_id = speaker_key(speaker) or safe_name(speaker, fallback="speaker")
+        filename = filename_template.format(
+            shot_id=shot.shot_id,
+            shot_dir_name=paths.shot_dir.name,
+            speaker=canonical_speaker_name(speaker),
+            speaker_key=speaker_id,
+            source_group=str(mapping.get("source_group") or ""),
+            line_id=str(mapping.get("line_id") or ""),
+        )
+        path = paths.media_dir / filename
+        return StemDestination(path=path, external_value=str(path))
+
+    return destination
+
+
+def plan_voice_promotions(
+    *,
+    rows: Sequence[Mapping[str, Any]],
+    clips: Sequence[VoiceInput],
+    shot_paths_by_id: Mapping[str, ExternalShotPaths],
+    speaker_db_path: Path,
+    sim_threshold: float = 0.65,
+    rms_threshold_db: float = -55.0,
+    destination_policy: StemDestinationPolicy,
+    aliases: Mapping[str, Sequence[str]] | None = None,
+) -> list[dict[str, Any]]:
+    del speaker_db_path, sim_threshold, rms_threshold_db
+    shot_aliases: tuple[str, ...] = ("shot_id", "id", "number", "Shot ID")
+    speaker_aliases: tuple[str, ...] = ("speaker", "on_screen_speaker", "character")
+    if aliases:
+        shot_aliases = tuple(aliases.get("shot_id", shot_aliases))
+        speaker_aliases = tuple(aliases.get("speaker", speaker_aliases))
+    clips_by_shot: dict[str, list[VoiceInput]] = {}
+    for clip in clips:
+        clips_by_shot.setdefault(clip.shot_id, []).append(clip)
+
+    plan: list[dict[str, Any]] = []
+    for row in rows:
+        shot_id = str(_first(row, shot_aliases) or "").strip()
+        speaker = canonical_speaker_name(str(_first(row, speaker_aliases) or ""))
+        if not shot_id or not speaker:
+            continue
+        shot_paths = shot_paths_by_id.get(shot_id)
+        candidates = clips_by_shot.get(shot_id, [])
+        if shot_paths is None:
+            plan.append(_promotion_row(shot_id, speaker, "", "", 0.0, "missing_shot_paths"))
+            continue
+        if len(candidates) != 1:
+            plan.append(
+                _promotion_row(
+                    shot_id,
+                    speaker,
+                    "",
+                    "",
+                    0.0,
+                    "needs_review" if candidates else "no_candidate",
+                    candidate_count=len(candidates),
+                )
+            )
+            continue
+        clip = candidates[0]
+        shot = ShotRecord(
+            shot_id=shot_id,
+            video_path=shot_paths.video_path or shot_paths.shot_dir,
+            existing_speaker=speaker,
+        )
+        destination = destination_policy(
+            shot,
+            speaker,
+            {"source_group": clip.source_group, "clip_id": clip.clip_id},
+        )
+        plan.append(
+            _promotion_row(
+                shot_id,
+                speaker,
+                str(clip.path),
+                str(destination.path),
+                1.0,
+                "accepted",
+                reason="single speaker with one voiced candidate",
+                candidate_count=1,
+            )
+        )
+    return plan
+
+
+def _first(row: Mapping[str, Any], aliases: Sequence[str]) -> Any:
+    for key in aliases:
+        if row.get(key) not in (None, ""):
+            return row[key]
+    return None
+
+
+def _promotion_row(
+    shot_id: str,
+    speaker: str,
+    source_path: str,
+    target_path: str,
+    score: float,
+    status: str,
+    *,
+    reason: str = "",
+    candidate_count: int = 0,
+) -> dict[str, Any]:
+    return {
+        "shot_id": shot_id,
+        "speaker": speaker,
+        "source_path": source_path,
+        "target_path": target_path,
+        "score": score,
+        "status": status,
+        "reason": reason,
+        "candidate_count": candidate_count,
+    }

unrender/cli/__init__.py

@@ -0,0 +1,5 @@
+from __future__ import annotations
+
+from unrender.cli.main import main
+
+__all__ = ["main"]

unrender/cli/commands/__init__.py

@@ -0,0 +1,39 @@
+from __future__ import annotations
+
+from unrender.cli.commands.audio import (
+    _audio_build_clips,
+    _audio_map_dialogue,
+    _audio_resolve_clips,
+    _audio_separate,
+    _audio_shot_dx,
+    _audio_transcribe_lines,
+)
+from unrender.cli.commands.context import _projects_from_args
+from unrender.cli.commands.export import _export_artifacts
+from unrender.cli.commands.face import _face_build, _shots_match
+from unrender.cli.commands.health import _doctor, _status
+from unrender.cli.commands.labels import _labels_apply, _labels_interactive, _labels_template
+from unrender.cli.commands.timeline import _timeline_build
+from unrender.cli.commands.voice import _voice_build, _voice_clone, _voice_match
+
+__all__ = [
+    "_audio_build_clips",
+    "_audio_map_dialogue",
+    "_audio_resolve_clips",
+    "_audio_separate",
+    "_audio_shot_dx",
+    "_audio_transcribe_lines",
+    "_doctor",
+    "_export_artifacts",
+    "_face_build",
+    "_labels_apply",
+    "_labels_interactive",
+    "_labels_template",
+    "_projects_from_args",
+    "_shots_match",
+    "_status",
+    "_timeline_build",
+    "_voice_build",
+    "_voice_clone",
+    "_voice_match",
+]