fow-cli 0.1.0__py3-none-any.whl

fly_on_the_wall/cli_speaker_review.py

@@ -0,0 +1,315 @@
+from __future__ import annotations
+
+from dataclasses import dataclass
+from pathlib import Path
+from typing import Annotated
+
+import typer
+from rich.console import Console
+
+from fly_on_the_wall.audio import AudioError
+from fly_on_the_wall.cli_menu import MenuChoice, select_menu
+from fly_on_the_wall.config import load_config
+from fly_on_the_wall.db import database
+from fly_on_the_wall.embeddings import EmbeddingBackend, PyannoteEmbeddingBackend
+from fly_on_the_wall.people import Person, list_people
+from fly_on_the_wall.processing import refresh_meeting
+from fly_on_the_wall.reanalysis import rerun_speaker_matching_for_meetings
+from fly_on_the_wall.speaker_identity import (
+    create_voice_identity_from_speaker,
+    prepare_speaker_review_clip,
+)
+from fly_on_the_wall.speakers import (
+    assign_speaker_to_person,
+    confirm_speaker_assignment,
+    list_review_speakers,
+    mark_speaker_ignored,
+    speaker_examples,
+)
+
+console = Console()
+
+
+@dataclass(frozen=True)
+class SpeakerReviewResult:
+    backend: EmbeddingBackend | None
+    changed_meeting: str | None = None
+    quit_review: bool = False
+
+
+def speakers_review(
+    meeting: Annotated[str | None, typer.Option("--meeting", "-m", help="Meeting ID or slug.")] = None,
+    include_uncertain: Annotated[
+        bool,
+        typer.Option("--include-uncertain", help="Also review uncertain speaker matches."),
+    ] = False,
+    only_uncertain: Annotated[
+        bool,
+        typer.Option("--only-uncertain", help="Review only uncertain speaker matches."),
+    ] = False,
+) -> None:
+    """Interactively review and assign unknown or uncertain meeting speakers."""
+    backend: EmbeddingBackend | None = None
+    changed_meetings: set[str] = set()
+    with database() as connection:
+        speakers = list_review_speakers(connection, meeting, include_uncertain, only_uncertain)
+        if not speakers:
+            console.print("No speakers found for review.")
+            return
+
+        for speaker in speakers:
+            review = _review_one_speaker(connection, speaker, backend)
+            backend = review.backend
+            if review.changed_meeting is not None:
+                changed_meetings.add(review.changed_meeting)
+            if review.quit_review:
+                break
+
+        _refresh_reviewed_meetings(connection, changed_meetings, backend)
+
+
+def _review_one_speaker(connection, speaker, backend: EmbeddingBackend | None) -> SpeakerReviewResult:
+    _print_speaker_review_prompt(connection, speaker)
+    clip_path = _speaker_review_clip(connection, speaker["id"])
+    while True:
+        action = _select_speaker_review_action(clip_path, speaker.get("review_kind") == "uncertain")
+        result = _apply_speaker_review_action(connection, speaker, action, backend)
+        backend = result.backend
+        if _speaker_review_action_finished(action, result):
+            return result
+
+
+def _speaker_review_action_finished(action: str, result: SpeakerReviewResult) -> bool:
+    return result.changed_meeting is not None or result.quit_review or action == "s"
+
+
+def _print_speaker_review_prompt(connection, speaker) -> None:
+    console.print(f"Meeting speaker: {speaker['id']}")
+    console.print(f"Meeting: {speaker['meeting_slug']}")
+    console.print(f"Provider label: {speaker['label']}")
+    if speaker.get("review_kind") == "uncertain":
+        console.print(f"Suggested person: {speaker['suggested_person_name']}")
+        if speaker.get("confidence") is not None:
+            console.print(f"Confidence: {speaker['confidence']:.3f}")
+        if speaker.get("margin") is not None:
+            console.print(f"Margin: {speaker['margin']:.3f}")
+    examples = speaker_examples(connection, speaker["id"], limit=1)
+    if examples:
+        console.print(f"Example: {examples[0]['text']}")
+
+
+def _speaker_review_clip(connection, speaker_id: str) -> Path | None:
+    try:
+        clip_path = prepare_speaker_review_clip(connection, speaker_id)
+    except AudioError as exc:
+        console.print(f"Could not extract review clip: {exc}")
+        return None
+    if clip_path is not None:
+        console.print(f"Clip: {clip_path}")
+    return clip_path
+
+
+def _apply_speaker_review_action(
+    connection, speaker, action: str, backend: EmbeddingBackend | None
+) -> SpeakerReviewResult:
+    if action == "a":
+        return _assign_with_voice_sample(connection, speaker, backend)
+    if action == "n":
+        return _assign_without_voice_sample(connection, speaker, backend)
+    if action == "c":
+        return _create_person_with_voice_sample(connection, speaker, backend)
+    if action == "o":
+        return _create_person_without_voice_sample(connection, speaker, backend)
+    if action == "v":
+        return _confirm_suggested_assignment(connection, speaker, backend)
+    return _apply_non_assignment_action(connection, speaker, action, backend)
+
+
+def _apply_non_assignment_action(
+    connection, speaker, action: str, backend: EmbeddingBackend | None
+) -> SpeakerReviewResult:
+    if action == "i":
+        mark_speaker_ignored(connection, speaker["id"])
+        console.print("Ignored meeting speaker; it will not appear in future reviews.")
+        return SpeakerReviewResult(backend, speaker["meeting_slug"])
+    if action == "s":
+        console.print("Skipped.")
+        return SpeakerReviewResult(backend)
+    if action == "q":
+        console.print("Review cancelled.")
+        return SpeakerReviewResult(backend, quit_review=True)
+    console.print("Choose an available action.")
+    return SpeakerReviewResult(backend)
+
+
+def _assign_with_voice_sample(connection, speaker, backend: EmbeddingBackend | None) -> SpeakerReviewResult:
+    person = _select_person(connection)
+    if person is None:
+        console.print("Assignment cancelled.")
+        return SpeakerReviewResult(backend)
+    backend = backend or _try_embedding_backend()
+    try:
+        result = create_voice_identity_from_speaker(connection, speaker["id"], person.id, storage=None, backend=backend)
+    except ValueError as exc:
+        console.print(str(exc))
+        return SpeakerReviewResult(backend)
+    console.print(f"Assigned meeting speaker to {result.person_name}")
+    console.print(f"Voice sample: {result.voice_sample.audio_path}")
+    return SpeakerReviewResult(backend, speaker["meeting_slug"])
+
+
+def _assign_without_voice_sample(connection, speaker, backend: EmbeddingBackend | None) -> SpeakerReviewResult:
+    person = _select_person(connection)
+    if person is None:
+        console.print("Assignment cancelled.")
+        return SpeakerReviewResult(backend)
+    assignment = assign_speaker_to_person(connection, speaker["id"], person.id)
+    console.print(f"Assigned meeting speaker to {assignment['name']} without voice sample.")
+    return SpeakerReviewResult(backend, speaker["meeting_slug"])
+
+
+def _create_person_with_voice_sample(connection, speaker, backend: EmbeddingBackend | None) -> SpeakerReviewResult:
+    name = typer.prompt("New known person name")
+    backend = backend or _try_embedding_backend()
+    try:
+        result = create_voice_identity_from_speaker(
+            connection,
+            speaker["id"],
+            name,
+            create_missing_person=True,
+            storage=None,
+            backend=backend,
+        )
+    except ValueError as exc:
+        console.print(str(exc))
+        return SpeakerReviewResult(backend)
+    console.print(f"Created known person {result.person_name}")
+    console.print(f"Voice sample: {result.voice_sample.audio_path}")
+    return SpeakerReviewResult(backend, speaker["meeting_slug"])
+
+
+def _create_person_without_voice_sample(connection, speaker, backend: EmbeddingBackend | None) -> SpeakerReviewResult:
+    name = typer.prompt("New known person name")
+    assignment = assign_speaker_to_person(connection, speaker["id"], name)
+    console.print(f"Created known person {assignment['name']}")
+    console.print(f"Assigned meeting speaker to {assignment['name']} without voice sample.")
+    return SpeakerReviewResult(backend, speaker["meeting_slug"])
+
+
+def _confirm_suggested_assignment(connection, speaker, backend: EmbeddingBackend | None) -> SpeakerReviewResult:
+    suggested_person_id = speaker.get("suggested_person_id")
+    suggested_person_name = speaker.get("suggested_person_name")
+    if not suggested_person_id:
+        console.print("No suggested person available for this speaker.")
+        return SpeakerReviewResult(backend)
+
+    backend = backend or _try_embedding_backend()
+    try:
+        result = create_voice_identity_from_speaker(connection, speaker["id"], suggested_person_id, backend=backend)
+    except ValueError as exc:
+        console.print(f"Could not create voice sample ({exc}); confirming assignment only.")
+        assignment = confirm_speaker_assignment(connection, speaker["id"])
+        console.print(f"Confirmed meeting speaker as {assignment['name']}.")
+        return SpeakerReviewResult(backend, speaker["meeting_slug"])
+
+    console.print(f"Confirmed meeting speaker as {suggested_person_name or result.person_name}.")
+    console.print(f"Voice sample: {result.voice_sample.audio_path}")
+    return SpeakerReviewResult(backend, speaker["meeting_slug"])
+
+
+def _refresh_reviewed_meetings(connection, changed_meetings: set[str], backend: EmbeddingBackend | None) -> None:
+    if not changed_meetings:
+        return
+    refresh_meetings = _speaker_review_follow_up(connection, changed_meetings)
+    if not refresh_meetings:
+        return
+    config = load_config()
+    for meeting_slug in sorted(refresh_meetings):
+        result = refresh_meeting(
+            connection,
+            meeting_slug,
+            config,
+            embedding_backend=backend,
+            progress=lambda message: console.print(f"-> {message}"),
+        )
+        console.print(f"Refreshed {result.meeting.slug}")
+        console.print(f"Transcript: {result.export.transcript_path}")
+        console.print(f"Analysis: {result.export.analysis_path}")
+
+
+def _speaker_review_follow_up(connection, changed_meetings: set[str]) -> set[str]:
+    console.print(f"Speaker review changed {len(changed_meetings)} meeting(s).")
+    while True:
+        action = _select_speaker_review_follow_up_action()
+        if action == "a":
+            return set(changed_meetings)
+        if action == "g":
+            return _speaker_review_global_follow_up(connection, changed_meetings)
+        if action == "n":
+            console.print("Refresh skipped. You can run refresh later.")
+            return set()
+        console.print("Choose an available follow-up action.")
+
+
+def _speaker_review_global_follow_up(connection, changed_meetings: set[str]) -> set[str]:
+    results = rerun_speaker_matching_for_meetings(connection)
+    refreshed = {result["meeting_slug"] for result in results if result["match_count"]}
+    if not refreshed:
+        console.print("No new speaker matches found in other meetings.")
+        return set(changed_meetings)
+    console.print(f"Refreshed speaker matching with new matches: {len(refreshed)}")
+    return set(changed_meetings) | refreshed
+
+
+def _try_embedding_backend() -> EmbeddingBackend | None:
+    try:
+        return PyannoteEmbeddingBackend()
+    except RuntimeError as exc:
+        console.print(f"Voice sample saved without embedding ({exc})")
+        return None
+
+
+def _select_person(connection) -> Person | None:
+    people = list_people(connection)
+    if not people:
+        console.print("No known people found. Create a known person instead.")
+        return None
+
+    choices = [
+        MenuChoice(str(index) if index <= 9 else None, person.display_name, person.id)
+        for index, person in enumerate(people, start=1)
+    ]
+    choices.append(MenuChoice("c", "Cancel", None))
+    selected_person_id = select_menu("Known person", choices)
+    if selected_person_id is None:
+        return None
+    return next(person for person in people if person.id == selected_person_id)
+
+
+def _select_speaker_review_action(clip_path: Path | None, can_confirm: bool = False) -> str:
+    choices = []
+    if clip_path is not None:
+        choices.append(MenuChoice("p", "Play clip", None, playback_path=clip_path))
+    if can_confirm:
+        choices.append(MenuChoice("v", "Confirm suggested person", "v"))
+    choices.extend(
+        [
+            MenuChoice("a", "Assign with voice sample", "a"),
+            MenuChoice("n", "Assign only", "n"),
+            MenuChoice("c", "New known person with voice sample", "c"),
+            MenuChoice("o", "New known person only", "o"),
+            MenuChoice("i", "Ignore speaker forever", "i"),
+            MenuChoice("s", "Skip this time", "s"),
+            MenuChoice("q", "Quit review", "q"),
+        ]
+    )
+    return select_menu("Action", choices) or "q"
+
+
+def _select_speaker_review_follow_up_action() -> str:
+    choices = [
+        MenuChoice("a", "Refresh affected meetings", "a"),
+        MenuChoice("g", "Refresh speaker matching globally", "g"),
+        MenuChoice("n", "Do nothing", "n"),
+    ]
+    return select_menu("Next", choices) or "n"

fly_on_the_wall/cli_watch.py

@@ -0,0 +1,209 @@
+from __future__ import annotations
+
+from pathlib import Path
+from time import sleep
+from typing import Annotated
+
+import typer
+from rich.console import Console
+from rich.table import Table
+from watchfiles import watch
+
+from fly_on_the_wall.config import load_config
+from fly_on_the_wall.db import database
+from fly_on_the_wall.watch import (
+    DEFAULT_STABLE_AGE_SECONDS,
+    add_watch_folder,
+    list_watch_folders,
+    remove_watch_folder,
+    scan_watch_folders,
+    set_watch_folder_enabled,
+)
+
+console = Console()
+watch_app = typer.Typer(help="Process audio from watched folders.", no_args_is_help=True)
+watch_folders_app = typer.Typer(help="Manage watched folders.", no_args_is_help=True)
+watch_app.add_typer(watch_folders_app, name="folders")
+
+
+@watch_app.command("scan")
+def watch_scan(
+    stable_age_seconds: Annotated[
+        int,
+        typer.Option(
+            "--stable-age-seconds",
+            min=0,
+            help="Only process files unchanged for at least this many seconds.",
+        ),
+    ] = DEFAULT_STABLE_AGE_SECONDS,
+) -> None:
+    """Scan enabled watched folders once and process new audio files."""
+    _scan_watch_once(load_config(), stable_age_seconds)
+
+
+@watch_app.command("run")
+def watch_run(
+    interval_seconds: Annotated[
+        int,
+        typer.Option("--interval-seconds", min=1, help="Seconds between safety scans."),
+    ] = 60,
+    stable_age_seconds: Annotated[
+        int,
+        typer.Option(
+            "--stable-age-seconds",
+            min=0,
+            help="Only process files unchanged for at least this many seconds.",
+        ),
+    ] = DEFAULT_STABLE_AGE_SECONDS,
+) -> None:
+    """Watch enabled folders and process new audio files as they appear."""
+    config = load_config()
+    folders = _enabled_watch_folders()
+    if not folders:
+        console.print("No enabled watch folders configured.")
+        console.print("Add one with: fow watch folders add <path>")
+        raise typer.Exit(code=1)
+
+    console.print("Watching folders for audio changes. Press Ctrl+C to stop.")
+    for path in [folder.path for folder in folders]:
+        console.print(f"- {path}")
+
+    _scan_watch_once(config, stable_age_seconds)
+    while True:
+        _watch_run_once(config, stable_age_seconds, interval_seconds)
+
+
+@watch_folders_app.command("add")
+def watch_folders_add(
+    path: Annotated[Path, typer.Argument(file_okay=False, dir_okay=True)],
+    name: Annotated[str | None, typer.Option("--name", "-n", help="Optional folder name.")] = None,
+) -> None:
+    """Add a folder to scan for audio files."""
+    with database() as connection:
+        try:
+            folder = add_watch_folder(connection, path, name)
+        except Exception as exc:
+            console.print(str(exc))
+            raise typer.Exit(code=1) from exc
+    console.print(f"Added watch folder {folder.path}")
+    if folder.name:
+        console.print(f"Name: {folder.name}")
+
+
+@watch_folders_app.command("list")
+def watch_folders_list() -> None:
+    """List watched folders."""
+    with database() as connection:
+        folders = list_watch_folders(connection)
+    if not folders:
+        console.print("No watch folders configured.")
+        return
+    table = Table(title="Watch Folders")
+    table.add_column("ID")
+    table.add_column("Name")
+    table.add_column("Enabled")
+    table.add_column("Path")
+    for folder in folders:
+        table.add_row(
+            folder.id,
+            folder.name or "",
+            "yes" if folder.enabled else "no",
+            str(folder.path),
+        )
+    console.print(table)
+
+
+@watch_folders_app.command("remove")
+def watch_folders_remove(identifier: str) -> None:
+    """Remove a watched folder by id, name, or path."""
+    with database() as connection:
+        folder = remove_watch_folder(connection, identifier)
+    if folder is None:
+        console.print(f"Watch folder not found: {identifier}")
+        raise typer.Exit(code=1)
+    console.print(f"Removed watch folder {folder.path}")
+
+
+@watch_folders_app.command("enable")
+def watch_folders_enable(identifier: str) -> None:
+    """Enable a watched folder by id, name, or path."""
+    _set_watch_folder_enabled_command(identifier, True)
+
+
+@watch_folders_app.command("disable")
+def watch_folders_disable(identifier: str) -> None:
+    """Disable a watched folder by id, name, or path."""
+    _set_watch_folder_enabled_command(identifier, False)
+
+
+def _watch_run_once(config, stable_age_seconds: int, interval_seconds: int) -> None:
+    existing_paths = _existing_watch_paths()
+    if not existing_paths:
+        console.print("No watched folders are currently mounted. Running safety scan.")
+        _scan_watch_once(config, stable_age_seconds)
+        sleep(interval_seconds)
+        return
+
+    changes = _watch_for_changes(existing_paths, interval_seconds)
+    if changes is None:
+        _scan_watch_once(config, stable_age_seconds)
+        return
+
+    _print_watch_changes(changes)
+    _scan_watch_once(config, stable_age_seconds)
+
+
+def _enabled_watch_folders():
+    with database() as connection:
+        return [folder for folder in list_watch_folders(connection) if folder.enabled]
+
+
+def _existing_watch_paths() -> list[Path]:
+    return [folder.path for folder in _enabled_watch_folders() if folder.path.is_dir()]
+
+
+def _watch_for_changes(paths: list[Path], interval_seconds: int):
+    try:
+        return next(
+            watch(
+                *paths,
+                recursive=True,
+                yield_on_timeout=True,
+                rust_timeout=interval_seconds * 1000,
+            )
+        )
+    except (OSError, RuntimeError) as exc:
+        console.print(f"Watch backend restarted after folder change: {exc}")
+        return None
+
+
+def _print_watch_changes(changes) -> None:
+    if changes:
+        console.print(f"Detected {len(changes)} file change(s).")
+        return
+    console.print("Running periodic safety scan.")
+
+
+def _scan_watch_once(config, stable_age_seconds: int) -> None:
+    with database() as connection:
+        result = scan_watch_folders(
+            connection,
+            config,
+            stable_age_seconds=stable_age_seconds,
+            progress=lambda message: console.print(f"-> {message}"),
+        )
+    console.print(
+        f"Watch scan complete: {result.processed} processed, "
+        f"{result.ignored} ignored, {result.skipped} skipped, "
+        f"{result.failed} failed, {result.seen} seen."
+    )
+
+
+def _set_watch_folder_enabled_command(identifier: str, enabled: bool) -> None:
+    with database() as connection:
+        folder = set_watch_folder_enabled(connection, identifier, enabled)
+    if folder is None:
+        console.print(f"Watch folder not found: {identifier}")
+        raise typer.Exit(code=1)
+    state = "Enabled" if enabled else "Disabled"
+    console.print(f"{state} watch folder {folder.path}")

fly_on_the_wall/config.py

@@ -0,0 +1,92 @@
+from __future__ import annotations
+
+import os
+from pathlib import Path
+from typing import Any, Literal
+
+import yaml
+from pydantic import BaseModel, ConfigDict, Field, ValidationError
+
+APP_DIR_NAME = "fly-on-the-wall"
+CONFIG_FILE_NAME = "config.yaml"
+GLOSSARY_FILE_NAME = "glossary.yaml"
+
+ProviderName = Literal["elevenlabs", "openai"]
+CleanupMode = Literal["off", "deterministic", "light"]
+
+API_KEY_ENV_VARS: dict[str, str] = {
+    "elevenlabs": "ELEVENLABS_API_KEY",
+    "openai": "OPENAI_API_KEY",
+}
+
+
+class ConfigError(RuntimeError):
+    """Raised when the application config cannot be loaded."""
+
+
+class ConfidenceThresholds(BaseModel):
+    model_config = ConfigDict(extra="forbid")
+
+    named: float = Field(default=0.78, ge=0.0, le=1.0)
+    uncertain: float = Field(default=0.62, ge=0.0, le=1.0)
+
+
+class AppConfig(BaseModel):
+    model_config = ConfigDict(extra="forbid")
+
+    default_transcription_provider: ProviderName = "elevenlabs"
+    language: str = "sv"
+    export_destination: Path | None = None
+    confidence_thresholds: ConfidenceThresholds = Field(default_factory=ConfidenceThresholds)
+    cleanup_mode: CleanupMode = "light"
+    glossary_path: Path | None = None
+
+
+def config_dir() -> Path:
+    xdg_config_home = os.environ.get("XDG_CONFIG_HOME")
+    if xdg_config_home:
+        return Path(xdg_config_home).expanduser() / APP_DIR_NAME
+    return Path.home() / ".config" / APP_DIR_NAME
+
+
+def default_config_path() -> Path:
+    return config_dir() / CONFIG_FILE_NAME
+
+
+def default_glossary_path() -> Path:
+    return config_dir() / GLOSSARY_FILE_NAME
+
+
+def load_config(path: Path | None = None) -> AppConfig:
+    config_path = path or default_config_path()
+    data = _read_yaml_mapping(config_path)
+
+    if "glossary_path" not in data:
+        data["glossary_path"] = default_glossary_path()
+
+    try:
+        return AppConfig.model_validate(data)
+    except ValidationError as exc:
+        raise ConfigError(f"Invalid config at {config_path}: {exc}") from exc
+
+
+def get_api_key(provider: str) -> str | None:
+    from fly_on_the_wall.secrets import get_api_key as get_secret_api_key
+
+    return get_secret_api_key(provider)
+
+
+def _read_yaml_mapping(path: Path) -> dict[str, Any]:
+    if not path.exists():
+        return {}
+
+    try:
+        content = yaml.safe_load(path.read_text())
+    except yaml.YAMLError as exc:
+        raise ConfigError(f"Invalid YAML at {path}: {exc}") from exc
+
+    if content is None:
+        return {}
+    if not isinstance(content, dict):
+        raise ConfigError(f"Config at {path} must be a YAML mapping.")
+    return content