Update ComfyUI-ShotSplitter: OUTPUT_IS_LIST for clip_paths, upload video button in JS

ComfyUI-ShotSplitter/.pytest_cache/CACHEDIR.TAG

@@ -0,0 +1,4 @@
+Signature: 8a477f597d28d172789f06886806bc55
+# This file is a cache directory tag created by pytest.
+# For information about cache directory tags, see:
+#	https://bford.info/cachedir/spec.html

ComfyUI-ShotSplitter/.pytest_cache/README.md

@@ -0,0 +1,8 @@
+# pytest cache directory #
+
+This directory contains data from the pytest's cache plugin,
+which provides the `--lf` and `--ff` options, as well as the `cache` fixture.
+
+**Do not** commit this to version control.
+
+See [the docs](https://docs.pytest.org/en/stable/how-to/cache.html) for more information.

ComfyUI-ShotSplitter/.pytest_cache/v/cache/lastfailed

@@ -0,0 +1,10 @@
+{
+  "tests/test_ensemble.py::test_union_within_window_merges_nearby": true,
+  "tests/test_ensemble.py::test_union_outside_window_keeps_both": true,
+  "tests/test_ensemble.py::test_union_empty_inputs_returns_empty": true,
+  "tests/test_ensemble.py::test_boundaries_to_intervals_adds_sentinels": true,
+  "tests/test_ensemble.py::test_boundaries_to_intervals_no_cuts_gives_single_shot": true,
+  "tests/test_ensemble.py::test_min_shot_filter_merges_short_with_right_neighbor": true,
+  "tests/test_ensemble.py::test_min_shot_filter_last_short_merges_with_left": true,
+  "tests/test_ensemble.py::test_min_shot_filter_keeps_all_when_above_threshold": true
+}

ComfyUI-ShotSplitter/.pytest_cache/v/cache/nodeids

@@ -0,0 +1,10 @@
+[
+  "tests/test_ensemble.py::test_boundaries_to_intervals_adds_sentinels",
+  "tests/test_ensemble.py::test_boundaries_to_intervals_no_cuts_gives_single_shot",
+  "tests/test_ensemble.py::test_min_shot_filter_keeps_all_when_above_threshold",
+  "tests/test_ensemble.py::test_min_shot_filter_last_short_merges_with_left",
+  "tests/test_ensemble.py::test_min_shot_filter_merges_short_with_right_neighbor",
+  "tests/test_ensemble.py::test_union_empty_inputs_returns_empty",
+  "tests/test_ensemble.py::test_union_outside_window_keeps_both",
+  "tests/test_ensemble.py::test_union_within_window_merges_nearby"
+]

ComfyUI-ShotSplitter/js/shot_splitter_ui.js

@@ -1,4 +1,6 @@
-// Oz_ShotSplitter preview: renders a stack of <video> tags from ui.videos payload.
+// Oz_ShotSplitter UI:
+// 1. Upload Video button (uses ComfyUI /upload/image endpoint, type=input)
+// 2. Preview stack of <video> tags from ui.videos payload
 // Adapted from ComfyUI-VideoHelperSuite VHS.core.js (addVideoPreview pattern).
 
 import { app } from "../../scripts/app.js";
@@ -19,13 +21,10 @@ function buildPreviewURL(entry) {
         type: entry.type || "output",
         subfolder: entry.subfolder || "",
     });
-    // Cache-bust so re-runs show the new file, not the stale one:
     return `/view?${params.toString()}&rand=${Math.random()}`;
 }
 
 function clearContainer(container) {
-    // Explicitly drop <video> src before removing, to help the browser
-    // release the underlying media resource and avoid leaks on re-execute.
     const videos = container.querySelectorAll("video");
     videos.forEach((v) => {
         try {
@@ -39,6 +38,118 @@ function clearContainer(container) {
     container.innerHTML = "";
 }
 
+// ---------- FEATURE 1: Upload Video Button ----------
+function addUploadButton(nodeType) {
+    chainCallback(nodeType.prototype, "onNodeCreated", function () {
+        if (this._ozUploadAdded) return;
+        this._ozUploadAdded = true;
+
+        const wrapper = document.createElement("div");
+        wrapper.style.cssText =
+            "display:flex;flex-direction:column;gap:4px;padding:4px;width:100%;box-sizing:border-box;";
+
+        const btn = document.createElement("button");
+        btn.textContent = "📤 Upload Video";
+        btn.type = "button";
+        btn.style.cssText =
+            "width:100%;padding:6px 8px;cursor:pointer;background:#3a3a3a;color:#fff;" +
+            "border:1px solid #555;border-radius:4px;font-size:12px;";
+        btn.addEventListener("mouseenter", () => (btn.style.background = "#4a4a4a"));
+        btn.addEventListener("mouseleave", () => (btn.style.background = "#3a3a3a"));
+
+        const status = document.createElement("div");
+        status.style.cssText = "font-size:10px;color:#888;text-align:center;min-height:12px;";
+
+        const fileInput = document.createElement("input");
+        fileInput.type = "file";
+        fileInput.accept = "video/*";
+        fileInput.style.display = "none";
+
+        btn.addEventListener("click", () => fileInput.click());
+
+        const node = this;
+        fileInput.addEventListener("change", async (e) => {
+            const file = e.target.files && e.target.files[0];
+            if (!file) return;
+
+            btn.disabled = true;
+            btn.textContent = `⏳ Uploading...`;
+            status.textContent = `${file.name} (${(file.size / 1024 / 1024).toFixed(1)} MB)`;
+
+            try {
+                const fd = new FormData();
+                // ComfyUI's /upload/image accepts arbitrary file types
+                fd.append("image", file, file.name);
+                fd.append("type", "input");
+                fd.append("subfolder", "");
+                fd.append("overwrite", "true");
+
+                const res = await fetch("/upload/image", {
+                    method: "POST",
+                    body: fd,
+                });
+                if (!res.ok) {
+                    throw new Error(`HTTP ${res.status} ${res.statusText}`);
+                }
+                const data = await res.json();
+                const uploadedName = data.name || file.name;
+
+                // Update the video widget options + value
+                const videoWidget = node.widgets && node.widgets.find((w) => w.name === "video");
+                if (videoWidget) {
+                    if (!videoWidget.options) videoWidget.options = {};
+                    if (!videoWidget.options.values) videoWidget.options.values = [];
+                    if (!videoWidget.options.values.includes(uploadedName)) {
+                        // Drop the placeholder if present
+                        videoWidget.options.values = videoWidget.options.values.filter(
+                            (v) => v !== "<no videos in input/>"
+                        );
+                        videoWidget.options.values.push(uploadedName);
+                        videoWidget.options.values.sort();
+                    }
+                    videoWidget.value = uploadedName;
+                    btn.textContent = `✅ ${uploadedName}`;
+                    status.textContent = "Video selected in dropdown.";
+                } else {
+                    btn.textContent = `⚠️ video widget not found`;
+                }
+
+                if (node.graph) {
+                    node.setSize(node.computeSize());
+                    node.graph.setDirtyCanvas(true, true);
+                }
+            } catch (err) {
+                console.error("[Oz ShotSplitter] Upload failed:", err);
+                btn.textContent = `❌ Upload failed`;
+                status.textContent = String(err.message || err);
+            } finally {
+                btn.disabled = false;
+                fileInput.value = "";
+                setTimeout(() => {
+                    btn.textContent = "📤 Upload Video";
+                }, 6000);
+            }
+        });
+
+        wrapper.appendChild(btn);
+        wrapper.appendChild(status);
+        wrapper.appendChild(fileInput);
+
+        const widget = this.addDOMWidget("upload_video", "upload", wrapper, {
+            serialize: false,
+            hideOnZoom: false,
+            getValue() {
+                return null;
+            },
+            setValue() {},
+        });
+        widget.computeSize = function (width) {
+            return [width, 56];
+        };
+    });
+}
+
+// ---------- Existing: Preview Stack ----------
 function addShotSplitterPreview(nodeType) {
     chainCallback(nodeType.prototype, "onNodeCreated", function () {
         const container = document.createElement("div");
@@ -58,11 +169,9 @@ function addShotSplitterPreview(nodeType) {
             getValue() { return null; },
             setValue() {},
         });
-        // Compute widget height based on number of children
         widget.computeSize = function (width) {
-            if (!container.children.length) return [width, -4]; // hidden when empty
+            if (!container.children.length) return [width, -4];
             const rows = container.children.length;
-            // Each preview row ~140px (label + video + padding)
             return [width, Math.min(rows * 140 + 20, 600)];
         };
 
@@ -113,7 +222,6 @@ function addShotSplitterPreview(nodeType) {
                 container.appendChild(wrap);
             });
         }
-        // Force relayout and redraw
         if (this.graph) {
             this.setSize(this.computeSize());
             this.graph.setDirtyCanvas(true, true);
@@ -125,6 +233,7 @@ app.registerExtension({
     name: "oz.shot_splitter",
     async beforeRegisterNodeDef(nodeType, nodeData) {
         if (nodeData && nodeData.name === "Oz_ShotSplitter") {
+            addUploadButton(nodeType);
             addShotSplitterPreview(nodeType);
         }
     },

ComfyUI-ShotSplitter/shot_splitter_node.py

@@ -27,6 +27,7 @@ class Oz_ShotSplitter:
     FUNCTION = "run"
     RETURN_TYPES = ("STRING", "IMAGE", "INT", "STRING")
     RETURN_NAMES = ("clip_paths", "first_frames", "shot_count", "manifest_json")
+    OUTPUT_IS_LIST = (True, False, False, False)
 
     @classmethod
     def INPUT_TYPES(cls):

ComfyUI-ShotSplitter/tests/.pytest_cache/CACHEDIR.TAG

@@ -0,0 +1,4 @@
+Signature: 8a477f597d28d172789f06886806bc55
+# This file is a cache directory tag created by pytest.
+# For information about cache directory tags, see:
+#	https://bford.info/cachedir/spec.html

ComfyUI-ShotSplitter/tests/.pytest_cache/README.md

@@ -0,0 +1,8 @@
+# pytest cache directory #
+
+This directory contains data from the pytest's cache plugin,
+which provides the `--lf` and `--ff` options, as well as the `cache` fixture.
+
+**Do not** commit this to version control.
+
+See [the docs](https://docs.pytest.org/en/stable/how-to/cache.html) for more information.

ComfyUI-ShotSplitter/tests/.pytest_cache/v/cache/lastfailed

@@ -0,0 +1 @@
+{}

ComfyUI-ShotSplitter/tests/.pytest_cache/v/cache/nodeids

@@ -0,0 +1,30 @@
+[
+  "test_cutter.py::test_cut_keep_audio_false_produces_video_only_clips",
+  "test_cutter.py::test_cut_preserves_audio_stream",
+  "test_cutter.py::test_cut_real_reel_two_shots_by_detected_boundary",
+  "test_cutter.py::test_cut_synthetic_3shots_all_succeed_and_duration_sum_matches",
+  "test_ensemble.py::test_boundaries_to_intervals_adds_sentinels",
+  "test_ensemble.py::test_boundaries_to_intervals_no_cuts_gives_single_shot",
+  "test_ensemble.py::test_min_shot_filter_keeps_all_when_above_threshold",
+  "test_ensemble.py::test_min_shot_filter_last_short_merges_with_left",
+  "test_ensemble.py::test_min_shot_filter_merges_short_with_right_neighbor",
+  "test_ensemble.py::test_union_empty_inputs_returns_empty",
+  "test_ensemble.py::test_union_outside_window_keeps_both",
+  "test_ensemble.py::test_union_within_window_merges_nearby",
+  "test_first_frame_reader.py::test_read_empty_list_returns_empty_tensor",
+  "test_first_frame_reader.py::test_read_missing_file_returns_black_fallback",
+  "test_first_frame_reader.py::test_read_multiple_clips_uses_first_as_reference_size",
+  "test_first_frame_reader.py::test_read_single_clip_returns_1x_tensor",
+  "test_node_e2e.py::test_e2e_3shot_synthetic_produces_three_clips",
+  "test_node_e2e.py::test_e2e_real_reel_produces_two_or_more_clips",
+  "test_pyscenedetect.py::test_pyscenedetect_prints_count",
+  "test_pyscenedetect.py::test_pyscenedetect_returns_list_of_ints",
+  "test_pyscenedetect.py::test_pyscenedetect_sorted_and_unique",
+  "test_transnet.py::test_transnet_detects_3shot_synthetic",
+  "test_transnet.py::test_transnet_detects_at_least_one_cut_in_real_reel",
+  "test_transnet.py::test_transnet_detects_synthetic_3shot_ground_truth",
+  "test_transnet.py::test_transnet_single_shot_returns_empty",
+  "test_transnet.py::test_transnet_single_shot_returns_empty_or_one",
+  "test_video_probe.py::test_probe_detects_audio_stream_correctly",
+  "test_video_probe.py::test_probe_returns_sensible_values"
+]

ComfyUI-ShotSplitter/tests/conftest.py

@@ -0,0 +1,5 @@
+import sys
+import os
+
+# Add project root to path so 'detectors' package is importable
+sys.path.insert(0, os.path.dirname(os.path.dirname(os.path.abspath(__file__))))

ComfyUI-ShotSplitter/tests/test_cutter.py

@@ -0,0 +1,120 @@
+"""Integration tests: cut test_3shots.mp4 and reel into pieces; verify with ffprobe."""
+
+import json
+import os
+import subprocess
+import tempfile
+
+import pytest
+
+from cutter import cut_shots
+from video_probe import probe
+
+THREESHOT = "/workspace/ComfyUI/input/test_3shots.mp4"
+REEL = "/workspace/ComfyUI/input/reel_multishot.mp4"
+
+
+def _probe_duration(path: str) -> float:
+    out = subprocess.check_output(
+        ["ffprobe", "-v", "error", "-print_format", "json", "-show_format", path],
+        text=True,
+    )
+    return float(json.loads(out)["format"]["duration"])
+
+
+@pytest.mark.skipif(not os.path.exists(THREESHOT), reason="sample missing")
+def test_cut_synthetic_3shots_all_succeed_and_duration_sum_matches():
+    info = probe(THREESHOT)
+    # Ground truth intervals from TransNet: [0-60), [60-120), [120-180)
+    intervals = [(0, 60), (60, 120), (120, info.total_frames)]
+    with tempfile.TemporaryDirectory() as td:
+        results = cut_shots(
+            THREESHOT,
+            intervals,
+            fps=info.fps,
+            output_dir=td,
+            filename_prefix="syn",
+            crf=23,
+            preset="veryfast",
+            keep_audio=True,
+            has_audio=info.has_audio,
+            vfr=info.vfr,
+        )
+        assert len(results) == 3
+        assert all(r.success for r in results), [r.error for r in results if not r.success]
+        for r in results:
+            assert os.path.isfile(r.path), f"missing: {r.path}"
+        total_cut = sum(_probe_duration(r.path) for r in results)
+        assert abs(total_cut - info.duration_s) < 0.25, (total_cut, info.duration_s)
+
+
+@pytest.mark.skipif(not os.path.exists(THREESHOT), reason="sample missing")
+def test_cut_preserves_audio_stream():
+    info = probe(THREESHOT)
+    if not info.has_audio:
+        pytest.skip("sample has no audio")
+    intervals = [(0, info.total_frames // 2), (info.total_frames // 2, info.total_frames)]
+    with tempfile.TemporaryDirectory() as td:
+        results = cut_shots(
+            THREESHOT,
+            intervals,
+            fps=info.fps,
+            output_dir=td,
+            filename_prefix="aud",
+            crf=23,
+            preset="veryfast",
+            keep_audio=True,
+            has_audio=True,
+            vfr=info.vfr,
+        )
+        assert all(r.success for r in results)
+        for r in results:
+            out_info = probe(r.path)
+            assert out_info.has_audio, f"audio stream missing in {r.path}"
+            assert out_info.audio_codec == "aac"
+
+
+@pytest.mark.skipif(not os.path.exists(REEL), reason="reel missing")
+def test_cut_real_reel_two_shots_by_detected_boundary():
+    info = probe(REEL)
+    # TransNet detected cut at frame 140 in this reel
+    intervals = [(0, 140), (140, info.total_frames)]
+    with tempfile.TemporaryDirectory() as td:
+        results = cut_shots(
+            REEL,
+            intervals,
+            fps=info.fps,
+            output_dir=td,
+            filename_prefix="reel",
+            crf=23,
+            preset="veryfast",
+            keep_audio=True,
+            has_audio=info.has_audio,
+            vfr=info.vfr,
+        )
+        assert all(r.success for r in results), [r.error for r in results if not r.success]
+        # Both clips should have video+audio, sum to within 0.3s of source
+        total_cut = sum(_probe_duration(r.path) for r in results)
+        assert abs(total_cut - info.duration_s) < 0.3, (total_cut, info.duration_s)
+
+
+@pytest.mark.skipif(not os.path.exists(THREESHOT), reason="sample missing")
+def test_cut_keep_audio_false_produces_video_only_clips():
+    info = probe(THREESHOT)
+    intervals = [(0, info.total_frames)]
+    with tempfile.TemporaryDirectory() as td:
+        results = cut_shots(
+            THREESHOT,
+            intervals,
+            fps=info.fps,
+            output_dir=td,
+            filename_prefix="noaud",
+            crf=23,
+            preset="veryfast",
+            keep_audio=False,
+            has_audio=info.has_audio,
+            vfr=info.vfr,
+        )
+        assert results[0].success
+        out_info = probe(results[0].path)
+        assert out_info.has_audio is False, "clip should have no audio stream"

ComfyUI-ShotSplitter/tests/test_ensemble.py

@@ -0,0 +1,61 @@
+"""Unit tests for ensemble merge logic — pure functions, no video I/O."""
+
+import pytest
+
+from detectors.ensemble import (
+    union_boundaries,
+    apply_min_shot_filter,
+    boundaries_to_intervals,
+)
+
+
+def test_union_within_window_merges_nearby():
+    a = [10, 50, 100]
+    b = [11, 48, 200]
+    # window=3: 10/11 merge -> 10; 50/48 merge -> 48; 100 alone; 200 alone
+    result = union_boundaries([a, b], window=3)
+    assert result == [10, 48, 100, 200]
+
+
+def test_union_outside_window_keeps_both():
+    a = [10, 50]
+    b = [20, 60]
+    # window=3: nothing merges (distances are 10)
+    result = union_boundaries([a, b], window=3)
+    assert result == [10, 20, 50, 60]
+
+
+def test_union_empty_inputs_returns_empty():
+    assert union_boundaries([[], []], window=3) == []
+    assert union_boundaries([], window=3) == []
+
+
+def test_boundaries_to_intervals_adds_sentinels():
+    result = boundaries_to_intervals([100, 200], total_frames=300)
+    assert result == [(0, 100), (100, 200), (200, 300)]
+
+
+def test_boundaries_to_intervals_no_cuts_gives_single_shot():
+    result = boundaries_to_intervals([], total_frames=500)
+    assert result == [(0, 500)]
+
+
+def test_min_shot_filter_merges_short_with_right_neighbor():
+    # fps=30, min=0.5s -> 15 frames
+    intervals = [(0, 100), (100, 105), (105, 300)]
+    # (100,105) is 5 frames, < 15; merge with right -> (100, 300)
+    result = apply_min_shot_filter(intervals, fps=30.0, min_shot_seconds=0.5)
+    assert result == [(0, 100), (100, 300)]
+
+
+def test_min_shot_filter_last_short_merges_with_left():
+    intervals = [(0, 100), (100, 300), (300, 305)]
+    # (300,305) is at the end; no right neighbor -> merge with left
+    result = apply_min_shot_filter(intervals, fps=30.0, min_shot_seconds=0.5)
+    assert result == [(0, 100), (100, 305)]
+
+
+def test_min_shot_filter_keeps_all_when_above_threshold():
+    intervals = [(0, 100), (100, 200), (200, 300)]
+    result = apply_min_shot_filter(intervals, fps=30.0, min_shot_seconds=0.5)
+    assert result == intervals

ComfyUI-ShotSplitter/tests/test_first_frame_reader.py

@@ -0,0 +1,39 @@
+"""Smoke test: read first frames of existing sample videos."""
+
+import os
+import pytest
+
+from first_frame_reader import read_first_frames
+
+THREESHOT = "/workspace/ComfyUI/input/test_3shots.mp4"
+IMBA = "/workspace/ComfyUI/input/imba.mp4"
+
+
+@pytest.mark.skipif(not os.path.exists(THREESHOT), reason="sample missing")
+def test_read_single_clip_returns_1x_tensor():
+    t = read_first_frames([THREESHOT])
+    assert t.shape[0] == 1
+    assert t.ndim == 4
+    assert t.shape[3] == 3
+    assert t.dtype.is_floating_point
+    assert 0.0 <= t.min().item() and t.max().item() <= 1.0
+
+
+@pytest.mark.skipif(not (os.path.exists(THREESHOT) and os.path.exists(IMBA)), reason="samples missing")
+def test_read_multiple_clips_uses_first_as_reference_size():
+    t = read_first_frames([THREESHOT, IMBA])
+    assert t.shape[0] == 2
+    # Second clip should be resized to match first
+    assert t[0].shape == t[1].shape
+
+
+def test_read_empty_list_returns_empty_tensor():
+    t = read_first_frames([])
+    assert t.shape[0] == 0
+
+
+def test_read_missing_file_returns_black_fallback():
+    t = read_first_frames(["/nonexistent/fake_clip.mp4"])
+    assert t.shape[0] == 1
+    # Black frame: all zeros
+    assert t.max().item() == 0.0

ComfyUI-ShotSplitter/tests/test_node_e2e.py

@@ -0,0 +1,102 @@
+"""End-to-end: run the full Oz_ShotSplitter pipeline on real samples."""
+
+import importlib.util
+import os
+import sys
+
+import pytest
+
+PACK_DIR = "/workspace/ComfyUI/custom_nodes/ComfyUI-ShotSplitter"
+
+
+def _load_pack():
+    """Load the hyphenated-name pack as a proper Python package."""
+    if "/workspace/ComfyUI" not in sys.path:
+        sys.path.insert(0, "/workspace/ComfyUI")
+
+    if "ComfyUI_ShotSplitter" in sys.modules:
+        return sys.modules["ComfyUI_ShotSplitter"]
+
+    spec = importlib.util.spec_from_file_location(
+        "ComfyUI_ShotSplitter",
+        os.path.join(PACK_DIR, "__init__.py"),
+        submodule_search_locations=[PACK_DIR],
+    )
+    mod = importlib.util.module_from_spec(spec)
+    sys.modules["ComfyUI_ShotSplitter"] = mod
+    spec.loader.exec_module(mod)
+    return mod
+
+
+THREESHOT = "test_3shots.mp4"
+REEL = "reel_multishot.mp4"
+
+
+@pytest.mark.skipif(
+    not os.path.exists(f"/workspace/ComfyUI/input/{THREESHOT}"),
+    reason="synthetic sample missing",
+)
+def test_e2e_3shot_synthetic_produces_three_clips():
+    pack = _load_pack()
+    node = pack.Oz_ShotSplitter()
+    out = node.run(
+        video=THREESHOT,
+        detector="ensemble",
+        min_shot_seconds=0.3,
+        merge_window_frames=3,
+        adaptive_threshold=3.0,
+        transnet_threshold=0.5,
+        output_subfolder="shots/e2e_syn_test",
+        filename_prefix="shot",
+        crf=23,
+        preset="veryfast",
+        keep_audio=True,
+    )
+    assert "result" in out
+    clip_paths, first_frames, shot_count, manifest_json = out["result"]
+    print(f"\n[E2E synthetic] shot_count={shot_count}")
+    print(f"[E2E synthetic] clip_paths={clip_paths}")
+    assert shot_count == 3, f"expected 3 shots for synthetic red/green/blue, got {shot_count}"
+    assert len(clip_paths) == 3
+    assert first_frames.shape[0] == 3
+    assert all(os.path.isfile(p) for p in clip_paths)
+    import json as _json
+    manifest = _json.loads(manifest_json)
+    assert len(manifest) == 3
+
+    # Verify the ui.videos payload is populated
+    assert "ui" in out
+    assert "videos" in out["ui"]
+    assert len(out["ui"]["videos"]) == 3
+    for v in out["ui"]["videos"]:
+        assert v["filename"].endswith(".mp4")
+        assert v["subfolder"] == "shots/e2e_syn_test"
+        assert v["type"] == "output"
+
+
+@pytest.mark.skipif(
+    not os.path.exists(f"/workspace/ComfyUI/input/{REEL}"),
+    reason="reel sample missing",
+)
+def test_e2e_real_reel_produces_two_or_more_clips():
+    pack = _load_pack()
+    node = pack.Oz_ShotSplitter()
+    out = node.run(
+        video=REEL,
+        detector="ensemble",
+        min_shot_seconds=0.5,
+        merge_window_frames=3,
+        adaptive_threshold=3.0,
+        transnet_threshold=0.5,
+        output_subfolder="shots/e2e_reel_test",
+        filename_prefix="shot",
+        crf=23,
+        preset="veryfast",
+        keep_audio=True,
+    )
+    clip_paths, first_frames, shot_count, manifest_json = out["result"]
+    print(f"\n[E2E reel] shot_count={shot_count}")
+    print(f"[E2E reel] clip_paths={clip_paths}")
+    assert shot_count >= 2, f"expected >=2 shots in reel, got {shot_count}"
+    assert all(os.path.isfile(p) for p in clip_paths)
+    assert first_frames.shape[0] == shot_count

ComfyUI-ShotSplitter/tests/test_pyscenedetect.py

@@ -0,0 +1,29 @@
+"""Smoke test for PySceneDetect adapter against imba.mp4 on remote."""
+
+import os
+import pytest
+
+from detectors.pyscenedetect_adapter import detect_pyscenedetect
+
+SAMPLE = "/workspace/ComfyUI/input/imba.mp4"
+
+
+@pytest.mark.skipif(not os.path.exists(SAMPLE), reason="sample video not present")
+def test_pyscenedetect_returns_list_of_ints():
+    boundaries = detect_pyscenedetect(SAMPLE, adaptive_threshold=3.0)
+    assert isinstance(boundaries, list)
+    assert all(isinstance(b, int) and b > 0 for b in boundaries)
+
+
+@pytest.mark.skipif(not os.path.exists(SAMPLE), reason="sample video not present")
+def test_pyscenedetect_sorted_and_unique():
+    boundaries = detect_pyscenedetect(SAMPLE, adaptive_threshold=3.0)
+    assert boundaries == sorted(set(boundaries))
+
+
+@pytest.mark.skipif(not os.path.exists(SAMPLE), reason="sample video not present")
+def test_pyscenedetect_prints_count(capsys):
+    """Just surface how many boundaries were detected for manual inspection."""
+    boundaries = detect_pyscenedetect(SAMPLE, adaptive_threshold=3.0)
+    print(f"\n[info] PySceneDetect boundaries for imba.mp4: {boundaries} (count={len(boundaries)})")
+    assert boundaries is not None  # sanity

ComfyUI-ShotSplitter/tests/test_transnet.py

@@ -0,0 +1,36 @@
+"""Smoke tests for TransNetV2 wrapper."""
+
+import os
+import pytest
+
+from detectors.transnet import detect_transnet
+
+THREESHOT = "/workspace/ComfyUI/input/test_3shots.mp4"
+REEL = "/workspace/ComfyUI/input/reel_multishot.mp4"
+IMBA = "/workspace/ComfyUI/input/imba.mp4"
+
+
+@pytest.mark.skipif(not os.path.exists(THREESHOT), reason="synthetic 3-shot missing")
+def test_transnet_detects_synthetic_3shot_ground_truth():
+    boundaries = detect_transnet(THREESHOT, threshold=0.5)
+    print(f"\n[info] TransNet on test_3shots.mp4: {boundaries}")
+    assert len(boundaries) == 2, f"expected 2 cuts, got {len(boundaries)}: {boundaries}"
+    # Ground truth: frame 60 and 120. Tolerance +/- 3 frames.
+    assert 57 <= boundaries[0] <= 63, f"first cut expected ~60, got {boundaries[0]}"
+    assert 117 <= boundaries[1] <= 123, f"second cut expected ~120, got {boundaries[1]}"
+
+
+@pytest.mark.skipif(not os.path.exists(REEL), reason="reel sample missing")
+def test_transnet_detects_at_least_one_cut_in_real_reel():
+    boundaries = detect_transnet(REEL, threshold=0.5)
+    print(f"\n[info] TransNet on reel_multishot.mp4: {boundaries}")
+    assert len(boundaries) >= 1, f"expected at least 1 cut in multi-shot reel, got {boundaries}"
+    # PSD found 1 cut near frame 140. TransNet should agree on at least one cut there or nearby.
+
+
+@pytest.mark.skipif(not os.path.exists(IMBA), reason="imba sample missing")
+def test_transnet_single_shot_returns_empty_or_one():
+    boundaries = detect_transnet(IMBA, threshold=0.5)
+    print(f"\n[info] TransNet on imba.mp4: {boundaries}")
+    # imba.mp4 is a single 8.7s phone video — expect 0, tolerate up to 1 (TransNet is sensitive)
+    assert len(boundaries) <= 1, f"expected <=1 cut in single-shot video, got {boundaries}"

ComfyUI-ShotSplitter/tests/test_video_probe.py

@@ -0,0 +1,29 @@
+"""Integration tests for video_probe — require a real file on the remote."""
+
+import os
+import pytest
+
+from video_probe import probe
+
+SAMPLE = "/workspace/ComfyUI/input/imba.mp4"
+
+
+@pytest.mark.skipif(not os.path.exists(SAMPLE), reason="sample video not present")
+def test_probe_returns_sensible_values():
+    info = probe(SAMPLE)
+    assert info.width > 0
+    assert info.height > 0
+    assert info.fps > 0
+    assert info.duration_s > 0
+    assert info.total_frames > 0
+
+
+@pytest.mark.skipif(not os.path.exists(SAMPLE), reason="sample video not present")
+def test_probe_detects_audio_stream_correctly():
+    info = probe(SAMPLE)
+    # Just check has_audio is a bool (whether True or False depends on the sample)
+    assert isinstance(info.has_audio, bool)
+    if info.has_audio:
+        assert info.audio_codec is not None
+        assert info.audio_sample_rate is not None and info.audio_sample_rate > 0
+        assert info.audio_channels is not None and info.audio_channels > 0