swap-cli 0.1.2__tar.gz → 0.1.3__tar.gz

{swap_cli-0.1.2 → swap_cli-0.1.3}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: swap-cli
-Version: 0.1.2
+Version: 0.1.3
 Summary: Real-time deepfake on your desktop. Bring your own Decart API key.
 Project-URL: Homepage, https://github.com/BlAcQW/swap-cli
 Project-URL: Repository, https://github.com/BlAcQW/swap-cli

{swap_cli-0.1.2 → swap_cli-0.1.3}/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "swap-cli"
-version = "0.1.2"
+version = "0.1.3"
 description = "Real-time deepfake on your desktop. Bring your own Decart API key."
 authors = [{ name = "BlAcQW", email = "enochhenyo@gmail.com" }]
 readme = "README.md"

{swap_cli-0.1.2 → swap_cli-0.1.3}/src/swap_cli/display.py

@@ -39,16 +39,11 @@ class Display:
         on_quit: callable = lambda: None,  # type: ignore[assignment]
         virtual_camera: bool = False,
         watermark: WatermarkRemover | None = None,
-        show_window: bool = True,
     ) -> None:
         self._track = track
         self._record_path = record_path
         self._on_quit = on_quit
         self._virtual_camera = virtual_camera
-        # Show the cv2 preview window. False in GUI mode: the session runs on a
-        # worker thread, and macOS forbids OpenCV HighGUI off the main thread, so
-        # the GUI renders frames itself (tkinter, main thread) via latest_frame().
-        self._show_window = show_window
         # Sprint 15: optional per-frame watermark remover. None = no-op.
         # Injected as a configured instance so _loop stays thin and the
         # remover is unit-testable in isolation.
@@ -79,8 +74,7 @@ class Display:
             with suppress(Exception):
                 self._vcam.close()
             self._vcam = None
-        if self._show_window:
-            cv2.destroyAllWindows()
+        cv2.destroyAllWindows()
 
     def snapshot(self, dest: Path) -> bool:
         """Save the most recent rendered frame as JPEG. Returns success."""
@@ -89,19 +83,9 @@ class Display:
         dest.parent.mkdir(parents=True, exist_ok=True)
         return cv2.imwrite(str(dest), self._latest_bgr)
 
-    def latest_frame(self) -> np.ndarray | None:
-        """Most recent processed (cleaned) frame — for the in-app GUI preview.
-        The render loop rebinds this each frame, so the read is atomic."""
-        return self._latest_bgr
-
-    def latest_raw_frame(self) -> np.ndarray | None:
-        """Most recent RAW (pre-removal) frame — for GUI watermark capture."""
-        return self._latest_raw_bgr
-
     async def _loop(self) -> None:
-        if self._show_window:
-            cv2.namedWindow(WINDOW_TITLE, cv2.WINDOW_NORMAL)
-            cv2.resizeWindow(WINDOW_TITLE, 960, 540)
+        cv2.namedWindow(WINDOW_TITLE, cv2.WINDOW_NORMAL)
+        cv2.resizeWindow(WINDOW_TITLE, 960, 540)
         first_frame = True
         try:
             while not self._stopped.is_set():
@@ -117,6 +101,7 @@ class Display:
                 self._maybe_init_writer(bgr.shape, fps_guess=20)
                 if self._writer is not None:
                     self._writer.write(bgr)
+                cv2.imshow(WINDOW_TITLE, bgr)
                 # Sprint 14k: also push the frame to the OBS Virtual Camera
                 # driver so Zoom/Meet/Discord pick it up as a real camera.
                 # pyvirtualcam expects RGB.
@@ -130,15 +115,6 @@ class Display:
                         except Exception as err:  # noqa: BLE001
                             print(f"[display] vcam send error: {err}", flush=True)
                             # Don't tear the driver down on a single bad frame.
-                if not self._show_window:
-                    # GUI renders the preview itself (tkinter, main thread) and
-                    # drives capture/stop — no cv2 window/keys here. Yield so a
-                    # non-vcam session doesn't spin the loop hot.
-                    if not self._virtual_camera:
-                        await asyncio.sleep(0)
-                    first_frame = False
-                    continue
-                cv2.imshow(WINDOW_TITLE, bgr)
                 if first_frame:
                     # Flash topmost so the cv2 window pops above the tk GUI on
                     # Windows. We don't want it pinned forever — just one beat.
@@ -166,20 +142,11 @@ class Display:
                 self._on_quit()
             self._stopped.set()
         finally:
-            if self._show_window:
-                cv2.destroyAllWindows()
-
-    def capture_watermark(self, roi: tuple[int, int, int, int]) -> None:
-        """Public entry for the GUI: capture the badge template from a caller-
-        supplied ROI (the GUI's tk drag-selector), instead of cv2.selectROI."""
-        self._capture_watermark_template(roi=roi)
+            cv2.destroyAllWindows()
 
-    def _capture_watermark_template(
-        self, roi: tuple[int, int, int, int] | None = None
-    ) -> None:
-        """Select the watermark on the current frame and save it as the template
-        PNG (Sprint 15). `roi` is supplied by the GUI's tk selector; when None
-        (CLI / cv2-window mode) we fall back to cv2.selectROI on the W key.
+    def _capture_watermark_template(self) -> None:
+        """Drag-select the watermark on the current frame and save it as the
+        template PNG (Sprint 15). Bound to the `w` key in the preview window.
 
         Captures from the RAW (pre-removal) frame so it works even while
         removal is on but not matching. Persists the path AND the frame width
@@ -196,13 +163,12 @@ class Display:
         try:
             from . import config as _config
 
-            if roi is None:
-                roi = cv2.selectROI(
-                    "select watermark — ENTER to save, C to cancel",
-                    source,
-                    showCrosshair=False,
-                )
-                cv2.destroyWindow("select watermark — ENTER to save, C to cancel")
+            roi = cv2.selectROI(
+                "select watermark — ENTER to save, C to cancel",
+                source,
+                showCrosshair=False,
+            )
+            cv2.destroyWindow("select watermark — ENTER to save, C to cancel")
             x, y, w, h = (int(v) for v in roi)
             if w <= 0 or h <= 0:
                 print("[display] watermark capture cancelled.", flush=True)

{swap_cli-0.1.2 → swap_cli-0.1.3}/src/swap_cli/gui.py

@@ -11,10 +11,9 @@ import asyncio
 import sys
 import threading
 import tkinter as tk
-from contextlib import suppress
 from pathlib import Path
 from tkinter import filedialog
-from typing import TYPE_CHECKING, Any, Callable
+from typing import TYPE_CHECKING, Callable
 
 import customtkinter as ctk
 from PIL import Image
@@ -117,14 +116,6 @@ class SwapGUI(ctk.CTk):
         # Set by runtime.run_session via the on_runtime_ready callback. Calling
         # this from the tk main thread cleanly winds the session down.
         self._stop_session: Callable[[], None] | None = None
-        # In-app live preview (macOS-safe: rendered on the tk main thread instead
-        # of an OpenCV window). _display is the live Display, handed over via
-        # on_display_ready; the rest is the preview-window/render-loop state.
-        self._display: Any = None
-        self._preview_win: ctk.CTkToplevel | None = None
-        self._preview_label: ctk.CTkLabel | None = None
-        self._preview_image: ctk.CTkImage | None = None
-        self._preview_after_id: str | None = None
         # Voice-only test state (no Decart). Independent of _session_thread.
         self._voice_test_thread: threading.Thread | None = None
         self._voice_test_loop: asyncio.AbstractEventLoop | None = None
@@ -480,7 +471,7 @@ class SwapGUI(ctk.CTk):
         # Footer (pinned)
         ctk.CTkLabel(
             bottom,
-            text="swap-cli — click Stop (or close the preview) to end the session",
+            text="swap-cli — Press Q in the preview window to stop",
             font=ctk.CTkFont(size=10),
             text_color="#6b7280",
         ).pack(pady=(8, 0))
@@ -669,11 +660,6 @@ class SwapGUI(ctk.CTk):
         def _capture_stop(stop_fn: Callable[[], None]) -> None:
             self._stop_session = stop_fn
 
-        def _on_display_ready(disp: Any) -> None:
-            # Called from the worker thread; just store the ref. The main-thread
-            # render loop (started below) picks it up to draw frames.
-            self._display = disp
-
         # Voice opts: only set when toggle is on AND a library/user voice is
         # picked. We resolve the mic + virtual cable here using
         # voice_router's auto-detect so the user doesn't have to pick from
@@ -708,8 +694,6 @@ class SwapGUI(ctk.CTk):
             record=record_path,
             on_status_change=_emit_status,
             on_runtime_ready=_capture_stop,
-            show_preview_window=False,  # render in-app (macOS-safe), not a cv2 window
-            on_display_ready=_on_display_ready,
             reference_voice=voice_id,
             microphone_device=mic_device,
             voice_output_device=out_device,
@@ -771,9 +755,6 @@ class SwapGUI(ctk.CTk):
         self._session_thread = threading.Thread(target=worker, daemon=True)
         self._session_thread.start()
 
-        # Open the in-app live preview (tk main thread) and start polling frames.
-        self._open_preview()
-
         # Best-effort license check (non-blocking).
         threading.Thread(target=self._check_license_async, daemon=True).start()
 
@@ -830,116 +811,6 @@ class SwapGUI(ctk.CTk):
         self._stop_btn.configure(state="disabled")
         self._stop_session = None
 
-    # ── In-app live preview (macOS-safe: tk main thread, not a cv2 window) ──
-
-    def _open_preview(self) -> None:
-        """Open the live preview window and start polling frames on the main
-        thread. Replaces the cv2 window, which can't run off the main thread on
-        macOS (the session runs on a worker thread)."""
-        self._close_preview()
-        win = ctk.CTkToplevel(self)
-        win.title("swap — Lucy 2 live")
-        win.geometry("900x600")
-        self._preview_win = win
-        self._preview_label = ctk.CTkLabel(win, text="Connecting…")
-        self._preview_label.pack(fill="both", expand=True, padx=8, pady=8)
-        bar = ctk.CTkFrame(win, fg_color="transparent")
-        bar.pack(fill="x", padx=8, pady=(0, 8))
-        ctk.CTkButton(
-            bar, text="Capture watermark", command=self._on_capture_watermark
-        ).pack(side="left")
-        ctk.CTkButton(
-            bar, text="Stop", fg_color="#b91c1c", hover_color="#991b1b",
-            command=self._on_stop,
-        ).pack(side="right")
-        # Closing the preview window ends the session (mirrors the old Q-to-quit).
-        win.protocol("WM_DELETE_WINDOW", self._on_stop)
-        self._preview_after_id = self.after(100, self._render_preview)
-
-    def _render_preview(self) -> None:
-        win = self._preview_win
-        if win is None or not win.winfo_exists():
-            return
-        disp = self._display
-        frame = disp.latest_frame() if disp is not None else None
-        if frame is not None and self._preview_label is not None:
-            try:
-                img = Image.fromarray(frame[:, :, ::-1].copy())  # BGR→RGB
-                w, h = img.size
-                scale = min(884 / w, 500 / h, 1.0)
-                size = (max(1, int(w * scale)), max(1, int(h * scale)))
-                self._preview_image = ctk.CTkImage(light_image=img, dark_image=img, size=size)
-                self._preview_label.configure(image=self._preview_image, text="")
-            except Exception:  # preview is best-effort; never crash the GUI
-                pass
-        # ~20 fps preview; the virtual camera still runs full-rate on the worker.
-        self._preview_after_id = self.after(50, self._render_preview)
-
-    def _close_preview(self) -> None:
-        if self._preview_after_id is not None:
-            with suppress(Exception):
-                self.after_cancel(self._preview_after_id)
-            self._preview_after_id = None
-        if self._preview_win is not None:
-            with suppress(Exception):
-                self._preview_win.destroy()
-        self._preview_win = None
-        self._preview_label = None
-        self._preview_image = None
-        self._display = None
-
-    def _on_capture_watermark(self) -> None:
-        """Grab the current RAW frame and let the user box the badge (tk drag
-        selector) — the cross-platform replacement for the cv2 W-key capture."""
-        disp = self._display
-        frame = disp.latest_raw_frame() if disp is not None else None
-        if frame is None:
-            self._status_var.set("No live frame yet — wait for the preview.")
-            return
-        self._select_roi_and_capture(frame)
-
-    def _select_roi_and_capture(self, frame: Any) -> None:
-        from PIL import ImageTk
-
-        h, w = frame.shape[:2]
-        scale = min(900 / w, 600 / h, 1.0)
-        dw, dh = max(1, int(w * scale)), max(1, int(h * scale))
-        photo = ImageTk.PhotoImage(Image.fromarray(frame[:, :, ::-1].copy()).resize((dw, dh)))
-        top = ctk.CTkToplevel(self)
-        top.title("Drag a box around the badge, release to capture")
-        canvas = tk.Canvas(top, width=dw, height=dh, highlightthickness=0, cursor="crosshair")
-        canvas.pack()
-        canvas.create_image(0, 0, anchor="nw", image=photo)
-        canvas._photo = photo  # keep a ref so it isn't GC'd
-        st: dict[str, Any] = {"x0": 0, "y0": 0, "rect": None}
-
-        def on_press(e: Any) -> None:
-            st["x0"], st["y0"] = e.x, e.y
-            if st["rect"] is not None:
-                canvas.delete(st["rect"])
-            st["rect"] = canvas.create_rectangle(e.x, e.y, e.x, e.y, outline="#22d3ee", width=2)
-
-        def on_drag(e: Any) -> None:
-            if st["rect"] is not None:
-                canvas.coords(st["rect"], st["x0"], st["y0"], e.x, e.y)
-
-        def on_release(e: Any) -> None:
-            rx, ry = int(min(st["x0"], e.x) / scale), int(min(st["y0"], e.y) / scale)
-            rw, rh = int(abs(e.x - st["x0"]) / scale), int(abs(e.y - st["y0"]) / scale)
-            with suppress(Exception):
-                top.destroy()
-            if rw > 5 and rh > 5 and self._display is not None:
-                try:
-                    self._display.capture_watermark((rx, ry, rw, rh))
-                    self._status_var.set("Watermark captured — removal updated.")
-                except Exception as err:
-                    self._status_var.set(f"Capture failed: {err}")
-
-        canvas.bind("<Button-1>", on_press)
-        canvas.bind("<B1-Motion>", on_drag)
-        canvas.bind("<ButtonRelease-1>", on_release)
-        top.grab_set()
-
     def _on_enable_voice(self) -> None:
         """Open the Enable Voice modal: prereq check + guided install."""
         modal = _EnableVoiceModal(self)
@@ -1136,9 +1007,6 @@ class SwapGUI(ctk.CTk):
         return label_to_id.get(self._voice_var.get())
 
     def _set_running(self, running: bool) -> None:
-        if not running:
-            # Session ended (stop / drop / error) → tear down the live preview.
-            self._close_preview()
         self._live_btn.configure(state="disabled" if running else "normal")
         self._stop_btn.configure(state="normal" if running else "disabled")
         self._select_face_btn.configure(state="disabled" if running else "normal")

{swap_cli-0.1.2 → swap_cli-0.1.3}/src/swap_cli/runtime.py

@@ -66,14 +66,6 @@ class RunOptions:
     # the session is set up. Calling that function from any thread cleanly
     # winds down the live session.
     on_runtime_ready: Callable[[Callable[[], None]], None] | None = None
-    # Show the cv2 preview window. False in GUI mode: the GUI renders the preview
-    # itself (tkinter, main thread) because macOS forbids OpenCV windows off the
-    # main thread (the session runs on a worker thread).
-    show_preview_window: bool = True
-    # Optional callback handed the live Display once created, so the GUI can poll
-    # frames (display.latest_frame()) and drive watermark capture. Called from the
-    # worker thread; the GUI marshals to the tk main thread.
-    on_display_ready: Callable[[Any], None] | None = None
     # Voice cloning (optional, sprint 13). All None = video-only, current behavior.
     # When all three are set, run_session will spin a parallel voice task in 13b.
     reference_voice: str | None = None  # voice id (library) or path to WAV/MP3
@@ -170,8 +162,6 @@ async def run_session(opts: RunOptions) -> None:
                             display_box=display_box,
                             virtual_camera=opts.virtual_camera,
                             watermark=_build_watermark_remover(opts),
-                            show_window=opts.show_preview_window,
-                            on_display_ready=opts.on_display_ready,
                         ),
                         initial_state=ModelState(
                             prompt=Prompt(text=opts.prompt, enhance=True),
@@ -376,8 +366,6 @@ def _on_remote_stream(
     display_box: list[Display | None],
     virtual_camera: bool = False,
     watermark: Any = None,
-    show_window: bool = True,
-    on_display_ready: Callable[[Any], None] | None = None,
 ) -> None:
     record_path = record if record is not None else None
     if record is not None and not record.is_absolute():
@@ -391,13 +379,9 @@ def _on_remote_stream(
         on_quit=quit_event.set,
         virtual_camera=virtual_camera,
         watermark=watermark,
-        show_window=show_window,
     )
     disp.start()
     display_box[0] = disp
-    if on_display_ready is not None:
-        with suppress(Exception):
-            on_display_ready(disp)
 
 
 def _build_set_input(prompt: str, reference: str) -> Any:

swap_cli-0.1.3/src/swap_cli/version.py

@@ -0,0 +1 @@
+__version__ = "0.1.3"

{swap_cli-0.1.2 → swap_cli-0.1.3}/tests/test_watermark.py

@@ -853,66 +853,5 @@ def test_bundled_template_uses_its_own_ref_width() -> None:
     assert rem._params.template_ref_width == BUNDLED_TEMPLATE_REF_WIDTH
 
 
-def test_display_windowless_skips_cv2_window(monkeypatch) -> None:
-    """GUI mode (show_window=False): the loop opens NO cv2 window (macOS can't
-    run HighGUI off the main thread) and exposes frames via latest_frame()."""
-    import asyncio
-    from unittest.mock import MagicMock
-
-    from swap_cli import display as disp_mod
-    from swap_cli.display import Display
-
-    called = {"w": False}
-    for fn in ("namedWindow", "resizeWindow", "imshow", "waitKey",
-               "destroyAllWindows", "setWindowProperty"):
-        monkeypatch.setattr(disp_mod.cv2, fn,
-                            lambda *a, **k: called.__setitem__("w", True))
-
-    arr = np.zeros((12, 16, 3), np.uint8)
-    arr[4:8, 4:12] = 200
-    disp = Display(track=MagicMock(), show_window=False)
-    calls = {"n": 0}
-
-    async def _recv():
-        calls["n"] += 1
-        if calls["n"] >= 2:
-            disp._stopped.set()
-        frame = MagicMock()
-        frame.to_ndarray = lambda format: arr  # to_ndarray(format=...) keyword
-        return frame
-
-    disp._track.recv = _recv
-    asyncio.run(disp._loop())  # must not raise
-    assert called["w"] is False  # no cv2 window touched
-    assert disp.latest_frame() is not None
-    assert disp.latest_raw_frame() is not None
-
-
-def test_capture_watermark_with_roi_writes_template(tmp_path: Path, monkeypatch) -> None:
-    """GUI capture path: capture_watermark(roi) crops the RAW frame, writes the
-    template, and updates config — no cv2 window needed (replaces the W key)."""
-    from unittest.mock import MagicMock
-
-    from swap_cli import config as cfgmod
-    from swap_cli import display as disp_mod
-    from swap_cli.display import Display
-
-    monkeypatch.setattr(cfgmod, "config_path", lambda: tmp_path / "config.toml")
-    dest = tmp_path / "wm.png"
-    monkeypatch.setattr(disp_mod, "default_watermark_template_path", lambda: dest)
-
-    frame = _textured_frame()
-    cv2.putText(frame, "AI GENERATED", (310, 84), cv2.FONT_HERSHEY_SIMPLEX, 0.6,
-                (255, 255, 255), 2, cv2.LINE_AA)
-    disp = Display(track=MagicMock(), show_window=False)
-    disp._latest_raw_bgr = frame
-    disp.capture_watermark((300, 60, 180, 40))
-
-    assert dest.is_file()
-    cfg = cfgmod.load()
-    assert cfg.watermark_template == str(dest)
-    assert cfg.watermark_template_width == frame.shape[1]
-
-
 if __name__ == "__main__":
     sys.exit(pytest.main([__file__, "-v"]))

swap_cli-0.1.2/src/swap_cli/version.py

@@ -1 +0,0 @@
-__version__ = "0.1.2"