fow-cli 0.1.0__py3-none-any.whl

fly_on_the_wall/setup.py

@@ -0,0 +1,221 @@
+from __future__ import annotations
+
+import importlib.util
+from pathlib import Path
+from shutil import which
+
+import typer
+from rich.console import Console
+from rich.table import Table
+
+from fly_on_the_wall.db import database
+from fly_on_the_wall.doctor import run_checks
+from fly_on_the_wall.people import create_person, get_person, get_user_person, set_user_person
+from fly_on_the_wall.people_embeddings import people_embedding_status
+from fly_on_the_wall.publishing import add_publish_target, list_publish_targets
+from fly_on_the_wall.secrets import SecretError, get_api_key_status, set_api_key
+from fly_on_the_wall.storage import storage_paths
+from fly_on_the_wall.watch import add_watch_folder, list_watch_folders
+
+
+def run_setup(console: Console) -> None:
+    """Run the interactive first-run setup wizard."""
+    console.print("Fly on the Wall setup")
+    console.print("This command checks required setup and can configure optional features.")
+    console.print("")
+
+    _show_runtime_summary(console)
+    _setup_secrets(console)
+    _setup_user_identity(console)
+    _setup_speaker_identity(console)
+    _setup_publishing(console)
+    _setup_watch_folders(console)
+    _show_final_summary(console)
+
+
+def _show_runtime_summary(console: Console) -> None:
+    checks = run_checks()
+    table = Table(title="Setup Checks")
+    table.add_column("Check")
+    table.add_column("Status")
+    table.add_column("Detail")
+    for check in checks:
+        table.add_row(check.name, "ok" if check.ok else "missing", check.detail)
+    console.print(table)
+
+    if which("ffmpeg") is None:
+        console.print("FFmpeg is required for audio processing.")
+        console.print("Install it with your OS package manager, then run `fow doctor`.")
+    console.print("")
+
+
+def _setup_secrets(console: Console) -> None:
+    console.print("Secrets")
+    for provider in ["elevenlabs", "openai"]:
+        _setup_secret(console, provider)
+
+    console.print("")
+
+
+def _setup_secret(console: Console, provider: str) -> None:
+    status = get_api_key_status(provider)
+    if status.available:
+        console.print(f"- {provider}: configured via {status.source}")
+        return
+    if not typer.confirm(f"Store a {provider} API key in the OS keyring?", default=False):
+        console.print(f"- {provider}: skipped")
+        return
+    value = typer.prompt(f"{provider} API key", hide_input=True).strip()
+    if not value:
+        console.print(f"- {provider}: skipped empty value")
+        return
+    try:
+        set_api_key(provider, value)
+    except SecretError as exc:
+        console.print(str(exc))
+        _print_secret_env_fallback(console, provider)
+        return
+    console.print(f"- {provider}: stored in OS keyring")
+
+
+def _print_secret_env_fallback(console: Console, provider: str) -> None:
+    status = get_api_key_status(provider)
+    if status.env_var:
+        console.print(f"  Alternative: set {status.env_var} in your shell environment.")
+
+
+def _setup_user_identity(console: Console) -> None:
+    with database() as connection:
+        user = get_user_person(connection)
+        if user is not None:
+            console.print(f"User identity: {user.display_name}")
+            console.print("")
+            return
+
+        if not typer.confirm("Set your own person identity for speaker matching?", default=True):
+            console.print("User identity: skipped")
+            console.print("")
+            return
+
+        display_name = typer.prompt("Your display name").strip()
+        if not display_name:
+            console.print("User identity: skipped empty name")
+            console.print("")
+            return
+        person = get_person(connection, display_name) or create_person(connection, display_name)
+        set_user_person(connection, person.id)
+    console.print(f"User identity: {display_name}")
+    console.print("")
+
+
+def _setup_speaker_identity(console: Console) -> None:
+    console.print("Speaker identity")
+    if _identity_dependencies_available():
+        with database() as connection:
+            status = people_embedding_status(connection)
+        console.print("- local speaker identity dependencies: available")
+        console.print(f"- voice sample embeddings: {status.embedded_voice_samples}/{status.voice_samples} embedded")
+        if status.missing_voice_sample_embeddings:
+            console.print("Run `fow people embeddings backfill` to embed missing voice samples.")
+        console.print("")
+        return
+
+    console.print("- local speaker identity dependencies: missing")
+    if typer.confirm("Do you want guidance for enabling recurring speaker identity?", default=True):
+        console.print("Install or upgrade the package with the identity extra, then rerun setup:")
+        console.print('  uv tool install "fly-on-the-wall[identity]"')
+        console.print('  uv tool upgrade --reinstall "fly-on-the-wall[identity]"')
+        console.print('  pipx install "fly-on-the-wall[identity]"')
+        console.print('  pipx inject fly-on-the-wall "fly-on-the-wall[identity]"')
+        console.print("If you installed from source, run `uv sync --extra identity`.")
+    console.print("")
+
+
+def _identity_dependencies_available() -> bool:
+    return all(_module_available(module) for module in ["pyannote.audio", "torch", "torchaudio"])
+
+
+def _setup_publishing(console: Console) -> None:
+    with database() as connection:
+        targets = list_publish_targets(connection)
+        if targets:
+            console.print("Publishing")
+            for target in targets:
+                console.print(f"- {target.name}: {target.path}")
+            console.print("")
+            return
+
+        if not typer.confirm("Publish notes to an Obsidian folder?", default=False):
+            console.print("Publishing: skipped")
+            console.print("")
+            return
+
+        path = Path(typer.prompt("Obsidian folder path")).expanduser()
+        name = typer.prompt("Target name", default="obsidian").strip() or "obsidian"
+        auto_publish = typer.confirm("Auto-publish processed/refreshed meetings?", default=True)
+        path.mkdir(parents=True, exist_ok=True)
+        target = add_publish_target(connection, "obsidian", path, name, auto_publish=auto_publish)
+    console.print(f"Publishing: added {target.name} -> {target.path}")
+    console.print("")
+
+
+def _setup_watch_folders(console: Console) -> None:
+    with database() as connection:
+        folders = list_watch_folders(connection)
+        if folders:
+            _print_watch_folders(console, folders)
+            console.print("")
+            return
+
+        if not typer.confirm("Watch folders for new recordings?", default=False):
+            console.print("Watched folders: skipped")
+            console.print("")
+            return
+
+        while True:
+            _prompt_watch_folder(console, connection)
+            if not typer.confirm("Add another watched folder?", default=False):
+                break
+    console.print("")
+
+
+def _print_watch_folders(console: Console, folders: list) -> None:
+    console.print("Watched folders")
+    for folder in folders:
+        state = "enabled" if folder.enabled else "disabled"
+        console.print(f"- {folder.path} ({state})")
+
+
+def _prompt_watch_folder(console: Console, connection) -> None:
+    path_text = typer.prompt("Folder path to watch").strip()
+    if not path_text:
+        return
+    name = typer.prompt("Folder name", default="").strip() or None
+    folder = add_watch_folder(connection, Path(path_text), name)
+    console.print(f"Added watch folder: {folder.path}")
+
+
+def _show_final_summary(console: Console) -> None:
+    paths = storage_paths()
+    checks = run_checks()
+    required_failures = [
+        check for check in checks if check.name in {"python", "ffmpeg", "elevenlabs api key"} and not check.ok
+    ]
+
+    console.print("Setup summary")
+    console.print(f"- App data: {paths.root}")
+    console.print(f"- Required setup: {'ready' if not required_failures else 'incomplete'}")
+    if required_failures:
+        for check in required_failures:
+            console.print(f"  missing: {check.name} ({check.detail})")
+        console.print("Run `fow doctor` after fixing missing items.")
+    else:
+        console.print("Fly on the Wall is ready.")
+        console.print("Next: `fow process path/to/meeting.m4a`")
+
+
+def _module_available(module_name: str) -> bool:
+    try:
+        return importlib.util.find_spec(module_name) is not None
+    except ModuleNotFoundError:
+        return False

fly_on_the_wall/speaker_identity.py

@@ -0,0 +1,173 @@
+from __future__ import annotations
+
+from dataclasses import dataclass
+from pathlib import Path
+from sqlite3 import Connection
+
+from fly_on_the_wall.embeddings import (
+    EmbeddingBackend,
+    PyannoteEmbeddingBackend,
+    cache_local_speaker_embedding,
+    cache_voice_sample_embedding,
+)
+from fly_on_the_wall.people import create_person, get_person
+from fly_on_the_wall.speaker_matching import SpeakerMatch, match_local_speakers
+from fly_on_the_wall.speakers import assign_speaker_to_person
+from fly_on_the_wall.storage import StoragePaths, storage_paths
+from fly_on_the_wall.voice_samples import VoiceSample, create_voice_sample_from_span
+
+
+@dataclass(frozen=True)
+class SpeakerClip:
+    local_speaker_id: str
+    meeting_id: str
+    source_audio_path: Path
+    start_time: float
+    end_time: float
+
+
+@dataclass(frozen=True)
+class VoiceIdentityResult:
+    local_speaker_id: str
+    person_id: str
+    person_name: str
+    voice_sample: VoiceSample
+    embedded: bool
+
+
+def create_voice_identity_from_speaker(
+    connection: Connection,
+    local_speaker_id: str,
+    person_id_or_name: str,
+    create_missing_person: bool = False,
+    storage: StoragePaths | None = None,
+    backend: EmbeddingBackend | None = None,
+) -> VoiceIdentityResult:
+    person = get_person(connection, person_id_or_name)
+    if person is None and create_missing_person:
+        person = create_person(connection, person_id_or_name)
+    if person is None:
+        raise ValueError(f"Person not found: {person_id_or_name}")
+
+    clip = representative_speaker_clip(connection, local_speaker_id)
+    if clip is None:
+        raise ValueError(f"Local speaker has no timestamped audio: {local_speaker_id}")
+
+    paths = storage or storage_paths()
+    sample = create_voice_sample_from_span(
+        connection,
+        person.id,
+        clip.source_audio_path,
+        clip.meeting_id,
+        local_speaker_id,
+        clip.start_time,
+        clip.end_time,
+        paths,
+    )
+    assign_speaker_to_person(connection, local_speaker_id, person.id)
+
+    embedded = False
+    if backend is not None:
+        cache_voice_sample_embedding(connection, sample.id, backend, paths)
+        cache_local_speaker_embedding(connection, local_speaker_id, sample.audio_path, backend, paths)
+        embedded = True
+
+    return VoiceIdentityResult(
+        local_speaker_id=local_speaker_id,
+        person_id=person.id,
+        person_name=person.display_name,
+        voice_sample=sample,
+        embedded=embedded,
+    )
+
+
+def prepare_speaker_review_clip(
+    connection: Connection,
+    local_speaker_id: str,
+    storage: StoragePaths | None = None,
+) -> Path | None:
+    clip = representative_speaker_clip(connection, local_speaker_id)
+    if clip is None:
+        return None
+
+    paths = storage or storage_paths()
+    output_path = paths.artifacts / clip.meeting_id / "review-clips" / f"{local_speaker_id}.wav"
+    from fly_on_the_wall.audio import extract_clip
+
+    return extract_clip(clip.source_audio_path, output_path, clip.start_time, clip.end_time)
+
+
+def cache_provider_run_speaker_embeddings(
+    connection: Connection,
+    provider_run_id: str,
+    backend: EmbeddingBackend,
+    storage: StoragePaths | None = None,
+) -> int:
+    paths = storage or storage_paths()
+    rows = connection.execute(
+        "SELECT id FROM local_speakers WHERE provider_run_id = ? ORDER BY label",
+        (provider_run_id,),
+    ).fetchall()
+    count = 0
+    for row in rows:
+        review_clip = prepare_speaker_review_clip(connection, row["id"], paths)
+        if review_clip is None:
+            continue
+        cache_local_speaker_embedding(connection, row["id"], review_clip, backend, paths)
+        count += 1
+    return count
+
+
+def match_provider_run_speakers(
+    connection: Connection,
+    provider_run_id: str,
+    backend: EmbeddingBackend | None = None,
+    storage: StoragePaths | None = None,
+) -> list[SpeakerMatch]:
+    if backend is None and not _has_voice_sample_embeddings(connection):
+        return match_local_speakers(connection, provider_run_id)
+
+    resolved_backend = backend or PyannoteEmbeddingBackend()
+    cache_provider_run_speaker_embeddings(connection, provider_run_id, resolved_backend, storage)
+    return match_local_speakers(connection, provider_run_id)
+
+
+def _has_voice_sample_embeddings(connection: Connection) -> bool:
+    return (
+        connection.execute("SELECT 1 FROM voice_samples WHERE embedding_path IS NOT NULL LIMIT 1").fetchone()
+        is not None
+    )
+
+
+def representative_speaker_clip(
+    connection: Connection,
+    local_speaker_id: str,
+) -> SpeakerClip | None:
+    row = connection.execute(
+        """
+        SELECT local_speakers.meeting_id,
+               meetings.imported_audio_path,
+               segments.start_time,
+               segments.end_time
+        FROM segments
+        JOIN local_speakers ON local_speakers.id = segments.local_speaker_id
+        JOIN meetings ON meetings.id = local_speakers.meeting_id
+        WHERE segments.local_speaker_id = ?
+          AND segments.start_time IS NOT NULL
+          AND segments.end_time IS NOT NULL
+          AND meetings.imported_audio_path IS NOT NULL
+        ORDER BY (segments.end_time - segments.start_time) DESC, segments.sequence
+        LIMIT 1
+        """,
+        (local_speaker_id,),
+    ).fetchone()
+    if row is None:
+        return None
+
+    return SpeakerClip(
+        local_speaker_id=local_speaker_id,
+        meeting_id=row["meeting_id"],
+        source_audio_path=Path(row["imported_audio_path"]),
+        start_time=float(row["start_time"]),
+        end_time=float(row["end_time"]),
+    )

fly_on_the_wall/speaker_matching.py

@@ -0,0 +1,134 @@
+from __future__ import annotations
+
+import json
+from dataclasses import dataclass
+from pathlib import Path
+from sqlite3 import Connection
+from uuid import uuid4
+
+from fly_on_the_wall.config import ConfidenceThresholds
+from fly_on_the_wall.embeddings import cosine_similarity, read_embedding
+
+
+@dataclass(frozen=True)
+class SpeakerMatch:
+    local_speaker_id: str
+    person_id: str | None
+    status: str
+    confidence: float | None
+    margin: float | None
+
+
+def match_local_speakers(
+    connection: Connection,
+    provider_run_id: str,
+    thresholds: ConfidenceThresholds | None = None,
+) -> list[SpeakerMatch]:
+    resolved_thresholds = thresholds or ConfidenceThresholds()
+    local_speakers = connection.execute(
+        "SELECT id FROM local_speakers WHERE provider_run_id = ? ORDER BY label",
+        (provider_run_id,),
+    ).fetchall()
+
+    matches: list[SpeakerMatch] = []
+    for local_speaker in local_speakers:
+        match = match_local_speaker(connection, local_speaker["id"], resolved_thresholds)
+        _store_assignment(connection, match)
+        matches.append(match)
+    return matches
+
+
+def match_local_speaker(
+    connection: Connection,
+    local_speaker_id: str,
+    thresholds: ConfidenceThresholds,
+) -> SpeakerMatch:
+    local_embedding = connection.execute(
+        """
+        SELECT embedding_path FROM local_speaker_embeddings
+        WHERE local_speaker_id = ?
+        ORDER BY created_at DESC
+        LIMIT 1
+        """,
+        (local_speaker_id,),
+    ).fetchone()
+    if local_embedding is None:
+        return SpeakerMatch(local_speaker_id, None, "unknown", None, None)
+
+    local_vector = read_embedding(Path(local_embedding["embedding_path"]))
+    scores = _score_people(connection, local_vector)
+    if not scores:
+        return SpeakerMatch(local_speaker_id, None, "unknown", None, None)
+
+    best = scores[0]
+    second_score = scores[1]["score"] if len(scores) > 1 else 0.0
+    margin = best["score"] - second_score
+    if best["score"] >= thresholds.named:
+        status = "known"
+        person_id = best["person_id"]
+    elif best["score"] >= thresholds.uncertain:
+        status = "uncertain"
+        person_id = best["person_id"]
+    else:
+        status = "unknown"
+        person_id = None
+    return SpeakerMatch(local_speaker_id, person_id, status, best["score"], margin)
+
+
+def _score_people(connection: Connection, local_vector: list[float]) -> list[dict[str, float | str]]:
+    rows = connection.execute(
+        """
+        SELECT person_id, id AS voice_sample_id, embedding_path
+        FROM voice_samples
+        WHERE embedding_path IS NOT NULL
+        """
+    ).fetchall()
+    best_by_person: dict[str, dict[str, float | str]] = {}
+    for row in rows:
+        score = cosine_similarity(local_vector, read_embedding(Path(row["embedding_path"])))
+        current = best_by_person.get(row["person_id"])
+        if current is None or score > current["score"]:
+            best_by_person[row["person_id"]] = {
+                "person_id": row["person_id"],
+                "voice_sample_id": row["voice_sample_id"],
+                "score": score,
+            }
+    return sorted(best_by_person.values(), key=lambda item: item["score"], reverse=True)
+
+
+def _store_assignment(connection: Connection, match: SpeakerMatch) -> None:
+    existing = connection.execute(
+        "SELECT evidence_json FROM speaker_assignments WHERE local_speaker_id = ?",
+        (match.local_speaker_id,),
+    ).fetchone()
+    if existing is not None:
+        try:
+            evidence = json.loads(existing["evidence_json"])
+        except json.JSONDecodeError:
+            evidence = {}
+        if evidence.get("method") == "user_correction":
+            return
+
+    with connection:
+        connection.execute(
+            """
+            INSERT INTO speaker_assignments(
+                id, local_speaker_id, person_id, status, confidence, margin, evidence_json
+            ) VALUES (?, ?, ?, ?, ?, ?, ?)
+            ON CONFLICT(local_speaker_id) DO UPDATE SET
+                person_id = excluded.person_id,
+                status = excluded.status,
+                confidence = excluded.confidence,
+                margin = excluded.margin,
+                evidence_json = excluded.evidence_json
+            """,
+            (
+                str(uuid4()),
+                match.local_speaker_id,
+                match.person_id,
+                match.status,
+                match.confidence,
+                match.margin,
+                json.dumps({"method": "embedding_cosine"}),
+            ),
+        )