fow-cli 0.1.0__py3-none-any.whl

fly_on_the_wall/__init__.py

@@ -0,0 +1,3 @@
+"""Fly on the Wall CLI application."""
+
+__version__ = "0.1.0"

fly_on_the_wall/audio.py

@@ -0,0 +1,164 @@
+from __future__ import annotations
+
+import json
+import subprocess
+import sys
+import time
+from pathlib import Path
+from select import select
+
+
+class AudioError(RuntimeError):
+    """Raised when an audio operation fails."""
+
+
+def get_duration(audio_path: Path) -> float:
+    result = _run(
+        [
+            "ffprobe",
+            "-v",
+            "error",
+            "-show_entries",
+            "format=duration",
+            "-of",
+            "default=noprint_wrappers=1:nokey=1",
+            str(audio_path),
+        ]
+    )
+    try:
+        return float(result.stdout.strip())
+    except ValueError as exc:
+        raise AudioError(f"Could not read duration for {audio_path}") from exc
+
+
+def probe_metadata(audio_path: Path) -> dict:
+    result = _run(
+        [
+            "ffprobe",
+            "-v",
+            "quiet",
+            "-print_format",
+            "json",
+            "-show_format",
+            "-show_streams",
+            str(audio_path),
+        ]
+    )
+    try:
+        return json.loads(result.stdout)
+    except json.JSONDecodeError as exc:
+        raise AudioError(f"Could not parse metadata for {audio_path}") from exc
+
+
+def convert_to_wav(input_path: Path, output_path: Path) -> Path:
+    output_path.parent.mkdir(parents=True, exist_ok=True)
+    _run(["ffmpeg", "-y", "-i", str(input_path), str(output_path)])
+    return output_path
+
+
+def normalize_for_embedding(input_path: Path, output_path: Path) -> Path:
+    output_path.parent.mkdir(parents=True, exist_ok=True)
+    _run(
+        [
+            "ffmpeg",
+            "-y",
+            "-i",
+            str(input_path),
+            "-ac",
+            "1",
+            "-ar",
+            "16000",
+            str(output_path),
+        ]
+    )
+    return output_path
+
+
+def extract_clip(input_path: Path, output_path: Path, start: float, end: float) -> Path:
+    if end <= start:
+        raise ValueError("Clip end must be greater than start.")
+
+    output_path.parent.mkdir(parents=True, exist_ok=True)
+    _run(
+        [
+            "ffmpeg",
+            "-y",
+            "-ss",
+            f"{max(0.0, start):.3f}",
+            "-to",
+            f"{end:.3f}",
+            "-i",
+            str(input_path),
+            str(output_path),
+        ]
+    )
+    return output_path
+
+
+def play_audio(audio_path: Path, player: str = "ffplay", stop_on_enter: bool = False) -> None:
+    command = audio_playback_command(audio_path, player)
+    if stop_on_enter:
+        _run_until_enter(command)
+        return
+    _run(command)
+
+
+def audio_playback_command(audio_path: Path, player: str = "ffplay") -> list[str]:
+    if player == "ffplay":
+        return ["ffplay", "-nodisp", "-autoexit", str(audio_path)]
+    return [player, str(audio_path)]
+
+
+def start_audio_playback(audio_path: Path, player: str = "ffplay") -> subprocess.Popen:
+    command = audio_playback_command(audio_path, player)
+    try:
+        return subprocess.Popen(command, stdout=subprocess.DEVNULL, stderr=subprocess.DEVNULL)
+    except FileNotFoundError as exc:
+        raise AudioError(f"Required audio tool not found: {command[0]}") from exc
+
+
+def stop_audio_playback(process: subprocess.Popen) -> None:
+    if process.poll() is not None:
+        return
+    process.terminate()
+    try:
+        process.wait(timeout=2)
+    except subprocess.TimeoutExpired:
+        process.kill()
+        process.wait()
+
+
+def _run_until_enter(command: list[str]) -> None:
+    try:
+        process = subprocess.Popen(command, stdout=subprocess.DEVNULL, stderr=subprocess.DEVNULL)
+    except FileNotFoundError as exc:
+        raise AudioError(f"Required audio tool not found: {command[0]}") from exc
+
+    try:
+        while process.poll() is None:
+            if sys.stdin.isatty():
+                ready, _, _ = select([sys.stdin], [], [], 0.1)
+                if ready:
+                    sys.stdin.readline()
+                    process.terminate()
+                    break
+            else:
+                time.sleep(0.1)
+    except KeyboardInterrupt:
+        process.terminate()
+    finally:
+        try:
+            process.wait(timeout=2)
+        except subprocess.TimeoutExpired:
+            process.kill()
+            process.wait()
+
+
+def _run(command: list[str]) -> subprocess.CompletedProcess[str]:
+    try:
+        return subprocess.run(command, check=True, capture_output=True, text=True)
+    except FileNotFoundError as exc:
+        raise AudioError(f"Required audio tool not found: {command[0]}") from exc
+    except subprocess.CalledProcessError as exc:
+        message = exc.stderr.strip() or exc.stdout.strip() or str(exc)
+        raise AudioError(f"Audio command failed: {message}") from exc

fly_on_the_wall/audio_metadata.py

@@ -0,0 +1,241 @@
+from __future__ import annotations
+
+import json
+import re
+from dataclasses import dataclass
+from datetime import datetime
+from pathlib import Path
+from sqlite3 import Connection
+
+from fly_on_the_wall.audio import AudioError, probe_metadata
+from fly_on_the_wall.storage import StoragePaths
+
+
+@dataclass(frozen=True)
+class NormalizedAudioMetadata:
+    recorded_at: str | None = None
+    recorded_at_source: str | None = None
+    recorded_at_confidence: str | None = None
+    duration_seconds: float | None = None
+    size_bytes: int | None = None
+    bit_rate: int | None = None
+    codec: str | None = None
+    sample_rate: int | None = None
+    channels: int | None = None
+    channel_layout: str | None = None
+    container_format: str | None = None
+    metadata_title: str | None = None
+    metadata_artist: str | None = None
+    metadata_album: str | None = None
+    metadata_genre: str | None = None
+    metadata_comment: str | None = None
+    metadata_encoder: str | None = None
+    device_or_software: str | None = None
+
+
+def extract_and_store_audio_metadata(
+    connection: Connection,
+    meeting_id: str,
+    audio_path: Path,
+    storage: StoragePaths,
+) -> None:
+    try:
+        raw_metadata = probe_metadata(audio_path)
+    except AudioError:
+        return
+
+    metadata_dir = storage.artifacts / meeting_id
+    metadata_dir.mkdir(parents=True, exist_ok=True)
+    raw_metadata_path = metadata_dir / "audio-metadata.ffprobe.json"
+    raw_metadata_path.write_text(json.dumps(raw_metadata, indent=2) + "\n")
+
+    normalized = normalize_audio_metadata(raw_metadata, audio_path)
+    with connection:
+        connection.execute(
+            """
+            INSERT OR REPLACE INTO audio_metadata(
+                id,
+                meeting_id,
+                raw_metadata_path,
+                recorded_at,
+                recorded_at_source,
+                recorded_at_confidence,
+                duration_seconds,
+                size_bytes,
+                bit_rate,
+                codec,
+                sample_rate,
+                channels,
+                channel_layout,
+                container_format,
+                metadata_title,
+                metadata_artist,
+                metadata_album,
+                metadata_genre,
+                metadata_comment,
+                metadata_encoder,
+                device_or_software
+            ) VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)
+            """,
+            (
+                meeting_id,
+                meeting_id,
+                str(raw_metadata_path),
+                normalized.recorded_at,
+                normalized.recorded_at_source,
+                normalized.recorded_at_confidence,
+                normalized.duration_seconds,
+                normalized.size_bytes,
+                normalized.bit_rate,
+                normalized.codec,
+                normalized.sample_rate,
+                normalized.channels,
+                normalized.channel_layout,
+                normalized.container_format,
+                normalized.metadata_title,
+                normalized.metadata_artist,
+                normalized.metadata_album,
+                normalized.metadata_genre,
+                normalized.metadata_comment,
+                normalized.metadata_encoder,
+                normalized.device_or_software,
+            ),
+        )
+
+
+def normalize_audio_metadata(raw_metadata: dict, audio_path: Path) -> NormalizedAudioMetadata:
+    audio_stream = _first_audio_stream(raw_metadata)
+    format_data = raw_metadata.get("format") if isinstance(raw_metadata.get("format"), dict) else {}
+    format_tags = _normalized_tags(format_data.get("tags"))
+    stream_tags = _normalized_tags(audio_stream.get("tags"))
+    tags = {**stream_tags, **format_tags}
+    recorded_at, recorded_at_source, recorded_at_confidence = _recorded_at(tags, audio_path)
+
+    return NormalizedAudioMetadata(
+        recorded_at=recorded_at,
+        recorded_at_source=recorded_at_source,
+        recorded_at_confidence=recorded_at_confidence,
+        duration_seconds=_optional_float(format_data.get("duration")),
+        size_bytes=_optional_int(format_data.get("size")),
+        bit_rate=_optional_int(format_data.get("bit_rate") or audio_stream.get("bit_rate")),
+        codec=_optional_str(audio_stream.get("codec_name")),
+        sample_rate=_optional_int(audio_stream.get("sample_rate")),
+        channels=_optional_int(audio_stream.get("channels")),
+        channel_layout=_optional_str(audio_stream.get("channel_layout")),
+        container_format=_optional_str(format_data.get("format_name")),
+        metadata_title=tags.get("title"),
+        metadata_artist=tags.get("artist"),
+        metadata_album=tags.get("album"),
+        metadata_genre=tags.get("genre"),
+        metadata_comment=tags.get("comment"),
+        metadata_encoder=tags.get("encoder"),
+        device_or_software=tags.get("artist") or tags.get("encoder"),
+    )
+
+
+def _first_audio_stream(raw_metadata: dict) -> dict:
+    streams = raw_metadata.get("streams")
+    if not isinstance(streams, list):
+        return {}
+    for stream in streams:
+        if isinstance(stream, dict) and stream.get("codec_type") == "audio":
+            return stream
+    return {}
+
+
+def _normalized_tags(tags: object) -> dict[str, str]:
+    if not isinstance(tags, dict):
+        return {}
+    return {str(key).lower(): str(value).strip() for key, value in tags.items() if str(value).strip()}
+
+
+def _recorded_at(tags: dict[str, str], audio_path: Path) -> tuple[str | None, str | None, str | None]:
+    for key in ("date", "creation_time", "com.apple.quicktime.creationdate"):
+        parsed = _parse_datetime(tags.get(key))
+        if parsed is not None:
+            return parsed, f"metadata.{key}", "medium"
+
+    title = tags.get("title")
+    parsed = _parse_philips_title_datetime(title)
+    if parsed is not None:
+        return parsed, "metadata.title", "high"
+
+    parsed = _parse_recup_filename_datetime(audio_path.name)
+    if parsed is not None:
+        return parsed, "filename.recup", "medium"
+
+    parsed = _parse_recorder_filename_datetime(audio_path.name)
+    if parsed is not None:
+        return parsed, "filename.recorder", "medium"
+
+    try:
+        mtime = datetime.fromtimestamp(audio_path.stat().st_mtime).replace(microsecond=0)
+    except OSError:
+        return None, None, None
+    return _format_datetime(mtime), "filesystem.mtime", "low"
+
+
+def _parse_philips_title_datetime(value: str | None) -> str | None:
+    if not value:
+        return None
+    match = re.search(r"(\d{4}-\d{2}-\d{2})[ T](\d{2}:\d{2}:\d{2})", value)
+    if match is None:
+        return None
+    return _parse_datetime(f"{match.group(1)} {match.group(2)}")
+
+
+def _parse_recup_filename_datetime(value: str) -> str | None:
+    match = re.search(r"DV-(\d{4})-(\d{2})-(\d{2})-(\d{2})(\d{2})(\d{2})", value)
+    if match is None:
+        return None
+    year, month, day, hour, minute, second = match.groups()
+    return _parse_datetime(f"{year}-{month}-{day} {hour}:{minute}:{second}")
+
+
+def _parse_recorder_filename_datetime(value: str) -> str | None:
+    match = re.search(r"(\d{2})(\d{2})(\d{2})_(\d{2})(\d{2})(\d{2})", value)
+    if match is None:
+        return None
+    year, month, day, hour, minute, second = match.groups()
+    return _parse_datetime(f"20{year}-{month}-{day} {hour}:{minute}:{second}")
+
+
+def _parse_datetime(value: str | None) -> str | None:
+    if not value:
+        return None
+    normalized = value.strip().replace("Z", "+00:00")
+    for fmt in (None, "%Y-%m-%d %H:%M:%S", "%Y-%m-%dT%H:%M:%S"):
+        try:
+            if fmt is None:
+                parsed = datetime.fromisoformat(normalized)
+            else:
+                parsed = datetime.strptime(normalized, fmt)
+        except ValueError:
+            continue
+        return _format_datetime(parsed.replace(tzinfo=None))
+    return None
+
+
+def _format_datetime(value: datetime) -> str:
+    return value.strftime("%Y-%m-%d %H:%M:%S")
+
+
+def _optional_str(value: object) -> str | None:
+    if value is None:
+        return None
+    text = str(value).strip()
+    return text or None
+
+
+def _optional_int(value: object) -> int | None:
+    try:
+        return int(value) if value is not None else None
+    except (TypeError, ValueError):
+        return None
+
+
+def _optional_float(value: object) -> float | None:
+    try:
+        return float(value) if value is not None else None
+    except (TypeError, ValueError):
+        return None

fly_on_the_wall/cache.py

@@ -0,0 +1,26 @@
+from __future__ import annotations
+
+import hashlib
+from pathlib import Path
+
+
+def text_sha256(value: str) -> str:
+    return hashlib.sha256(value.encode()).hexdigest()
+
+
+def read_cached_text(cache_dir: Path, cache_key: str) -> str | None:
+    path = _cache_path(cache_dir, cache_key)
+    if not path.exists():
+        return None
+    return path.read_text()
+
+
+def write_cached_text(cache_dir: Path, cache_key: str, value: str) -> Path:
+    path = _cache_path(cache_dir, cache_key)
+    path.parent.mkdir(parents=True, exist_ok=True)
+    path.write_text(value)
+    return path
+
+
+def _cache_path(cache_dir: Path, cache_key: str) -> Path:
+    return cache_dir / f"{cache_key}.txt"

fly_on_the_wall/cleanup.py

@@ -0,0 +1,29 @@
+from __future__ import annotations
+
+import re
+
+
+def deterministic_cleanup(transcript: str) -> str:
+    turns = [_parse_turn(line) for line in transcript.splitlines() if line.strip()]
+    merged: list[tuple[str, str]] = []
+    for speaker, text in turns:
+        cleaned_text = normalize_whitespace(text)
+        if not cleaned_text:
+            continue
+        if merged and merged[-1][0] == speaker:
+            previous_speaker, previous_text = merged[-1]
+            merged[-1] = (previous_speaker, normalize_whitespace(f"{previous_text} {cleaned_text}"))
+        else:
+            merged.append((speaker, cleaned_text))
+    return "\n\n".join(f"{speaker}: {text}" for speaker, text in merged)
+
+
+def normalize_whitespace(value: str) -> str:
+    return re.sub(r"\s+", " ", value).strip()
+
+
+def _parse_turn(line: str) -> tuple[str, str]:
+    if ":" not in line:
+        return "Unknown", line
+    speaker, text = line.split(":", 1)
+    return normalize_whitespace(speaker), text