Legend of Valor: Act I rendered, notebook viewer + LTX-2 load fixes

film/legend-of-valor/README.md

@@ -0,0 +1,45 @@
+# Legend of Valor
+
+A 107.6-second vertical short film — 576 x 1024 at 24 fps, 5 acts, 15 shots, 40 denoising steps each —
+rendered with `LTX2ConditionPipeline` from [Lightricks/LTX-2](https://huggingface.co/Lightricks/LTX-2).
+
+## The story
+
+Assembled from *Arena of Valor*'s documented lore (TiMi Studio Group / Level Infinite), not invented:
+
+- **Volkath, The Black Apostate** — *"Light is fleeting, Darkness is forever."* Lord of **Lokheim** and the
+  demons. His recorded story opens on **Mt. Orphean**: a golden-haired boy with crimson eyes asks his teacher
+  *"What is the meaning of life without freedom?"* and is told, *"True freedom is not to do whatever you want;
+  it is to be able to refuse what you do not want to do."*
+- **Ilumia, The Seer** — Goddess of Light in **Veda**, succeeding **Edras**, the Holy Light Master. Also born
+  on Mt. Orphean. The Temple was founded on belief in her.
+- **Antaris Battlefield**, its lanes named for the **Dark Slayer** and the **Abyssal Dragon**; **Horizon
+  Valley**, where the Dark Slayer holds the **Drake Mondester** sealed inside its body.
+
+The spine is canon: the light and the dark came from the same mountain.
+
+| Act | Shots | Files |
+|---|---|---|
+| I — The Peak | 3 | `p1-s1` .. `p1-s3` |
+| II — The Schism | 3 | `p2-s1` .. `p2-s3` |
+| III — Lokheim Marches | 4 | `p3-s1` .. `p3-s4` |
+| IV — The Beasts | 2 | `p4-s1`, `p4-s2` |
+| V — The Crystal | 3 | `p5-s1` .. `p5-s3` |
+
+## Files
+
+- `film.json` — the shot list this film was rendered from (full prompts, seeds, durations).
+- `make_film.py` — the renderer. Chains each shot on the previous shot's last frame *within* an act, so motion
+  is continuous; dissolves shots together; writes a sidecar per shot.
+- `notebook.py` — the marimo notebook that drives it.
+
+## Rendering notes
+
+Each shot is conditioned on the last frame of the shot before it, which keeps motion continuous inside an act
+— but faces drift *between* acts. Locking a character's look needs one still per character used as the opening
+condition of every shot they appear in.
+
+## Licence
+
+Volkath, Ilumia, Edras, Maloch and the rest are Tencent / TiMi Studio Group characters, and the LTX-2 weights
+carry Lightricks' own licence. Personal use is one thing; publishing at reach is another.

logs/legend-of-valor-film.log

@@ -1,3 +1,11 @@
 18:00:30 film 'legend-of-valor': 5 pieces, 15 shots, 108s total
 18:00:30 skip p1s1 (already rendered)
 18:00:32 p1s2: 32.0 GB free on the GPU
+18:06:48 backed up p1-s2.mp4 -> dragonlimited/LTX2-marimo
+18:06:49 backed up p1-s2.json -> dragonlimited/LTX2-marimo
+18:06:49 rendered p1s2 (193 frames) in 379s total
+18:06:51 p1s3: 32.0 GB free on the GPU
+18:11:28 backed up p1-s3.mp4 -> dragonlimited/LTX2-marimo
+18:11:29 backed up p1-s3.json -> dragonlimited/LTX2-marimo
+18:11:29 rendered p1s3 (145 frames) in 659s total
+18:11:31 p2s1: 32.0 GB free on the GPU

notebook.py

@@ -1194,6 +1194,106 @@ def film_render(film_spec, make_film, pipe, render_film):
     return
 
 
+@app.cell
+def refresh(mo):
+    # A timer so the viewer below stays current while a film renders. It sits in its own cell because marimo
+    # will not let a cell read a widget it created — the same reason the film button is split across two cells.
+    refresh_timer = mo.ui.refresh(
+        options=["10s", "30s", "1m", "5m"],
+        default_interval="30s",
+        label="Auto-refresh",
+    )
+    refresh_timer
+
+    return (refresh_timer,)
+
+
+@app.cell
+def watch(OUTPUT_DIR, film_spec, mo, refresh_timer):
+    # The one place to watch everything this notebook generates.
+    #
+    # Section 4 shows the single-shot render and section 5 the *finished* films (`outputs/*.mp4`). The takes of a
+    # film being rendered live in `outputs/film/<title>/`, and nothing surfaced those — so a render could run for
+    # an hour while the notebook looked empty. This cell is that viewer.
+    #
+    # It reads `refresh_timer`, so it re-runs on the timer and new takes appear on their own.
+    _refreshed_at = refresh_timer.value
+
+    _film_dir = OUTPUT_DIR / "film" / film_spec["title"] if film_spec else None
+    _takes = sorted(_film_dir.glob("p*-s*.mp4")) if _film_dir and _film_dir.is_dir() else []
+    _films = sorted(OUTPUT_DIR.glob("*.mp4"), key=lambda _p: _p.stat().st_mtime, reverse=True)
+
+    _planned = (
+        [
+            (f"p{_p}-s{_s}", _piece.get("name", f"piece-{_p}"), _shot["seconds"])
+            for _p, _piece in enumerate(film_spec["pieces"], 1)
+            for _s, _shot in enumerate(_piece["shots"], 1)
+        ]
+        if film_spec
+        else []
+    )
+    _done = {_take.stem for _take in _takes}
+
+
+    def _player(_path, _caption):
+        """A generated video with its own download button."""
+        return mo.vstack(
+            [
+                mo.video(_path, width=200, muted=True),
+                mo.md(_caption),
+                mo.download(
+                    lambda _p=_path: _p.read_bytes(),
+                    filename=_path.name,
+                    mimetype="video/mp4",
+                    label="⬇ .mp4",
+                ),
+            ]
+        )
+
+
+    _blocks = [mo.md(f"## Watch — refreshed {_refreshed_at}")]
+
+    if _films:
+        _blocks.append(mo.md(f"### Finished films — {len(_films)} in `outputs/`"))
+        _blocks.append(
+            mo.hstack(
+                [_player(_f, f"**`{_f.name}`** — {_f.stat().st_size / 1e6:.1f} MB") for _f in _films[:6]],
+                wrap=True,
+                align="start",
+            )
+        )
+
+    if not film_spec:
+        _blocks.append(mo.md("_No `film.json`, so no film is planned._"))
+    else:
+        _blocks.append(mo.md(f"### Film takes — **{len(_done)} of {len(_planned)}** rendered"))
+        _blocks.append(
+            mo.hstack(
+                [
+                    _player(_take, f"**`{_take.stem}`** — {_seconds:g}s · {_take.stat().st_size / 1e6:.2f} MB")
+                    for _take in _takes
+                    for _name, _act, _seconds in _planned
+                    if _name == _take.stem
+                ],
+                wrap=True,
+                align="start",
+            )
+            if _takes
+            else mo.md("_Nothing rendered yet._")
+        )
+        _pending = [f"`{_n}` — {_a} ({_s:g}s)" for _n, _a, _s in _planned if _n not in _done]
+        _blocks.append(
+            mo.accordion({"Still to render": mo.md("\n\n".join(f"- {_item}" for _item in _pending))})
+            if _pending
+            else mo.md("_**All shots rendered.** The joined film lands in `outputs/` once assembly runs._")
+        )
+
+    video_viewer = mo.vstack(_blocks)
+    video_viewer
+
+    return
+
+
 @app.cell
 def tips(mo):
     mo.md("""