swap-cli 0.1.1__py3-none-any.whl

swap_cli/config.py

@@ -0,0 +1,152 @@
+"""Local config: Decart API key + license key, stored in user config dir."""
+
+from __future__ import annotations
+
+import hashlib
+import os
+import platform
+import tomllib
+import uuid
+from dataclasses import dataclass
+from pathlib import Path
+from typing import Any
+
+from platformdirs import user_config_dir
+
+APP_NAME = "swap-cli"
+CONFIG_FILENAME = "config.toml"
+
+
+@dataclass(frozen=True)
+class Config:
+    """User configuration. Read-only at runtime."""
+
+    license_key: str | None
+    decart_api_key: str | None
+    license_cached_at: int | None  # unix seconds; for offline grace
+    license_cached_valid_until: int | None  # unix seconds
+    # Voice cloning preferences (sprint 13). All optional — older config files
+    # without these fields load fine. voice_enabled is the sticky toggle state.
+    voice_enabled: bool = False
+    last_voice_id: str | None = None
+    last_microphone: int | None = None
+    last_voice_output: int | None = None
+    # Sprint 14e: voice path is RVC-only. Field kept for forward
+    # compatibility (future engines: Applio, GPT-SoVITS).
+    voice_engine: str = "rvc"
+    # Sprint 14i: when True, the streaming engine sets index_rate=0
+    # (skip Faiss retrieval). Trades timbre quality for big speedup —
+    # essential on weak GPUs or when using voices with huge .index files.
+    voice_fast: bool = False
+
+    @property
+    def is_complete(self) -> bool:
+        return bool(self.license_key) and bool(self.decart_api_key)
+
+
+def config_path() -> Path:
+    return Path(user_config_dir(APP_NAME)) / CONFIG_FILENAME
+
+
+def load() -> Config:
+    """Load config from disk. Returns an empty config if file is missing."""
+    path = config_path()
+    if not path.exists():
+        return Config(None, None, None, None)
+    try:
+        data = tomllib.loads(path.read_text("utf-8"))
+    except (tomllib.TOMLDecodeError, OSError):
+        return Config(None, None, None, None)
+
+    return Config(
+        license_key=_clean(data.get("license_key")),
+        decart_api_key=_clean(data.get("decart_api_key")),
+        license_cached_at=_int_or_none(data.get("license_cached_at")),
+        license_cached_valid_until=_int_or_none(data.get("license_cached_valid_until")),
+        voice_enabled=bool(data.get("voice_enabled", False)),
+        last_voice_id=_clean(data.get("last_voice_id")),
+        last_microphone=_int_or_none(data.get("last_microphone")),
+        last_voice_output=_int_or_none(data.get("last_voice_output")),
+        voice_engine=_clean(data.get("voice_engine")) or "rvc",
+        voice_fast=bool(data.get("voice_fast", False)),
+    )
+
+
+def save(cfg: Config) -> Path:
+    """Write config atomically with restrictive perms."""
+    path = config_path()
+    path.parent.mkdir(parents=True, exist_ok=True)
+
+    body: list[str] = []
+    if cfg.license_key:
+        body.append(f'license_key = "{_escape(cfg.license_key)}"')
+    if cfg.decart_api_key:
+        body.append(f'decart_api_key = "{_escape(cfg.decart_api_key)}"')
+    if cfg.license_cached_at is not None:
+        body.append(f"license_cached_at = {cfg.license_cached_at}")
+    if cfg.license_cached_valid_until is not None:
+        body.append(f"license_cached_valid_until = {cfg.license_cached_valid_until}")
+    if cfg.voice_enabled:
+        body.append("voice_enabled = true")
+    if cfg.last_voice_id:
+        body.append(f'last_voice_id = "{_escape(cfg.last_voice_id)}"')
+    if cfg.last_microphone is not None:
+        body.append(f"last_microphone = {cfg.last_microphone}")
+    if cfg.last_voice_output is not None:
+        body.append(f"last_voice_output = {cfg.last_voice_output}")
+    if cfg.voice_engine and cfg.voice_engine != "rvc":
+        body.append(f'voice_engine = "{_escape(cfg.voice_engine)}"')
+    if cfg.voice_fast:
+        body.append("voice_fast = true")
+
+    text = "\n".join(body) + "\n"
+    tmp = path.with_suffix(path.suffix + ".tmp")
+    tmp.write_text(text, encoding="utf-8")
+    if os.name != "nt":
+        os.chmod(tmp, 0o600)
+    tmp.replace(path)
+    return path
+
+
+def update(**kwargs: Any) -> Config:
+    """Patch the on-disk config with new values."""
+    current = load()
+    merged = Config(
+        license_key=kwargs.get("license_key", current.license_key),
+        decart_api_key=kwargs.get("decart_api_key", current.decart_api_key),
+        license_cached_at=kwargs.get("license_cached_at", current.license_cached_at),
+        license_cached_valid_until=kwargs.get(
+            "license_cached_valid_until", current.license_cached_valid_until
+        ),
+        voice_enabled=kwargs.get("voice_enabled", current.voice_enabled),
+        last_voice_id=kwargs.get("last_voice_id", current.last_voice_id),
+        last_microphone=kwargs.get("last_microphone", current.last_microphone),
+        last_voice_output=kwargs.get("last_voice_output", current.last_voice_output),
+        voice_engine=kwargs.get("voice_engine", current.voice_engine),
+        voice_fast=kwargs.get("voice_fast", current.voice_fast),
+    )
+    save(merged)
+    return merged
+
+
+def machine_id() -> str:
+    """Stable, hashed device identifier. Never sends raw MAC/serial off-device."""
+    raw = f"{uuid.getnode()}|{platform.node()}|{platform.machine()}|{platform.system()}"
+    return hashlib.sha256(raw.encode("utf-8")).hexdigest()[:32]
+
+
+def _clean(value: Any) -> str | None:
+    if not isinstance(value, str):
+        return None
+    stripped = value.strip()
+    return stripped or None
+
+
+def _int_or_none(value: Any) -> int | None:
+    if isinstance(value, int):
+        return value
+    return None
+
+
+def _escape(value: str) -> str:
+    return value.replace("\\", "\\\\").replace('"', '\\"')

swap_cli/devices.py

@@ -0,0 +1,216 @@
+"""Cross-platform camera enumeration.
+
+We probe up to MAX_CAMERAS by opening each index in a SUBPROCESS so a
+native crash (common on Alienware/IR cameras with OpenCV) only kills
+the probe — not the GUI.
+
+Friendly names:
+- Windows: pygrabber's DirectShow filter list ("Logitech BRIO", etc.)
+- Linux: /sys/class/video4linux/videoN/name
+- macOS: AVFoundation gives us no easy name list, fall back to generic
+"""
+
+from __future__ import annotations
+
+import platform
+import subprocess
+import sys
+from dataclasses import dataclass
+from pathlib import Path
+
+MAX_CAMERAS = 6
+PROBE_TIMEOUT_S = 3.0
+
+
+@dataclass(frozen=True)
+class CameraDevice:
+    index: int
+    label: str
+    # Sprint 14o: True when the device's name matches a virtual-camera
+    # driver (OBS / Snap / ManyCam / DroidCam / XSplit / generic). The
+    # GUI deprioritises these in auto-pick to avoid the feedback loop:
+    # swap reading from OBS Virtual Camera while also writing to it.
+    virtual: bool = False
+
+
+# Virtual-camera deny list. Sprint 14o: user hit a feedback loop where
+# swap auto-picked OBS Virtual Camera (because the real webcam probe
+# timed out) and then also wrote its output to it — Lucy was consuming
+# its own previous frames. Mirror voice_router's Sound Mapper pattern.
+_VIRTUAL_CAMERA_NEEDLES = (
+    "obs virtual",
+    "virtual camera",
+    "virtual webcam",
+    "snap camera",
+    "manycam",
+    "xsplit",
+    "droidcam",
+    "e2esoft",
+    "iriun",
+)
+
+
+def is_virtual_camera(name: str) -> bool:
+    """True iff the device name matches a known virtual-camera driver."""
+    n = (name or "").lower()
+    return any(needle in n for needle in _VIRTUAL_CAMERA_NEEDLES)
+
+
+# Inline probe script — runs in a child Python process so an OpenCV
+# native crash (access violation on e.g. Alienware IR cameras) only kills
+# the child, not the GUI.
+_PROBE_SCRIPT = """
+import sys
+import cv2
+idx = int(sys.argv[1])
+backend = int(sys.argv[2])
+cap = cv2.VideoCapture(idx, backend)
+try:
+    if not cap.isOpened():
+        sys.exit(2)
+    ok, _ = cap.read()
+    sys.exit(0 if ok else 3)
+finally:
+    cap.release()
+"""
+
+
+def _backend_for_platform() -> int:
+    """Pick the most stable cv2 capture backend for the current OS."""
+    import cv2
+
+    if sys.platform == "win32":
+        return cv2.CAP_DSHOW
+    if sys.platform == "darwin":
+        return cv2.CAP_AVFOUNDATION
+    return cv2.CAP_V4L2
+
+
+def _probe_one(index: int, backend: int) -> tuple[bool, str]:
+    """Probe a single camera index in an isolated subprocess.
+
+    Returns (ok, reason). reason is one of:
+      ""             - probe succeeded
+      "timeout"      - cv2.VideoCapture blocked > PROBE_TIMEOUT_S; most
+                       common cause is another app holding the camera
+                       (Zoom/Teams/Discord/browsers)
+      "not_present"  - probe returned non-zero exit; the index doesn't
+                       map to a real device
+      "error:<msg>"  - subprocess raised something unexpected
+    """
+    try:
+        proc = subprocess.run(
+            [sys.executable, "-c", _PROBE_SCRIPT, str(index), str(backend)],
+            capture_output=True,
+            timeout=PROBE_TIMEOUT_S,
+        )
+        if proc.returncode == 0:
+            return True, ""
+        return False, "not_present"
+    except subprocess.TimeoutExpired:
+        return False, "timeout"
+    except Exception as err:  # noqa: BLE001
+        return False, f"error:{err}"
+
+
+def _windows_friendly_names() -> dict[int, str]:
+    """Return {index: friendly name} from DirectShow's filter list.
+
+    pygrabber wraps the same DirectShow API OBS / Discord / Zoom use, so
+    the names match what users see in those apps. Returns {} if the
+    library is missing or anything goes sideways.
+    """
+    try:
+        from pygrabber.dshow_graph import FilterGraph  # type: ignore[import-not-found]
+
+        graph = FilterGraph()
+        names = graph.get_input_devices()
+        return {i: name for i, name in enumerate(names)}
+    except Exception as err:  # noqa: BLE001
+        print(f"[devices] friendly-name lookup unavailable: {err}", flush=True)
+        return {}
+
+
+def _linux_friendly_names() -> dict[int, str]:
+    """Read /sys/class/video4linux/videoN/name on Linux. Empty dict on failure."""
+    out: dict[int, str] = {}
+    base = Path("/sys/class/video4linux")
+    if not base.exists():
+        return out
+    try:
+        for entry in base.glob("video*"):
+            stem = entry.name.removeprefix("video")
+            if not stem.isdigit():
+                continue
+            idx = int(stem)
+            name_file = entry / "name"
+            if name_file.exists():
+                out[idx] = name_file.read_text(encoding="utf-8", errors="replace").strip()
+    except Exception as err:  # noqa: BLE001
+        print(f"[devices] /sys readout failed: {err}", flush=True)
+    return out
+
+
+def _friendly_names() -> dict[int, str]:
+    if sys.platform == "win32":
+        return _windows_friendly_names()
+    if sys.platform.startswith("linux"):
+        return _linux_friendly_names()
+    return {}
+
+
+def enumerate_cameras() -> list[CameraDevice]:
+    """Return working cameras with their friendly names where possible.
+
+    Sprint 14o: each device now carries a `virtual` flag so the GUI can
+    deprioritise OBS/Snap/etc. when picking the default input. Probe
+    failures distinguish timeout (camera held by another app) from
+    not_present (no device at that index).
+    """
+    backend = _backend_for_platform()
+    names = _friendly_names()
+    if names:
+        print(f"[devices] friendly names: {names}", flush=True)
+
+    devices: list[CameraDevice] = []
+    for i in range(MAX_CAMERAS):
+        print(f"[devices] probing index {i} (subprocess, backend={backend})", flush=True)
+        ok, reason = _probe_one(i, backend)
+        if ok:
+            friendly = names.get(i)
+            label = _label_for(i, friendly)
+            virtual = is_virtual_camera(friendly or "")
+            tag = " [virtual]" if virtual else ""
+            print(f"[devices] index {i} ok — {label}{tag}", flush=True)
+            devices.append(CameraDevice(index=i, label=label, virtual=virtual))
+        elif reason == "timeout":
+            print(
+                f"[devices] index {i} probe timed out — another app may be holding "
+                "this camera (Zoom/Teams/Discord/browsers). Close it and re-launch.",
+                flush=True,
+            )
+        elif reason.startswith("error:"):
+            print(f"[devices] index {i} probe error: {reason[6:]}", flush=True)
+        else:
+            print(f"[devices] index {i} unavailable", flush=True)
+    real = sum(1 for d in devices if not d.virtual)
+    virtual = sum(1 for d in devices if d.virtual)
+    print(
+        f"[devices] {len(devices)} camera(s) found ({real} real, {virtual} virtual)",
+        flush=True,
+    )
+    return devices
+
+
+def _label_for(index: int, friendly: str | None = None) -> str:
+    if friendly:
+        return f"{friendly} (#{index})"
+    system = platform.system()
+    suffix = {
+        "Darwin": "FaceTime / iSight",
+        "Windows": "DirectShow",
+        "Linux": "/dev/video",
+    }.get(system, "")
+    if index == 0:
+        return f"Camera 0 (default){' · ' + suffix if suffix else ''}"
+    return f"Camera {index}"

swap_cli/display.py

@@ -0,0 +1,177 @@
+"""Render an aiortc remote video track in a cv2.imshow window.
+
+Also handles snapshot-on-keypress, optional MP4 recording, and
+(Sprint 14k) optional output to a virtual camera device so apps like
+Zoom/Meet/Discord see the deepfake stream directly.
+"""
+
+from __future__ import annotations
+
+import asyncio
+import time
+from contextlib import suppress
+from pathlib import Path
+from typing import TYPE_CHECKING, Any
+
+import cv2
+import numpy as np
+
+if TYPE_CHECKING:
+    from aiortc.mediastreams import MediaStreamTrack
+
+
+WINDOW_TITLE = "swap — Lucy 2 live"
+
+
+class Display:
+    """Pulls frames from a remote MediaStreamTrack and renders them.
+
+    Press Q in the window or call `stop()` to terminate the loop.
+    """
+
+    def __init__(
+        self,
+        track: MediaStreamTrack,
+        *,
+        record_path: Path | None = None,
+        on_quit: callable = lambda: None,  # type: ignore[assignment]
+        virtual_camera: bool = False,
+    ) -> None:
+        self._track = track
+        self._record_path = record_path
+        self._on_quit = on_quit
+        self._virtual_camera = virtual_camera
+        self._writer: cv2.VideoWriter | None = None
+        # pyvirtualcam.Camera — lazy-init on first frame so we know the
+        # actual width/height from Decart's stream rather than guessing.
+        self._vcam: Any = None
+        self._task: asyncio.Task[None] | None = None
+        self._stopped = asyncio.Event()
+        self._latest_bgr: np.ndarray | None = None
+
+    def start(self) -> None:
+        self._task = asyncio.create_task(self._loop())
+
+    async def stop(self) -> None:
+        self._stopped.set()
+        if self._task:
+            self._task.cancel()
+            with suppress(asyncio.CancelledError):
+                await self._task
+        if self._writer is not None:
+            self._writer.release()
+        if self._vcam is not None:
+            with suppress(Exception):
+                self._vcam.close()
+            self._vcam = None
+        cv2.destroyAllWindows()
+
+    def snapshot(self, dest: Path) -> bool:
+        """Save the most recent rendered frame as JPEG. Returns success."""
+        if self._latest_bgr is None:
+            return False
+        dest.parent.mkdir(parents=True, exist_ok=True)
+        return cv2.imwrite(str(dest), self._latest_bgr)
+
+    async def _loop(self) -> None:
+        cv2.namedWindow(WINDOW_TITLE, cv2.WINDOW_NORMAL)
+        cv2.resizeWindow(WINDOW_TITLE, 960, 540)
+        first_frame = True
+        try:
+            while not self._stopped.is_set():
+                frame = await self._track.recv()
+                bgr = frame.to_ndarray(format="bgr24")
+                self._latest_bgr = bgr
+                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.
+                if self._virtual_camera:
+                    self._maybe_init_vcam(bgr.shape, fps_guess=20)
+                    if self._vcam is not None:
+                        try:
+                            rgb = cv2.cvtColor(bgr, cv2.COLOR_BGR2RGB)
+                            self._vcam.send(rgb)
+                            self._vcam.sleep_until_next_frame()
+                        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 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.
+                    with suppress(Exception):
+                        cv2.setWindowProperty(WINDOW_TITLE, cv2.WND_PROP_TOPMOST, 1)
+                        cv2.waitKey(1)
+                        cv2.setWindowProperty(WINDOW_TITLE, cv2.WND_PROP_TOPMOST, 0)
+                    first_frame = False
+                key = cv2.waitKey(1) & 0xFF
+                if key in (ord("q"), ord("Q"), 27):  # q or ESC
+                    self._on_quit()
+                    self._stopped.set()
+                    break
+        except asyncio.CancelledError:
+            raise
+        except Exception as err:  # noqa: BLE001 — show + exit cleanly
+            print(f"[display] error: {err}")
+        finally:
+            cv2.destroyAllWindows()
+
+    def _maybe_init_writer(self, shape: tuple[int, ...], fps_guess: int) -> None:
+        if self._record_path is None or self._writer is not None:
+            return
+        h, w = shape[:2]
+        fourcc = cv2.VideoWriter_fourcc(*"mp4v")  # type: ignore[attr-defined]
+        self._record_path.parent.mkdir(parents=True, exist_ok=True)
+        self._writer = cv2.VideoWriter(str(self._record_path), fourcc, fps_guess, (w, h))
+
+    def _maybe_init_vcam(self, shape: tuple[int, ...], fps_guess: int) -> None:
+        """Open pyvirtualcam.Camera on the first frame so we use the
+        actual stream resolution. Silently no-ops if pyvirtualcam isn't
+        installed or no virtual camera driver is registered — preview
+        window keeps working in that case."""
+        if self._vcam is not None:
+            return
+        try:
+            import pyvirtualcam  # type: ignore[import-not-found]
+        except ImportError:
+            # Pure-Python wrapper missing; ship hint via the doctor row.
+            self._virtual_camera = False
+            print(
+                "[display] vcam: pyvirtualcam not installed — `pip install pyvirtualcam`",
+                flush=True,
+            )
+            return
+        h, w = shape[:2]
+        try:
+            # backend=None lets pyvirtualcam pick the right one per OS:
+            # Windows → OBS Virtual Camera, macOS → OBS, Linux → v4l2loopback.
+            self._vcam = pyvirtualcam.Camera(width=w, height=h, fps=fps_guess)
+            print(
+                f"[display] vcam ready: '{self._vcam.device}' "
+                f"{w}x{h}@{fps_guess}fps — Zoom/Meet/Discord can pick it now.",
+                flush=True,
+            )
+        except Exception as err:  # noqa: BLE001
+            # Driver not installed, busy, or fps unsupported. Disable vcam
+            # for this session and keep the preview window healthy.
+            self._virtual_camera = False
+            self._vcam = None
+            print(
+                f"[display] vcam unavailable: {err}\n"
+                "[display] Install OBS Studio for the OBS Virtual Camera driver: "
+                "https://obsproject.com/download",
+                flush=True,
+            )
+
+
+def default_snapshot_path() -> Path:
+    ts = time.strftime("%Y%m%d-%H%M%S")
+    return Path.cwd() / "snapshots" / f"swap-{ts}.jpg"
+
+
+def default_recording_path() -> Path:
+    ts = time.strftime("%Y%m%d-%H%M%S")
+    return Path.cwd() / "recordings" / f"swap-{ts}.mp4"