subtitle-engine 0.1.0__tar.gz → 0.1.2__tar.gz

{subtitle_engine-0.1.0/src/subtitle_engine.egg-info → subtitle_engine-0.1.2}/PKG-INFO

@@ -1,11 +1,11 @@
 Metadata-Version: 2.4
 Name: subtitle-engine
-Version: 0.1.0
+Version: 0.1.2
 Summary: Generate SRT subtitles from audio/video files using WhisperX
 Author: Leevi Puntanen
 License-Expression: MIT
-Project-URL: Homepage, https://github.com/leevipuntanen/subtitle-engine
-Project-URL: Issues, https://github.com/leevipuntanen/subtitle-engine/issues
+Project-URL: Homepage, https://github.com/leevipun/subtitle-engine
+Project-URL: Issues, https://github.com/leevipun/subtitle-engine/issues
 Keywords: subtitles,srt,whisperx,transcription,asr
 Classifier: Development Status :: 4 - Beta
 Classifier: Intended Audience :: End Users/Desktop
@@ -58,7 +58,7 @@ subeng video.mp4 --output subtitles.srt
 # Use a different model or language
 subeng video.mp4 --model medium --language fi
 
-# Force CPU / CUDA / MPS
+# Force CPU / CUDA
 subeng video.mp4 --device cpu
 
 # Speaker diarization (requires a Hugging Face token)
@@ -75,7 +75,7 @@ subeng video.mp4 --caption --ollama-model qwen3.5:0.8b
 | `--output`, `-o` | Output SRT file path |
 | `--model`, `-m` | WhisperX model: `tiny`, `base`, `small` (default), `medium`, `large-v2`, `large-v3` |
 | `--language`, `-l` | ISO language code, e.g. `en`, `fi`. Auto-detected if omitted. |
-| `--device`, `-d` | `cpu`, `cuda` or `mps`. Auto-detected if omitted. |
+| `--device`, `-d` | `cpu` or `cuda`. Auto-detected if omitted. |
 | `--batch-size`, `-b` | Inference batch size (default: 16) |
 | `--compute-type`, `-c` | `int8` or `float16`. Auto-selected if omitted. |
 | `--diarize` | Enable speaker diarization |

{subtitle_engine-0.1.0 → subtitle_engine-0.1.2}/README.md

@@ -32,7 +32,7 @@ subeng video.mp4 --output subtitles.srt
 # Use a different model or language
 subeng video.mp4 --model medium --language fi
 
-# Force CPU / CUDA / MPS
+# Force CPU / CUDA
 subeng video.mp4 --device cpu
 
 # Speaker diarization (requires a Hugging Face token)
@@ -49,7 +49,7 @@ subeng video.mp4 --caption --ollama-model qwen3.5:0.8b
 | `--output`, `-o` | Output SRT file path |
 | `--model`, `-m` | WhisperX model: `tiny`, `base`, `small` (default), `medium`, `large-v2`, `large-v3` |
 | `--language`, `-l` | ISO language code, e.g. `en`, `fi`. Auto-detected if omitted. |
-| `--device`, `-d` | `cpu`, `cuda` or `mps`. Auto-detected if omitted. |
+| `--device`, `-d` | `cpu` or `cuda`. Auto-detected if omitted. |
 | `--batch-size`, `-b` | Inference batch size (default: 16) |
 | `--compute-type`, `-c` | `int8` or `float16`. Auto-selected if omitted. |
 | `--diarize` | Enable speaker diarization |

{subtitle_engine-0.1.0 → subtitle_engine-0.1.2}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "subtitle-engine"
-version = "0.1.0"
+version = "0.1.2"
 description = "Generate SRT subtitles from audio/video files using WhisperX"
 readme = "README.md"
 license = "MIT"
@@ -35,11 +35,11 @@ dev = [
 ]
 
 [project.scripts]
-subeng = "subtitle_engine.cli:app"
+subeng = "subtitle_engine.cli:main_entry"
 
 [project.urls]
-Homepage = "https://github.com/leevipuntanen/subtitle-engine"
-Issues = "https://github.com/leevipuntanen/subtitle-engine/issues"
+Homepage = "https://github.com/leevipun/subtitle-engine"
+Issues = "https://github.com/leevipun/subtitle-engine/issues"
 
 [tool.setuptools.packages.find]
 where = ["src"]

{subtitle_engine-0.1.0 → subtitle_engine-0.1.2}/src/subtitle_engine/__init__.py

@@ -1,3 +1,3 @@
 """Subtitle Engine — generate SRT files with WhisperX."""
 
-__version__ = "0.1.0"
+__version__ = "0.1.1"

{subtitle_engine-0.1.0 → subtitle_engine-0.1.2}/src/subtitle_engine/cli.py

@@ -1,14 +1,17 @@
 """Command-line interface for subtitle-engine."""
 
+import sys
 from pathlib import Path
 from typing import Annotated, Optional
 
 import typer
 from rich.console import Console
 
+from subtitle_engine import __version__
 from subtitle_engine.captioner import generate_caption
 from subtitle_engine.srt_writer import write_srt
 from subtitle_engine.transcriber import transcribe
+from subtitle_engine.updater import UpdateCheckError, check_for_update, update_package
 from subtitle_engine.utils import resolve_output_path, validate_media_file
 
 app = typer.Typer(
@@ -18,7 +21,48 @@ app = typer.Typer(
 console = Console()
 
 
-@app.command()
+def _version_callback(value: bool) -> None:
+    if value:
+        console.print(f"subeng {__version__}")
+        raise typer.Exit()
+
+
+def update() -> None:
+    """Update subeng to the latest version from PyPI."""
+    try:
+        update_info = check_for_update(force=True)
+    except UpdateCheckError as exc:
+        console.print(f"[red]Error:[/red] {exc}")
+        raise typer.Exit(code=1) from exc
+
+    if update_info is None:
+        console.print(f"[green]subeng is up to date ({__version__}).[/green]")
+        return
+
+    console.print(
+        f"[bold]A new version is available:[/bold] "
+        f"{update_info.current} → {update_info.latest}"
+    )
+    console.print("[bold]Updating...[/bold]")
+    try:
+        update_package()
+    except UpdateCheckError as exc:
+        console.print(f"[red]Error:[/red] {exc}")
+        raise typer.Exit(code=1) from exc
+    console.print("[green]Update complete.[/green]")
+
+
+def main_entry() -> None:
+    """Route ``subeng update`` to the updater; otherwise run the Typer app."""
+    if len(sys.argv) > 1 and sys.argv[1] == "update":
+        update()
+    else:
+        app()
+
+
+@app.command(
+    epilog="Run 'subeng update' to update to the latest version.",
+)
 def main(
     input_file: Annotated[
         Path,
@@ -61,7 +105,7 @@ def main(
         typer.Option(
             "--device",
             "-d",
-            help="Device: cpu, cuda or mps. Auto-detected if omitted.",
+            help="Device: cpu or cuda. Auto-detected if omitted.",
         ),
     ] = None,
     batch_size: Annotated[
@@ -118,6 +162,31 @@ def main(
             envvar="OLLAMA_HOST",
         ),
     ] = "http://localhost:11434",
+    quiet: Annotated[
+        bool,
+        typer.Option(
+            "--quiet",
+            "-q",
+            help="Only print errors.",
+        ),
+    ] = False,
+    verbose: Annotated[
+        bool,
+        typer.Option(
+            "--verbose",
+            help="Show WhisperX progress bars and warnings.",
+        ),
+    ] = False,
+    version: Annotated[
+        bool,
+        typer.Option(
+            "--version",
+            "-v",
+            help="Show the version and exit.",
+            callback=_version_callback,
+            is_eager=True,
+        ),
+    ] = False,
 ) -> None:
     """Generate SRT subtitles from a media file."""
     try:
@@ -127,12 +196,22 @@ def main(
         if caption and not ollama_model:
             raise ValueError("--ollama-model is required when using --caption")
 
-        console.print(f"[bold]Transcribing:[/bold] {input_file}")
-        console.print(f"[bold]Model:[/bold] {model}")
-        if language:
-            console.print(f"[bold]Language:[/bold] {language}")
-        if device:
-            console.print(f"[bold]Device:[/bold] {device}")
+        if not quiet:
+            update_info = check_for_update()
+            if update_info:
+                console.print(
+                    f"[yellow]A new version of subeng is available:[/yellow] "
+                    f"{update_info.current} → {update_info.latest}. "
+                    f"Run [bold]subeng update[/bold] to install it."
+                )
+
+        if not quiet:
+            console.print(f"[bold]Transcribing:[/bold] {input_file}")
+            console.print(f"[bold]Model:[/bold] {model}")
+            if language:
+                console.print(f"[bold]Language:[/bold] {language}")
+            if device:
+                console.print(f"[bold]Device:[/bold] {device}")
 
         segments = transcribe(
             input_file,
@@ -143,10 +222,12 @@ def main(
             compute_type=compute_type,
             diarize=diarize,
             hf_token=hf_token,
+            verbose=verbose,
         )
 
         write_srt(segments, output_path)
-        console.print(f"[green]Wrote subtitles to:[/green] {output_path}")
+        if not quiet:
+            console.print(f"[green]Wrote subtitles to:[/green] {output_path}")
 
         if caption:
             transcript = " ".join(str(segment.get("text", "")).strip() for segment in segments)
@@ -157,7 +238,8 @@ def main(
             )
             caption_path = output_path.with_suffix(".caption.txt")
             caption_path.write_text(caption_text, encoding="utf-8")
-            console.print(f"[green]Wrote caption to:[/green] {caption_path}")
+            if not quiet:
+                console.print(f"[green]Wrote caption to:[/green] {caption_path}")
     except (ValueError, FileNotFoundError, ConnectionError) as exc:
         console.print(f"[red]Error:[/red] {exc}")
         raise typer.Exit(code=1) from exc
@@ -167,4 +249,4 @@ def main(
 
 
 if __name__ == "__main__":
-    app()
+    main_entry()

subtitle_engine-0.1.2/src/subtitle_engine/transcriber.py

@@ -0,0 +1,187 @@
+"""WhisperX transcription wrapper."""
+
+import contextlib
+import io
+import logging
+import os
+import warnings
+from pathlib import Path
+from typing import Iterator, Optional
+
+import torch
+import whisperx
+
+
+VALID_MODELS = {"tiny", "base", "small", "medium", "large-v2", "large-v3"}
+VALID_DEVICES = {"cpu", "cuda"}
+
+
+def _detect_device(device: Optional[str]) -> str:
+    """Pick a device if none was specified.
+
+    Note: MPS is intentionally excluded because the WhisperX backend
+    (faster-whisper / CTranslate2) only supports CPU and CUDA.
+    """
+    if device:
+        return device
+    if torch.cuda.is_available():
+        return "cuda"
+    return "cpu"
+
+
+def _default_compute_type(device: str) -> str:
+    """Pick a safe compute type for the device."""
+    if device == "cpu":
+        return "int8"
+    return "float16"
+
+
+def _validate_model(model_name: str) -> None:
+    """Raise a ValueError if the model name is unknown."""
+    if model_name not in VALID_MODELS:
+        joined = ", ".join(sorted(VALID_MODELS))
+        raise ValueError(f"Unknown model '{model_name}'. Choose from: {joined}")
+
+
+def _validate_device(device: str) -> None:
+    """Raise a ValueError if the device name is unknown."""
+    if device not in VALID_DEVICES:
+        joined = ", ".join(sorted(VALID_DEVICES))
+        raise ValueError(f"Unknown device '{device}'. Choose from: {joined}")
+
+
+@contextlib.contextmanager
+def _suppress_external_output(verbose: bool) -> Iterator[None]:
+    """Silence tqdm, warnings, and noisy loggers unless verbose is True."""
+    if verbose:
+        yield
+        return
+
+    original_tqdm_disable: Optional[bool] = None
+    original_tqdm_env = os.environ.get("TQDM_DISABLE")
+    try:
+        import tqdm as _tqdm
+
+        original_tqdm_disable = _tqdm.tqdm.disable
+        _tqdm.tqdm.disable = True
+    except Exception:  # noqa: BLE001
+        _tqdm = None
+
+    os.environ["TQDM_DISABLE"] = "1"
+
+    loggers = [
+        "whisperx",
+        "faster_whisper",
+        "pyannote.audio",
+        "transformers",
+        "torch",
+    ]
+    original_levels: dict[str, int] = {}
+    for name in loggers:
+        logger = logging.getLogger(name)
+        original_levels[name] = logger.level
+        logger.setLevel(logging.WARNING)
+
+    buf = io.StringIO()
+    try:
+        with warnings.catch_warnings():
+            warnings.simplefilter("ignore")
+            with contextlib.redirect_stdout(buf), contextlib.redirect_stderr(buf):
+                yield
+    finally:
+        if original_tqdm_env is None:
+            os.environ.pop("TQDM_DISABLE", None)
+        else:
+            os.environ["TQDM_DISABLE"] = original_tqdm_env
+        if original_tqdm_disable is not None and _tqdm is not None:
+            _tqdm.tqdm.disable = original_tqdm_disable
+        for name, level in original_levels.items():
+            logging.getLogger(name).setLevel(level)
+
+
+def transcribe(
+    audio_path: Path,
+    *,
+    model_name: str = "small",
+    language: Optional[str] = None,
+    device: Optional[str] = None,
+    batch_size: int = 16,
+    compute_type: Optional[str] = None,
+    diarize: bool = False,
+    hf_token: Optional[str] = None,
+    verbose: bool = False,
+) -> list[dict]:
+    """Transcribe an audio/video file and return SRT-ready segments.
+
+    Parameters
+    ----------
+    audio_path:
+        Path to the media file to transcribe.
+    model_name:
+        WhisperX model size. One of: tiny, base, small, medium, large-v2, large-v3.
+    language:
+        ISO language code, e.g. ``en`` or ``fi``. If ``None``, WhisperX auto-detects.
+    device:
+        ``cpu``, ``cuda`` or ``mps``. Auto-detected if omitted.
+    batch_size:
+        WhisperX batch size for transcription.
+    compute_type:
+        ``int8`` or ``float16``. Auto-selected per device if omitted.
+    diarize:
+        Whether to run speaker diarization.
+    hf_token:
+        Hugging Face token required for diarization.
+
+    Returns
+    -------
+    A list of segment dicts with ``start``, ``end`` and ``text`` keys.
+    """
+    _validate_model(model_name)
+
+    audio_path = Path(audio_path)
+    if not audio_path.exists():
+        raise FileNotFoundError(f"Audio file not found: {audio_path}")
+
+    device = _detect_device(device)
+    _validate_device(device)
+
+    if compute_type is None:
+        compute_type = _default_compute_type(device)
+
+    if diarize and not hf_token:
+        raise ValueError("--hf-token is required when using --diarize")
+
+    with _suppress_external_output(verbose):
+        audio = whisperx.load_audio(str(audio_path))
+
+        model = whisperx.load_model(model_name, device, compute_type=compute_type)
+        result = model.transcribe(audio, batch_size=batch_size, language=language)
+
+        # Free transcription model memory before alignment
+        del model
+
+        detected_language = result.get("language")
+        if detected_language:
+            align_model, align_metadata = whisperx.load_align_model(
+                language_code=detected_language, device=device
+            )
+            result = whisperx.align(
+                result["segments"],
+                align_model,
+                align_metadata,
+                audio,
+                device,
+                return_char_alignments=False,
+            )
+            del align_model
+
+        if diarize:
+            diarize_model = whisperx.DiarizationPipeline(
+                model_name="pyannote/speaker-diarization-3.1",
+                use_auth_token=hf_token,
+                device=device,
+            )
+            diarize_segments = diarize_model(audio)
+            result = whisperx.assign_word_speakers(diarize_segments, result)
+
+        return result["segments"]

subtitle_engine-0.1.2/src/subtitle_engine/updater.py

@@ -0,0 +1,158 @@
+"""Update checker and in-place updater for subtitle-engine."""
+
+from __future__ import annotations
+
+import json
+import subprocess
+import sys
+from dataclasses import dataclass
+from datetime import datetime, timedelta, timezone
+from pathlib import Path
+from typing import Optional
+from urllib.request import Request, urlopen
+
+from subtitle_engine import __version__
+
+PYPI_PACKAGE_NAME = "subtitle-engine"
+PYPI_JSON_URL = f"https://pypi.org/pypi/{PYPI_PACKAGE_NAME}/json"
+CACHE_DIR = Path.home() / ".cache" / "subeng"
+CACHE_FILE = CACHE_DIR / "update_check.json"
+CACHE_TTL = timedelta(days=1)
+REQUEST_TIMEOUT = 5  # seconds
+
+
+@dataclass(frozen=True)
+class UpdateInfo:
+    """Information about an available update."""
+
+    current: str
+    latest: str
+
+
+class UpdateCheckError(Exception):
+    """Raised when the update check fails."""
+
+
+def _version_key(version: str) -> tuple[int, ...]:
+    """Convert a version string to a comparable tuple of integers.
+
+    Non-numeric parts are stripped, so ``1.2.3a1`` is treated like ``1.2.3``.
+    """
+    parts: list[int] = []
+    for part in version.split("."):
+        numeric = ""
+        for ch in part:
+            if ch.isdigit():
+                numeric += ch
+            else:
+                break
+        parts.append(int(numeric) if numeric else 0)
+    return tuple(parts)
+
+
+def is_update_available(current: str, latest: str) -> bool:
+    """Return ``True`` if ``latest`` is newer than ``current``."""
+    return _version_key(latest) > _version_key(current)
+
+
+def _cache_path() -> Path:
+    """Return the path to the update-check cache file, creating the directory if needed."""
+    CACHE_DIR.mkdir(parents=True, exist_ok=True)
+    return CACHE_FILE
+
+
+def _read_cached_check() -> Optional[UpdateInfo]:
+    """Read the cached update check if it exists and is still fresh."""
+    cache = _cache_path()
+    if not cache.exists():
+        return None
+    try:
+        data = json.loads(cache.read_text(encoding="utf-8"))
+        checked_at = datetime.fromisoformat(data["checked_at"])
+        if datetime.now(timezone.utc) - checked_at > CACHE_TTL:
+            return None
+        latest = data["latest"]
+        if is_update_available(__version__, latest):
+            return UpdateInfo(current=__version__, latest=latest)
+        return None
+    except (KeyError, ValueError, OSError):
+        return None
+
+
+def _write_cached_check(latest: str) -> None:
+    """Write the result of an update check to the cache."""
+    cache = _cache_path()
+    payload = {
+        "checked_at": datetime.now(timezone.utc).isoformat(),
+        "latest": latest,
+    }
+    try:
+        cache.write_text(json.dumps(payload), encoding="utf-8")
+    except OSError:
+        # Caching is best-effort; never fail the CLI because of it.
+        pass
+
+
+def fetch_latest_version(timeout: int = REQUEST_TIMEOUT) -> str:
+    """Fetch the latest released version from PyPI.
+
+    Raises:
+        UpdateCheckError: if the request fails or the response is unusable.
+    """
+    request = Request(
+        PYPI_JSON_URL,
+        headers={"Accept": "application/json", "User-Agent": f"subeng/{__version__}"},
+    )
+    try:
+        with urlopen(request, timeout=timeout) as response:  # noqa: S310
+            data = json.loads(response.read().decode("utf-8"))
+    except (OSError, json.JSONDecodeError) as exc:
+        raise UpdateCheckError(f"Could not check for updates: {exc}") from exc
+
+    try:
+        return str(data["info"]["version"])
+    except (KeyError, TypeError) as exc:
+        raise UpdateCheckError(f"Unexpected PyPI response: {exc}") from exc
+
+
+def check_for_update(force: bool = False) -> Optional[UpdateInfo]:
+    """Check whether a newer version is available on PyPI.
+
+    The result is cached for ``CACHE_TTL`` (one day) unless ``force`` is ``True``.
+    Network failures are swallowed unless ``force`` is ``True``.
+
+    Returns:
+        ``UpdateInfo`` if a newer version exists, otherwise ``None``.
+    """
+    if not force:
+        cached = _read_cached_check()
+        if cached is not None:
+            return cached
+
+    try:
+        latest = fetch_latest_version()
+    except UpdateCheckError:
+        if force:
+            raise
+        return None
+
+    _write_cached_check(latest)
+
+    if is_update_available(__version__, latest):
+        return UpdateInfo(current=__version__, latest=latest)
+    return None
+
+
+def update_package() -> None:
+    """Upgrade subtitle-engine in the current Python environment using pip.
+
+    Raises:
+        UpdateCheckError: if the pip command fails.
+    """
+    command = [sys.executable, "-m", "pip", "install", "--upgrade", PYPI_PACKAGE_NAME]
+    try:
+        subprocess.run(command, check=True)  # noqa: S603
+    except subprocess.CalledProcessError as exc:
+        raise UpdateCheckError(f"Update failed (exit code {exc.returncode}).") from exc
+    except FileNotFoundError as exc:
+        raise UpdateCheckError(f"Could not run pip: {exc}") from exc

{subtitle_engine-0.1.0 → subtitle_engine-0.1.2/src/subtitle_engine.egg-info}/PKG-INFO

@@ -1,11 +1,11 @@
 Metadata-Version: 2.4
 Name: subtitle-engine
-Version: 0.1.0
+Version: 0.1.2
 Summary: Generate SRT subtitles from audio/video files using WhisperX
 Author: Leevi Puntanen
 License-Expression: MIT
-Project-URL: Homepage, https://github.com/leevipuntanen/subtitle-engine
-Project-URL: Issues, https://github.com/leevipuntanen/subtitle-engine/issues
+Project-URL: Homepage, https://github.com/leevipun/subtitle-engine
+Project-URL: Issues, https://github.com/leevipun/subtitle-engine/issues
 Keywords: subtitles,srt,whisperx,transcription,asr
 Classifier: Development Status :: 4 - Beta
 Classifier: Intended Audience :: End Users/Desktop
@@ -58,7 +58,7 @@ subeng video.mp4 --output subtitles.srt
 # Use a different model or language
 subeng video.mp4 --model medium --language fi
 
-# Force CPU / CUDA / MPS
+# Force CPU / CUDA
 subeng video.mp4 --device cpu
 
 # Speaker diarization (requires a Hugging Face token)
@@ -75,7 +75,7 @@ subeng video.mp4 --caption --ollama-model qwen3.5:0.8b
 | `--output`, `-o` | Output SRT file path |
 | `--model`, `-m` | WhisperX model: `tiny`, `base`, `small` (default), `medium`, `large-v2`, `large-v3` |
 | `--language`, `-l` | ISO language code, e.g. `en`, `fi`. Auto-detected if omitted. |
-| `--device`, `-d` | `cpu`, `cuda` or `mps`. Auto-detected if omitted. |
+| `--device`, `-d` | `cpu` or `cuda`. Auto-detected if omitted. |
 | `--batch-size`, `-b` | Inference batch size (default: 16) |
 | `--compute-type`, `-c` | `int8` or `float16`. Auto-selected if omitted. |
 | `--diarize` | Enable speaker diarization |

{subtitle_engine-0.1.0 → subtitle_engine-0.1.2}/src/subtitle_engine.egg-info/SOURCES.txt

@@ -6,6 +6,7 @@ src/subtitle_engine/captioner.py
 src/subtitle_engine/cli.py
 src/subtitle_engine/srt_writer.py
 src/subtitle_engine/transcriber.py
+src/subtitle_engine/updater.py
 src/subtitle_engine/utils.py
 src/subtitle_engine.egg-info/PKG-INFO
 src/subtitle_engine.egg-info/SOURCES.txt
@@ -15,4 +16,6 @@ src/subtitle_engine.egg-info/requires.txt
 src/subtitle_engine.egg-info/top_level.txt
 tests/test_captioner.py
 tests/test_cli.py
-tests/test_srt_writer.py
+tests/test_srt_writer.py
+tests/test_transcriber.py
+tests/test_updater.py

subtitle_engine-0.1.2/src/subtitle_engine.egg-info/entry_points.txt

@@ -0,0 +1,2 @@
+[console_scripts]
+subeng = subtitle_engine.cli:main_entry

subtitle_engine-0.1.2/tests/test_cli.py

@@ -0,0 +1,147 @@
+"""Tests for CLI helpers and argument parsing."""
+
+import sys
+from pathlib import Path
+from unittest.mock import patch
+
+import pytest
+import typer
+from typer.testing import CliRunner
+
+from subtitle_engine import __version__
+from subtitle_engine.cli import app, main_entry, update
+from subtitle_engine.updater import UpdateCheckError, UpdateInfo
+from subtitle_engine.utils import resolve_output_path, validate_media_file
+
+runner = CliRunner()
+
+
+@pytest.fixture(autouse=True)
+def disable_update_check():
+    """Prevent the CLI from hitting the network during transcription tests."""
+    with patch("subtitle_engine.cli.check_for_update", return_value=None):
+        yield
+
+
+def test_resolve_output_path_default():
+    input_path = Path("movie.mp4")
+    assert resolve_output_path(input_path) == Path("movie.srt")
+
+
+def test_resolve_output_path_explicit():
+    input_path = Path("movie.mp4")
+    output = Path("custom.srt")
+    assert resolve_output_path(input_path, output) == output
+
+
+def test_validate_media_file_supported():
+    validate_media_file(Path("video.mp4"))
+
+
+def test_validate_media_file_unsupported():
+    with pytest.raises(ValueError, match="Unsupported file type"):
+        validate_media_file(Path("file.txt"))
+
+
+def test_cli_help():
+    result = runner.invoke(app, ["--help"])
+    assert result.exit_code == 0
+    assert "Generate SRT subtitles" in result.output
+
+
+def test_cli_no_args():
+    result = runner.invoke(app)
+    assert result.exit_code != 0
+    assert "Usage:" in result.output
+
+
+def test_caption_requires_ollama_model(tmp_path: Path):
+    media = tmp_path / "video.mp4"
+    media.write_bytes(b"fake")
+    result = runner.invoke(app, [str(media), "--caption"])
+    assert result.exit_code != 0
+    assert "--ollama-model is required" in result.output
+
+
+def test_cli_version_long():
+    result = runner.invoke(app, ["--version"])
+    assert result.exit_code == 0
+    assert "subeng" in result.output
+    assert "0.1.1" in result.output
+
+
+def test_cli_version_short():
+    result = runner.invoke(app, ["-v"])
+    assert result.exit_code == 0
+    assert "subeng" in result.output
+
+
+def test_cli_version_no_extra_output():
+    result = runner.invoke(app, ["--version"])
+    assert result.exit_code == 0
+    assert result.output.strip() == "subeng 0.1.1"
+
+
+def test_cli_quiet_hides_status_but_keeps_errors(tmp_path: Path):
+    media = tmp_path / "video.mp4"
+    media.write_bytes(b"fake")
+    result = runner.invoke(app, [str(media), "--caption", "-q"])
+    assert result.exit_code != 0
+    assert "Error:" in result.output
+    assert "Transcribing:" not in result.output
+
+
+def test_cli_verbose_accepted(tmp_path: Path):
+    media = tmp_path / "video.mp4"
+    media.write_bytes(b"fake")
+    result = runner.invoke(app, [str(media), "--caption", "--verbose"])
+    assert result.exit_code != 0
+    assert "--ollama-model is required" in result.output
+
+
+def test_update_command_shows_up_to_date():
+    with patch("subtitle_engine.cli.check_for_update", return_value=None) as mock_check:
+        result = runner.invoke(app, ["update"])
+        # The Typer app itself does not register ``update`` as a command; it is
+        # routed via ``main_entry``. Invoking the app directly with ``update``
+        # should therefore fail as an unknown command.
+        assert result.exit_code != 0
+        mock_check.assert_not_called()
+
+
+def test_update_function_runs_upgrade_when_available():
+    update_info = UpdateInfo(current=__version__, latest="9.9.9")
+    with patch("subtitle_engine.cli.check_for_update", return_value=update_info) as mock_check:
+        with patch("subtitle_engine.cli.update_package") as mock_upgrade:
+            update()
+            mock_check.assert_called_once_with(force=True)
+            mock_upgrade.assert_called_once()
+
+
+def test_update_function_reports_up_to_date():
+    with patch("subtitle_engine.cli.check_for_update", return_value=None) as mock_check:
+        with patch("subtitle_engine.cli.update_package") as mock_upgrade:
+            update()
+            mock_check.assert_called_once_with(force=True)
+            mock_upgrade.assert_not_called()
+
+
+def test_update_function_handles_check_error():
+    with patch("subtitle_engine.cli.check_for_update", side_effect=UpdateCheckError("no network")):
+        with pytest.raises(typer.Exit) as exc_info:
+            update()
+        assert exc_info.value.exit_code == 1
+
+
+def test_main_entry_routes_update_command():
+    with patch("subtitle_engine.cli.update") as mock_update:
+        with patch.object(sys, "argv", ["subeng", "update"]):
+            main_entry()
+        mock_update.assert_called_once()
+
+
+def test_main_entry_runs_typer_app_for_transcription():
+    with patch("subtitle_engine.cli.app") as mock_app:
+        with patch.object(sys, "argv", ["subeng", "video.mp4"]):
+            main_entry()
+        mock_app.assert_called_once()

subtitle_engine-0.1.2/tests/test_transcriber.py

@@ -0,0 +1,26 @@
+"""Tests for the WhisperX transcription wrapper."""
+
+import logging
+import warnings
+
+from subtitle_engine.transcriber import _suppress_external_output
+
+
+def test_suppress_external_output_hides_noise(capsys):
+    with _suppress_external_output(verbose=False):
+        print("stdout noise")
+        print("stderr noise", flush=True)
+        warnings.warn("warning noise")
+        logging.getLogger("whisperx").warning("logger noise")
+
+    captured = capsys.readouterr()
+    assert captured.out == ""
+    assert captured.err == ""
+
+
+def test_suppress_external_output_verbose_keeps_noise(capsys):
+    with _suppress_external_output(verbose=True):
+        print("visible output")
+
+    captured = capsys.readouterr()
+    assert "visible output" in captured.out

subtitle_engine-0.1.2/tests/test_updater.py

@@ -0,0 +1,172 @@
+"""Tests for the update checker and updater."""
+
+import json
+import subprocess
+import sys
+from datetime import datetime, timedelta, timezone
+from pathlib import Path
+from unittest.mock import MagicMock, patch
+
+import pytest
+
+from subtitle_engine import __version__
+from subtitle_engine import updater
+from subtitle_engine.updater import (
+    UpdateCheckError,
+    UpdateInfo,
+    check_for_update,
+    fetch_latest_version,
+    is_update_available,
+    update_package,
+)
+
+
+@pytest.fixture
+def fresh_cache(tmp_path: Path, monkeypatch):
+    """Redirect the update-check cache to a temporary directory."""
+    cache_dir = tmp_path / "cache"
+    monkeypatch.setattr(updater, "CACHE_DIR", cache_dir)
+    monkeypatch.setattr(updater, "CACHE_FILE", cache_dir / "update_check.json")
+    return cache_dir
+
+
+def test_is_update_available_when_latest_is_newer():
+    assert is_update_available("0.1.0", "0.2.0") is True
+    assert is_update_available("0.1.1", "0.1.2") is True
+
+
+def test_is_update_available_when_latest_is_older_or_equal():
+    assert is_update_available("0.2.0", "0.1.0") is False
+    assert is_update_available("0.1.1", "0.1.1") is False
+
+
+def test_is_update_available_ignores_non_numeric_suffixes():
+    assert is_update_available("0.1.1", "0.1.2a1") is True
+    assert is_update_available("0.1.2", "0.1.2a1") is False
+
+
+def test_fetch_latest_version_parses_pypi_response():
+    mock_response = MagicMock()
+    mock_response.read.return_value = json.dumps({"info": {"version": "9.9.9"}}).encode("utf-8")
+    mock_context = MagicMock()
+    mock_context.__enter__.return_value = mock_response
+
+    with patch("subtitle_engine.updater.urlopen", return_value=mock_context):
+        assert fetch_latest_version() == "9.9.9"
+
+
+def test_fetch_latest_version_raises_on_bad_response():
+    mock_response = MagicMock()
+    mock_response.read.return_value = json.dumps({"info": {}}).encode("utf-8")
+    mock_context = MagicMock()
+    mock_context.__enter__.return_value = mock_response
+
+    with patch("subtitle_engine.updater.urlopen", return_value=mock_context):
+        with pytest.raises(UpdateCheckError):
+            fetch_latest_version()
+
+
+def test_fetch_latest_version_raises_on_network_error():
+    with patch("subtitle_engine.updater.urlopen", side_effect=OSError("no network")):
+        with pytest.raises(UpdateCheckError):
+            fetch_latest_version()
+
+
+def test_check_for_update_returns_info_when_update_available(fresh_cache: Path):
+    mock_response = MagicMock()
+    mock_response.read.return_value = json.dumps({"info": {"version": "9.9.9"}}).encode("utf-8")
+    mock_context = MagicMock()
+    mock_context.__enter__.return_value = mock_response
+
+    with patch("subtitle_engine.updater.urlopen", return_value=mock_context):
+        result = check_for_update()
+
+    assert result == UpdateInfo(current=__version__, latest="9.9.9")
+    assert (fresh_cache / "update_check.json").exists()
+
+
+def test_check_for_update_uses_cache_instead_of_fetching(fresh_cache: Path):
+    fresh_cache.mkdir(parents=True, exist_ok=True)
+    cache = fresh_cache / "update_check.json"
+    cache.write_text(
+        json.dumps(
+            {
+                "checked_at": datetime.now(timezone.utc).isoformat(),
+                "latest": "9.9.9",
+            }
+        ),
+        encoding="utf-8",
+    )
+
+    with patch("subtitle_engine.updater.urlopen") as mock_urlopen:
+        result = check_for_update()
+        mock_urlopen.assert_not_called()
+
+    assert result == UpdateInfo(current=__version__, latest="9.9.9")
+
+
+def test_check_for_update_cache_ignores_stale_entries(fresh_cache: Path):
+    fresh_cache.mkdir(parents=True, exist_ok=True)
+    cache = fresh_cache / "update_check.json"
+    stale_time = datetime.now(timezone.utc) - timedelta(days=2)
+    cache.write_text(
+        json.dumps(
+            {
+                "checked_at": stale_time.isoformat(),
+                "latest": "9.9.9",
+            }
+        ),
+        encoding="utf-8",
+    )
+
+    mock_response = MagicMock()
+    mock_response.read.return_value = json.dumps({"info": {"version": "9.9.10"}}).encode("utf-8")
+    mock_context = MagicMock()
+    mock_context.__enter__.return_value = mock_response
+
+    with patch("subtitle_engine.updater.urlopen", return_value=mock_context):
+        result = check_for_update()
+
+    assert result == UpdateInfo(current=__version__, latest="9.9.10")
+
+
+def test_check_for_update_returns_none_when_up_to_date(fresh_cache: Path):
+    mock_response = MagicMock()
+    mock_response.read.return_value = json.dumps({"info": {"version": __version__}}).encode("utf-8")
+    mock_context = MagicMock()
+    mock_context.__enter__.return_value = mock_response
+
+    with patch("subtitle_engine.updater.urlopen", return_value=mock_context):
+        result = check_for_update()
+
+    assert result is None
+
+
+def test_check_for_update_swallows_network_errors_by_default(fresh_cache: Path):
+    with patch("subtitle_engine.updater.urlopen", side_effect=OSError("no network")):
+        result = check_for_update()
+    assert result is None
+
+
+def test_check_for_update_force_re_raises_network_errors(fresh_cache: Path):
+    with patch("subtitle_engine.updater.urlopen", side_effect=OSError("no network")):
+        with pytest.raises(UpdateCheckError):
+            check_for_update(force=True)
+
+
+def test_update_package_runs_pip_upgrade():
+    with patch("subtitle_engine.updater.subprocess.run") as mock_run:
+        update_package()
+        mock_run.assert_called_once()
+        command = mock_run.call_args[0][0]
+        assert command[0] == sys.executable
+        assert command[1:] == ["-m", "pip", "install", "--upgrade", "subtitle-engine"]
+
+
+def test_update_package_raises_on_pip_failure():
+    with patch(
+        "subtitle_engine.updater.subprocess.run",
+        side_effect=subprocess.CalledProcessError(1, ["pip"]),
+    ):
+        with pytest.raises(UpdateCheckError):
+            update_package()

subtitle_engine-0.1.0/src/subtitle_engine/transcriber.py

@@ -1,129 +0,0 @@
-"""WhisperX transcription wrapper."""
-
-from pathlib import Path
-from typing import Optional
-
-import torch
-import whisperx
-
-
-VALID_MODELS = {"tiny", "base", "small", "medium", "large-v2", "large-v3"}
-VALID_DEVICES = {"cpu", "cuda", "mps"}
-
-
-def _detect_device(device: Optional[str]) -> str:
-    """Pick a device if none was specified."""
-    if device:
-        return device
-    if torch.cuda.is_available():
-        return "cuda"
-    if torch.backends.mps.is_available():
-        return "mps"
-    return "cpu"
-
-
-def _default_compute_type(device: str) -> str:
-    """Pick a safe compute type for the device."""
-    if device == "cpu":
-        return "int8"
-    return "float16"
-
-
-def _validate_model(model_name: str) -> None:
-    """Raise a ValueError if the model name is unknown."""
-    if model_name not in VALID_MODELS:
-        joined = ", ".join(sorted(VALID_MODELS))
-        raise ValueError(f"Unknown model '{model_name}'. Choose from: {joined}")
-
-
-def _validate_device(device: str) -> None:
-    """Raise a ValueError if the device name is unknown."""
-    if device not in VALID_DEVICES:
-        joined = ", ".join(sorted(VALID_DEVICES))
-        raise ValueError(f"Unknown device '{device}'. Choose from: {joined}")
-
-
-def transcribe(
-    audio_path: Path,
-    *,
-    model_name: str = "small",
-    language: Optional[str] = None,
-    device: Optional[str] = None,
-    batch_size: int = 16,
-    compute_type: Optional[str] = None,
-    diarize: bool = False,
-    hf_token: Optional[str] = None,
-) -> list[dict]:
-    """Transcribe an audio/video file and return SRT-ready segments.
-
-    Parameters
-    ----------
-    audio_path:
-        Path to the media file to transcribe.
-    model_name:
-        WhisperX model size. One of: tiny, base, small, medium, large-v2, large-v3.
-    language:
-        ISO language code, e.g. ``en`` or ``fi``. If ``None``, WhisperX auto-detects.
-    device:
-        ``cpu``, ``cuda`` or ``mps``. Auto-detected if omitted.
-    batch_size:
-        WhisperX batch size for transcription.
-    compute_type:
-        ``int8`` or ``float16``. Auto-selected per device if omitted.
-    diarize:
-        Whether to run speaker diarization.
-    hf_token:
-        Hugging Face token required for diarization.
-
-    Returns
-    -------
-    A list of segment dicts with ``start``, ``end`` and ``text`` keys.
-    """
-    _validate_model(model_name)
-
-    audio_path = Path(audio_path)
-    if not audio_path.exists():
-        raise FileNotFoundError(f"Audio file not found: {audio_path}")
-
-    device = _detect_device(device)
-    _validate_device(device)
-
-    if compute_type is None:
-        compute_type = _default_compute_type(device)
-
-    if diarize and not hf_token:
-        raise ValueError("--hf-token is required when using --diarize")
-
-    audio = whisperx.load_audio(str(audio_path))
-
-    model = whisperx.load_model(model_name, device, compute_type=compute_type)
-    result = model.transcribe(audio, batch_size=batch_size, language=language)
-
-    # Free transcription model memory before alignment
-    del model
-
-    detected_language = result.get("language")
-    if detected_language:
-        align_model, align_metadata = whisperx.load_align_model(
-            language_code=detected_language, device=device
-        )
-        result = whisperx.align(
-            result["segments"],
-            align_model,
-            align_metadata,
-            audio,
-            device,
-            return_char_alignments=False,
-        )
-        del align_model
-
-    if diarize:
-        diarize_model = whisperx.DiarizationPipeline(
-            model_name="pyannote/speaker-diarization-3.1",
-            use_auth_token=hf_token,
-            device=device,
-        )
-        diarize_segments = diarize_model(audio)
-        result = whisperx.assign_word_speakers(diarize_segments, result)
-
-    return result["segments"]

subtitle_engine-0.1.0/src/subtitle_engine.egg-info/entry_points.txt

@@ -1,2 +0,0 @@
-[console_scripts]
-subeng = subtitle_engine.cli:app

subtitle_engine-0.1.0/tests/test_cli.py

@@ -1,51 +0,0 @@
-"""Tests for CLI helpers and argument parsing."""
-
-from pathlib import Path
-
-import pytest
-from typer.testing import CliRunner
-
-from subtitle_engine.cli import app
-from subtitle_engine.utils import resolve_output_path, validate_media_file
-
-runner = CliRunner()
-
-
-def test_resolve_output_path_default():
-    input_path = Path("movie.mp4")
-    assert resolve_output_path(input_path) == Path("movie.srt")
-
-
-def test_resolve_output_path_explicit():
-    input_path = Path("movie.mp4")
-    output = Path("custom.srt")
-    assert resolve_output_path(input_path, output) == output
-
-
-def test_validate_media_file_supported():
-    validate_media_file(Path("video.mp4"))
-
-
-def test_validate_media_file_unsupported():
-    with pytest.raises(ValueError, match="Unsupported file type"):
-        validate_media_file(Path("file.txt"))
-
-
-def test_cli_help():
-    result = runner.invoke(app, ["--help"])
-    assert result.exit_code == 0
-    assert "Generate SRT subtitles" in result.output
-
-
-def test_cli_no_args():
-    result = runner.invoke(app)
-    assert result.exit_code != 0
-    assert "Usage:" in result.output
-
-
-def test_caption_requires_ollama_model(tmp_path: Path):
-    media = tmp_path / "video.mp4"
-    media.write_bytes(b"fake")
-    result = runner.invoke(app, [str(media), "--caption"])
-    assert result.exit_code != 0
-    assert "--ollama-model is required" in result.output