fow-cli 0.1.0__py3-none-any.whl

fly_on_the_wall/cli_costs.py

@@ -0,0 +1,81 @@
+from __future__ import annotations
+
+import typer
+from rich.console import Console
+from rich.table import Table
+
+from fly_on_the_wall.costs import cost_summary, meeting_cost_summary
+from fly_on_the_wall.db import database
+
+console = Console()
+costs_app = typer.Typer(help="Inspect external service usage and estimated costs.", no_args_is_help=True)
+
+
+@costs_app.command("summary")
+def costs_summary() -> None:
+    """Show estimated external service costs by provider and service."""
+    with database() as connection:
+        rows = cost_summary(connection)
+    if not rows:
+        console.print("No service usage recorded yet.")
+        return
+    table = Table(title="Estimated Service Costs")
+    table.add_column("Provider")
+    table.add_column("Service")
+    table.add_column("Calls", justify="right")
+    table.add_column("Input", justify="right")
+    table.add_column("Output", justify="right")
+    table.add_column("Estimated Cost", justify="right")
+    for row in rows:
+        table.add_row(
+            row["provider"],
+            row["service"],
+            str(row["calls"]),
+            _format_quantity(row["input_quantity"]),
+            _format_quantity(row["output_quantity"]),
+            _format_usd(row["estimated_cost_usd"]),
+        )
+    console.print(table)
+
+
+@costs_app.command("meeting")
+def costs_meeting(meeting: str) -> None:
+    """Show estimated external service costs for one meeting."""
+    with database() as connection:
+        rows = meeting_cost_summary(connection, meeting)
+    if not rows:
+        console.print(f"No service usage recorded for meeting: {meeting}")
+        return
+    table = Table(title=f"Estimated Service Costs: {meeting}")
+    table.add_column("Provider")
+    table.add_column("Service")
+    table.add_column("Model")
+    table.add_column("Calls", justify="right")
+    table.add_column("Input", justify="right")
+    table.add_column("Output", justify="right")
+    table.add_column("Estimated Cost", justify="right")
+    for row in rows:
+        table.add_row(
+            row["provider"],
+            row["service"],
+            row["model"],
+            str(row["calls"]),
+            _format_quantity(row["input_quantity"]),
+            _format_quantity(row["output_quantity"]),
+            _format_usd(row["estimated_cost_usd"]),
+        )
+    console.print(table)
+
+
+def _format_usd(value: float | None) -> str:
+    if value is None:
+        return "unknown"
+    return f"${value:.4f}"
+
+
+def _format_quantity(value: float | None) -> str:
+    if value is None:
+        return "0"
+    if float(value).is_integer():
+        return str(int(value))
+    return f"{value:.2f}"

fly_on_the_wall/cli_menu.py

@@ -0,0 +1,163 @@
+from __future__ import annotations
+
+import subprocess
+import threading
+from dataclasses import dataclass
+from pathlib import Path
+
+from prompt_toolkit.application import Application
+from prompt_toolkit.key_binding import KeyBindings
+from prompt_toolkit.layout import HSplit, Layout, Window
+from prompt_toolkit.layout.controls import FormattedTextControl
+
+from fly_on_the_wall.audio import AudioError, start_audio_playback, stop_audio_playback
+
+
+@dataclass(frozen=True)
+class MenuChoice:
+    shortcut: str | None
+    label: str
+    value: str | None
+    playback_path: Path | None = None
+
+
+def select_menu(title: str, choices: list[MenuChoice]) -> str | None:
+    return InteractiveMenu(title, choices).run()
+
+
+class InteractiveMenu:
+    def __init__(self, title: str, choices: list[MenuChoice]) -> None:
+        self.title = title
+        self.choices = choices
+        self.selected_index = 0
+        self.selected_value: str | None = None
+        self.status_message = ""
+        self.playback_process = None
+        self.key_bindings = KeyBindings()
+        self.application = self._build_application()
+
+    def run(self) -> str | None:
+        try:
+            self.application.run()
+        except (KeyboardInterrupt, EOFError):
+            return None
+        return self.selected_value
+
+    def _build_application(self) -> Application:
+        self._bind_navigation_keys()
+        self._bind_shortcut_keys()
+        control = FormattedTextControl(self._render_menu, focusable=True)
+        return Application(
+            layout=Layout(HSplit([Window(content=control, always_hide_cursor=True)])),
+            key_bindings=self.key_bindings,
+            full_screen=False,
+            style=None,
+        )
+
+    def _bind_navigation_keys(self) -> None:
+        @self.key_bindings.add("up")
+        def _up(_event) -> None:
+            self._move(-1)
+
+        @self.key_bindings.add("down")
+        def _down(_event) -> None:
+            self._move(1)
+
+        @self.key_bindings.add("enter")
+        def _enter(_event) -> None:
+            if self._playback_is_running():
+                self._stop_playback()
+                return
+            self._finish(self.choices[self.selected_index])
+
+        @self.key_bindings.add("escape")
+        @self.key_bindings.add("c-c")
+        def _cancel(_event) -> None:
+            self._cancel()
+
+    def _bind_shortcut_keys(self) -> None:
+        bound_shortcuts: set[str] = set()
+        for choice in self.choices:
+            if choice.shortcut is None or choice.shortcut in bound_shortcuts:
+                continue
+            bound_shortcuts.add(choice.shortcut)
+            self.key_bindings.add(choice.shortcut)(lambda _event, selected=choice: self._finish(selected))
+
+    def _finish(self, choice: MenuChoice) -> None:
+        if choice.playback_path is not None:
+            self._toggle_playback(choice.playback_path)
+            return
+        self._stop_playback()
+        self.selected_value = choice.value
+        self.application.exit()
+
+    def _cancel(self) -> None:
+        self._stop_playback()
+        self.selected_value = None
+        self.application.exit()
+
+    def _toggle_playback(self, audio_path: Path) -> None:
+        if self._playback_is_running():
+            self._stop_playback()
+            return
+        try:
+            self.playback_process = start_audio_playback(audio_path)
+        except AudioError as exc:
+            self.status_message = f"Could not play clip: {exc}"
+            self.application.invalidate()
+            return
+        self.status_message = "Playing. Press Enter to stop."
+        self._watch_playback_completion(self.playback_process)
+        self.application.invalidate()
+
+    def _stop_playback(self) -> None:
+        if self.playback_process is not None:
+            stop_audio_playback(self.playback_process)
+            self.playback_process = None
+        self.status_message = ""
+        self.application.invalidate()
+
+    def _move(self, offset: int) -> None:
+        self.selected_index = (self.selected_index + offset) % len(self.choices)
+        self.application.invalidate()
+
+    def _render_menu(self):
+        self._clear_finished_playback()
+        lines = [("class:title", f"{self.title}\n")]
+        lines.extend(self._choice_lines())
+        if self.status_message:
+            lines.append(("class:status", f"\n{self.status_message}\n"))
+        lines.append(("class:help", "\nUse arrows, Enter, shortcut key, or Esc to cancel."))
+        return lines
+
+    def _choice_lines(self) -> list[tuple[str, str]]:
+        lines = []
+        for index, choice in enumerate(self.choices):
+            prefix = ">" if index == self.selected_index else " "
+            style = "class:selected" if index == self.selected_index else ""
+            shortcut = f"[{choice.shortcut}] " if choice.shortcut is not None else ""
+            lines.append((style, f"{prefix} {shortcut}{choice.label}\n"))
+        return lines
+
+    def _playback_is_running(self) -> bool:
+        return self.playback_process is not None and self.playback_process.poll() is None
+
+    def _watch_playback_completion(self, process: subprocess.Popen) -> None:
+        thread = threading.Thread(target=self._wait_for_playback_completion, args=(process,), daemon=True)
+        thread.start()
+
+    def _wait_for_playback_completion(self, process: subprocess.Popen) -> None:
+        process.wait()
+        if self._clear_finished_playback(process):
+            self.application.invalidate()
+
+    def _clear_finished_playback(self, process: subprocess.Popen | None = None) -> bool:
+        if self.playback_process is None:
+            return False
+        if process is not None and self.playback_process is not process:
+            return False
+        if self.playback_process.poll() is None:
+            return False
+        self.playback_process = None
+        self.status_message = ""
+        return True

fly_on_the_wall/cli_publish.py

@@ -0,0 +1,141 @@
+from __future__ import annotations
+
+from pathlib import Path
+from typing import Annotated
+
+import typer
+from rich.console import Console
+from rich.table import Table
+
+from fly_on_the_wall.db import database
+from fly_on_the_wall.publishing import (
+    add_publish_target,
+    list_publish_targets,
+    publish_all_meetings,
+    publish_meeting,
+    remove_publish_target,
+    set_publish_target_enabled,
+)
+
+console = Console()
+publish_app = typer.Typer(help="Publish meetings to external targets.", no_args_is_help=True)
+publish_targets_app = typer.Typer(help="Manage publish targets.", no_args_is_help=True)
+publish_app.add_typer(publish_targets_app, name="targets")
+
+
+@publish_app.command("meeting")
+def publish_meeting_command(
+    meeting: str,
+    target: Annotated[str, typer.Option("--target", "-t", help="Publish target name or id.")],
+) -> None:
+    """Publish one meeting to a configured target."""
+    with database() as connection:
+        try:
+            result = publish_meeting(connection, meeting, target)
+        except ValueError as exc:
+            console.print(str(exc))
+            raise typer.Exit(code=1) from exc
+    console.print(f"Published {meeting} to {result.target.name}")
+    console.print(f"Output: {result.output_path}")
+
+
+@publish_app.command("all")
+def publish_all_command(
+    target: Annotated[str, typer.Option("--target", "-t", help="Publish target name or id.")],
+    only_unpublished: Annotated[
+        bool,
+        typer.Option("--only-unpublished", help="Skip meetings already published to this target."),
+    ] = False,
+) -> None:
+    """Publish all exported meetings to a configured target."""
+    with database() as connection:
+        try:
+            results = publish_all_meetings(connection, target, only_unpublished)
+        except ValueError as exc:
+            console.print(str(exc))
+            raise typer.Exit(code=1) from exc
+
+    if not results:
+        console.print("No meetings to publish.")
+        return
+    for result in results:
+        console.print(f"Published to {result.target.name}: {result.output_path}")
+    console.print(f"Published {len(results)} meeting(s).")
+
+
+@publish_targets_app.command("add")
+def publish_targets_add(
+    target_type: str,
+    path: Annotated[Path, typer.Argument(file_okay=False, dir_okay=True)],
+    name: Annotated[str, typer.Option("--name", "-n", help="Target name.")],
+    auto_publish: Annotated[
+        bool, typer.Option("--auto-publish", help="Publish processed meetings automatically.")
+    ] = False,
+) -> None:
+    """Add an external publish target."""
+    with database() as connection:
+        try:
+            target = add_publish_target(connection, target_type, path, name, auto_publish)
+        except Exception as exc:
+            console.print(str(exc))
+            raise typer.Exit(code=1) from exc
+    console.print(f"Added {target.target_type} publish target {target.name}")
+    console.print(f"Path: {target.path}")
+
+
+@publish_targets_app.command("list")
+def publish_targets_list() -> None:
+    """List publish targets."""
+    with database() as connection:
+        targets = list_publish_targets(connection)
+    if not targets:
+        console.print("No publish targets configured.")
+        return
+    table = Table(title="Publish Targets")
+    table.add_column("Name")
+    table.add_column("Type")
+    table.add_column("Auto")
+    table.add_column("Enabled")
+    table.add_column("Path")
+    for target in targets:
+        table.add_row(
+            target.name,
+            target.target_type,
+            "yes" if target.auto_publish else "no",
+            "yes" if target.enabled else "no",
+            str(target.path),
+        )
+    console.print(table)
+
+
+@publish_targets_app.command("remove")
+def publish_targets_remove(identifier: str) -> None:
+    """Remove a publish target by id or name."""
+    with database() as connection:
+        target = remove_publish_target(connection, identifier)
+    if target is None:
+        console.print(f"Publish target not found: {identifier}")
+        raise typer.Exit(code=1)
+    console.print(f"Removed publish target {target.name}")
+
+
+@publish_targets_app.command("enable")
+def publish_targets_enable(identifier: str) -> None:
+    """Enable a publish target by id or name."""
+    _set_publish_target_enabled_command(identifier, True)
+
+
+@publish_targets_app.command("disable")
+def publish_targets_disable(identifier: str) -> None:
+    """Disable a publish target by id or name."""
+    _set_publish_target_enabled_command(identifier, False)
+
+
+def _set_publish_target_enabled_command(identifier: str, enabled: bool) -> None:
+    with database() as connection:
+        target = set_publish_target_enabled(connection, identifier, enabled)
+    if target is None:
+        console.print(f"Publish target not found: {identifier}")
+        raise typer.Exit(code=1)
+    state = "Enabled" if enabled else "Disabled"
+    console.print(f"{state} publish target {target.name}")