subtitle-engine 0.1.3.2__tar.gz → 0.1.4__tar.gz

{subtitle_engine-0.1.3.2/src/subtitle_engine.egg-info → subtitle_engine-0.1.4}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: subtitle-engine
-Version: 0.1.3.2
+Version: 0.1.4
 Summary: Generate SRT subtitles from audio/video files using WhisperX
 Author: Leevi Puntanen
 License-Expression: MIT
@@ -20,6 +20,7 @@ License-File: LICENSE
 Requires-Dist: typer>=0.12.0
 Requires-Dist: whisperx>=3.8.0
 Requires-Dist: requests>=2.32.0
+Requires-Dist: questionary>=2.0.0
 Provides-Extra: dev
 Requires-Dist: pytest>=8.0.0; extra == "dev"
 Dynamic: license-file
@@ -67,6 +68,9 @@ subeng video.mp4 --diarize --hf-token $HF_TOKEN
 # Generate a caption from the transcript using Ollama
 subeng video.mp4 --caption --ollama-model qwen3.5:0.6b
 
+# Generate a caption from an existing SRT file
+subeng caption subtitles.srt
+
 # Short-form subtitles (2-5 words per line, default)
 subeng video.mp4 --preset shortform
 
@@ -87,8 +91,9 @@ subeng video.mp4 --preset longform
 | `--diarize` | Enable speaker diarization |
 | `--hf-token` | Hugging Face token for diarization (or set `HF_TOKEN` env var) |
 | `--caption` | Generate a caption from the transcript via Ollama |
-| `--ollama-model` | Ollama model name (required with `--caption`) |
+| `--ollama-model` | Ollama model name. If omitted, installed models are listed and you can pick one. |
 | `--ollama-host` | Ollama API host (default: `http://localhost:11434`) |
+| `caption` | Generate a caption from an existing SRT file (e.g. `subeng caption file.srt`) |
 | `--preset`, `-p` | Subtitle style: `shortform` (2-5 words, default) or `longform` (10-14 words) |
 
 ## Development

{subtitle_engine-0.1.3.2 → subtitle_engine-0.1.4}/README.md

@@ -41,6 +41,9 @@ subeng video.mp4 --diarize --hf-token $HF_TOKEN
 # Generate a caption from the transcript using Ollama
 subeng video.mp4 --caption --ollama-model qwen3.5:0.6b
 
+# Generate a caption from an existing SRT file
+subeng caption subtitles.srt
+
 # Short-form subtitles (2-5 words per line, default)
 subeng video.mp4 --preset shortform
 
@@ -61,8 +64,9 @@ subeng video.mp4 --preset longform
 | `--diarize` | Enable speaker diarization |
 | `--hf-token` | Hugging Face token for diarization (or set `HF_TOKEN` env var) |
 | `--caption` | Generate a caption from the transcript via Ollama |
-| `--ollama-model` | Ollama model name (required with `--caption`) |
+| `--ollama-model` | Ollama model name. If omitted, installed models are listed and you can pick one. |
 | `--ollama-host` | Ollama API host (default: `http://localhost:11434`) |
+| `caption` | Generate a caption from an existing SRT file (e.g. `subeng caption file.srt`) |
 | `--preset`, `-p` | Subtitle style: `shortform` (2-5 words, default) or `longform` (10-14 words) |
 
 ## Development

{subtitle_engine-0.1.3.2 → subtitle_engine-0.1.4}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "subtitle-engine"
-version = "0.1.3.2"
+version = "0.1.4"
 description = "Generate SRT subtitles from audio/video files using WhisperX"
 readme = "README.md"
 license = "MIT"
@@ -27,6 +27,7 @@ dependencies = [
     "typer>=0.12.0",
     "whisperx>=3.8.0",
     "requests>=2.32.0",
+    "questionary>=2.0.0",
 ]
 
 [project.optional-dependencies]

{subtitle_engine-0.1.3.2 → subtitle_engine-0.1.4}/src/subtitle_engine/__init__.py

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

{subtitle_engine-0.1.3.2 → subtitle_engine-0.1.4}/src/subtitle_engine/cli.py

@@ -4,13 +4,15 @@ import sys
 from pathlib import Path
 from typing import Annotated, Optional
 
+import questionary
+import requests
 import typer
 from rich.console import Console
 
 from subtitle_engine import __version__
-from subtitle_engine.captioner import generate_caption
+from subtitle_engine.captioner import generate_caption, list_models
 from subtitle_engine.segmenter import VALID_PRESETS, split_segments
-from subtitle_engine.srt_writer import write_srt
+from subtitle_engine.srt_writer import extract_text_from_srt, 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
@@ -22,6 +24,30 @@ app = typer.Typer(
 console = Console()
 
 
+def _select_ollama_model(host: str) -> str:
+    """List available Ollama models and prompt the user to pick one."""
+    try:
+        models = list_models(host)
+    except requests.RequestException as exc:
+        raise ConnectionError(
+            f"Could not connect to Ollama at {host}. Is Ollama running?"
+        ) from exc
+
+    if not models:
+        raise ConnectionError(f"No Ollama models found at {host}.")
+
+    choice = questionary.select(
+        "Select an Ollama model:",
+        choices=models,
+        default=models[0],
+    ).ask()
+
+    if choice is None:
+        raise ValueError("No model selected")
+
+    return choice
+
+
 def _version_callback(value: bool) -> None:
     if value:
         console.print(f"subeng {__version__}")
@@ -54,14 +80,27 @@ def update() -> None:
 
 
 def main_entry() -> None:
-    """Route ``subeng update`` to the updater; otherwise run the Typer app."""
+    """Route subcommands; default to the ``main`` transcription command."""
+    if len(sys.argv) > 1 and sys.argv[1] in ("-v", "--version"):
+        console.print(f"subeng {__version__}")
+        return
     if len(sys.argv) > 1 and sys.argv[1] == "update":
         update()
-    else:
-        app()
+        return
+
+    # If the user did not supply a subcommand (or global option), default to ``main``.
+    args = sys.argv.copy()
+    if (
+        len(args) > 1
+        and not args[1].startswith("-")
+        and args[1] not in ("main", "caption")
+    ):
+        args.insert(1, "main")
+    app(args[1:])
 
 
 @app.command(
+    name="main",
     epilog="Run 'subeng update' to update to the latest version.",
 )
 def main(
@@ -152,7 +191,7 @@ def main(
         Optional[str],
         typer.Option(
             "--ollama-model",
-            help="Ollama model for caption generation. Required if --caption is set.",
+            help="Ollama model for caption generation. If omitted, installed models are listed.",
         ),
     ] = None,
     ollama_host: Annotated[
@@ -207,7 +246,7 @@ def main(
         output_path = resolve_output_path(input_file, output)
 
         if caption and not ollama_model:
-            raise ValueError("--ollama-model is required when using --caption")
+            ollama_model = _select_ollama_model(ollama_host)
 
         if not quiet:
             update_info = check_for_update()
@@ -263,5 +302,76 @@ def main(
         raise typer.Exit(code=1) from exc
 
 
+@app.command(name="caption")
+def caption_command(
+    input_file: Annotated[
+        Path,
+        typer.Argument(
+            help="SRT file to generate a caption from",
+            exists=True,
+            file_okay=True,
+            dir_okay=False,
+            readable=True,
+        ),
+    ],
+    output: Annotated[
+        Optional[Path],
+        typer.Option(
+            "--output",
+            "-o",
+            help="Output caption file (default: <input>.caption.txt)",
+            file_okay=True,
+            dir_okay=False,
+        ),
+    ] = None,
+    ollama_model: Annotated[
+        Optional[str],
+        typer.Option(
+            "--ollama-model",
+            "-m",
+            help="Ollama model for caption generation",
+        ),
+    ] = None,
+    ollama_host: Annotated[
+        str,
+        typer.Option(
+            "--ollama-host",
+            help="Ollama API host",
+            envvar="OLLAMA_HOST",
+        ),
+    ] = "http://localhost:11434",
+    quiet: Annotated[
+        bool,
+        typer.Option(
+            "--quiet",
+            "-q",
+            help="Only print errors.",
+        ),
+    ] = False,
+) -> None:
+    """Generate a caption from an existing SRT file."""
+    try:
+        if not ollama_model:
+            ollama_model = _select_ollama_model(ollama_host)
+
+        transcript = extract_text_from_srt(input_file)
+        caption_text = generate_caption(
+            transcript,
+            model=ollama_model,
+            host=ollama_host,
+        )
+
+        caption_path = output or input_file.with_suffix(".caption.txt")
+        caption_path.write_text(caption_text, encoding="utf-8")
+        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
+    except Exception as exc:  # noqa: BLE001
+        console.print(f"[red]Caption generation failed:[/red] {exc}")
+        raise typer.Exit(code=1) from exc
+
+
 if __name__ == "__main__":
     main_entry()

{subtitle_engine-0.1.3.2 → subtitle_engine-0.1.4}/src/subtitle_engine/srt_writer.py

@@ -1,5 +1,6 @@
 """Convert transcription segments to SRT format."""
 
+import re
 from pathlib import Path
 from typing import Iterable
 
@@ -38,6 +39,48 @@ def segments_to_srt(segments: Iterable[dict]) -> str:
     return "\n".join(blocks)
 
 
+def extract_text_from_srt(path: Path) -> str:
+    """Read an SRT file and return the spoken text as a single string.
+
+    Parameters
+    ----------
+    path:
+        Path to the SRT file to read.
+
+    Returns
+    -------
+    The transcript text with subtitle lines joined by spaces.
+
+    Raises
+    ------
+    FileNotFoundError:
+        If the SRT file does not exist.
+    ValueError:
+        If no subtitle text can be extracted from the file.
+    """
+    path = Path(path)
+    if not path.exists():
+        raise FileNotFoundError(f"SRT file not found: {path}")
+
+    content = path.read_text(encoding="utf-8")
+    blocks = re.split(r"\n\s*\n", content.strip())
+
+    texts: list[str] = []
+    for block in blocks:
+        lines = block.strip().splitlines()
+        # A valid block has at least an index, a timecode line, and one text line.
+        if len(lines) < 3:
+            continue
+        text = " ".join(line.strip() for line in lines[2:] if line.strip())
+        if text:
+            texts.append(text)
+
+    if not texts:
+        raise ValueError(f"No subtitle text found in {path}")
+
+    return " ".join(texts)
+
+
 def write_srt(segments: Iterable[dict], output_path: Path) -> None:
     """Write segments to an SRT file."""
     output_path = Path(output_path)

{subtitle_engine-0.1.3.2 → subtitle_engine-0.1.4/src/subtitle_engine.egg-info}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: subtitle-engine
-Version: 0.1.3.2
+Version: 0.1.4
 Summary: Generate SRT subtitles from audio/video files using WhisperX
 Author: Leevi Puntanen
 License-Expression: MIT
@@ -20,6 +20,7 @@ License-File: LICENSE
 Requires-Dist: typer>=0.12.0
 Requires-Dist: whisperx>=3.8.0
 Requires-Dist: requests>=2.32.0
+Requires-Dist: questionary>=2.0.0
 Provides-Extra: dev
 Requires-Dist: pytest>=8.0.0; extra == "dev"
 Dynamic: license-file
@@ -67,6 +68,9 @@ subeng video.mp4 --diarize --hf-token $HF_TOKEN
 # Generate a caption from the transcript using Ollama
 subeng video.mp4 --caption --ollama-model qwen3.5:0.6b
 
+# Generate a caption from an existing SRT file
+subeng caption subtitles.srt
+
 # Short-form subtitles (2-5 words per line, default)
 subeng video.mp4 --preset shortform
 
@@ -87,8 +91,9 @@ subeng video.mp4 --preset longform
 | `--diarize` | Enable speaker diarization |
 | `--hf-token` | Hugging Face token for diarization (or set `HF_TOKEN` env var) |
 | `--caption` | Generate a caption from the transcript via Ollama |
-| `--ollama-model` | Ollama model name (required with `--caption`) |
+| `--ollama-model` | Ollama model name. If omitted, installed models are listed and you can pick one. |
 | `--ollama-host` | Ollama API host (default: `http://localhost:11434`) |
+| `caption` | Generate a caption from an existing SRT file (e.g. `subeng caption file.srt`) |
 | `--preset`, `-p` | Subtitle style: `shortform` (2-5 words, default) or `longform` (10-14 words) |
 
 ## Development

{subtitle_engine-0.1.3.2 → subtitle_engine-0.1.4}/src/subtitle_engine.egg-info/requires.txt

@@ -1,6 +1,7 @@
 typer>=0.12.0
 whisperx>=3.8.0
 requests>=2.32.0
+questionary>=2.0.0
 
 [dev]
 pytest>=8.0.0

subtitle_engine-0.1.4/tests/test_cli.py

@@ -0,0 +1,274 @@
+"""Tests for CLI helpers and argument parsing."""
+
+import sys
+from pathlib import Path
+from unittest.mock import Mock, patch
+
+import pytest
+import typer
+from typer.testing import CliRunner
+
+from subtitle_engine import __version__
+from subtitle_engine.cli import _select_ollama_model, 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_prompts_for_ollama_model(tmp_path: Path):
+    media = tmp_path / "video.mp4"
+    media.write_bytes(b"fake")
+    with patch("subtitle_engine.cli._select_ollama_model", return_value="qwen3.5:0.8b") as mock_select:
+        with patch("subtitle_engine.cli.transcribe", return_value=[{"start": 0.0, "end": 1.0, "text": "hello"}]):
+            with patch("subtitle_engine.cli.split_segments", return_value=[{"start": 0.0, "end": 1.0, "text": "hello"}]):
+                with patch("subtitle_engine.cli.generate_caption", return_value="A caption"):
+                    result = runner.invoke(app, ["main", str(media), "--caption"])
+    assert result.exit_code == 0
+    mock_select.assert_called_once_with("http://localhost:11434")
+    assert "Wrote caption" in result.output
+
+
+def test_cli_version_long():
+    result = runner.invoke(app, ["main", "--version"])
+    assert result.exit_code == 0
+    assert "subeng" in result.output
+    assert "0.1.3" in result.output
+
+
+def test_cli_version_short():
+    result = runner.invoke(app, ["main", "-v"])
+    assert result.exit_code == 0
+    assert "subeng" in result.output
+
+
+def test_cli_version_no_extra_output():
+    result = runner.invoke(app, ["main", "--version"])
+    assert result.exit_code == 0
+    assert result.output.strip() == f"subeng {__version__}"
+
+
+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,
+        ["main", str(media), "--caption", "--ollama-model", "qwen3.5:0.8b", "-q"],
+    )
+    assert result.exit_code != 0
+    assert "Transcription failed:" 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,
+        ["main", str(media), "--caption", "--ollama-model", "qwen3.5:0.8b", "--verbose"],
+    )
+    assert result.exit_code != 0
+    assert "Transcription failed:" in result.output
+    assert "Transcribing:" 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_with(["main", "video.mp4"])
+
+
+def test_main_entry_routes_caption_command():
+    with patch("subtitle_engine.cli.app") as mock_app:
+        with patch.object(sys, "argv", ["subeng", "caption", "file.srt"]):
+            main_entry()
+        mock_app.assert_called_once_with(["caption", "file.srt"])
+
+
+def test_main_entry_handles_version_flag(capsys):
+    with patch.object(sys, "argv", ["subeng", "--version"]):
+        assert main_entry() is None
+    captured = capsys.readouterr()
+    assert captured.out.strip() == f"subeng {__version__}"
+
+
+def test_cli_preset_shortform_accepted(tmp_path: Path):
+    media = tmp_path / "video.mp4"
+    media.write_bytes(b"fake")
+    result = runner.invoke(app, ["main", str(media), "--preset", "shortform"])
+    # Validation passes; transcription fails because the file is fake.
+    assert result.exit_code != 0
+    assert "Preset: shortform" in result.output
+
+
+def test_cli_preset_longform_accepted(tmp_path: Path):
+    media = tmp_path / "video.mp4"
+    media.write_bytes(b"fake")
+    result = runner.invoke(app, ["main", str(media), "--preset", "longform"])
+    assert result.exit_code != 0
+    assert "Preset: longform" in result.output
+
+
+def test_cli_invalid_preset_rejected(tmp_path: Path):
+    media = tmp_path / "video.mp4"
+    media.write_bytes(b"fake")
+    result = runner.invoke(app, ["main", str(media), "--preset", "invalid"])
+    assert result.exit_code != 0
+    assert "Unknown preset" in result.output
+
+
+def test_select_ollama_model_returns_chosen_model():
+    mock_select = Mock(ask=Mock(return_value="model-b"))
+    with patch("subtitle_engine.cli.list_models", return_value=["model-a", "model-b"]):
+        with patch("subtitle_engine.cli.questionary.select", return_value=mock_select):
+            assert _select_ollama_model("http://localhost:11434") == "model-b"
+
+
+def test_select_ollama_model_empty_list_raises():
+    with patch("subtitle_engine.cli.list_models", return_value=[]):
+        with pytest.raises(ConnectionError, match="No Ollama models"):
+            _select_ollama_model("http://localhost:11434")
+
+
+def test_select_ollama_model_no_selection_raises():
+    mock_select = Mock(ask=Mock(return_value=None))
+    with patch("subtitle_engine.cli.list_models", return_value=["model-a"]):
+        with patch("subtitle_engine.cli.questionary.select", return_value=mock_select):
+            with pytest.raises(ValueError, match="No model selected"):
+                _select_ollama_model("http://localhost:11434")
+
+
+def test_caption_command_generates_caption(tmp_path: Path):
+    srt = tmp_path / "subs.srt"
+    srt.write_text(
+        "1\n00:00:00,000 --> 00:00:02,000\nHello world\n",
+        encoding="utf-8",
+    )
+    mock_select = Mock(ask=Mock(return_value="qwen3.5:0.8b"))
+    with patch("subtitle_engine.cli.list_models", return_value=["qwen3.5:0.8b"]):
+        with patch("subtitle_engine.cli.questionary.select", return_value=mock_select):
+            with patch("subtitle_engine.cli.generate_caption", return_value="A caption") as mock_generate:
+                result = runner.invoke(app, ["caption", str(srt)])
+    assert result.exit_code == 0
+    mock_generate.assert_called_once()
+    assert (tmp_path / "subs.caption.txt").read_text(encoding="utf-8") == "A caption"
+
+
+def test_caption_command_uses_explicit_model(tmp_path: Path):
+    srt = tmp_path / "subs.srt"
+    srt.write_text(
+        "1\n00:00:00,000 --> 00:00:02,000\nHello world\n",
+        encoding="utf-8",
+    )
+    with patch("subtitle_engine.cli.generate_caption", return_value="A caption") as mock_generate:
+        result = runner.invoke(app, ["caption", str(srt), "--ollama-model", "llama3.2"])
+    assert result.exit_code == 0
+    mock_generate.assert_called_once()
+    _, kwargs = mock_generate.call_args
+    assert kwargs["model"] == "llama3.2"
+
+
+def test_caption_command_custom_output(tmp_path: Path):
+    srt = tmp_path / "subs.srt"
+    srt.write_text(
+        "1\n00:00:00,000 --> 00:00:02,000\nHello world\n",
+        encoding="utf-8",
+    )
+    output = tmp_path / "custom.txt"
+    with patch("subtitle_engine.cli.generate_caption", return_value="A caption"):
+        result = runner.invoke(app, ["caption", str(srt), "--ollama-model", "llama3.2", "--output", str(output)])
+    assert result.exit_code == 0
+    assert output.read_text(encoding="utf-8") == "A caption"
+
+
+def test_caption_command_no_models_raises(tmp_path: Path):
+    srt = tmp_path / "subs.srt"
+    srt.write_text(
+        "1\n00:00:00,000 --> 00:00:02,000\nHello world\n",
+        encoding="utf-8",
+    )
+    with patch("subtitle_engine.cli.list_models", return_value=[]):
+        result = runner.invoke(app, ["caption", str(srt)])
+    assert result.exit_code != 0
+    assert "No Ollama models" in result.output

{subtitle_engine-0.1.3.2 → subtitle_engine-0.1.4}/tests/test_srt_writer.py

@@ -2,9 +2,12 @@
 
 from pathlib import Path
 
+import pytest
+
 from subtitle_engine.srt_writer import (
     _format_segment,
     _format_time,
+    extract_text_from_srt,
     segments_to_srt,
     write_srt,
 )
@@ -64,3 +67,48 @@ def test_write_srt_creates_parent_dirs(tmp_path: Path):
     output = tmp_path / "nested" / "dir" / "subs.srt"
     write_srt(segments, output)
     assert output.exists()
+
+
+def test_extract_text_from_srt(tmp_path: Path):
+    srt = tmp_path / "subs.srt"
+    srt.write_text(
+        "1\n00:00:00,000 --> 00:00:02,000\nHello world\n\n"
+        "2\n00:00:03,000 --> 00:00:05,000\nSecond line\n",
+        encoding="utf-8",
+    )
+    assert extract_text_from_srt(srt) == "Hello world Second line"
+
+
+def test_extract_text_from_srt_multiline_text(tmp_path: Path):
+    srt = tmp_path / "subs.srt"
+    srt.write_text(
+        "1\n00:00:00,000 --> 00:00:04,000\nFirst line\nSecond line\n",
+        encoding="utf-8",
+    )
+    assert extract_text_from_srt(srt) == "First line Second line"
+
+
+def test_extract_text_from_srt_ignores_blank_blocks(tmp_path: Path):
+    srt = tmp_path / "subs.srt"
+    srt.write_text(
+        "1\n00:00:00,000 --> 00:00:02,000\nHello\n\n"
+        "2\n00:00:03,000 --> 00:00:05,000\n   \n",
+        encoding="utf-8",
+    )
+    assert extract_text_from_srt(srt) == "Hello"
+
+
+def test_extract_text_from_srt_missing_file(tmp_path: Path):
+    missing = tmp_path / "missing.srt"
+    with pytest.raises(FileNotFoundError):
+        extract_text_from_srt(missing)
+
+
+def test_extract_text_from_srt_no_text(tmp_path: Path):
+    srt = tmp_path / "subs.srt"
+    srt.write_text(
+        "1\n00:00:00,000 --> 00:00:02,000\n   \n",
+        encoding="utf-8",
+    )
+    with pytest.raises(ValueError, match="No subtitle text"):
+        extract_text_from_srt(srt)

subtitle_engine-0.1.3.2/tests/test_cli.py

@@ -1,172 +0,0 @@
-"""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.3" 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.3"
-
-
-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()
-
-
-def test_cli_preset_shortform_accepted(tmp_path: Path):
-    media = tmp_path / "video.mp4"
-    media.write_bytes(b"fake")
-    result = runner.invoke(app, [str(media), "--preset", "shortform"])
-    # Validation passes; transcription fails because the file is fake.
-    assert result.exit_code != 0
-    assert "Preset: shortform" in result.output
-
-
-def test_cli_preset_longform_accepted(tmp_path: Path):
-    media = tmp_path / "video.mp4"
-    media.write_bytes(b"fake")
-    result = runner.invoke(app, [str(media), "--preset", "longform"])
-    assert result.exit_code != 0
-    assert "Preset: longform" in result.output
-
-
-def test_cli_invalid_preset_rejected(tmp_path: Path):
-    media = tmp_path / "video.mp4"
-    media.write_bytes(b"fake")
-    result = runner.invoke(app, [str(media), "--preset", "invalid"])
-    assert result.exit_code != 0
-    assert "Unknown preset" in result.output