wizz-method 2.21.0 → 2.23.0

package/src/skills-lib/wizz-video-effects/scripts/check_one_take.py

@@ -0,0 +1,159 @@
+# -*- coding: utf-8 -*-
+"""ONE-TAKE gate: no passage is only a change of scene.
+
+For a piece meant as one continuous shot (a camera that flies from one beat
+into the next, an element that becomes the next screen). Two checks:
+
+    CARRY (blocks, timeline). Every scene after the first declares in
+        `carry` what on screen survives the passage and becomes the next beat
+        ("the price chip grows into the checkout card"). A scene without it,
+        or whose `transition` is a plain `cut`, is a swap, not a passage.
+    CUTS (blocks, final MP4). On a small luma copy of every frame
+        (one_take.analysis_width x one_take.analysis_height), a frame whose
+        mean absolute difference to the previous one is above
+        one_take.cut_min_diff AND one_take.cut_ratio times the median of its
+        neighbours (one_take.neighbour_frames on each side) is a hard cut. A
+        whip or a fast push changes many frames in a row, so it is not an
+        isolated spike; a cut is one.
+
+What it cannot see:
+    - A dissolve between two unrelated scenes has no spike: it passes CUTS.
+      Only the `carry` line and the eye catch it.
+    - Whether the declared carry is really on screen. Extract the frames
+      around each passage and look.
+    - A cut hidden under a flash or a whip blur spreads its change over
+      several frames and passes.
+
+Exit code: 0 pass, 1 fail, 2 file or config unreadable.
+"""
+from __future__ import annotations
+
+import argparse
+import os
+import statistics
+import subprocess
+import sys
+from dataclasses import dataclass
+from typing import Iterable
+
+from check_dead_frames import mean_abs_diff
+from check_safe_zone import ReadError, all_frames, video_fps
+from config import Config, ConfigError, add_config_arg, load, optional_block
+from timeline import TimelineError, load as load_timeline
+
+BLOCK = "one_take"
+
+
+@dataclass(frozen=True)
+class OneTakeRules:
+    width: int
+    height: int
+    cut_min_diff: float
+    cut_ratio: float
+    neighbour_frames: int
+
+
+def rules(cfg: Config) -> tuple[OneTakeRules, bool]:
+    """(rules, from_template). Refuses an incoherent block."""
+    b, from_template = optional_block(cfg, BLOCK)
+    try:
+        r = OneTakeRules(
+            width=int(b["analysis_width"]), height=int(b["analysis_height"]),
+            cut_min_diff=float(b["cut_min_diff"]), cut_ratio=float(b["cut_ratio"]),
+            neighbour_frames=int(b["neighbour_frames"]))
+    except (KeyError, TypeError, ValueError) as e:
+        raise ConfigError(f"{BLOCK}: missing or invalid key ({e})") from e
+    if r.width <= 0 or r.height <= 0:
+        raise ConfigError(f"{BLOCK}.analysis_width and analysis_height must be > 0")
+    if r.cut_min_diff <= 0 or r.cut_ratio <= 1:
+        raise ConfigError(f"{BLOCK}.cut_min_diff must be > 0 and cut_ratio > 1")
+    if r.neighbour_frames < 1:
+        raise ConfigError(f"{BLOCK}.neighbour_frames must be >= 1")
+    return r, from_template
+
+
+def missing_carry(scenes) -> list[tuple[int, float, str]]:
+    """(index, start, reason) of every scene after the first that is a swap."""
+    out = []
+    for i, sc in enumerate(scenes or []):
+        if i == 0:
+            continue
+        start = float(sc.get("start", 0.0))
+        if not str(sc.get("carry") or "").strip():
+            out.append((i, start, "no `carry`"))
+        elif sc.get("transition") == "cut":
+            out.append((i, start, "`transition` is a plain cut"))
+    return out
+
+
+def diffs(frames: Iterable[bytes]) -> list[float]:
+    """diffs[i] = change from frame i to frame i + 1."""
+    out, prev = [], None
+    for fr in frames:
+        if prev is not None:
+            out.append(mean_abs_diff(fr, prev))
+        prev = fr
+    return out
+
+
+def cut_frames(d: list[float], r: OneTakeRules) -> list[int]:
+    """Frame index (the first frame after the jump) of every isolated spike."""
+    out = []
+    k = r.neighbour_frames
+    for i, v in enumerate(d):
+        if v <= r.cut_min_diff:
+            continue
+        around = d[max(0, i - k):i] + d[i + 1:i + 1 + k]
+        base = statistics.median(around) if around else 0.0
+        if v > r.cut_ratio * base:
+            out.append(i + 1)
+    return out
+
+
+def report(name: str, cuts: list[int], fps: float, swaps, r: OneTakeRules,
+           from_template: bool) -> int:
+    print(f"{name}: one-take gate")
+    if from_template:
+        print(f"  note: no '{BLOCK}' block in the project config; using the template's")
+    if swaps is None:
+        print("  note: no --timeline; the `carry` of each passage was not checked")
+    elif swaps:
+        print(f"  SWAP: {len(swaps)} passage(s) with nothing carried into the next beat:")
+        for i, start, why in swaps[:10]:
+            print(f"     scene {i} at {start:6.2f}s: {why}")
+    else:
+        print("  ok: every passage declares what it carries")
+    if cuts:
+        print(f"  CUT: {len(cuts)} hard cut(s) (frame change above one_take.cut_min_diff="
+              f"{r.cut_min_diff} and {r.cut_ratio}x its neighbours):")
+        for f in cuts[:10]:
+            print(f"     {f / fps:6.2f}s (frame {f})")
+    else:
+        print("  ok: no hard cut in the file")
+    return 1 if cuts or swaps else 0
+
+
+def main(argv: list[str] | None = None) -> int:
+    ap = argparse.ArgumentParser(description="One-take gate: every passage carries something (timeline) and the final MP4 has no hard cut.")
+    add_config_arg(ap)
+    ap.add_argument("video", help="final MP4")
+    ap.add_argument("--timeline", help="timeline JSON; checks the `carry` of every scene")
+    args = ap.parse_args(argv)
+    try:
+        cfg = load(args.config)
+        r, from_template = rules(cfg)
+        swaps = missing_carry(load_timeline(args.timeline).get("scenes")) if args.timeline else None
+        if not os.path.exists(args.video):
+            raise ReadError(f"video not found: {args.video}")
+        d = diffs(f for _, f in all_frames(args.video, r.width, r.height))
+        if not d:
+            raise ReadError("fewer than two frames decoded")
+        return report(os.path.basename(args.video), cut_frames(d, r), video_fps(args.video),
+                      swaps, r, from_template)
+    except (ConfigError, ReadError, TimelineError, subprocess.SubprocessError, OSError) as e:
+        print(f"ERROR: {e}")
+        return 2
+
+
+if __name__ == "__main__":
+    sys.exit(main())

package/src/skills-lib/wizz-video-effects/scripts/config.py

@@ -540,6 +540,19 @@ def validate(c: Config) -> None:
     _validate_audio_blocks(c)
 
 
+def optional_block(c: Config, key: str) -> tuple[dict, bool]:
+    """(block, from_template) for a block added after projects already had a
+    config. A project config without it uses the TEMPLATE's block, so the
+    number still lives in one file; the caller says so in its report."""
+    own = _read_json(c.source).get(key)
+    if isinstance(own, dict):
+        return _notes_out(own), False
+    tpl = _read_json(TEMPLATE).get(key)
+    if not isinstance(tpl, dict):
+        raise ConfigError(f"block {key!r} is missing from the config and from the template")
+    return _notes_out(tpl), True
+
+
 # -------------------------------------------------------------------- CLI glue
 
 

package/src/skills-lib/wizz-video-effects/scripts/test_chrome.py

@@ -0,0 +1,181 @@
+# -*- coding: utf-8 -*-
+"""Tests of check_chrome.py: the page-chrome / slide-look rules on a layout
+snapshot (DOM of a HyperFrames composition) and on the text layers of a
+Remotion timeline."""
+import io
+import json
+import tempfile
+import unittest
+from contextlib import redirect_stdout
+from pathlib import Path
+
+import check_chrome as CC
+from config import TEMPLATE, load
+
+CFG = load(TEMPLATE)
+RULES = CC.rules(CFG)[0]
+W, H = 1080, 1920
+
+
+def block(text, x0, y0, x1, y1, font=60, **kw):
+    return {"text": text, "box": [x0 * W, y0 * H, x1 * W, y1 * H], "font_px": font, **kw}
+
+
+def snap(*blocks, shapes=(), t=1.0):
+    return {"width": W, "height": H, "samples": [{"t": t, "blocks": list(blocks), "shapes": list(shapes)}]}
+
+
+def lint(data, allow=()):
+    samples = CC.samples_from_snapshot(data)
+    return CC.lint(samples, RULES, set(allow))
+
+
+def rules_hit(rep):
+    return {h["rule"] for h in rep["hits"]}
+
+
+class TestPageChrome(unittest.TestCase):
+    def test_clean_reel_passes(self):
+        rep = lint(snap(block("O erro que custa caro", 0.1, 0.40, 0.9, 0.48, font=96, align="center"),
+                        block("custa", 0.35, 0.70, 0.65, 0.74, font=72, role="caption")))
+        self.assertTrue(rep["passed"], rep["hits"])
+
+    def test_corner_brand_label_fails(self):
+        rep = lint(snap(block("WIZZ", 0.05, 0.03, 0.15, 0.05, font=30)))
+        self.assertIn("C1", rules_hit(rep))
+        self.assertFalse(rep["passed"])
+
+    def test_tracked_caps_label_fails(self):
+        rep = lint(snap(block("NOVO MÉTODO", 0.3, 0.30, 0.7, 0.32, font=36, caps=True, tracking_em=0.2)))
+        self.assertIn("C2", rules_hit(rep))
+
+    def test_counter_fails(self):
+        for text in ("02 / 05", "01 - THE WAIT", "Parte 3", "Step 2"):
+            with self.subTest(text=text):
+                rep = lint(snap(block(text, 0.4, 0.5, 0.6, 0.52, font=40)))
+                self.assertIn("C3", rules_hit(rep))
+
+    def test_twenty_four_seven_is_not_a_counter(self):
+        rep = lint(snap(block("24/7 suporte", 0.4, 0.5, 0.6, 0.52, font=40)))
+        self.assertNotIn("C3", rules_hit(rep))
+
+    def test_timecode_and_metadata_fail(self):
+        for text in ("00:00:12", "30 FPS", "1080x1920", "REC"):
+            with self.subTest(text=text):
+                rep = lint(snap(block(text, 0.4, 0.5, 0.6, 0.52, font=40)))
+                self.assertIn("C4", rules_hit(rep))
+
+    def test_progress_bar_growing_fails(self):
+        data = {"width": W, "height": H, "samples": [
+            {"t": t, "blocks": [], "shapes": [{"id": "bar", "kind": "bar", "box": [0, 10, w * W, 18]}]}
+            for t, w in ((1.0, 0.1), (2.0, 0.3), (3.0, 0.5))]}
+        rep = lint(data)
+        self.assertIn("P1", rules_hit(rep))
+
+    def test_header_bar_fails(self):
+        rep = lint(snap(shapes=[{"kind": "bar", "box": [0, 0, W, 0.06 * H], "filled": True}]))
+        self.assertIn("C6", rules_hit(rep))
+
+    def test_full_frame_background_is_not_a_bar(self):
+        rep = lint(snap(shapes=[{"kind": "bar", "box": [0, 0, W, H], "filled": True}]))
+        self.assertNotIn("C6", rules_hit(rep))
+
+    def test_kicker_over_headline_fails(self):
+        rep = lint(snap(block("o segredo", 0.1, 0.38, 0.4, 0.40, font=30),
+                        block("Pare de perder dinheiro", 0.1, 0.41, 0.9, 0.47, font=90)))
+        self.assertIn("C7", rules_hit(rep))
+
+    def test_left_headline_beside_right_media_fails(self):
+        rep = lint(snap(block("Seu app", 0.05, 0.40, 0.45, 0.46, font=90, align="left"),
+                        shapes=[{"kind": "media", "box": [0.55 * W, 0.30 * H, 0.95 * W, 0.70 * H]}]))
+        hits = [h for h in rep["hits"] if h["rule"] == "D1"]
+        self.assertTrue(hits)
+        self.assertEqual(hits[0]["sev"], "FAIL")
+
+    def test_left_headline_alone_only_warns(self):
+        rep = lint(snap(block("Seu app", 0.05, 0.40, 0.45, 0.46, font=90, align="left")))
+        hits = [h for h in rep["hits"] if h["rule"] == "D1"]
+        self.assertEqual([h["sev"] for h in hits], ["WARN"])
+        self.assertTrue(rep["passed"])
+
+
+class TestExemptions(unittest.TestCase):
+    def test_caption_and_legal_roles_are_not_chrome(self):
+        rep = lint(snap(block("PARTE 2", 0.4, 0.5, 0.6, 0.52, font=40, role="caption"),
+                        block("Resultados variam. CNPJ 00.000", 0.05, 0.95, 0.6, 0.97, font=24, role="legal")))
+        self.assertTrue(rep["passed"], rep["hits"])
+
+    def test_allow_list_from_a_measured_style(self):
+        data = {"width": W, "height": H, "samples": [
+            {"t": t, "blocks": [], "shapes": [{"id": "bar", "kind": "bar", "box": [0, 10, w * W, 18]}]}
+            for t, w in ((1.0, 0.1), (2.0, 0.3), (3.0, 0.5))]}
+        rep = lint(data, allow={"P1"})
+        self.assertTrue(rep["passed"])
+        self.assertEqual(rep["allowed"], ["P1"])
+
+    def test_text_in_flight_is_not_a_held_label(self):
+        # Same label at a different place 0.1 s later: it is moving through
+        # the corner, not parked there.
+        data = {"width": W, "height": H, "samples": [
+            {"t": 1.0, "blocks": [block("WIZZ", 0.05, 0.03, 0.15, 0.05, font=30)], "shapes": []},
+            {"t": 1.1, "blocks": [block("WIZZ", 0.25, 0.20, 0.35, 0.22, font=30)], "shapes": []}]}
+        self.assertNotIn("C1", rules_hit(lint(data)))
+
+
+class TestTimeline(unittest.TestCase):
+    def test_remotion_text_layers_are_linted(self):
+        tl = {"duration": 10.0, "elements": [
+            {"at": 0.0, "until": 10.0, "kind": "text", "text": "02/05",
+             "box": [900, 40, 1040, 80], "font_px": 32},
+            {"at": 0.6, "kind": "text"}]}   # an element without text is skipped
+        samples = CC.samples_from_timeline(tl, CFG.frame.width, CFG.frame.height, RULES)
+        rep = CC.lint(samples, RULES, set())
+        self.assertIn("C3", rules_hit(rep))
+        self.assertIn("C1", rules_hit(rep))
+
+    def test_timeline_progress_bar_from_box_end(self):
+        tl = {"duration": 10.0, "elements": [
+            {"at": 0.0, "until": 10.0, "kind": "bar", "box": [0, 1880, 100, 1890],
+             "box_end": [0, 1880, 1080, 1890]}]}
+        samples = CC.samples_from_timeline(tl, W, H, RULES)
+        self.assertIn("P1", rules_hit(CC.lint(samples, RULES, set())))
+
+    def test_flash_label_shorter_than_held_s_is_skipped(self):
+        tl = {"duration": 5.0, "elements": [
+            {"at": 1.0, "until": 1.1, "kind": "text", "text": "WIZZ",
+             "box": [40, 40, 200, 80], "font_px": 30}]}
+        samples = CC.samples_from_timeline(tl, W, H, RULES)
+        self.assertNotIn("C1", rules_hit(CC.lint(samples, RULES, set())))
+
+
+class TestCli(unittest.TestCase):
+    def _run(self, args):
+        buf = io.StringIO()
+        with redirect_stdout(buf):
+            code = CC.main(["--config", str(TEMPLATE), *args])
+        return code, buf.getvalue()
+
+    def test_snapshot_fail_exits_1(self):
+        with tempfile.TemporaryDirectory() as tmp:
+            p = Path(tmp) / "layout.json"
+            p.write_text(json.dumps(snap(block("00:00:12", 0.4, 0.5, 0.6, 0.52, font=40))), encoding="utf-8")
+            code, out = self._run(["--snapshot", str(p)])
+        self.assertEqual(code, 1, out)
+        self.assertIn("C4", out)
+
+    def test_timeline_allow_key_is_read(self):
+        with tempfile.TemporaryDirectory() as tmp:
+            p = Path(tmp) / "t.json"
+            p.write_text(json.dumps({"duration": 5.0, "chrome_allow": ["C3"], "elements": [
+                {"at": 0.0, "until": 5.0, "kind": "text", "text": "Dia 3",
+                 "box": [400, 900, 680, 960], "font_px": 40}]}), encoding="utf-8")
+            code, out = self._run(["--timeline", str(p)])
+        self.assertEqual(code, 0, out)
+
+    def test_missing_input_exits_2(self):
+        code, _ = self._run(["--snapshot", "/nonexistent.json"])
+        self.assertEqual(code, 2)
+
+
+if __name__ == "__main__":
+    unittest.main()

package/src/skills-lib/wizz-video-effects/scripts/test_dead_frames.py

@@ -0,0 +1,171 @@
+# -*- coding: utf-8 -*-
+"""Tests of check_dead_frames.py: flat-field runs (blocks), frozen picture
+(warns), the motion note, and the config fallback to the template. The
+ffmpeg round trip is skipped when ffmpeg is absent."""
+import copy
+import io
+import json
+import random
+import shutil
+import subprocess
+import tempfile
+import unittest
+from contextlib import redirect_stdout
+from pathlib import Path
+
+import check_dead_frames as DF
+from config import TEMPLATE, load
+
+CFG = load(TEMPLATE)
+RULES = DF.rules(CFG)[0]
+W, H = RULES.width, RULES.height
+SIZE = W * H
+
+
+def flat(v: int = 0) -> bytes:
+    return bytes([v]) * SIZE
+
+
+def textured(seed: int, amp: int = 60) -> bytes:
+    rnd = random.Random(seed)
+    return bytes(100 + rnd.randrange(amp) for _ in range(SIZE))
+
+
+def jitter(base: bytes, seed: int, amp: int = 3) -> bytes:
+    """The same picture plus small per-pixel noise: a talking head that
+    barely moves (sensor noise, breathing, compression)."""
+    rnd = random.Random(seed)
+    return bytes(max(0, min(255, b + rnd.randrange(-amp, amp + 1))) for b in base)
+
+
+class TestFrameMeasures(unittest.TestCase):
+    def test_uniform_frame_is_flat(self):
+        self.assertTrue(DF.is_flat(flat(0), RULES))
+        self.assertTrue(DF.is_flat(flat(200), RULES))
+
+    def test_textured_frame_is_not_flat(self):
+        self.assertFalse(DF.is_flat(textured(1), RULES))
+
+    def test_dark_frame_with_one_small_caption_is_not_flat(self):
+        # Range catches it even when std-dev is tiny: that frame belongs to
+        # the density gate, not to this one.
+        f = bytearray(flat(10))
+        f[SIZE // 2:SIZE // 2 + 6] = bytes([250]) * 6
+        self.assertFalse(DF.is_flat(bytes(f), RULES))
+
+    def test_mean_abs_diff(self):
+        self.assertEqual(DF.mean_abs_diff(flat(10), flat(10)), 0.0)
+        self.assertAlmostEqual(DF.mean_abs_diff(flat(10), flat(14)), 4.0)
+
+    def test_runs(self):
+        self.assertEqual(DF.runs([False, True, True, False, True]), [(1, 2), (4, 4)])
+        self.assertEqual(DF.runs([]), [])
+
+
+class TestAnalyze(unittest.TestCase):
+    FPS = 30.0
+
+    def _rep(self, frames):
+        return DF.analyze(frames, self.FPS, RULES)
+
+    def test_short_black_dip_inside_a_transition_passes(self):
+        frames = [textured(i) for i in range(20)] + [flat()] * RULES.flat_max_frames \
+            + [textured(100 + i) for i in range(20)]
+        rep = self._rep(frames)
+        self.assertTrue(rep["passed"], rep)
+        self.assertEqual(rep["flat_fail"], [])
+        self.assertEqual(len(rep["flat_ignored"]), 1)
+
+    def test_black_gap_longer_than_the_limit_fails(self):
+        frames = [textured(i) for i in range(20)] + [flat()] * (RULES.flat_max_frames + 2) \
+            + [textured(100 + i) for i in range(20)]
+        rep = self._rep(frames)
+        self.assertFalse(rep["passed"])
+        (s, e), = rep["flat_fail"]
+        self.assertEqual((s, e), (20, 20 + RULES.flat_max_frames + 1))
+
+    def test_frozen_picture_warns_but_does_not_block(self):
+        still = textured(7)
+        n = int(self.FPS * (RULES.frozen_warn_s + 1.0))
+        frames = [textured(i) for i in range(10)] + [still] * n + [textured(50 + i) for i in range(10)]
+        rep = self._rep(frames)
+        self.assertTrue(rep["passed"])
+        self.assertEqual(len(rep["frozen_warn"]), 1)
+
+    def test_talking_head_micro_motion_is_not_frozen(self):
+        base = textured(3)
+        frames = [jitter(base, i) for i in range(int(self.FPS * 4))]
+        rep = self._rep(frames)
+        self.assertEqual(rep["frozen_warn"], [])
+        self.assertTrue(rep["passed"])
+
+    def test_motion_note_is_reported(self):
+        frames = [textured(i) for i in range(5)]
+        rep = self._rep(frames)
+        self.assertGreater(rep["motion_mean"], 0.0)
+
+    def test_no_frame_is_an_error(self):
+        with self.assertRaises(DF.ReadError):
+            self._rep([])
+
+
+class TestConfigFallback(unittest.TestCase):
+    def test_config_without_block_uses_template(self):
+        raw = json.loads(TEMPLATE.read_text(encoding="utf-8"))
+        raw = {k: v for k, v in copy.deepcopy(raw).items() if k != "dead_frames"}
+        with tempfile.TemporaryDirectory() as tmp:
+            p = Path(tmp) / "effects.config.json"
+            p.write_text(json.dumps(raw), encoding="utf-8")
+            r, from_template = DF.rules(load(p))
+        self.assertTrue(from_template)
+        self.assertEqual(r.flat_max_frames, RULES.flat_max_frames)
+
+    def test_incoherent_block_is_refused(self):
+        raw = json.loads(TEMPLATE.read_text(encoding="utf-8"))
+        raw["dead_frames"]["flat_max_frames"] = -1
+        with tempfile.TemporaryDirectory() as tmp:
+            p = Path(tmp) / "effects.config.json"
+            p.write_text(json.dumps(raw), encoding="utf-8")
+            with self.assertRaises(DF.ConfigError):
+                DF.rules(load(p))
+
+
+class TestCli(unittest.TestCase):
+    def test_missing_video_exits_2(self):
+        buf = io.StringIO()
+        with redirect_stdout(buf):
+            code = DF.main(["--config", str(TEMPLATE), "/nonexistent/final.mp4"])
+        self.assertEqual(code, 2)
+
+
+@unittest.skipUnless(shutil.which("ffmpeg") and shutil.which("ffprobe"), "ffmpeg not installed")
+class TestOnRealFile(unittest.TestCase):
+    def _make(self, tmp: str, black_s: float) -> str:
+        out = str(Path(tmp) / "piece.mp4")
+        src = ("testsrc2=size=270x480:rate=30:duration=1[a];"
+               f"color=black:size=270x480:rate=30:duration={black_s}[b];"
+               "testsrc2=size=270x480:rate=30:duration=1[c];[a][b][c]concat=n=3:v=1:a=0")
+        subprocess.run(["ffmpeg", "-v", "error", "-y", "-filter_complex", src,
+                        "-pix_fmt", "yuv420p", out], check=True)
+        return out
+
+    def _run(self, video: str) -> tuple[int, str]:
+        buf = io.StringIO()
+        with redirect_stdout(buf):
+            code = DF.main(["--config", str(TEMPLATE), video])
+        return code, buf.getvalue()
+
+    def test_half_second_black_gap_fails(self):
+        with tempfile.TemporaryDirectory() as tmp:
+            code, out = self._run(self._make(tmp, 0.5))
+        self.assertEqual(code, 1, out)
+        self.assertIn("FLAT", out)
+
+    def test_one_frame_black_dip_passes(self):
+        with tempfile.TemporaryDirectory() as tmp:
+            code, out = self._run(self._make(tmp, 1 / 30))
+        self.assertEqual(code, 0, out)
+
+
+if __name__ == "__main__":
+    unittest.main()

package/src/skills-lib/wizz-video-effects/scripts/test_one_take.py

@@ -0,0 +1,126 @@
+# -*- coding: utf-8 -*-
+"""Tests of check_one_take.py: the `carry` of every passage (timeline), hard
+cuts as isolated spikes of frame change (a whip is not one), and the config
+fallback to the template. The ffmpeg round trip is skipped when ffmpeg is
+absent."""
+import io
+import json
+import shutil
+import subprocess
+import tempfile
+import unittest
+from contextlib import redirect_stdout
+from pathlib import Path
+
+import check_one_take as OT
+from config import TEMPLATE, load
+
+CFG = load(TEMPLATE)
+RULES = OT.rules(CFG)[0]
+W, H = RULES.width, RULES.height
+SIZE = W * H
+
+
+def gradient(offset: int) -> bytes:
+    """A horizontal ramp shifted by `offset` columns: a camera that pans."""
+    return bytes(((x + offset) * 4) % 256 for _ in range(H) for x in range(W))
+
+
+def flat(v: int) -> bytes:
+    return bytes([v]) * SIZE
+
+
+class TestCarry(unittest.TestCase):
+    def test_every_passage_with_carry_passes(self):
+        scenes = [{"start": 0.0}, {"start": 3.0, "transition": "push", "carry": "price chip grows into the card"}]
+        self.assertEqual(OT.missing_carry(scenes), [])
+
+    def test_scene_without_carry_is_a_swap(self):
+        scenes = [{"start": 0.0}, {"start": 3.0, "transition": "push"}, {"start": 6.0, "carry": "  "}]
+        self.assertEqual([i for i, _, _ in OT.missing_carry(scenes)], [1, 2])
+
+    def test_plain_cut_with_carry_is_still_a_swap(self):
+        scenes = [{"start": 0.0}, {"start": 3.0, "transition": "cut", "carry": "the logo"}]
+        self.assertEqual(OT.missing_carry(scenes)[0][2], "`transition` is a plain cut")
+
+    def test_first_scene_needs_nothing(self):
+        self.assertEqual(OT.missing_carry([{"start": 0.0}]), [])
+        self.assertEqual(OT.missing_carry(None), [])
+
+
+class TestCuts(unittest.TestCase):
+    def test_slow_pan_has_no_cut(self):
+        d = OT.diffs(gradient(i) for i in range(40))
+        self.assertEqual(OT.cut_frames(d, RULES), [])
+
+    def test_hard_cut_is_found_on_the_first_frame_after_it(self):
+        frames = [gradient(i) for i in range(20)] + [flat(240 - i) for i in range(20)]
+        d = OT.diffs(frames)
+        self.assertEqual(OT.cut_frames(d, RULES), [20])
+
+    def test_fast_whip_over_several_frames_is_not_a_cut(self):
+        # Large change on every frame for a while: a move, not a cut.
+        frames = [gradient(0)] * 10 + [gradient(i * 9) for i in range(1, 9)] + [gradient(72)] * 10
+        d = OT.diffs(frames)
+        self.assertGreater(max(d), RULES.cut_min_diff)
+        self.assertEqual(OT.cut_frames(d, RULES), [])
+
+    def test_small_jump_under_the_floor_is_ignored(self):
+        frames = [flat(100)] * 10 + [flat(100 + int(RULES.cut_min_diff) - 2)] * 10
+        self.assertEqual(OT.cut_frames(OT.diffs(frames), RULES), [])
+
+
+class TestRules(unittest.TestCase):
+    def test_template_block_is_coherent(self):
+        r, _ = OT.rules(CFG)
+        self.assertGreater(r.cut_ratio, 1)
+
+    def test_project_config_without_block_falls_back_to_template(self):
+        with tempfile.TemporaryDirectory() as tmp:
+            data = json.loads(Path(TEMPLATE).read_text(encoding="utf-8"))
+            data.pop(OT.BLOCK)
+            p = Path(tmp) / "effects.config.json"
+            p.write_text(json.dumps(data), encoding="utf-8")
+            _, from_template = OT.rules(load(str(p)))
+            self.assertTrue(from_template)
+
+
+@unittest.skipUnless(shutil.which("ffmpeg") and shutil.which("ffprobe"), "ffmpeg not installed")
+class TestRoundTrip(unittest.TestCase):
+    def _render(self, tmp: str, filters: str) -> str:
+        out = str(Path(tmp) / "piece.mp4")
+        subprocess.run(["ffmpeg", "-v", "error", "-y", "-f", "lavfi", "-i", filters,
+                        "-pix_fmt", "yuv420p", out], check=True)
+        return out
+
+    def _run(self, *args) -> tuple[int, str]:
+        buf = io.StringIO()
+        with redirect_stdout(buf):
+            code = OT.main(["--config", str(TEMPLATE), *args])
+        return code, buf.getvalue()
+
+    def test_two_colours_spliced_fail_and_a_timeline_without_carry_too(self):
+        with tempfile.TemporaryDirectory() as tmp:
+            video = self._render(tmp, "color=c=0x202020:s=270x480:d=1:r=24,format=gray[a];"
+                                      "color=c=0xe0e0e0:s=270x480:d=1:r=24,format=gray[b];"
+                                      "[a][b]concat=n=2:v=1")
+            tl = Path(tmp) / "t.json"
+            tl.write_text(json.dumps({"scenes": [{"start": 0}, {"start": 1, "transition": "cut"}]}))
+            code, out = self._run(video, "--timeline", str(tl))
+            self.assertEqual(code, 1, out)
+            self.assertIn("CUT", out)
+            self.assertIn("SWAP", out)
+
+    def test_continuous_gradient_passes(self):
+        with tempfile.TemporaryDirectory() as tmp:
+            video = self._render(tmp, "gradients=s=270x480:d=2:r=24:speed=0.02")
+            code, out = self._run(video)
+            self.assertEqual(code, 0, out)
+
+    def test_missing_video_is_an_input_error(self):
+        code, _ = self._run("/nonexistent.mp4")
+        self.assertEqual(code, 2)
+
+
+if __name__ == "__main__":
+    unittest.main()

package/src/skills-lib/wizz-video-styles/LICENSE-lemo-opuscar.txt

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 LemoLab
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.