fow-cli 0.1.0__py3-none-any.whl

fly_on_the_wall/speakers.py

@@ -0,0 +1,221 @@
+from __future__ import annotations
+
+import json
+from sqlite3 import Connection
+from uuid import uuid4
+
+from fly_on_the_wall.people import create_person, get_person
+
+
+def list_unknown_speakers(connection: Connection, meeting_id_or_slug: str | None = None) -> list[dict]:
+    params: list[str] = []
+    meeting_filter = ""
+    if meeting_id_or_slug:
+        meeting_filter = "AND (meetings.id = ? OR meetings.slug = ?)"
+        params.extend([meeting_id_or_slug, meeting_id_or_slug])
+
+    rows = connection.execute(
+        f"""
+        SELECT local_speakers.id,
+               local_speakers.label,
+               meetings.slug AS meeting_slug,
+               provider_runs.id AS provider_run_id,
+               COUNT(segments.id) AS segment_count
+        FROM local_speakers
+        JOIN meetings ON meetings.id = local_speakers.meeting_id
+        JOIN provider_runs ON provider_runs.id = local_speakers.provider_run_id
+        LEFT JOIN segments ON segments.local_speaker_id = local_speakers.id
+        LEFT JOIN speaker_assignments
+            ON speaker_assignments.local_speaker_id = local_speakers.id
+        WHERE (speaker_assignments.id IS NULL OR speaker_assignments.status = 'unknown')
+        {meeting_filter}
+        GROUP BY local_speakers.id
+        ORDER BY meetings.created_at DESC, local_speakers.label
+        """,
+        params,
+    ).fetchall()
+    return [dict(row) for row in rows]
+
+
+def list_uncertain_speakers(connection: Connection, meeting_id_or_slug: str | None = None) -> list[dict]:
+    params: list[str] = []
+    meeting_filter = ""
+    if meeting_id_or_slug:
+        meeting_filter = "AND (meetings.id = ? OR meetings.slug = ?)"
+        params.extend([meeting_id_or_slug, meeting_id_or_slug])
+
+    rows = connection.execute(
+        f"""
+        SELECT local_speakers.id,
+               local_speakers.label,
+               meetings.slug AS meeting_slug,
+               provider_runs.id AS provider_run_id,
+               speaker_assignments.person_id AS suggested_person_id,
+               people.display_name AS suggested_person_name,
+               speaker_assignments.confidence,
+               speaker_assignments.margin,
+               COUNT(segments.id) AS segment_count
+        FROM local_speakers
+        JOIN meetings ON meetings.id = local_speakers.meeting_id
+        JOIN provider_runs ON provider_runs.id = local_speakers.provider_run_id
+        JOIN speaker_assignments
+            ON speaker_assignments.local_speaker_id = local_speakers.id
+        JOIN people ON people.id = speaker_assignments.person_id
+        LEFT JOIN segments ON segments.local_speaker_id = local_speakers.id
+        WHERE speaker_assignments.status = 'uncertain'
+        {meeting_filter}
+        GROUP BY local_speakers.id
+        ORDER BY meetings.created_at DESC, speaker_assignments.confidence DESC, local_speakers.label
+        """,
+        params,
+    ).fetchall()
+    return [dict(row) for row in rows]
+
+
+def list_review_speakers(
+    connection: Connection,
+    meeting_id_or_slug: str | None = None,
+    include_uncertain: bool = False,
+    only_uncertain: bool = False,
+) -> list[dict]:
+    uncertain = [
+        _with_review_kind(speaker, "uncertain") for speaker in list_uncertain_speakers(connection, meeting_id_or_slug)
+    ]
+    if only_uncertain:
+        return uncertain
+
+    unknown = [
+        _with_review_kind(speaker, "unknown") for speaker in list_unknown_speakers(connection, meeting_id_or_slug)
+    ]
+    if include_uncertain:
+        return unknown + uncertain
+    return unknown
+
+
+def confirm_speaker_assignment(connection: Connection, local_speaker_id: str) -> dict:
+    row = connection.execute(
+        """
+        SELECT speaker_assignments.person_id, people.display_name
+        FROM speaker_assignments
+        JOIN people ON people.id = speaker_assignments.person_id
+        WHERE speaker_assignments.local_speaker_id = ?
+          AND speaker_assignments.status = 'uncertain'
+        """,
+        (local_speaker_id,),
+    ).fetchone()
+    if row is None:
+        raise ValueError(f"No uncertain speaker assignment found: {local_speaker_id}")
+    return assign_speaker_to_person(connection, local_speaker_id, row["person_id"])
+
+
+def _with_review_kind(speaker: dict, review_kind: str) -> dict:
+    result = dict(speaker)
+    result["review_kind"] = review_kind
+    return result
+
+
+def speaker_examples(connection: Connection, local_speaker_id: str, limit: int = 3) -> list[dict]:
+    rows = connection.execute(
+        """
+        SELECT text, start_time, end_time
+        FROM segments
+        WHERE local_speaker_id = ?
+        ORDER BY sequence
+        LIMIT ?
+        """,
+        (local_speaker_id, limit),
+    ).fetchall()
+    return [dict(row) for row in rows]
+
+
+def assign_speaker_to_person(connection: Connection, local_speaker_id: str, person_id_or_name: str) -> dict:
+    person = get_person(connection, person_id_or_name)
+    if person is None:
+        person = create_person(connection, person_id_or_name)
+        created_person = True
+    else:
+        created_person = False
+
+    meeting_id = _local_speaker_meeting_id(connection, local_speaker_id)
+    if meeting_id is None:
+        raise ValueError(f"Local speaker not found: {local_speaker_id}")
+
+    with connection:
+        connection.execute(
+            """
+            INSERT INTO speaker_assignments(id, local_speaker_id, person_id, status, evidence_json)
+            VALUES (?, ?, ?, ?, ?)
+            ON CONFLICT(local_speaker_id) DO UPDATE SET
+                person_id = excluded.person_id,
+                status = excluded.status,
+                evidence_json = excluded.evidence_json
+            """,
+            (
+                str(uuid4()),
+                local_speaker_id,
+                person.id,
+                "known",
+                json.dumps({"method": "user_correction"}),
+            ),
+        )
+        _record_correction(connection, "speaker_assignment", meeting_id, local_speaker_id, person.id)
+    return {
+        "local_speaker_id": local_speaker_id,
+        "person_id": person.id,
+        "name": person.display_name,
+        "created_person": created_person,
+    }
+
+
+def mark_speaker_unknown(connection: Connection, local_speaker_id: str) -> None:
+    _mark_speaker_status(connection, local_speaker_id, "unknown")
+
+
+def mark_speaker_ignored(connection: Connection, local_speaker_id: str) -> None:
+    _mark_speaker_status(connection, local_speaker_id, "ignored")
+
+
+def _mark_speaker_status(connection: Connection, local_speaker_id: str, status: str) -> None:
+    meeting_id = _local_speaker_meeting_id(connection, local_speaker_id)
+    if meeting_id is None:
+        raise ValueError(f"Local speaker not found: {local_speaker_id}")
+
+    with connection:
+        connection.execute(
+            """
+            INSERT INTO speaker_assignments(id, local_speaker_id, person_id, status, evidence_json)
+            VALUES (?, ?, NULL, ?, ?)
+            ON CONFLICT(local_speaker_id) DO UPDATE SET
+                person_id = NULL,
+                status = excluded.status,
+                evidence_json = excluded.evidence_json
+            """,
+            (
+                str(uuid4()),
+                local_speaker_id,
+                status,
+                json.dumps({"method": "user_correction", "action": status}),
+            ),
+        )
+        _record_correction(connection, "speaker_assignment", meeting_id, local_speaker_id, None)
+
+
+def _local_speaker_meeting_id(connection: Connection, local_speaker_id: str) -> str | None:
+    row = connection.execute("SELECT meeting_id FROM local_speakers WHERE id = ?", (local_speaker_id,)).fetchone()
+    return None if row is None else row["meeting_id"]
+
+
+def _record_correction(
+    connection: Connection,
+    correction_type: str,
+    meeting_id: str,
+    local_speaker_id: str,
+    person_id: str | None,
+) -> None:
+    connection.execute(
+        """
+        INSERT INTO corrections(id, correction_type, meeting_id, local_speaker_id, person_id)
+        VALUES (?, ?, ?, ?, ?)
+        """,
+        (str(uuid4()), correction_type, meeting_id, local_speaker_id, person_id),
+    )

fly_on_the_wall/storage.py

@@ -0,0 +1,53 @@
+from __future__ import annotations
+
+import os
+from dataclasses import dataclass
+from pathlib import Path
+
+from fly_on_the_wall.config import APP_DIR_NAME
+
+
+@dataclass(frozen=True)
+class StoragePaths:
+    root: Path
+    database: Path
+    audio: Path
+    artifacts: Path
+    voice_samples: Path
+    exports: Path
+
+    @property
+    def directories(self) -> tuple[Path, ...]:
+        return (
+            self.root,
+            self.audio,
+            self.artifacts,
+            self.voice_samples,
+            self.exports,
+        )
+
+
+def data_dir() -> Path:
+    xdg_data_home = os.environ.get("XDG_DATA_HOME")
+    if xdg_data_home:
+        return Path(xdg_data_home).expanduser() / APP_DIR_NAME
+    return Path.home() / ".local" / "share" / APP_DIR_NAME
+
+
+def storage_paths(root: Path | None = None) -> StoragePaths:
+    storage_root = root or data_dir()
+    return StoragePaths(
+        root=storage_root,
+        database=storage_root / "fly.db",
+        audio=storage_root / "audio",
+        artifacts=storage_root / "artifacts",
+        voice_samples=storage_root / "voice-samples",
+        exports=storage_root / "exports",
+    )
+
+
+def ensure_storage_layout(root: Path | None = None) -> StoragePaths:
+    paths = storage_paths(root)
+    for directory in paths.directories:
+        directory.mkdir(parents=True, exist_ok=True)
+    return paths

fly_on_the_wall/voice_samples.py

@@ -0,0 +1,125 @@
+from __future__ import annotations
+
+import shutil
+from dataclasses import dataclass
+from pathlib import Path
+from sqlite3 import Connection
+from uuid import uuid4
+
+from fly_on_the_wall.audio import extract_clip
+from fly_on_the_wall.storage import StoragePaths, storage_paths
+
+
+@dataclass(frozen=True)
+class VoiceSample:
+    id: str
+    person_id: str
+    audio_path: Path
+    source_meeting_id: str | None = None
+    source_local_speaker_id: str | None = None
+    start_time: float | None = None
+    end_time: float | None = None
+
+
+def create_voice_sample_from_clip(
+    connection: Connection,
+    person_id: str,
+    clip_path: Path,
+    storage: StoragePaths | None = None,
+) -> VoiceSample:
+    if not clip_path.is_file():
+        raise FileNotFoundError(f"Voice sample clip does not exist: {clip_path}")
+
+    paths = storage or storage_paths()
+    sample_id = str(uuid4())
+    stored_path = paths.voice_samples / person_id / f"{sample_id}{clip_path.suffix}"
+    stored_path.parent.mkdir(parents=True, exist_ok=True)
+    shutil.copy2(clip_path, stored_path)
+
+    sample = VoiceSample(id=sample_id, person_id=person_id, audio_path=stored_path)
+    _insert_voice_sample(connection, sample)
+    return sample
+
+
+def create_voice_sample_from_span(
+    connection: Connection,
+    person_id: str,
+    source_audio_path: Path,
+    source_meeting_id: str,
+    source_local_speaker_id: str | None,
+    start_time: float,
+    end_time: float,
+    storage: StoragePaths | None = None,
+) -> VoiceSample:
+    paths = storage or storage_paths()
+    sample_id = str(uuid4())
+    stored_path = paths.voice_samples / person_id / f"{sample_id}.wav"
+    extract_clip(source_audio_path, stored_path, start_time, end_time)
+
+    sample = VoiceSample(
+        id=sample_id,
+        person_id=person_id,
+        audio_path=stored_path,
+        source_meeting_id=source_meeting_id,
+        source_local_speaker_id=source_local_speaker_id,
+        start_time=start_time,
+        end_time=end_time,
+    )
+    _insert_voice_sample(connection, sample)
+    return sample
+
+
+def list_voice_samples(connection: Connection, person_id: str) -> list[VoiceSample]:
+    rows = connection.execute(
+        """
+        SELECT id,
+               person_id,
+               audio_path,
+               source_meeting_id,
+               source_local_speaker_id,
+               start_time,
+               end_time
+        FROM voice_samples
+        WHERE person_id = ?
+        ORDER BY created_at
+        """,
+        (person_id,),
+    ).fetchall()
+    return [
+        VoiceSample(
+            id=row["id"],
+            person_id=row["person_id"],
+            audio_path=Path(row["audio_path"]),
+            source_meeting_id=row["source_meeting_id"],
+            source_local_speaker_id=row["source_local_speaker_id"],
+            start_time=row["start_time"],
+            end_time=row["end_time"],
+        )
+        for row in rows
+    ]
+
+
+def _insert_voice_sample(connection: Connection, sample: VoiceSample) -> None:
+    with connection:
+        connection.execute(
+            """
+            INSERT INTO voice_samples(
+                id,
+                person_id,
+                source_meeting_id,
+                source_local_speaker_id,
+                start_time,
+                end_time,
+                audio_path
+            ) VALUES (?, ?, ?, ?, ?, ?, ?)
+            """,
+            (
+                sample.id,
+                sample.person_id,
+                sample.source_meeting_id,
+                sample.source_local_speaker_id,
+                sample.start_time,
+                sample.end_time,
+                str(sample.audio_path),
+            ),
+        )