fow-cli 0.1.0__py3-none-any.whl

fly_on_the_wall/doctor.py

@@ -0,0 +1,142 @@
+from __future__ import annotations
+
+import importlib.util
+import sys
+from dataclasses import dataclass
+from shutil import which
+
+from fly_on_the_wall.config import default_config_path, load_config
+from fly_on_the_wall.db import database
+from fly_on_the_wall.secrets import get_api_key_status
+from fly_on_the_wall.storage import storage_paths
+
+
+@dataclass(frozen=True)
+class DoctorCheck:
+    name: str
+    ok: bool
+    detail: str
+
+
+def run_checks() -> list[DoctorCheck]:
+    paths = storage_paths()
+    checks = [
+        DoctorCheck(
+            name="python",
+            ok=sys.version_info >= (3, 12),
+            detail=f"{sys.version_info.major}.{sys.version_info.minor}.{sys.version_info.micro}",
+        ),
+        DoctorCheck(
+            name="ffmpeg",
+            ok=which("ffmpeg") is not None,
+            detail=which("ffmpeg") or "not found",
+        ),
+        DoctorCheck(
+            name="config path",
+            ok=True,
+            detail=str(default_config_path()),
+        ),
+        DoctorCheck(
+            name="storage path",
+            ok=True,
+            detail=str(paths.root),
+        ),
+    ]
+
+    config = load_config()
+    provider = config.default_transcription_provider
+    provider_status = get_api_key_status(provider)
+    checks.append(
+        DoctorCheck(
+            name=f"{provider} api key",
+            ok=provider_status.available,
+            detail=_secret_detail(provider_status.source, provider_status.env_var),
+        )
+    )
+    openai_status = get_api_key_status("openai")
+    checks.append(
+        DoctorCheck(
+            name="openai api key",
+            ok=openai_status.available,
+            detail=_secret_detail(openai_status.source, openai_status.env_var),
+        )
+    )
+    checks.extend(_speaker_embedding_checks())
+    return checks
+
+
+def _speaker_embedding_checks() -> list[DoctorCheck]:
+    pyannote_available = _module_available("pyannote.audio")
+    counts = _speaker_embedding_counts()
+    return [
+        DoctorCheck(
+            name="pyannote.audio",
+            ok=pyannote_available,
+            detail=(
+                "available for speaker embeddings"
+                if pyannote_available
+                else "missing; install the identity extra for local speaker embeddings"
+            ),
+        ),
+        DoctorCheck(
+            name="voice sample embeddings",
+            ok=counts["voice_samples"] == 0 or counts["embedded_voice_samples"] == counts["voice_samples"],
+            detail=(f"{counts['embedded_voice_samples']}/{counts['voice_samples']} voice samples embedded"),
+        ),
+        DoctorCheck(
+            name="local speaker embeddings",
+            ok=counts["local_speakers"] == 0 or counts["embedded_local_speakers"] > 0 or pyannote_available,
+            detail=(f"{counts['embedded_local_speakers']}/{counts['local_speakers']} local speakers embedded"),
+        ),
+    ]
+
+
+def _speaker_embedding_counts() -> dict[str, int]:
+    with database() as connection:
+        voice = connection.execute(
+            """
+            SELECT COUNT(*) AS total,
+                   SUM(CASE WHEN embedding_path IS NOT NULL THEN 1 ELSE 0 END) AS embedded
+            FROM voice_samples
+            """
+        ).fetchone()
+        local = connection.execute(
+            """
+            SELECT COUNT(DISTINCT local_speakers.id) AS total,
+                   COUNT(DISTINCT local_speaker_embeddings.local_speaker_id) AS embedded
+            FROM local_speakers
+            LEFT JOIN local_speaker_embeddings
+                ON local_speaker_embeddings.local_speaker_id = local_speakers.id
+            """
+        ).fetchone()
+    return {
+        "voice_samples": int(voice["total"] or 0),
+        "embedded_voice_samples": int(voice["embedded"] or 0),
+        "local_speakers": int(local["total"] or 0),
+        "embedded_local_speakers": int(local["embedded"] or 0),
+    }
+
+
+def _module_available(module_name: str) -> bool:
+    try:
+        return importlib.util.find_spec(module_name) is not None
+    except ModuleNotFoundError:
+        return False
+
+
+def _secret_detail(source: str, env_var: str | None) -> str:
+    if source == "env":
+        return f"{env_var} is set"
+    if source == "keyring":
+        return "set in OS keyring"
+    if source == "missing":
+        return f"{env_var} is not set and no keyring entry was found"
+    return "unknown provider"
+
+
+def has_failures(checks: list[DoctorCheck]) -> bool:
+    return any(not check.ok for check in checks)
+
+
+def check_names(checks: list[DoctorCheck]) -> set[str]:
+    return {check.name for check in checks}

fly_on_the_wall/embeddings.py

@@ -0,0 +1,142 @@
+from __future__ import annotations
+
+import json
+import math
+from dataclasses import dataclass
+from pathlib import Path
+from sqlite3 import Connection
+from typing import Protocol
+from uuid import uuid4
+
+from fly_on_the_wall.storage import StoragePaths, storage_paths
+
+DEFAULT_EMBEDDING_MODEL = "pyannote/wespeaker-voxceleb-resnet34-LM"
+
+
+class EmbeddingBackend(Protocol):
+    model_name: str
+
+    def embed(self, audio_path: Path) -> list[float]: ...
+
+
+@dataclass(frozen=True)
+class CachedEmbedding:
+    model_name: str
+    path: Path
+    vector: list[float]
+
+
+class PyannoteEmbeddingBackend:
+    model_name = DEFAULT_EMBEDDING_MODEL
+
+    def __init__(self) -> None:
+        try:
+            from pyannote.audio import Inference, Model
+        except ImportError as exc:
+            raise RuntimeError("pyannote.audio is required for local speaker embeddings.") from exc
+
+        model = Model.from_pretrained(self.model_name)
+        self._inference = Inference(model, window="whole")
+
+    def embed(self, audio_path: Path) -> list[float]:
+        embedding = self._inference(str(audio_path))
+        if hasattr(embedding, "tolist"):
+            return [float(value) for value in embedding.tolist()]
+        return [float(value) for value in embedding]
+
+
+def cache_voice_sample_embedding(
+    connection: Connection,
+    voice_sample_id: str,
+    backend: EmbeddingBackend,
+    storage: StoragePaths | None = None,
+) -> CachedEmbedding:
+    sample = connection.execute(
+        "SELECT person_id, audio_path FROM voice_samples WHERE id = ?", (voice_sample_id,)
+    ).fetchone()
+    if sample is None:
+        raise ValueError(f"Voice sample does not exist: {voice_sample_id}")
+
+    paths = storage or storage_paths()
+    vector = backend.embed(Path(sample["audio_path"]))
+    embedding_path = _write_embedding(
+        paths.artifacts / "embeddings" / "voice-samples" / sample["person_id"],
+        voice_sample_id,
+        backend.model_name,
+        vector,
+    )
+
+    with connection:
+        connection.execute(
+            """
+            UPDATE voice_samples
+            SET embedding_model = ?, embedding_path = ?
+            WHERE id = ?
+            """,
+            (backend.model_name, str(embedding_path), voice_sample_id),
+        )
+    return CachedEmbedding(backend.model_name, embedding_path, vector)
+
+
+def cache_local_speaker_embedding(
+    connection: Connection,
+    local_speaker_id: str,
+    audio_path: Path,
+    backend: EmbeddingBackend,
+    storage: StoragePaths | None = None,
+) -> CachedEmbedding:
+    if connection.execute("SELECT 1 FROM local_speakers WHERE id = ?", (local_speaker_id,)).fetchone() is None:
+        raise ValueError(f"Local speaker does not exist: {local_speaker_id}")
+
+    paths = storage or storage_paths()
+    vector = backend.embed(audio_path)
+    embedding_path = _write_embedding(
+        paths.artifacts / "embeddings" / "local-speakers",
+        local_speaker_id,
+        backend.model_name,
+        vector,
+    )
+    embedding_id = str(uuid4())
+    with connection:
+        connection.execute(
+            """
+            INSERT INTO local_speaker_embeddings(
+                id, local_speaker_id, audio_path, embedding_model, embedding_path
+            ) VALUES (?, ?, ?, ?, ?)
+            ON CONFLICT(local_speaker_id, embedding_model) DO UPDATE SET
+                audio_path = excluded.audio_path,
+                embedding_path = excluded.embedding_path
+            """,
+            (
+                embedding_id,
+                local_speaker_id,
+                str(audio_path),
+                backend.model_name,
+                str(embedding_path),
+            ),
+        )
+    return CachedEmbedding(backend.model_name, embedding_path, vector)
+
+
+def read_embedding(path: Path) -> list[float]:
+    data = json.loads(path.read_text())
+    return [float(value) for value in data["vector"]]
+
+
+def cosine_similarity(left: list[float], right: list[float]) -> float:
+    if len(left) != len(right):
+        raise ValueError("Embedding vectors must have the same length.")
+    numerator = sum(a * b for a, b in zip(left, right, strict=True))
+    left_norm = math.sqrt(sum(a * a for a in left))
+    right_norm = math.sqrt(sum(b * b for b in right))
+    if left_norm == 0 or right_norm == 0:
+        return 0.0
+    return numerator / (left_norm * right_norm)
+
+
+def _write_embedding(directory: Path, source_id: str, model_name: str, vector: list[float]) -> Path:
+    safe_model_name = model_name.replace("/", "--")
+    path = directory / f"{source_id}.{safe_model_name}.json"
+    path.parent.mkdir(parents=True, exist_ok=True)
+    path.write_text(json.dumps({"model": model_name, "vector": vector}) + "\n")
+    return path

fly_on_the_wall/exporting.py

@@ -0,0 +1,155 @@
+from __future__ import annotations
+
+import hashlib
+import json
+import re
+from dataclasses import dataclass
+from datetime import UTC, datetime
+from pathlib import Path
+from sqlite3 import Connection
+from uuid import uuid4
+
+from fly_on_the_wall.storage import StoragePaths, storage_paths
+
+
+@dataclass(frozen=True)
+class ExportResult:
+    id: str
+    output_dir: Path
+    transcript_path: Path
+    analysis_path: Path
+    manifest_path: Path
+
+
+def export_markdown_transcript(
+    connection: Connection,
+    meeting_id: str,
+    transcript: str,
+    analysis: str,
+    storage: StoragePaths | None = None,
+) -> ExportResult:
+    meeting = connection.execute(
+        """
+        SELECT meetings.*, audio_metadata.recorded_at, audio_metadata.recorded_at_confidence
+        FROM meetings
+        LEFT JOIN audio_metadata ON audio_metadata.meeting_id = meetings.id
+        WHERE meetings.id = ?
+        """,
+        (meeting_id,),
+    ).fetchone()
+    if meeting is None:
+        raise ValueError(f"Meeting does not exist: {meeting_id}")
+
+    export_id = str(uuid4())
+    timestamp = datetime.now(UTC).strftime("%Y%m%dT%H%M%SZ")
+    paths = storage or storage_paths()
+    output_dir = paths.exports / meeting["slug"] / f"{timestamp}-{export_id[:8]}"
+    transcript_path = output_dir / "transcript.md"
+    analysis_path = output_dir / "analysis.md"
+    manifest_path = output_dir / "manifest.json"
+    output_dir.mkdir(parents=True, exist_ok=False)
+
+    markdown = _markdown_document(dict(meeting), transcript)
+    transcript_path.write_text(markdown)
+    analysis_markdown = analysis.strip() + "\n"
+    analysis_path.write_text(analysis_markdown)
+    manifest_path.write_text(
+        json.dumps(
+            {
+                "id": export_id,
+                "meeting_id": meeting_id,
+                "format": "markdown",
+                "transcript_path": str(transcript_path),
+                "analysis_path": str(analysis_path),
+                "transcript_sha256": _sha256(markdown),
+                "analysis_sha256": _sha256(analysis_markdown),
+            },
+            indent=2,
+        )
+        + "\n"
+    )
+
+    with connection:
+        connection.execute(
+            """
+            INSERT INTO exports(id, meeting_id, format, output_dir, manifest_path)
+            VALUES (?, ?, ?, ?, ?)
+            """,
+            (export_id, meeting_id, "markdown", str(output_dir), str(manifest_path)),
+        )
+    return ExportResult(export_id, output_dir, transcript_path, analysis_path, manifest_path)
+
+
+def _markdown_document(meeting: dict, transcript: str) -> str:
+    turns = _readable_turns(transcript)
+    people = _participants(turns)
+    date, time = _date_time(_meeting_timestamp(meeting))
+    lines = [
+        f"# {meeting['title']}",
+        "",
+        f"Date: {date}",
+        f"Time: {time}",
+        "Location: Unknown",
+        "Position: Unknown",
+        f"People: {', '.join(people) if people else 'Unknown'}",
+        "",
+        "## Manuscript",
+        "",
+    ]
+    for speaker, text in turns:
+        lines.append(f"**{speaker}:** {text}")
+        lines.append("")
+    return "\n".join(lines).rstrip() + "\n"
+
+
+def _readable_turns(transcript: str) -> list[tuple[str, str]]:
+    unknown_speakers: dict[str, str] = {}
+    turns: list[tuple[str, str]] = []
+    for block in [block.strip() for block in transcript.split("\n\n") if block.strip()]:
+        speaker, text, source_label = _parse_turn(block)
+        if speaker == "Unknown":
+            key = source_label or speaker
+            if key not in unknown_speakers:
+                unknown_speakers[key] = f"Unknown speaker {len(unknown_speakers) + 1}"
+            speaker = unknown_speakers[key]
+        turns.append((speaker, text))
+    return turns
+
+
+def _parse_turn(block: str) -> tuple[str, str, str | None]:
+    speaker, separator, text = block.partition(":")
+    if not separator:
+        return "Unknown", block, None
+
+    match = re.match(
+        r"^(?P<name>.*?)(?:\s+\[[^\]]+\])?(?:\s+\((?P<source>[^)]+)\))?$",
+        speaker.strip(),
+    )
+    if match is None:
+        return speaker.strip() or "Unknown", text.strip(), None
+    return match.group("name").strip() or "Unknown", text.strip(), match.group("source")
+
+
+def _participants(turns: list[tuple[str, str]]) -> list[str]:
+    participants: list[str] = []
+    for speaker, _ in turns:
+        if speaker not in participants:
+            participants.append(speaker)
+    return participants
+
+
+def _date_time(created_at: str | None) -> tuple[str, str]:
+    if not created_at:
+        return "Unknown", "Unknown"
+    date, _, time = created_at.partition(" ")
+    return date or "Unknown", time or "Unknown"
+
+
+def _meeting_timestamp(meeting: dict) -> str | None:
+    if meeting.get("recorded_at_confidence") in {"high", "medium"}:
+        return meeting.get("recorded_at")
+    return meeting.get("created_at")
+
+
+def _sha256(value: str) -> str:
+    return hashlib.sha256(value.encode()).hexdigest()

fly_on_the_wall/glossary.py

@@ -0,0 +1,31 @@
+from __future__ import annotations
+
+from pathlib import Path
+from typing import Any
+
+import yaml
+
+
+def load_glossary_terms(path: Path | None) -> list[str]:
+    if path is None or not path.exists():
+        return []
+    data = yaml.safe_load(path.read_text())
+    return sorted(set(_collect_terms(data)))
+
+
+def _collect_terms(value: Any) -> list[str]:
+    if value is None:
+        return []
+    if isinstance(value, str):
+        return [value]
+    if isinstance(value, list):
+        terms: list[str] = []
+        for item in value:
+            terms.extend(_collect_terms(item))
+        return terms
+    if isinstance(value, dict):
+        terms = []
+        for item in value.values():
+            terms.extend(_collect_terms(item))
+        return terms
+    return []