wizz-method 2.11.1 → 2.12.0

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

@@ -0,0 +1,190 @@
+# -*- coding: utf-8 -*-
+"""Tests of the timeline gates: check_excess.py (blocks), check_rhythm.py
+(warns only) and the frame evaluation of check_safe_zone.py."""
+import io
+import json
+import math
+import tempfile
+import unittest
+from contextlib import redirect_stdout
+from pathlib import Path
+
+import check_excess as CE
+import check_rhythm as CR
+import check_safe_zone as CS
+from config import TEMPLATE, load
+
+CFG = load(TEMPLATE)
+
+
+def _run(main, args) -> tuple[int, str]:
+    buf = io.StringIO()
+    with redirect_stdout(buf):
+        code = main(["--config", str(TEMPLATE), *args])
+    return code, buf.getvalue()
+
+
+def _write(tmp: str, name: str, data: dict) -> str:
+    p = Path(tmp) / f"{name}.json"
+    p.write_text(json.dumps(data), encoding="utf-8")
+    return str(p)
+
+
+class TestExcess(unittest.TestCase):
+    CLEAN = {"duration": 30.0, "punches": [2.0, 12.0, 24.0], "flashes": [6.0, 18.0],
+             "scenes": [{"start": 0.0, "dur": 15.0, "transition": "cut"},
+                        {"start": 15.0, "dur": 15.0, "transition": "whip"}]}
+
+    def test_clean_timeline_passes(self):
+        rep = CE.analyze(self.CLEAN, "clean", CFG)
+        self.assertTrue(rep["passed"], rep["violations"])
+
+    def test_glued_punches_fail(self):
+        rep = CE.analyze({**self.CLEAN, "punches": [2.0, 3.0, 12.0]}, "glued", CFG)
+        self.assertFalse(rep["passed"])
+        self.assertTrue(any("gap" in v for v in rep["violations"]))
+
+    def test_over_ceiling_fails(self):
+        many = [float(i * 4) for i in range(8)]   # 8 punches in 30s, ceiling 5
+        rep = CE.analyze({**self.CLEAN, "punches": many}, "busy", CFG)
+        self.assertTrue(any("ceiling" in v for v in rep["violations"]))
+
+    def test_dominant_crossing_fails(self):
+        rep = CE.analyze({**self.CLEAN, "shakes": [12.5]}, "cross", CFG)
+        self.assertTrue(any("gap_min_global" in v for v in rep["violations"]))
+
+    def test_scene_cut_sound_colliding_with_sfx_fails(self):
+        # The cut sound fill_breaths writes on a scene and an sfx[] entry
+        # mapped earlier, 60 ms apart: heard as one dirty sound.
+        scenes = [{"start": 0.0, "dur": 15.0, "transition": "cut"},
+                  {"start": 15.0, "dur": 15.0, "transition": "whip",
+                   "sfx": {"event": "block_cut", "src": "sfx/whoosh.mp3", "vol": 0.55}}]
+        sfx = [{"at": 15.06, "event": "price", "src": "sfx/cash.mp3", "vol": 0.55}]
+        rep = CE.analyze({**self.CLEAN, "scenes": scenes, "sfx": sfx}, "clash", CFG)
+        self.assertFalse(rep["passed"])
+        self.assertTrue(any("collision" in v for v in rep["violations"]), rep["violations"])
+
+    def test_same_sound_too_many_times_fails(self):
+        sfx = [{"at": float(t), "event": "element_in", "src": "sfx/pop.mp3", "vol": 0.5}
+               for t in (1, 3, 5, 7)]
+        rep = CE.analyze({**self.CLEAN, "sfx": sfx}, "pops", CFG)
+        self.assertTrue(any("same_sound_in_row" in v for v in rep["violations"]), rep["violations"])
+
+    def test_sound_without_known_event_fails(self):
+        sfx = [{"at": 4.0, "src": "sfx/vine-boom.mp3", "vol": 0.5}]
+        rep = CE.analyze({**self.CLEAN, "sfx": sfx}, "meme", CFG)
+        self.assertTrue(any("unknown_event" in v for v in rep["violations"]), rep["violations"])
+
+    def test_duration_derived_from_scenes(self):
+        data = {k: v for k, v in self.CLEAN.items() if k != "duration"}
+        rep = CE.analyze(data, "x", CFG)
+        self.assertEqual((rep["duration"], rep["duration_derived"]), (30.0, True))
+
+    def test_cli_blocks_and_warn_mode(self):
+        with tempfile.TemporaryDirectory() as tmp:
+            bad = _write(tmp, "bad", {**self.CLEAN, "punches": [2.0, 2.5]})
+            good = _write(tmp, "good", self.CLEAN)
+            self.assertEqual(_run(CE.main, [bad])[0], 1)
+            self.assertEqual(_run(CE.main, [bad, "--warn"])[0], 0)
+            self.assertEqual(_run(CE.main, [good])[0], 0)
+            self.assertEqual(_run(CE.main, [str(Path(tmp) / "missing.json")])[0], 2)
+
+    def test_json_output(self):
+        with tempfile.TemporaryDirectory() as tmp:
+            code, out = _run(CE.main, [_write(tmp, "p", self.CLEAN), "--json"])
+            self.assertTrue(json.loads(out)["p"]["passed"])
+
+
+class TestRhythm(unittest.TestCase):
+    R = CFG.rhythm
+
+    def test_longest_static(self):
+        self.assertEqual(CR.longest_static([2.0, 4.0], 12.0), (8.0, 4.0))
+        self.assertEqual(CR.longest_static([], 3.0), (3.0, 0.0))
+
+    def test_cadence(self):
+        self.assertEqual(CR.cadence([1.0, 2.0, 3.0], 0.0, 3.0), 1.0)
+        self.assertTrue(math.isinf(CR.cadence([5.0], 0.0, 3.0)))
+        self.assertEqual(CR.cadence([0.0, 1.5], 0.0, 3.0), 3.0)   # t=0 is not a change
+
+    def test_good_rhythm_has_no_warning(self):
+        pts = [1.5, 3.0] + [3.0 + 3.0 * i for i in range(1, 9)]
+        data = {"duration": 30.0, "scenes": [{"start": 0.0, "dur": 30.0}],
+                "elements": [{"at": t} for t in pts]}
+        rep = CR.analyze(data, "ok", self.R)
+        self.assertEqual(rep["warnings"], [])
+
+    def test_static_hook_and_slow_body_warn(self):
+        data = {"duration": 30.0, "scenes": [{"start": 0.0, "dur": 20.0},
+                                             {"start": 20.0, "dur": 10.0}]}
+        rep = CR.analyze(data, "slow", self.R)
+        text = " ".join(rep["warnings"])
+        self.assertIn("max_static_s", text)
+        self.assertIn("hook_cut_every_s", text)
+        self.assertIn("body_cut_every_s", text)
+
+    def test_frantic_body_warns(self):
+        pts = [0.5 * i for i in range(1, 60)]
+        rep = CR.analyze({"duration": 30.0, "punches": pts}, "frantic", self.R)
+        self.assertTrue(any("body" in w for w in rep["warnings"]))
+
+    def test_sfx_is_not_a_visual_change(self):
+        data = {"duration": 10.0, "sfx": [{"at": t} for t in range(1, 10)]}
+        self.assertEqual(CR.analyze(data, "audio-only", self.R)["changes"], 0)
+
+    def test_cli_never_blocks(self):
+        with tempfile.TemporaryDirectory() as tmp:
+            p = _write(tmp, "slow", {"duration": 30.0, "scenes": [{"start": 0.0, "dur": 30.0}]})
+            code, out = _run(CR.main, [p])
+            self.assertEqual(code, 0)
+            self.assertIn("WARNING", out)
+            code, out = _run(CR.main, [p, "--json"])
+            self.assertIsNone(json.loads(out)["slow"]["hook_every_s"])
+
+
+class TestSafeZoneFrame(unittest.TestCase):
+    G, H = CFG.safe_zone_gate, CFG.frame.height
+    ROW = bytes([0, 255] * (CFG.safe_zone_gate.sample_width // 2))
+
+    def _frame(self, rows: range) -> bytes:
+        f = bytearray(self.G.sample_width * self.H)
+        for y in rows:
+            f[y * self.G.sample_width:(y + 1) * self.G.sample_width] = self.ROW
+        return bytes(f)
+
+    def test_row_std(self):
+        self.assertEqual(CS.row_std(bytes(10)), 0.0)
+        self.assertAlmostEqual(CS.row_std(bytes([0, 255] * 5)), 127.5)
+
+    def test_empty_and_inside(self):
+        zone = CFG.safe_zone("organic")
+        self.assertEqual(CS.evaluate(self._frame(range(0)), CFG, zone)[0], "empty")
+        state, top, bottom, _ = CS.evaluate(self._frame(range(600, 700)), CFG, zone)
+        self.assertEqual((state, top, bottom), ("ok", 600, 699))
+
+    def test_graze_warns_and_invasion_fails(self):
+        zone = CFG.safe_zone("organic")
+        few = range(zone.top - self.G.min_rows_to_fail + 1, zone.top + 50)
+        many = range(zone.top - self.G.min_rows_to_fail - 5, zone.top + 50)
+        self.assertEqual(CS.evaluate(self._frame(few), CFG, zone)[0], "warn")
+        self.assertEqual(CS.evaluate(self._frame(many), CFG, zone)[0], "fail")
+
+    def test_same_frame_passes_organic_and_fails_ad(self):
+        frame = self._frame(range(1300, 1400))   # below the ad bottom (1248)
+        self.assertEqual(CS.evaluate(frame, CFG, CFG.safe_zone("organic"))[0], "ok")
+        self.assertEqual(CS.evaluate(frame, CFG, CFG.safe_zone("ad"))[0], "fail")
+
+    def test_edge_artifact_rows_ignored(self):
+        edge = range(0, self.G.edge_artifact_rows)
+        self.assertEqual(CS.evaluate(self._frame(edge), CFG, CFG.safe_zone())[0], "empty")
+
+    def test_profile_resolution(self):
+        with tempfile.TemporaryDirectory() as tmp:
+            p = _write(tmp, "t", {"safe_zone_profile": "ad"})
+            self.assertEqual(CS.resolve_profile(CFG, None, p).name, "ad")
+            self.assertEqual(CS.resolve_profile(CFG, "organic", p).name, "organic")
+            self.assertEqual(CS.resolve_profile(CFG, None, None).name, CFG.safe_zone_profile)
+
+
+if __name__ == "__main__":
+    unittest.main()

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

@@ -0,0 +1,135 @@
+# -*- coding: utf-8 -*-
+"""Tests of config.py against the shipped template and broken variants."""
+import copy
+import json
+import os
+import tempfile
+import unittest
+from pathlib import Path
+
+import config
+from config import TEMPLATE, ConfigError, load
+
+RAW = json.loads(TEMPLATE.read_text(encoding="utf-8"))
+
+
+def _load_variant(mutate) -> config.Config:
+    data = copy.deepcopy(RAW)
+    mutate(data)
+    with tempfile.TemporaryDirectory() as tmp:
+        p = Path(tmp) / "effects.config.json"
+        p.write_text(json.dumps(data), encoding="utf-8")
+        return load(p)
+
+
+class TestTemplate(unittest.TestCase):
+    def test_template_is_valid(self):
+        cfg = load(TEMPLATE)
+        self.assertEqual(cfg.offer, "")
+        self.assertEqual((cfg.frame.width, cfg.frame.height, cfg.frame.fps), (1080, 1920, 30))
+
+    def test_two_safe_zone_profiles(self):
+        cfg = load(TEMPLATE)
+        self.assertEqual(set(cfg.safe_zones), {"organic", "ad"})
+        self.assertEqual(cfg.safe_zone().name, cfg.safe_zone_profile)
+        org = cfg.safe_zone("organic")
+        self.assertEqual((org.top, org.bottom, org.left, org.right), (250, 1570, 60, 920))
+
+    def test_ad_profile_matches_meta_percentages(self):
+        cfg = load(TEMPLATE)
+        ad = cfg.safe_zone("ad")
+        h, w = cfg.frame.height, cfg.frame.width
+        self.assertGreaterEqual(ad.top, 0.14 * h)
+        self.assertLessEqual(ad.bottom, h - 0.35 * h)
+        self.assertGreaterEqual(ad.left, 0.06 * w)
+        self.assertLessEqual(ad.right, w - 0.06 * w)
+
+    def test_weak_numbers_carry_a_source(self):
+        for block in ("ducking", "loudness", "rhythm"):
+            self.assertIn("_source", RAW[block], block)
+        self.assertIn("no primary source", RAW["ducking"]["_source"])
+        for name, zone in RAW["safe_zones"].items():
+            self.assertIn("_source", zone, name)
+
+    def test_no_glitch_event(self):
+        cfg = load(TEMPLATE)
+        self.assertFalse(any("glitch" in e.sound for e in cfg.sound.events.values()))
+
+    def test_unknown_profile_fails_loudly(self):
+        with self.assertRaises(ConfigError):
+            load(TEMPLATE).safe_zone("tiktok-dark-mode")
+
+
+class TestLookup(unittest.TestCase):
+    def test_env_variable_is_used(self):
+        old = os.environ.get(config.ENV_CONFIG)
+        os.environ[config.ENV_CONFIG] = str(TEMPLATE)
+        try:
+            self.assertEqual(load().source, TEMPLATE.resolve())
+        finally:
+            if old is None:
+                os.environ.pop(config.ENV_CONFIG, None)
+            else:
+                os.environ[config.ENV_CONFIG] = old
+
+    def test_missing_file_says_how_to_fix(self):
+        with self.assertRaises(ConfigError) as ctx:
+            load("/no/such/effects.config.json")
+        self.assertIn("template", str(ctx.exception))
+
+
+class TestValidation(unittest.TestCase):
+    def test_event_louder_than_voice_ceiling_is_refused(self):
+        def m(d):
+            d["sound"]["events"]["verdict"]["vol"] = 0.9
+        with self.assertRaises(ConfigError):
+            _load_variant(m)
+
+    def test_trigger_without_budget_rule_is_refused(self):
+        def m(d):
+            d["sound"]["events"]["verdict"]["triggers"] = ["confetti"]
+        with self.assertRaises(ConfigError):
+            _load_variant(m)
+
+    def test_profile_outside_frame_is_refused(self):
+        def m(d):
+            d["safe_zones"]["ad"]["bottom"] = 5000
+        with self.assertRaises(ConfigError):
+            _load_variant(m)
+
+    def test_default_profile_must_exist(self):
+        def m(d):
+            d["safe_zone_profile"] = "stories"
+        with self.assertRaises(ConfigError):
+            _load_variant(m)
+
+    def test_curve_must_end_at_one(self):
+        def m(d):
+            d["budget"]["curve"][-1]["until_frac"] = 0.9
+        with self.assertRaises(ConfigError):
+            _load_variant(m)
+
+    def test_positive_true_peak_is_refused(self):
+        def m(d):
+            d["loudness"]["max_true_peak_db"] = 0.5
+        with self.assertRaises(ConfigError):
+            _load_variant(m)
+
+    def test_body_range_must_be_ordered(self):
+        def m(d):
+            d["rhythm"]["body_cut_every_s"] = [4.0, 2.5]
+        with self.assertRaises(ConfigError):
+            _load_variant(m)
+
+    def test_avatar_block_is_optional(self):
+        cfg = _load_variant(lambda d: d.pop("avatar"))
+        self.assertIsNone(cfg.avatar)
+
+    def test_missing_block_names_the_key(self):
+        with self.assertRaises(ConfigError) as ctx:
+            _load_variant(lambda d: d.pop("loudness"))
+        self.assertIn("loudness", str(ctx.exception))
+
+
+if __name__ == "__main__":
+    unittest.main()

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

@@ -0,0 +1,179 @@
+# -*- coding: utf-8 -*-
+"""Tests of fill_breaths.py with the shipped template config.
+
+Covers the regressions of the source project: hand-written gaps (2.5/5.0)
+instead of the config ones, the per-kind ceiling ignored, every new punch
+asking for a sound evaluated TOGETHER with the existing sounds, plus the new
+breath source from ctc-align words and the punch band per safe zone profile.
+"""
+import unittest
+
+import fill_breaths as FB
+from config import TEMPLATE, load
+
+CFG = load(TEMPLATE)
+PUNCH = CFG.budget.rule("punch")
+DENSE = [round(x * 0.5, 1) for x in range(2, 158)]   # a breath every 0.5s over 80s
+
+
+def _all_punch(cands):
+    return {t: "punch" for t in cands}
+
+
+class TestGapFromConfig(unittest.TestCase):
+    def test_candidate_closer_than_gap_min_is_refused(self):
+        near = 10.0 + PUNCH.gap_min - 0.9
+        new, *_ = FB.fill_holes([near, 20.0], [10.0], _all_punch([near, 20.0]), 60.0,
+                                [10.0], [], CFG)
+        self.assertNotIn(near, new)
+        self.assertIn(20.0, new)
+
+
+class TestCeiling(unittest.TestCase):
+    def test_stops_at_ceiling_and_reports(self):
+        cap = CFG.budget.ceiling("punch", 80.0)
+        new, no_breath, no_budget, stopped = FB.fill_holes(
+            DENSE, [], _all_punch(DENSE), 80.0, [], [], CFG)
+        self.assertEqual(len(new), cap)
+        self.assertEqual(stopped, (cap, cap))
+        self.assertTrue(no_budget)
+
+    def test_exhausted_budget_adds_nothing(self):
+        cap = CFG.budget.ceiling("punch", 80.0)
+        existing = [float(i * 5) for i in range(cap)]
+        new, *_ = FB.fill_holes(DENSE, existing, _all_punch(DENSE), 80.0, existing, [], CFG)
+        self.assertEqual(new, [])
+
+    def test_no_breath_hole_is_marked_not_aborted(self):
+        cands = [30.0]
+        new, no_breath, _, _ = FB.fill_holes(cands, [], _all_punch(cands), 60.0, [], [], CFG)
+        self.assertEqual(new, [30.0])
+        self.assertTrue(no_breath)
+
+
+class TestIdempotent(unittest.TestCase):
+    def test_fixed_point(self):
+        eff = _all_punch(DENSE)
+        n1, *_ = FB.fill_holes(DENSE, [], eff, 80.0, [], [], CFG)
+        p1 = sorted(n1)
+        n2, *_ = FB.fill_holes(DENSE, p1, eff, 80.0, p1, [], CFG)
+        self.assertEqual(n2, [])
+
+
+class TestPunchSounds(unittest.TestCase):
+    EV = CFG.breaths.punch_sound_event
+
+    def _entry(self, t, event):
+        return {"at": t, "event": event, "src": CFG.sound.src(event),
+                "vol": CFG.sound.events[event].vol}
+
+    def test_every_new_punch_is_accounted_for(self):
+        shots, refused, _, _ = FB.request_punch_sounds([2.0, 6.0, 10.0], [], CFG)
+        self.assertEqual({s.t for s in shots} | {r.t for r in refused}, {2.0, 6.0, 10.0})
+
+    def test_isolated_punch_gets_the_configured_event(self):
+        shots, refused, _, _ = FB.request_punch_sounds([5.0], [], CFG)
+        self.assertEqual((shots[0].event, refused), (self.EV, []))
+
+    def test_collision_with_existing_sound(self):
+        w = CFG.sound.collision_window_s
+        shots, refused, _, _ = FB.request_punch_sounds(
+            [5.0 + w / 2], [self._entry(5.0, "block_cut")], CFG)
+        self.assertEqual(shots, [])
+        self.assertEqual(refused[0].rule, "collision")
+
+    def test_joint_evaluation_catches_same_sound_run(self):
+        n = CFG.sound.max_same_sound_in_row
+        existing = [self._entry(float(i + 1), self.EV) for i in range(n)]
+        shots, refused, _, _ = FB.request_punch_sounds([float(n + 1)], existing, CFG)
+        self.assertEqual(shots, [])
+        self.assertEqual(refused[0].rule, "same_sound_in_row")
+
+    def test_existing_sounds_are_not_displaced(self):
+        existing = [self._entry(1.0, "element_in"), self._entry(20.0, "block_cut")]
+        *_, displaced = FB.request_punch_sounds([10.0], existing, CFG)
+        self.assertEqual(displaced, [])
+
+    def test_unrecoverable_entry_is_reported(self):
+        _, _, unrec, _ = FB.request_punch_sounds(
+            [5.0], [{"at": 1.0, "src": "sfx/nope.mp3", "vol": 0.99}], CFG)
+        self.assertEqual(unrec[0]["src"], "sfx/nope.mp3")
+
+
+class TestEventOf(unittest.TestCase):
+    def test_explicit_event_wins(self):
+        self.assertEqual(FB.event_of({"event": "price", "src": "x", "vol": 0}, CFG), "price")
+
+    def test_rebuilt_from_file_and_volume(self):
+        e = CFG.sound.events
+        a = {"src": "sfx/whoosh.mp3", "vol": e["block_cut"].vol}
+        b = {"src": "sfx/whoosh.mp3", "vol": e["scene_cut"].vol}
+        self.assertEqual((FB.event_of(a, CFG), FB.event_of(b, CFG)), ("block_cut", "scene_cut"))
+
+    def test_unknown_pair_is_none(self):
+        self.assertIsNone(FB.event_of({"src": "sfx/none.mp3", "vol": 0.5}, CFG))
+
+
+class TestBreathsFromWords(unittest.TestCase):
+    def test_only_gaps_long_enough(self):
+        m = CFG.breaths.min_silence_s
+        words = [{"start": 0.0, "end": 1.0}, {"start": 1.0 + m / 2, "end": 2.0},
+                 {"start": 2.0 + m * 2, "end": 3.0}]
+        self.assertEqual(FB.breaths_from_words(words, CFG), [(2.0, 2.0 + m * 2)])
+
+    def test_candidates_in_the_middle_and_inside_guard(self):
+        g = CFG.breaths.edge_guard_s
+        c = FB.candidates_from([(0.0, g), (4.0, 5.0), (9.8, 10.0)], 0.0, 10.0, CFG)
+        self.assertEqual(c, [4.5])
+
+
+class TestPunchBand(unittest.TestCase):
+    def test_band_is_inside_the_zone_and_matches_source_number(self):
+        top, bottom = FB.punch_band(CFG.safe_zone("organic"), CFG)
+        self.assertEqual(top, 294)   # source project: 294, rounded up to 295 by hand
+        self.assertLess(bottom, CFG.safe_zone("organic").bottom)
+
+    def test_ad_profile_band_is_tighter(self):
+        org, ad = FB.punch_band(CFG.safe_zone("organic"), CFG), FB.punch_band(CFG.safe_zone("ad"), CFG)
+        self.assertGreater(ad[0], org[0])
+        self.assertLess(ad[1], org[1])
+
+    def test_effect_for_frame(self):
+        g, h = CFG.safe_zone_gate, CFG.frame.height
+        blank = bytes(g.sample_width * h)
+        zone = CFG.safe_zone("organic")
+        self.assertEqual(FB.effect_for_frame(blank, zone, CFG), "punch")
+        row = bytes([0, 255] * (g.sample_width // 2))
+        at_edge = bytearray(blank)
+        at_edge[zone.top * g.sample_width:(zone.top + 1) * g.sample_width] = row
+        self.assertEqual(FB.effect_for_frame(bytes(at_edge), zone, CFG), "flash")
+
+
+class TestPlan(unittest.TestCase):
+    DATA = {"duration": 20.0,
+            "words": [{"text": f"w{i}", "start": i * 0.3, "end": i * 0.3 + 0.25}
+                      for i in range(20)],
+            "scenes": [{"start": 0.0, "dur": 10.0, "transition": "cut"},
+                       {"start": 10.0, "dur": 10.0, "transition": "cut"}],
+            "punches": [], "flashes": [], "sfx": []}
+
+    def test_plan_and_apply_are_pure(self):
+        cands = [13.0, 15.0, 17.0]
+        before = repr(self.DATA)
+        p = FB.plan(self.DATA, CFG, cands, _all_punch(cands))
+        out = FB.apply(self.DATA, p)
+        self.assertEqual(repr(self.DATA), before)
+        self.assertEqual(out["scenes"][0]["transition"], CFG.breaths.pace_profiles["first"].transition)
+        self.assertIn("sfx", out["scenes"][1])
+        self.assertTrue(out["punches"])
+        self.assertTrue(all("event" in s for s in out["sfx"]))
+
+    def test_pace_profile(self):
+        f = CFG.breaths.fast_speech_wps
+        self.assertEqual(FB.pace_profile(0, 99.0, CFG), "first")
+        self.assertEqual(FB.pace_profile(1, f, CFG), "fast")
+        self.assertEqual(FB.pace_profile(1, f - 0.1, CFG), "slow")
+
+
+if __name__ == "__main__":
+    unittest.main()

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

@@ -0,0 +1,173 @@
+# -*- coding: utf-8 -*-
+"""Tests of sound.py: the three refusals, the bridge to the budget, coverage
+and narration ducking. Uses the shipped template config: if someone changes
+max_same_sound_in_row or an event vol without adjusting here, tests say so."""
+import tempfile
+import unittest
+from pathlib import Path
+
+import sound
+from config import TEMPLATE, SoundEvent, load
+from sound import coverage, ducking_envelope, effect_candidates, gain_db_at, map_requests
+
+CFG = load(TEMPLATE)
+SFX_DIR = TEMPLATE.parent / "sfx"
+
+
+class TestMap(unittest.TestCase):
+    def test_maps_event_to_file_and_config_volume(self):
+        res = map_requests([(1.0, "verdict")], CFG)
+        self.assertEqual(res.refusals, ())
+        s = res.shots[0]
+        self.assertEqual(s.src, "sfx/stamp.mp3")
+        self.assertEqual(s.vol, CFG.sound.events["verdict"].vol)
+        self.assertEqual(s.triggers, ("shake",))
+
+    def test_unknown_event_is_refused_and_lists_valid_ones(self):
+        res = map_requests([(1.0, "no_such_event")], CFG)
+        self.assertEqual(res.shots, ())
+        self.assertEqual(res.refusals[0].rule, "unknown_event")
+        self.assertIn("verdict", res.refusals[0].detail)
+
+    def test_collision_refuses_the_second(self):
+        w = CFG.sound.collision_window_s
+        res = map_requests([(1.0, "click"), (1.0 + w / 2, "click")], CFG)
+        self.assertEqual([s.t for s in res.shots], [1.0])
+        self.assertEqual(res.refusals[0].rule, "collision")
+
+    def test_exactly_the_window_is_not_a_collision(self):
+        w = CFG.sound.collision_window_s
+        res = map_requests([(1.0, "click"), (1.0 + w, "click")], CFG)
+        self.assertEqual(len(res.shots), 2)
+
+    def test_same_sound_in_row_limit(self):
+        n = CFG.sound.max_same_sound_in_row
+        res = map_requests([(float(i), "click") for i in range(n + 2)], CFG)
+        self.assertEqual(len(res.shots), n)
+        self.assertTrue(all(r.rule == "same_sound_in_row" for r in res.refusals))
+
+    def test_other_sound_resets_the_run(self):
+        n = CFG.sound.max_same_sound_in_row
+        req = [(float(i), "click") for i in range(n)] + [(float(n), "send"), (float(n + 1), "click")]
+        res = map_requests(req, CFG)
+        self.assertEqual(res.refusals, ())
+
+    def test_order_by_time_not_arrival(self):
+        res = map_requests([(3.0, "send"), (1.0, "click"), (2.0, "paste")], CFG)
+        self.assertEqual([s.t for s in res.shots], [1.0, 2.0, 3.0])
+
+    def test_deterministic(self):
+        req = [(5.0, "block_cut"), (5.5, "element_in"), (5.55, "list_item"), (99.0, "x")]
+        self.assertEqual(map_requests(req, CFG), map_requests(list(reversed(req)), CFG))
+
+
+class TestEffectCandidates(unittest.TestCase):
+    def test_strength_not_volume_decides(self):
+        c = effect_candidates(map_requests([(2.5, "verdict")], CFG))[0]
+        self.assertEqual((c["t"], c["kind"]), (2.5, "shake"))
+        self.assertEqual(c["strength"], CFG.sound.events["verdict"].strength)
+        self.assertGreater(c["strength"], CFG.sound.events["verdict"].vol)
+
+    def test_volume_fallback_is_declared(self):
+        ev = SoundEvent(key="x", sound="pop", vol=0.42, when="", triggers=("punch",))
+        shot = sound.Shot(t=1.0, event="x", src="sfx/pop.mp3", vol=ev.vol, triggers=ev.triggers)
+        c = effect_candidates(sound.SoundResult(shots=(shot,), refusals=()))[0]
+        self.assertEqual(c["strength"], 0.42)
+        self.assertIn("strength from volume", c["reason"])
+
+    def test_no_trigger_no_candidate(self):
+        self.assertEqual(effect_candidates(map_requests([(1.0, "click")], CFG)), [])
+
+    def test_plain_dicts(self):
+        c = effect_candidates(map_requests([(1.0, "verdict")], CFG))[0]
+        self.assertEqual(set(c), {"t", "kind", "strength", "reason"})
+
+
+class TestCoverage(unittest.TestCase):
+    def test_template_events_all_have_a_shipped_file(self):
+        cov = coverage(CFG, SFX_DIR)
+        self.assertTrue(cov["sfx_dir_exists"], cov["sfx_dir"])
+        self.assertEqual(cov["events_without_file"], [])
+
+    def test_no_glitch_shipped(self):
+        self.assertFalse(any(n.startswith("glitch") for n in coverage(CFG, SFX_DIR)["on_disk"]))
+
+    def test_fabricated_folder(self):
+        with tempfile.TemporaryDirectory() as tmp:
+            (Path(tmp) / "pop.mp3").touch()
+            (Path(tmp) / "unused.mp3").touch()
+            cov = coverage(CFG, tmp)
+            self.assertEqual(cov["sounds_without_event"], ["unused"])
+            self.assertIn("verdict", cov["events_without_file"])
+            self.assertNotIn("element_in", cov["events_without_file"])
+
+    def test_missing_folder_does_not_crash(self):
+        cov = coverage(CFG, "/no/such/sfx")
+        self.assertFalse(cov["sfx_dir_exists"])
+        self.assertEqual(len(cov["events_without_file"]), len(CFG.sound.events))
+
+
+WORDS = [{"text": "stop", "start": 1.00, "end": 1.30},
+         {"text": "now", "start": 1.35, "end": 1.60},
+         {"text": "price", "start": 5.50, "end": 5.90}]
+
+
+class TestDucking(unittest.TestCase):
+    def test_no_window_when_sfx_sits_in_silence(self):
+        sfx = [{"at": 3.0, "event": "block_cut", "dur": 0.5}]
+        self.assertEqual(ducking_envelope(sfx, WORDS, CFG), [])
+
+    def test_window_when_sfx_covers_a_word_onset(self):
+        d = CFG.ducking
+        sfx = [{"at": 5.40, "event": "price", "dur": 0.45}]
+        [w] = ducking_envelope(sfx, WORDS, CFG, fps=30)
+        self.assertAlmostEqual(w["start"], 5.40 - d.attack_s)
+        self.assertAlmostEqual(w["end"], 5.85 + d.release_s)
+        self.assertEqual(w["depth_db"], d.depth_db)
+        self.assertIn("price", w["cause"])
+        self.assertEqual(w["from_frame"], int(w["start"] * 30))
+        self.assertGreaterEqual(w["to_frame"] / 30, w["end"])
+
+    def test_onset_just_before_the_hit_counts_within_attack(self):
+        d = CFG.ducking
+        sfx = [{"at": 5.50 + d.attack_s / 2, "dur": 0.2, "src": "sfx/pop.mp3"}]
+        self.assertEqual(len(ducking_envelope(sfx, WORDS, CFG)), 1)
+
+    def test_word_already_started_is_not_an_onset(self):
+        # SFX in the middle of "price" (onset 5.50, well before the SFX).
+        sfx = [{"at": 5.70, "event": "click", "dur": 0.1}]
+        self.assertEqual(ducking_envelope(sfx, WORDS, CFG), [])
+
+    def test_duration_fallbacks(self):
+        d = CFG.ducking
+        sfx = [{"at": 0.9, "src": "sfx/pop.mp3"}]
+        [w] = ducking_envelope(sfx, WORDS, CFG)
+        self.assertAlmostEqual(w["end"], 0.9 + d.assumed_sfx_duration_s + d.release_s)
+        [w2] = ducking_envelope(sfx, WORDS, CFG, durations={"sfx/pop.mp3": 0.3})
+        self.assertAlmostEqual(w2["end"], 0.9 + 0.3 + d.release_s)
+
+    def test_overlapping_windows_merge(self):
+        sfx = [{"at": 0.95, "dur": 0.3, "event": "a"}, {"at": 1.30, "dur": 0.3, "event": "b"}]
+        windows = ducking_envelope(sfx, WORDS, CFG)
+        self.assertEqual(len(windows), 1)
+        self.assertIn(";", windows[0]["cause"])
+
+    def test_gain_shape(self):
+        d = CFG.ducking
+        [w] = ducking_envelope([{"at": 5.40, "dur": 0.45}], WORDS, CFG)
+        self.assertEqual(gain_db_at(w["start"] - 0.01, [w]), 0.0)
+        self.assertAlmostEqual(gain_db_at(w["start"], [w]), 0.0)
+        self.assertAlmostEqual(gain_db_at(5.40, [w]), -d.depth_db)
+        self.assertAlmostEqual(gain_db_at(5.60, [w]), -d.depth_db)
+        mid_release = w["end"] - d.release_s / 2
+        self.assertAlmostEqual(gain_db_at(mid_release, [w]), -d.depth_db / 2)
+        self.assertEqual(gain_db_at(w["end"] + 0.01, [w]), 0.0)
+
+    def test_deterministic_and_order_free(self):
+        sfx = [{"at": 5.4, "dur": 0.45}, {"at": 0.95, "dur": 0.2}]
+        self.assertEqual(ducking_envelope(sfx, WORDS, CFG),
+                         ducking_envelope(list(reversed(sfx)), list(reversed(WORDS)), CFG))
+
+
+if __name__ == "__main__":
+    unittest.main()