openbbq 0.0.1__py3-none-any.whl

openbbq/__init__.py

@@ -0,0 +1 @@
+__version__ = "0.0.1"

openbbq/cli/__init__.py

@@ -0,0 +1,48 @@
+from __future__ import annotations
+
+import sys
+
+import typer
+from typer._click import ClickException  # typer >=0.26 bundles click privately
+from typer._click.exceptions import Abort
+from typer.main import get_command
+
+from ..errors import OpenBBQError
+from .app import app
+from .output import Output
+
+__all__ = ["app", "main"]
+
+
+def main() -> None:
+    """Console entry point, split by audience.
+
+    Human (TTY): typer renders everything natively — help, Rich usage panels,
+    completion, exit codes — and we only translate ``OpenBBQError``.
+    Machine (``--json`` / non-TTY): a single chokepoint emits compact JSON for
+    success, domain errors (exit 1) and usage errors (exit 2) alike, so
+    ``--json`` is honored uniformly.
+    """
+    if "--json" not in sys.argv and sys.stdout.isatty():
+        try:
+            app()
+        except OpenBBQError as err:
+            Output(json_mode=False).error(err)
+            raise SystemExit(1) from err
+        return
+
+    output = Output(json_mode=True)
+    command = get_command(app)
+    try:
+        rv = command(args=sys.argv[1:], prog_name="openbbq", standalone_mode=False)
+    except OpenBBQError as err:
+        output.error(err)
+        raise SystemExit(1) from err
+    except typer.Exit as err:
+        raise SystemExit(err.exit_code) from err
+    except Abort as err:
+        raise SystemExit(130) from err
+    except ClickException as err:  # missing/bad arg, unknown command, no command
+        output.usage_error(err)
+        raise SystemExit(err.exit_code) from err
+    raise SystemExit(rv if isinstance(rv, int) else 0)

openbbq/cli/app.py

@@ -0,0 +1,47 @@
+from __future__ import annotations
+
+from typing import Annotated
+
+import typer
+
+from .commands.auth import app as auth_app
+from .commands.burn import burn
+from .commands.doctor import doctor
+from .commands.export import export
+from .commands.extract_audio import extract_audio
+from .commands.fetch import fetch
+from .commands.glossary import app as glossary_app
+from .commands.init import init
+from .commands.models import app as models_app
+from .commands.segment import segment
+from .commands.status import status
+from .commands.transcribe import transcribe
+from .commands.translate import app as translate_app
+from .output import Output
+
+app = typer.Typer(no_args_is_help=True)
+
+
+@app.callback()
+def _root(
+    ctx: typer.Context,
+    json: Annotated[
+        bool, typer.Option("--json", help="Emit machine-readable JSON")
+    ] = False,
+) -> None:
+    ctx.obj = Output.detect(json)
+
+
+app.command()(doctor)
+app.command()(init)
+app.command()(status)
+app.command()(fetch)
+app.command(name="extract-audio")(extract_audio)
+app.command()(transcribe)
+app.command()(segment)
+app.add_typer(translate_app, name="translate")
+app.command()(export)
+app.command()(burn)
+app.add_typer(models_app, name="models")
+app.add_typer(glossary_app, name="glossary")
+app.add_typer(auth_app, name="auth")

openbbq/cli/commands/auth.py

@@ -0,0 +1,97 @@
+from __future__ import annotations
+
+from datetime import datetime
+from typing import Annotated
+
+import typer
+
+from ...core.auth import browser
+from ...core.auth import sites
+from ...core.auth import store as auth_store
+from ..output import Output
+from ..results import Result
+
+app = typer.Typer(no_args_is_help=True)
+
+
+class AuthStatusResult(Result):
+    site: str
+    configured: bool
+    cookie_count: int = 0
+    auth_cookie_count: int = 0
+    expires_at: datetime | None = None
+
+    @classmethod
+    def of(cls, status: auth_store.AuthStatus) -> AuthStatusResult:
+        return cls(
+            site=status.site,
+            configured=status.configured,
+            cookie_count=status.cookie_count,
+            auth_cookie_count=status.auth_cookie_count,
+            expires_at=status.expires_at,
+        )
+
+    def render(self) -> str:
+        if not self.configured:
+            return f"{self.site}: not configured"
+        expiry = f"\n  expires: {self.expires_at.isoformat()}" if self.expires_at else ""
+        return (
+            f"[green]✓[/] {self.site} auth configured\n"
+            f"  cookies: {self.cookie_count} ({self.auth_cookie_count} auth){expiry}"
+        )
+
+
+class AuthClearResult(Result):
+    site: str
+
+    def render(self) -> str:
+        return f"[green]✓[/] cleared auth: {self.site}"
+
+
+def _stderr(message: str) -> None:
+    typer.echo(message, err=True)
+
+
+@app.command(name="browser-login")
+def browser_login(
+    ctx: typer.Context,
+    site: Annotated[str, typer.Argument(help="site key, currently: youtube")],
+) -> None:
+    """Open a browser login window and save site cookies for later use."""
+    output: Output = ctx.obj
+    policy = sites.require_policy(site)
+
+    def wait_for_user() -> None:
+        _stderr("Complete login in the opened browser window.")
+        _stderr("Then close that browser window, return here, and press Enter.")
+        input()
+
+    raw = browser.browser_login(
+        policy.key,
+        wait_for_user=wait_for_user,
+        on_message=_stderr,
+    )
+    status = auth_store.save_cookies(policy.key, raw)
+    output.emit(AuthStatusResult.of(status))
+
+
+@app.command()
+def status(
+    ctx: typer.Context,
+    site: Annotated[str, typer.Argument(help="site key, currently: youtube")],
+) -> None:
+    """Show whether a site app session is configured."""
+    output: Output = ctx.obj
+    output.emit(AuthStatusResult.of(auth_store.status(site)))
+
+
+@app.command()
+def clear(
+    ctx: typer.Context,
+    site: Annotated[str, typer.Argument(help="site key, currently: youtube")],
+) -> None:
+    """Remove saved cookies for a site app session."""
+    output: Output = ctx.obj
+    policy = sites.require_policy(site)
+    auth_store.clear(policy.key)
+    output.emit(AuthClearResult(site=policy.key))

openbbq/cli/commands/burn.py

@@ -0,0 +1,250 @@
+from __future__ import annotations
+
+import time
+from datetime import datetime, timezone
+from pathlib import Path
+from typing import Annotated
+
+import typer
+from rich.console import Group, RenderableType
+from rich.progress import (
+    BarColumn,
+    Progress as RichProgress,
+    TextColumn,
+    TimeElapsedColumn,
+    TimeRemainingColumn,
+)
+from rich.style import Style
+from rich.table import Table
+from rich.text import Text
+
+from ...core import media
+from ...core import workspace as ws
+from ...errors import OpenBBQError
+from ...schemas import Manifest, Progress, Stage, StageState, StageStatus
+from ..output import Output
+from ..results import Result
+
+
+class BurnResult(Result):
+    workspace: str
+    artifact: str
+    subtitle: str
+    duration_s: float | None
+    elapsed_s: float
+    ffmpeg: str
+
+    def _artifact_text(self, artifact: str) -> Text:
+        path = Path(artifact)
+        resolved = path if path.is_absolute() else Path(self.workspace) / path
+        return Text(
+            artifact, style=Style(color="cyan", link=resolved.resolve().as_uri())
+        )
+
+    def _workspace_text(self) -> Text:
+        uri = Path(self.workspace).resolve().as_uri()
+        return Text(self.workspace, style=Style(color="cyan", link=uri))
+
+    def render(self) -> RenderableType:
+        table = Table.grid(padding=(0, 2))
+        table.add_column(justify="right", style="dim", no_wrap=True)
+        table.add_column(ratio=1)
+        table.add_row("workspace", self._workspace_text())
+        table.add_row("file", self._artifact_text(self.artifact))
+        table.add_row("subtitle", self._artifact_text(self.subtitle))
+        if self.duration_s is not None:
+            table.add_row("length", Text(_clock(self.duration_s)))
+        table.add_row("elapsed", Text(f"{self.elapsed_s:.1f}s"))
+        return Group(Text.assemble(("✓", "green"), (" video burned", "bold")), table)
+
+
+def _now() -> datetime:
+    return datetime.now(timezone.utc)
+
+
+def _clock(seconds: float) -> str:
+    total = int(round(seconds))
+    h, rem = divmod(total, 3600)
+    m, s = divmod(rem, 60)
+    return f"{h}:{m:02d}:{s:02d}" if h else f"{m}:{s:02d}"
+
+
+def _relative_to_workspace(path: Path, workspace: Path) -> str:
+    try:
+        return str(path.relative_to(workspace))
+    except ValueError:
+        return str(path)
+
+
+def _resolve_path(value: str, workspace: Path) -> Path:
+    path = Path(value).expanduser()
+    return path if path.is_absolute() else workspace / path
+
+
+def _resolve_subtitle(
+    workspace: Path, manifest: Manifest, subtitle: str | None
+) -> Path:
+    if subtitle is not None:
+        path = _resolve_path(subtitle, workspace)
+        if not path.exists():
+            raise OpenBBQError(
+                "missing_input",
+                subtitle=subtitle,
+                fix="check --subtitle, or run openbbq export --format ass",
+            )
+    else:
+        path = ws.require_artifact(
+            workspace,
+            manifest,
+            Stage.EXPORT,
+            fix="openbbq export --format ass",
+        )
+    if path.suffix.lower() != ".ass":
+        raise OpenBBQError(
+            "unsupported_subtitle_format",
+            artifact=_relative_to_workspace(path, workspace),
+            format=path.suffix.lower() or "(none)",
+            fix="openbbq export --format ass",
+        )
+    return path
+
+
+def _default_output(subtitle: Path) -> Path:
+    return subtitle.with_name(f"{subtitle.stem}-burned.mp4")
+
+
+def _record_running(
+    workspace: Path, manifest: Manifest, progress: media.BurnProgress
+) -> None:
+    ws.record_stage(
+        workspace,
+        manifest,
+        Stage.BURN,
+        StageState(
+            status=StageStatus.RUNNING,
+            progress=Progress(
+                done=progress.done,
+                total=progress.total,
+                label="burn subtitles",
+            ),
+            updated_at=_now(),
+        ),
+    )
+
+
+def burn(
+    ctx: typer.Context,
+    workspace: Annotated[
+        str | None,
+        typer.Option("--workspace", "-w", help="workspace dir (default: cwd upward)"),
+    ] = None,
+    subtitle: Annotated[
+        str | None,
+        typer.Option(
+            "--subtitle",
+            help="ASS subtitle file to burn (default: last export artifact)",
+        ),
+    ] = None,
+    output: Annotated[
+        str | None,
+        typer.Option(
+            "--output", help="output mp4 path (default: out/<lang>-burned.mp4)"
+        ),
+    ] = None,
+    ffmpeg: Annotated[
+        str | None,
+        typer.Option("--ffmpeg", help="ffmpeg executable with libass support"),
+    ] = None,
+) -> None:
+    """Hard-burn an exported ASS subtitle file into an MP4 video."""
+    output_obj: Output = ctx.obj
+    started = time.monotonic()
+    path = ws.resolve_workspace(workspace)
+    manifest = ws.read_manifest(path)
+    src = ws.media_input(manifest, path)
+    if src.suffix.lower() in ws.AUDIO_EXTS:
+        raise OpenBBQError(
+            "video_unavailable",
+            source=str(src),
+            fix="use a video source, or fetch media from the URL first",
+        )
+    sub = _resolve_subtitle(path, manifest, subtitle)
+    dest = _resolve_path(output, path) if output else _default_output(sub)
+
+    last_write = 0.0
+
+    def heartbeat(progress: media.BurnProgress) -> None:
+        nonlocal last_write
+        now = time.monotonic()
+        if not (
+            now - last_write >= 1.0
+            or progress.done == 0
+            or progress.done == progress.total
+        ):
+            return
+        _record_running(path, manifest, progress)
+        last_write = now
+
+    try:
+        if output_obj.json_mode:
+            outcome = media.burn_subtitles(
+                src, sub, dest, ffmpeg=ffmpeg, on_progress=heartbeat
+            )
+        else:
+            progress_bar = RichProgress(
+                TextColumn("[progress.description]{task.description}"),
+                BarColumn(),
+                TextColumn("{task.percentage:>3.0f}%"),
+                TimeElapsedColumn(),
+                TimeRemainingColumn(),
+                transient=True,
+            )
+            with progress_bar:
+                task = progress_bar.add_task("Burning subtitles", total=None)
+
+                def cb(progress: media.BurnProgress) -> None:
+                    progress_bar.update(
+                        task,
+                        completed=progress.done,
+                        total=progress.total,
+                    )
+                    heartbeat(progress)
+
+                outcome = media.burn_subtitles(
+                    src, sub, dest, ffmpeg=ffmpeg, on_progress=cb
+                )
+    except OpenBBQError as err:
+        ws.record_stage(
+            path,
+            manifest,
+            Stage.BURN,
+            StageState(
+                status=StageStatus.FAILED,
+                error=err.code,
+                updated_at=_now(),
+            ),
+        )
+        raise
+
+    artifact = _relative_to_workspace(dest, path)
+    subtitle_artifact = _relative_to_workspace(sub, path)
+    ws.record_stage(
+        path,
+        manifest,
+        Stage.BURN,
+        StageState(
+            status=StageStatus.DONE,
+            artifact=artifact,
+            updated_at=_now(),
+        ),
+    )
+    output_obj.emit(
+        BurnResult(
+            workspace=str(path),
+            artifact=artifact,
+            subtitle=subtitle_artifact,
+            duration_s=outcome.duration_s,
+            elapsed_s=round(time.monotonic() - started, 2),
+            ffmpeg=outcome.ffmpeg,
+        )
+    )

openbbq/cli/commands/doctor.py

@@ -0,0 +1,54 @@
+from __future__ import annotations
+
+import typer
+from rich.console import RenderableType
+from rich.table import Table
+
+from ...core import doctor as core
+from ...schemas import OpenBBQModel
+from ..output import Output
+from ..results import Result
+
+
+# --- contract layer: doctor's stdout shape + how it renders -------------------
+class CheckReport(OpenBBQModel):
+    name: str
+    ok: bool
+    detail: str
+    fix: str | None = None
+
+    @classmethod
+    def of(cls, c: core.Check) -> CheckReport:
+        return cls(name=c.name, ok=c.ok, detail=c.detail, fix=c.fix)
+
+
+class DoctorResult(Result):
+    healthy: bool  # all probes green (distinct from `ok` = the command ran)
+    checks: list[CheckReport]
+
+    @classmethod
+    def of(cls, checks: list[core.Check]) -> DoctorResult:
+        return cls(
+            healthy=all(c.ok for c in checks),
+            checks=[CheckReport.of(c) for c in checks],
+        )
+
+    def render(self) -> RenderableType:
+        table = Table(show_header=True, header_style="bold", box=None)
+        table.add_column("check")
+        table.add_column("status")
+        table.add_column("detail")
+        for c in self.checks:
+            mark = "[green]✓[/]" if c.ok else "[red]✗[/]"
+            detail = (
+                c.detail if c.ok or c.fix is None else f"{c.detail}\n[dim]fix:[/] {c.fix}"
+            )
+            table.add_row(c.name, mark, detail)
+        return table
+
+
+# --- shell layer: typer binding only ------------------------------------------
+def doctor(ctx: typer.Context) -> None:
+    """Probe the environment for required tools (read-only, idempotent)."""
+    output: Output = ctx.obj
+    output.emit(DoctorResult.of(core.run_checks()))

openbbq/cli/commands/export.py

@@ -0,0 +1,154 @@
+from __future__ import annotations
+
+import time
+from datetime import datetime, timezone
+from pathlib import Path
+from typing import Annotated
+
+import typer
+
+from ...core import export as exp
+from ...core import workspace as ws
+from ...errors import OpenBBQError
+from ...schemas import Stage, StageState, StageStatus
+from ..output import Output
+from ..results import Result
+
+
+# --- contract layer -----------------------------------------------------------
+class ExportResult(Result):
+    artifact: str  # relative to the workspace, or the given --output
+    mode: str  # source | target | bilingual
+    format: str  # subtitle format (srt | ass)
+    ass_preset: str | None = None  # ASS style preset when format=ass
+    cues: int
+    elapsed_s: float
+
+    def render(self) -> str:
+        detail = f"{self.cues} cues · {self.format} · {self.mode}"
+        if self.ass_preset is not None:
+            detail = f"{detail} · {self.ass_preset}"
+        return (
+            f"[green]✓[/] exported: {self.artifact}\n"
+            f"  {detail}"
+        )
+
+
+# --- shell layer --------------------------------------------------------------
+def export(
+    ctx: typer.Context,
+    workspace: Annotated[
+        str | None,
+        typer.Option("--workspace", "-w", help="workspace dir (default: cwd upward)"),
+    ] = None,
+    to: Annotated[
+        str | None,
+        typer.Option("--to", help="target language worksheet to render (e.g. zh)"),
+    ] = None,
+    mode: Annotated[
+        exp.ExportMode | None,
+        typer.Option(
+            "--mode", help="source | target | bilingual (default: source, or target with --to)"
+        ),
+    ] = None,
+    fmt: Annotated[
+        str, typer.Option("--format", help="subtitle format (srt | ass)")
+    ] = "srt",
+    output: Annotated[
+        str | None,
+        typer.Option("--output", help="output path (default: out/<lang>.<format>)"),
+    ] = None,
+    ass_preset: Annotated[
+        exp.AssPreset,
+        typer.Option(
+            "--ass-preset",
+            help="ASS style preset: default | compact | fansub | mobile",
+        ),
+    ] = exp.AssPreset.DEFAULT,
+    allow_missing: Annotated[
+        bool,
+        typer.Option(
+            "--allow-missing", help="fall back to source for untranslated cues"
+        ),
+    ] = False,
+) -> None:
+    """Render cues into a subtitle file."""
+    output_obj: Output = ctx.obj
+    started = time.monotonic()
+    if fmt not in exp.SUPPORTED_FORMATS:
+        raise OpenBBQError("unsupported_format", format=fmt, fix="use --format srt or ass")
+    if fmt != "ass" and ass_preset != exp.AssPreset.DEFAULT:
+        raise OpenBBQError(
+            "ass_preset_requires_ass",
+            preset=ass_preset.value,
+            format=fmt,
+            fix="use --format ass, or remove --ass-preset",
+        )
+
+    path = ws.resolve_workspace(workspace)
+    manifest = ws.read_manifest(path)
+    cpath = ws.require_artifact(path, manifest, Stage.SEGMENT, fix="openbbq segment")
+    doc = ws.read_cues(cpath)
+
+    translation = None
+    if to is not None:
+        wpath = ws.worksheet_path(path, to)  # validates lang
+        if not wpath.is_file():
+            raise OpenBBQError(
+                "translation_not_found", lang=to, fix=f"openbbq translate init {to}"
+            )
+        translation = ws.read_translation(wpath)
+
+    resolved = mode or exp.default_mode(to)
+    if resolved is not exp.ExportMode.SOURCE and translation is None:
+        raise OpenBBQError(
+            "translation_required", mode=resolved.value, fix="pass --to <lang>"
+        )
+    if fmt == "ass":
+        content = exp.render_ass(
+            doc,
+            resolved,
+            translation=translation,
+            allow_missing=allow_missing,
+            preset=ass_preset,
+        )
+    else:
+        content = exp.render_srt(
+            doc,
+            resolved,
+            translation=translation,
+            allow_missing=allow_missing,
+        )
+
+    lang = exp.output_lang(doc, translation, resolved)
+    dest = Path(output) if output else Path("out") / f"{lang}.{fmt}"
+    if not dest.is_absolute():
+        dest = path / dest
+    dest.parent.mkdir(parents=True, exist_ok=True)
+    dest.write_text(content)
+
+    # record the artifact relative to the workspace when it lives inside it
+    try:
+        artifact = str(dest.relative_to(path))
+    except ValueError:
+        artifact = str(dest)
+    ws.record_stage(
+        path,
+        manifest,
+        Stage.EXPORT,
+        StageState(
+            status=StageStatus.DONE,
+            artifact=artifact,
+            updated_at=datetime.now(timezone.utc),
+        ),
+    )
+    output_obj.emit(
+        ExportResult(
+            artifact=artifact,
+            mode=resolved.value,
+            format=fmt,
+            ass_preset=ass_preset.value if fmt == "ass" else None,
+            cues=len(doc.cues),
+            elapsed_s=round(time.monotonic() - started, 2),
+        )
+    )