fow-cli 0.1.0__py3-none-any.whl

fly_on_the_wall/reanalysis.py

@@ -0,0 +1,172 @@
+from __future__ import annotations
+
+from collections.abc import Callable
+from sqlite3 import Connection
+
+from fly_on_the_wall.meetings import get_meeting
+from fly_on_the_wall.pipeline import STALE, set_stage_status
+from fly_on_the_wall.speaker_identity import match_provider_run_speakers
+
+SPEAKER_DEPENDENT_STAGES = ("speaker_matching", "render", "cleanup", "export")
+
+
+def mark_speaker_reanalysis_stale(connection: Connection, meeting_id_or_slug: str) -> list[str]:
+    meeting = get_meeting(connection, meeting_id_or_slug)
+    if meeting is None:
+        raise ValueError(f"Meeting not found: {meeting_id_or_slug}")
+    for stage in SPEAKER_DEPENDENT_STAGES:
+        set_stage_status(connection, meeting["id"], stage, STALE)
+    return list(SPEAKER_DEPENDENT_STAGES)
+
+
+def list_stale_stages(connection: Connection) -> list[dict]:
+    rows = connection.execute(
+        """
+        SELECT meetings.slug AS meeting_slug,
+               pipeline_stages.meeting_id,
+               pipeline_stages.stage_name,
+               pipeline_stages.updated_at
+        FROM pipeline_stages
+        JOIN meetings ON meetings.id = pipeline_stages.meeting_id
+        WHERE pipeline_stages.status = 'stale'
+        ORDER BY pipeline_stages.updated_at DESC
+        """
+    ).fetchall()
+    return [dict(row) for row in rows]
+
+
+def list_stale_meetings(connection: Connection) -> list[dict]:
+    stages = list_stale_stages(connection)
+    seen: set[str] = set()
+    meetings: list[dict] = []
+    for stage in stages:
+        if stage["meeting_id"] in seen:
+            continue
+        seen.add(stage["meeting_id"])
+        meetings.append(
+            {
+                "meeting_id": stage["meeting_id"],
+                "meeting_slug": stage["meeting_slug"],
+            }
+        )
+    return meetings
+
+
+ProgressCallback = Callable[[str], None]
+
+
+def rerun_speaker_matching(
+    connection: Connection,
+    meeting_id_or_slug: str,
+    progress: ProgressCallback | None = None,
+) -> int:
+    meeting = get_meeting(connection, meeting_id_or_slug)
+    if meeting is None:
+        raise ValueError(f"Meeting not found: {meeting_id_or_slug}")
+
+    provider_run = connection.execute(
+        """
+        SELECT id FROM provider_runs
+        WHERE meeting_id = ? AND status = 'done'
+        ORDER BY completed_at DESC, created_at DESC
+        LIMIT 1
+        """,
+        (meeting["id"],),
+    ).fetchone()
+    if provider_run is None:
+        raise ValueError(f"No completed provider run found for meeting: {meeting_id_or_slug}")
+
+    if progress is not None:
+        progress(f"Embedding and matching speakers for {meeting['slug']}")
+    before = _speaker_assignment_snapshot(connection, provider_run["id"])
+    match_provider_run_speakers(connection, provider_run["id"])
+    after = _speaker_assignment_snapshot(connection, provider_run["id"])
+    return _changed_assignment_count(before, after)
+
+
+def rerun_speaker_matching_for_meetings(
+    connection: Connection,
+    include_known_speakers: bool = False,
+    progress: ProgressCallback | None = None,
+) -> list[dict]:
+    results: list[dict] = []
+    meetings = _speaker_reanalysis_meetings(connection, include_known_speakers)
+    if progress is not None:
+        progress(f"Found {len(meetings)} meeting(s) for speaker refresh")
+    for index, meeting in enumerate(meetings, start=1):
+        if progress is not None:
+            progress(f"Refreshing speaker matching for {meeting['slug']} ({index}/{len(meetings)})")
+        changed_count = rerun_speaker_matching(connection, meeting["id"], progress)
+        stages = mark_speaker_reanalysis_stale(connection, meeting["id"]) if changed_count else []
+        if progress is not None:
+            progress(f"{meeting['slug']}: {changed_count} speaker assignment change(s)")
+        results.append(
+            {
+                "meeting_id": meeting["id"],
+                "meeting_slug": meeting["slug"],
+                "match_count": changed_count,
+                "marked_stale": stages,
+            }
+        )
+    return results
+
+
+def _speaker_reanalysis_meetings(connection: Connection, include_known_speakers: bool) -> list[dict]:
+    if include_known_speakers:
+        rows = connection.execute(
+            """
+            SELECT DISTINCT meetings.id, meetings.slug
+            FROM meetings
+            JOIN provider_runs ON provider_runs.meeting_id = meetings.id
+            WHERE provider_runs.status = 'done'
+            ORDER BY meetings.created_at DESC
+            """
+        ).fetchall()
+    else:
+        rows = connection.execute(
+            """
+            SELECT DISTINCT meetings.id, meetings.slug
+            FROM meetings
+            JOIN provider_runs ON provider_runs.meeting_id = meetings.id
+            JOIN local_speakers ON local_speakers.meeting_id = meetings.id
+            LEFT JOIN speaker_assignments
+                ON speaker_assignments.local_speaker_id = local_speakers.id
+            WHERE provider_runs.status = 'done'
+              AND (speaker_assignments.id IS NULL OR speaker_assignments.status = 'unknown')
+            ORDER BY meetings.created_at DESC
+            """
+        ).fetchall()
+    return [dict(row) for row in rows]
+
+
+def _speaker_assignment_snapshot(connection: Connection, provider_run_id: str) -> dict[str, tuple]:
+    rows = connection.execute(
+        """
+        SELECT local_speakers.id AS local_speaker_id,
+               speaker_assignments.person_id,
+               speaker_assignments.status,
+               speaker_assignments.confidence,
+               speaker_assignments.margin,
+               speaker_assignments.evidence_json
+        FROM local_speakers
+        LEFT JOIN speaker_assignments
+            ON speaker_assignments.local_speaker_id = local_speakers.id
+        WHERE local_speakers.provider_run_id = ?
+        ORDER BY local_speakers.id
+        """,
+        (provider_run_id,),
+    ).fetchall()
+    return {
+        row["local_speaker_id"]: (
+            row["person_id"],
+            row["status"],
+            row["confidence"],
+            row["margin"],
+            row["evidence_json"],
+        )
+        for row in rows
+    }
+
+
+def _changed_assignment_count(before: dict[str, tuple], after: dict[str, tuple]) -> int:
+    return sum(1 for speaker_id, assignment in after.items() if before.get(speaker_id) != assignment)

fly_on_the_wall/recording_quality.py

@@ -0,0 +1,141 @@
+from __future__ import annotations
+
+import json
+import re
+from dataclasses import dataclass
+from sqlite3 import Connection
+
+from fly_on_the_wall.meetings import Meeting
+from fly_on_the_wall.normalization import NormalizedSegment
+
+MIN_DURATION_SECONDS = 3.0
+SUSPICIOUS_DURATION_SECONDS = 10.0
+SPARSE_DURATION_SECONDS = 120.0
+SPARSE_WORDS_PER_SECOND = 0.02
+MIN_MEANINGFUL_WORDS = 3
+
+FILLER_WORDS = {
+    "ah",
+    "eh",
+    "ehm",
+    "hm",
+    "hmm",
+    "ja",
+    "mm",
+    "mmm",
+    "nej",
+    "ok",
+    "okej",
+    "uh",
+    "um",
+    "yes",
+    "no",
+}
+HALLUCINATION_PHRASES = {
+    "tack för att du tittade",
+    "thanks for watching",
+    "thank you for watching",
+}
+
+
+@dataclass(frozen=True)
+class RecordingQuality:
+    status: str
+    reason: str
+    details: dict
+
+
+class RecordingIgnoredError(RuntimeError):
+    def __init__(self, meeting: Meeting, quality: RecordingQuality) -> None:
+        super().__init__(quality.reason)
+        self.meeting = meeting
+        self.quality = quality
+
+
+def assess_before_transcription(connection: Connection, meeting: Meeting) -> RecordingQuality | None:
+    duration = _duration_seconds(connection, meeting.id)
+    if duration is None:
+        return None
+    if duration < MIN_DURATION_SECONDS:
+        return RecordingQuality(
+            "empty",
+            "audio_too_short",
+            {"duration_seconds": duration, "threshold_seconds": MIN_DURATION_SECONDS},
+        )
+    if duration < SUSPICIOUS_DURATION_SECONDS:
+        return RecordingQuality(
+            "suspicious",
+            "audio_very_short",
+            {"duration_seconds": duration, "threshold_seconds": SUSPICIOUS_DURATION_SECONDS},
+        )
+    return None
+
+
+def assess_after_transcription(
+    connection: Connection, meeting: Meeting, segments: list[NormalizedSegment]
+) -> RecordingQuality:
+    duration = _duration_seconds(connection, meeting.id)
+    texts = [segment.text for segment in segments]
+    words = _words(" ".join(texts))
+    meaningful_words = [word for word in words if word not in FILLER_WORDS]
+    details = {
+        "segment_count": len(segments),
+        "word_count": len(words),
+        "meaningful_word_count": len(meaningful_words),
+        "duration_seconds": duration,
+    }
+
+    if not segments:
+        return RecordingQuality("empty", "no_transcript_segments", details)
+    if words and not meaningful_words:
+        return RecordingQuality("empty", "only_filler_words", details)
+    if _looks_like_hallucinated_boilerplate(" ".join(words)):
+        return RecordingQuality("nonsense", "hallucinated_boilerplate", details)
+    if duration is not None and duration >= SPARSE_DURATION_SECONDS:
+        density = len(words) / duration
+        details["words_per_second"] = density
+        if density < SPARSE_WORDS_PER_SECOND:
+            return RecordingQuality("nonsense", "very_low_speech_density", details)
+    if len(meaningful_words) < MIN_MEANINGFUL_WORDS:
+        return RecordingQuality("suspicious", "too_few_meaningful_words", details)
+    return RecordingQuality("normal", "passed_quality_checks", details)
+
+
+def store_recording_quality(connection: Connection, meeting_id: str, quality: RecordingQuality) -> None:
+    with connection:
+        connection.execute(
+            """
+            INSERT OR REPLACE INTO recording_quality(
+                id, meeting_id, status, reason, details_json, updated_at
+            ) VALUES (
+                COALESCE((SELECT id FROM recording_quality WHERE meeting_id = ?), ?),
+                ?, ?, ?, ?, CURRENT_TIMESTAMP
+            )
+            """,
+            (
+                meeting_id,
+                meeting_id,
+                meeting_id,
+                quality.status,
+                quality.reason,
+                json.dumps(quality.details, sort_keys=True),
+            ),
+        )
+
+
+def _duration_seconds(connection: Connection, meeting_id: str) -> float | None:
+    row = connection.execute(
+        "SELECT duration_seconds FROM audio_metadata WHERE meeting_id = ?", (meeting_id,)
+    ).fetchone()
+    if row is None or row["duration_seconds"] is None:
+        return None
+    return float(row["duration_seconds"])
+
+
+def _words(text: str) -> list[str]:
+    return [word.lower() for word in re.findall(r"[\wåäöÅÄÖ]+", text)]
+
+
+def _looks_like_hallucinated_boilerplate(text: str) -> bool:
+    normalized = " ".join(text.lower().split())
+    return any(phrase in normalized for phrase in HALLUCINATION_PHRASES)

fly_on_the_wall/rendering.py

@@ -0,0 +1,115 @@
+from __future__ import annotations
+
+from pathlib import Path
+from sqlite3 import Connection
+
+from fly_on_the_wall.storage import StoragePaths, storage_paths
+
+
+def render_diarized_transcript(
+    connection: Connection,
+    provider_run_id: str,
+    output_path: Path | None = None,
+    storage: StoragePaths | None = None,
+) -> str:
+    rows = connection.execute(
+        """
+        SELECT segments.text,
+               segments.language,
+               local_speakers.label AS speaker_label
+        FROM segments
+        LEFT JOIN local_speakers ON local_speakers.id = segments.local_speaker_id
+        WHERE segments.provider_run_id = ?
+        ORDER BY segments.sequence
+        """,
+        (provider_run_id,),
+    ).fetchall()
+    transcript = "\n\n".join(
+        _format_turn(row["speaker_label"] or "Unknown", row["language"], row["text"]) for row in rows
+    )
+
+    if output_path is None:
+        provider_run = connection.execute(
+            "SELECT meeting_id FROM provider_runs WHERE id = ?", (provider_run_id,)
+        ).fetchone()
+        if provider_run is not None:
+            paths = storage or storage_paths()
+            output_path = paths.artifacts / provider_run["meeting_id"] / "diarized-transcript.txt"
+
+    if output_path is not None:
+        output_path.parent.mkdir(parents=True, exist_ok=True)
+        output_path.write_text(transcript + "\n")
+
+    return transcript
+
+
+def render_named_transcript(
+    connection: Connection,
+    provider_run_id: str,
+    output_path: Path | None = None,
+    storage: StoragePaths | None = None,
+) -> str:
+    rows = connection.execute(
+        """
+        SELECT segments.text,
+               segments.language,
+               local_speakers.label AS speaker_label,
+               speaker_assignments.status AS assignment_status,
+               people.display_name
+        FROM segments
+        LEFT JOIN local_speakers ON local_speakers.id = segments.local_speaker_id
+        LEFT JOIN speaker_assignments
+            ON speaker_assignments.local_speaker_id = local_speakers.id
+        LEFT JOIN people ON people.id = speaker_assignments.person_id
+        WHERE segments.provider_run_id = ?
+        ORDER BY segments.sequence
+        """,
+        (provider_run_id,),
+    ).fetchall()
+    transcript = "\n\n".join(
+        _format_named_turn(
+            row["display_name"],
+            row["assignment_status"],
+            row["speaker_label"] or "Unknown",
+            row["language"],
+            row["text"],
+        )
+        for row in rows
+    )
+
+    if output_path is None:
+        provider_run = connection.execute(
+            "SELECT meeting_id FROM provider_runs WHERE id = ?", (provider_run_id,)
+        ).fetchone()
+        if provider_run is not None:
+            paths = storage or storage_paths()
+            output_path = paths.artifacts / provider_run["meeting_id"] / "named-transcript.txt"
+
+    if output_path is not None:
+        output_path.parent.mkdir(parents=True, exist_ok=True)
+        output_path.write_text(transcript + "\n")
+
+    return transcript
+
+
+def _format_turn(speaker_label: str, language: str | None, text: str) -> str:
+    language_marker = f" [{language}]" if language else ""
+    return f"{speaker_label}{language_marker}: {text}"
+
+
+def _format_named_turn(
+    display_name: str | None,
+    assignment_status: str | None,
+    speaker_label: str,
+    language: str | None,
+    text: str,
+) -> str:
+    if assignment_status == "known" and display_name:
+        name = display_name
+    elif assignment_status == "uncertain" and display_name:
+        name = f"{display_name}?"
+    else:
+        name = "Unknown"
+
+    language_marker = f" [{language}]" if language else ""
+    return f"{name}{language_marker} ({speaker_label}): {text}"

fly_on_the_wall/secrets.py

@@ -0,0 +1,93 @@
+from __future__ import annotations
+
+import os
+from dataclasses import dataclass
+from typing import Literal
+
+import keyring
+from keyring.errors import KeyringError
+
+from fly_on_the_wall.config import API_KEY_ENV_VARS
+
+KEYRING_SERVICE = "fly-on-the-wall"
+SecretSource = Literal["env", "keyring", "missing", "unknown"]
+
+
+class SecretError(RuntimeError):
+    """Raised when a secret cannot be stored or removed."""
+
+
+@dataclass(frozen=True)
+class SecretStatus:
+    provider: str
+    env_var: str | None
+    source: SecretSource
+
+    @property
+    def available(self) -> bool:
+        return self.source in {"env", "keyring"}
+
+
+def get_api_key(provider: str) -> str | None:
+    env_value = _get_env_key(provider)
+    if env_value:
+        return env_value
+    return _get_keyring_key(provider)
+
+
+def get_api_key_status(provider: str) -> SecretStatus:
+    normalized = provider.lower()
+    env_var = API_KEY_ENV_VARS.get(normalized)
+    if env_var is None:
+        return SecretStatus(provider=normalized, env_var=None, source="unknown")
+    if os.environ.get(env_var):
+        return SecretStatus(provider=normalized, env_var=env_var, source="env")
+    if _get_keyring_key(normalized):
+        return SecretStatus(provider=normalized, env_var=env_var, source="keyring")
+    return SecretStatus(provider=normalized, env_var=env_var, source="missing")
+
+
+def set_api_key(provider: str, value: str) -> None:
+    normalized = _require_known_provider(provider)
+    try:
+        keyring.set_password(KEYRING_SERVICE, normalized, value)
+    except KeyringError as exc:
+        raise SecretError(f"Could not store {normalized} API key in OS keyring: {exc}") from exc
+
+
+def remove_api_key(provider: str) -> None:
+    normalized = _require_known_provider(provider)
+    try:
+        keyring.delete_password(KEYRING_SERVICE, normalized)
+    except keyring.errors.PasswordDeleteError:
+        return
+    except KeyringError as exc:
+        raise SecretError(f"Could not remove {normalized} API key from OS keyring: {exc}") from exc
+
+
+def known_providers() -> list[str]:
+    return sorted(API_KEY_ENV_VARS)
+
+
+def _get_env_key(provider: str) -> str | None:
+    env_var = API_KEY_ENV_VARS.get(provider.lower())
+    if env_var is None:
+        return None
+    return os.environ.get(env_var) or None
+
+
+def _get_keyring_key(provider: str) -> str | None:
+    normalized = provider.lower()
+    if normalized not in API_KEY_ENV_VARS:
+        return None
+    try:
+        return keyring.get_password(KEYRING_SERVICE, normalized) or None
+    except KeyringError:
+        return None
+
+
+def _require_known_provider(provider: str) -> str:
+    normalized = provider.lower()
+    if normalized not in API_KEY_ENV_VARS:
+        raise SecretError(f"Unknown provider: {provider}")
+    return normalized

fly_on_the_wall/service_pricing.py

@@ -0,0 +1,75 @@
+from __future__ import annotations
+
+import json
+from dataclasses import dataclass
+from sqlite3 import Connection
+
+
+@dataclass(frozen=True)
+class ServicePrice:
+    id: str
+    provider: str
+    model: str
+    service: str
+    unit: str
+    input_unit_price_usd: float | None
+    output_unit_price_usd: float | None
+    cached_input_unit_price_usd: float | None
+    currency: str
+    source_name: str
+    source_url: str | None
+    pricing: dict
+    active: bool
+
+
+def list_service_prices(connection: Connection, active_only: bool = True) -> list[ServicePrice]:
+    where = "WHERE active = 1" if active_only else ""
+    rows = connection.execute(
+        f"""
+        SELECT * FROM service_prices
+        {where}
+        ORDER BY provider, model, service, unit
+        """
+    ).fetchall()
+    return [_service_price_from_row(row) for row in rows]
+
+
+def get_service_price(
+    connection: Connection,
+    provider: str,
+    model: str,
+    service: str,
+    unit: str,
+) -> ServicePrice | None:
+    row = connection.execute(
+        """
+        SELECT * FROM service_prices
+        WHERE provider = ?
+          AND model = ?
+          AND service = ?
+          AND unit = ?
+          AND active = 1
+        ORDER BY updated_at DESC
+        LIMIT 1
+        """,
+        (provider, model, service, unit),
+    ).fetchone()
+    return None if row is None else _service_price_from_row(row)
+
+
+def _service_price_from_row(row) -> ServicePrice:
+    return ServicePrice(
+        id=row["id"],
+        provider=row["provider"],
+        model=row["model"],
+        service=row["service"],
+        unit=row["unit"],
+        input_unit_price_usd=row["input_unit_price_usd"],
+        output_unit_price_usd=row["output_unit_price_usd"],
+        cached_input_unit_price_usd=row["cached_input_unit_price_usd"],
+        currency=row["currency"],
+        source_name=row["source_name"],
+        source_url=row["source_url"],
+        pricing=json.loads(row["pricing_json"]),
+        active=bool(row["active"]),
+    )