mvw-cli 0.1.1__tar.gz → 0.1.2__tar.gz

{mvw_cli-0.1.1 → mvw_cli-0.1.2}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: mvw-cli
-Version: 0.1.1
+Version: 0.1.2
 Summary: Search and download German public-broadcasting media from MediathekViewWeb, with Plex-friendly season downloads.
 Project-URL: Homepage, https://github.com/maxboettinger/mvw-cli
 Project-URL: Repository, https://github.com/maxboettinger/mvw-cli

{mvw_cli-0.1.1 → mvw_cli-0.1.2}/pyproject.toml

@@ -3,7 +3,7 @@ name = "mvw-cli"
 description = "Search and download German public-broadcasting media from MediathekViewWeb, with Plex-friendly season downloads."
 readme = "README.md"
 requires-python = ">=3.13"
-version = "0.1.1"
+version = "0.1.2"
 license = "MIT"
 license-files = ["LICENSE"]
 authors = [{ name = "Max Boettinger", email = "perplexity@bttngr.de" }]

{mvw_cli-0.1.1 → mvw_cli-0.1.2}/src/mvw/cli.py

@@ -5,10 +5,11 @@ from pathlib import Path
 from typing import Optional
 
 import typer
-from rich.console import Console
+from rich.console import Console, Group
+from rich.live import Live
 from rich.progress import (
-    BarColumn, DownloadColumn, Progress, SpinnerColumn,
-    TextColumn, TransferSpeedColumn,
+    BarColumn, DownloadColumn, MofNCompleteColumn, Progress, SpinnerColumn,
+    TextColumn, TimeRemainingColumn, TransferSpeedColumn,
 )
 
 from mvw import config as configmod
@@ -151,29 +152,48 @@ def download(
     _run_downloads(plan, subtitles=subtitles)
 
 
-def _run_downloads(plan, *, subtitles: bool) -> None:
-    progress = Progress(
+def _make_progress() -> tuple[Progress, Progress, Group]:
+    """Build the download progress display.
+
+    Two separate ``Progress`` instances are used because a single ``Progress``
+    applies one column set to every task, yet the two task kinds carry different
+    units: the overall bar counts *files*, while per-file bars count *bytes*.
+    Rendering a file count through byte/speed columns produced the nonsensical
+    "10/10 bytes" / "0 bytes/s" overall display. They are stacked in a ``Group``
+    so both still render under a single ``Live``.
+    """
+    overall = Progress(
+        TextColumn("[progress.description]{task.description}"),
+        BarColumn(),
+        MofNCompleteColumn(),  # "12/78", a count — no bogus byte unit
+        TimeRemainingColumn(),
+    )
+    per_file = Progress(
         SpinnerColumn(),
         TextColumn("[progress.description]{task.description}"),
         BarColumn(),
-        DownloadColumn(),
+        DownloadColumn(),       # bytes — correct here
         TransferSpeedColumn(),
-        console=console,
     )
+    return overall, per_file, Group(overall, per_file)
+
+
+def _run_downloads(plan, *, subtitles: bool) -> None:
+    overall_progress, file_progress, group = _make_progress()
     failures = 0
     ffmpeg_missing = False
-    with progress:
-        overall = progress.add_task("Overall", total=len(plan))
+    with Live(group, console=console):
+        overall = overall_progress.add_task("Overall", total=len(plan))
         for dest, url, _tier, sub_url in plan:
-            task = progress.add_task(dest.name, total=None)
+            task = file_progress.add_task(dest.name, total=None)
 
             def cb(done: int, total, _t=task):
-                progress.update(_t, completed=done, total=total)
+                file_progress.update(_t, completed=done, total=total)
 
             try:
                 if is_hls(url):
-                    progress.update(task, description=f"{dest.name} (ffmpeg)")
-                    download_hls(url, dest)
+                    file_progress.update(task, description=f"{dest.name} (ffmpeg)")
+                    download_hls(url, dest, on_progress=cb)
                 else:
                     download_file(url, dest, on_progress=cb)
                 if subtitles and sub_url:
@@ -187,8 +207,8 @@ def _run_downloads(plan, *, subtitles: bool) -> None:
                 failures += 1
                 err_console.print(display.error_panel(f"{dest.name}: {exc}"))
             finally:
-                progress.update(task, visible=False)
-                progress.advance(overall)
+                file_progress.update(task, visible=False)
+                overall_progress.advance(overall)
     if ffmpeg_missing:
         raise typer.Exit(4)
     elif failures:

{mvw_cli-0.1.1 → mvw_cli-0.1.2}/src/mvw/download.py

@@ -2,6 +2,8 @@ from __future__ import annotations
 
 import shutil
 import subprocess
+import tempfile
+import time
 from pathlib import Path
 from typing import Callable
 
@@ -79,14 +81,43 @@ def download(
     return dest
 
 
-def download_hls(url: str, dest: Path, *, ffmpeg: str = "ffmpeg") -> Path:
+def download_hls(
+    url: str,
+    dest: Path,
+    *,
+    ffmpeg: str = "ffmpeg",
+    on_progress: ProgressCb | None = None,
+    poll_interval: float = 0.5,
+) -> Path:
     if shutil.which(ffmpeg) is None:
         raise FFmpegMissingError(
             "ffmpeg not found on PATH; required for HLS (.m3u8) downloads"
         )
     dest.parent.mkdir(parents=True, exist_ok=True)
     cmd = [ffmpeg, "-y", "-i", url, "-c", "copy", str(dest)]
-    proc = subprocess.run(cmd, capture_output=True, text=True)
-    if proc.returncode != 0:
-        raise DownloadError(f"ffmpeg failed ({proc.returncode}): {proc.stderr[-300:]}")
+
+    def report() -> None:
+        # HLS has no known total, so report bytes written so far against an
+        # indeterminate total (None) to drive a live size/speed display.
+        if on_progress is not None:
+            try:
+                on_progress(dest.stat().st_size, None)
+            except OSError:
+                pass
+
+    # Stream ffmpeg's chatty stderr to a temp file rather than a PIPE we never
+    # read; an unread PIPE can fill its buffer and deadlock the child.
+    with tempfile.TemporaryFile(mode="w+", encoding="utf-8", errors="replace") as errf:
+        proc = subprocess.Popen(cmd, stdout=subprocess.DEVNULL, stderr=errf)
+        try:
+            while proc.poll() is None:
+                report()
+                time.sleep(poll_interval)
+        finally:
+            proc.wait()
+        if proc.returncode != 0:
+            errf.seek(0)
+            tail = errf.read()[-300:]
+            raise DownloadError(f"ffmpeg failed ({proc.returncode}): {tail}")
+    report()
     return dest

{mvw_cli-0.1.1 → mvw_cli-0.1.2}/tests/test_cli.py

@@ -55,7 +55,7 @@ def test_download_missing_ffmpeg_exits_4(monkeypatch, tmp_path):
                url_video_hd="https://cdn.example.com/stream_hd.m3u8")]
     monkeypatch.setattr(cli, "_make_client", lambda cfg: FakeClient(rows))
 
-    def _fake_download_hls(url, dest):
+    def _fake_download_hls(url, dest, **kwargs):
         raise FFmpegMissingError("ffmpeg not found on PATH")
 
     monkeypatch.setattr(cli, "download_hls", _fake_download_hls)
@@ -127,3 +127,22 @@ def test_season_flag_gates_foldering(monkeypatch, tmp_path):
     assert result_flat.exit_code == 0
     assert "Season 07" not in result_flat.stdout
     assert "s07e05" in result_flat.stdout.lower()
+
+
+def test_overall_progress_counts_files_not_bytes():
+    """Regression: the overall bar tracks a file count, so it must use a
+    count column (MofN) and never byte/speed columns, which produced the
+    bogus "10/10 bytes" / "0 bytes/s" display."""
+    from rich.progress import (
+        DownloadColumn, MofNCompleteColumn, TransferSpeedColumn,
+    )
+
+    overall, per_file, _ = cli._make_progress()
+
+    assert any(isinstance(c, MofNCompleteColumn) for c in overall.columns)
+    assert not any(
+        isinstance(c, (DownloadColumn, TransferSpeedColumn)) for c in overall.columns
+    )
+    # Per-file bars are byte-based and keep the byte/speed columns.
+    assert any(isinstance(c, DownloadColumn) for c in per_file.columns)
+    assert any(isinstance(c, TransferSpeedColumn) for c in per_file.columns)

{mvw_cli-0.1.1 → mvw_cli-0.1.2}/tests/test_download.py

@@ -4,7 +4,7 @@ import httpx
 import pytest
 import respx
 
-from mvw.download import DownloadError, download, is_hls, pick_resolution
+from mvw.download import DownloadError, download, download_hls, is_hls, pick_resolution
 from mvw.models import MediathekResult
 
 
@@ -55,3 +55,42 @@ def test_download_resumes_with_range(tmp_path: Path):
     respx.get("https://v/m.mp4").mock(side_effect=handler)
     download("https://v/m.mp4", dest)
     assert dest.read_bytes() == b"hello world"
+
+
+def _fake_ffmpeg(tmp_path: Path, *, sleep: float = 0.0, rc: int = 0) -> Path:
+    """A stand-in 'ffmpeg' that writes growing bytes to its output (last arg)."""
+    script = tmp_path / "fake_ffmpeg"
+    script.write_text(
+        "#!/bin/sh\n"
+        'eval out="\\${$#}"\n'
+        f"sleep {sleep}\n"
+        'printf "chunk-a" > "$out"\n'
+        'printf "chunk-b" >> "$out"\n'
+        f"exit {rc}\n"
+    )
+    script.chmod(0o755)
+    return script
+
+
+def test_download_hls_reports_progress_and_writes_output(tmp_path: Path):
+    ffmpeg = _fake_ffmpeg(tmp_path, sleep=0.6)  # outlive one poll tick
+    dest = tmp_path / "out.mkv"
+    seen: list[tuple[int, object]] = []
+
+    result = download_hls(
+        "https://x/playlist.m3u8", dest, ffmpeg=str(ffmpeg),
+        on_progress=lambda d, t: seen.append((d, t)), poll_interval=0.1,
+    )
+
+    assert result == dest
+    assert dest.read_bytes() == b"chunk-achunk-b"
+    # HLS has no known total, so it is reported as indeterminate.
+    assert seen and all(t is None for _, t in seen)
+    # Final report reflects the fully-written file size.
+    assert seen[-1][0] == len(b"chunk-achunk-b")
+
+
+def test_download_hls_raises_on_ffmpeg_failure(tmp_path: Path):
+    ffmpeg = _fake_ffmpeg(tmp_path, rc=1)
+    with pytest.raises(DownloadError, match="ffmpeg failed"):
+        download_hls("https://x/playlist.m3u8", tmp_path / "out.mkv", ffmpeg=str(ffmpeg))