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

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: mvw-cli
-Version: 0.1.1
+Version: 0.2.0
 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
@@ -162,6 +162,24 @@ mvw download QUERY
 | `--season-number` | — | Override detected season number |
 | `--subtitles` | off | Also fetch subtitle files alongside each video |
 | `--limit` | 200 | Maximum number of entries to resolve |
+| `--force` | off | Redownload every matched entry even if a valid file already exists |
+
+#### Download behavior and verification
+
+By default, `download` checks each target path before fetching:
+
+- an existing file is checked by probing the actual size of the version that
+  would be downloaded (an HTTP HEAD, falling back to a ranged request) and
+  comparing it to the file on disk; a match → `✓ … already exists, skipped`,
+  a mismatch → `⚠ … corrupted (size mismatch), redownloading`;
+- if the size cannot be determined (or for HLS `.m3u8`, which has no single
+  size), any non-empty existing file is treated as complete.
+
+Each fresh download is verified against the server's `Content-Length` before
+the temporary `.part` file is promoted to its final name (this now applies to
+HLS too, which is muxed to a `.part` and promoted only after ffmpeg succeeds),
+so an interrupted transfer never leaves a corrupt final file. A run ends with a
+summary line, e.g. `Done: 8 downloaded, 5 skipped, 2 redownloaded, 1 failed`.
 
 #### Filename template
 

{mvw_cli-0.1.1 → mvw_cli-0.2.0}/README.md

@@ -135,6 +135,24 @@ mvw download QUERY
 | `--season-number` | — | Override detected season number |
 | `--subtitles` | off | Also fetch subtitle files alongside each video |
 | `--limit` | 200 | Maximum number of entries to resolve |
+| `--force` | off | Redownload every matched entry even if a valid file already exists |
+
+#### Download behavior and verification
+
+By default, `download` checks each target path before fetching:
+
+- an existing file is checked by probing the actual size of the version that
+  would be downloaded (an HTTP HEAD, falling back to a ranged request) and
+  comparing it to the file on disk; a match → `✓ … already exists, skipped`,
+  a mismatch → `⚠ … corrupted (size mismatch), redownloading`;
+- if the size cannot be determined (or for HLS `.m3u8`, which has no single
+  size), any non-empty existing file is treated as complete.
+
+Each fresh download is verified against the server's `Content-Length` before
+the temporary `.part` file is promoted to its final name (this now applies to
+HLS too, which is muxed to a `.part` and promoted only after ffmpeg succeeds),
+so an interrupted transfer never leaves a corrupt final file. A run ends with a
+summary line, e.g. `Done: 8 downloaded, 5 skipped, 2 redownloaded, 1 failed`.
 
 #### Filename template
 

{mvw_cli-0.1.1 → mvw_cli-0.2.0}/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.2.0"
 license = "MIT"
 license-files = ["LICENSE"]
 authors = [{ name = "Max Boettinger", email = "perplexity@bttngr.de" }]

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

@@ -5,17 +5,19 @@ 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
 from mvw import display, episodes, filters, naming, query
 from mvw.api import MediathekClient, MediathekError
 from mvw.download import (
-    DownloadError, FFmpegMissingError, download as download_file, download_hls, is_hls, pick_resolution,
+    DownloadError, FFmpegMissingError, download as download_file, download_hls,
+    is_hls, pick_resolution, remote_size, verify_size,
 )
 
 app = typer.Typer(help="Search and download from MediathekViewWeb.", no_args_is_help=True)
@@ -94,6 +96,7 @@ def download(
     latest_season: bool = typer.Option(False, "--latest-season"),
     season_number: Optional[int] = typer.Option(None, "--season-number"),
     subtitles: bool = typer.Option(False, "--subtitles"),
+    force: bool = typer.Option(False, "--force", help="redownload even if a valid file exists"),
     limit: int = typer.Option(200, "--limit", help="max entries to resolve"),
 ) -> None:
     cfg = configmod.load()
@@ -148,50 +151,103 @@ def download(
         console.print(f"[dim]{len(plan)} file(s) planned[/]")
         return
 
-    _run_downloads(plan, subtitles=subtitles)
+    _run_downloads(plan, subtitles=subtitles, force=force)
 
 
-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,
     )
-    failures = 0
+    return overall, per_file, Group(overall, per_file)
+
+
+def _run_downloads(plan, *, subtitles: bool, force: bool = False) -> None:
+    overall_progress, file_progress, group = _make_progress()
+    counts = {"downloaded": 0, "skipped": 0, "redownloaded": 0, "failed": 0}
     ffmpeg_missing = False
-    with progress:
-        overall = progress.add_task("Overall", total=len(plan))
+    pkw = dict(no_wrap=True, overflow="ignore", crop=False)
+    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)
+            hls = is_hls(url)
+            probe: int | None = None
+            is_redownload = False
+            if not force and dest.exists():
+                # Probe the real size of the tier we'd fetch; HLS has no single
+                # size, so fall back to "exists and non-empty".
+                probe = None if hls else remote_size(url)
+                expected = 0 if (hls or probe is None) else probe
+                if verify_size(dest, expected):
+                    console.print(f"[green]✓[/] {dest.name} — already exists, skipped", **pkw)
+                    counts["skipped"] += 1
+                    overall_progress.advance(overall)
+                    continue
+                console.print(
+                    f"[yellow]⚠[/] {dest.name} — corrupted (size mismatch), redownloading",
+                    **pkw,
+                )
+                dest.unlink(missing_ok=True)
+                is_redownload = True
+
+            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)
+                if hls:
+                    file_progress.update(task, description=f"{dest.name} (ffmpeg)")
+                    download_hls(url, dest, on_progress=cb)
                 else:
-                    download_file(url, dest, on_progress=cb)
+                    download_file(url, dest, on_progress=cb, expected_size=probe)
+                counts["redownloaded" if is_redownload else "downloaded"] += 1
+                console.print(f"[cyan]↓[/] {dest.name} — downloaded", **pkw)
                 if subtitles and sub_url:
-                    download_file(sub_url, dest.with_suffix(".xml"))
+                    try:
+                        download_file(sub_url, dest.with_suffix(".xml"))
+                    except DownloadError as exc:
+                        err_console.print(
+                            f"[yellow]⚠[/] {dest.name} (subtitle) — failed: {exc}", **pkw
+                        )
             except FFmpegMissingError as exc:
                 ffmpeg_missing = True
                 err_console.print(display.error_panel(
                     f"{dest.name}: {exc}\nInstall ffmpeg: https://ffmpeg.org/download.html"
                 ))
             except DownloadError as exc:
-                failures += 1
-                err_console.print(display.error_panel(f"{dest.name}: {exc}"))
+                counts["failed"] += 1
+                console.print(f"[red]✗[/] {dest.name} — failed: {exc}", **pkw)
             finally:
-                progress.update(task, visible=False)
-                progress.advance(overall)
+                file_progress.update(task, visible=False)
+                overall_progress.advance(overall)
+    console.print(
+        f"[bold]Done:[/] {counts['downloaded']} downloaded, "
+        f"{counts['skipped']} skipped, {counts['redownloaded']} redownloaded, "
+        f"{counts['failed']} failed",
+        **pkw,
+    )
     if ffmpeg_missing:
         raise typer.Exit(4)
-    elif failures:
+    elif counts["failed"]:
         raise typer.Exit(5)
 
 

mvw_cli-0.2.0/src/mvw/download.py

@@ -0,0 +1,220 @@
+from __future__ import annotations
+
+import shutil
+import subprocess
+import tempfile
+import time
+from pathlib import Path
+from typing import Callable
+
+import httpx
+
+from mvw.models import MediathekResult
+
+ProgressCb = Callable[[int, "int | None"], None]
+
+
+class DownloadError(Exception):
+    pass
+
+
+class FFmpegMissingError(DownloadError):
+    pass
+
+
+def is_hls(url: str) -> bool:
+    return ".m3u8" in url.split("?", 1)[0].lower()
+
+
+def verify_size(path: Path, expected: int, *, tolerance: int = 0) -> bool:
+    """Return True if ``path`` is a plausibly complete download.
+
+    When ``expected`` is positive it is the byte oracle (the API ``size``):
+    the file must exist and its size must be within ``tolerance`` of it. When
+    ``expected`` is non-positive (e.g. HLS, where no reliable size exists),
+    validity degrades to "exists and is non-empty".
+    """
+    try:
+        actual = path.stat().st_size
+    except OSError:
+        return False
+    if expected > 0:
+        return abs(actual - expected) <= tolerance
+    return actual > 0
+
+
+def remote_size(url: str, *, client: httpx.Client | None = None) -> int | None:
+    """Best-effort probe of a URL's byte size without downloading the body.
+
+    Tries an HTTP HEAD first; if that gives no usable size (many CDNs reject
+    HEAD), falls back to a ranged GET and reads the total from Content-Range
+    WITHOUT reading the body. Returns the size in bytes, or None when it cannot
+    be determined or any network error occurs. Never raises — callers use it
+    only as a hint.
+    """
+    owns_client = client is None
+    client = client or httpx.Client(timeout=30.0, follow_redirects=True)
+    try:
+        try:
+            resp = client.head(url)
+            if resp.status_code == 200:
+                cl = resp.headers.get("content-length")
+                if cl is not None and cl.isdigit():
+                    return int(cl)
+        except httpx.HTTPError:
+            pass
+        # Fallback: a 1-byte ranged GET exposes the full size via Content-Range.
+        # Use stream() and never read the body, so a server that ignores Range
+        # (returns 200) does not trigger a full download.
+        try:
+            with client.stream("GET", url, headers={"Range": "bytes=0-0"}) as resp:
+                if resp.status_code == 206:
+                    cr = resp.headers.get("content-range")  # "bytes 0-0/12345"
+                    if cr and "/" in cr:
+                        total = cr.rsplit("/", 1)[1]
+                        if total.isdigit():
+                            return int(total)
+        except httpx.HTTPError:
+            pass
+        return None
+    finally:
+        if owns_client:
+            client.close()
+
+
+def pick_resolution(result: MediathekResult, preference: str) -> tuple[str, str]:
+    url, tier = result.resolve_video(preference)
+    if not url:
+        raise DownloadError("no video URL available for this entry")
+    return url, tier
+
+
+def download(
+    url: str,
+    dest: Path,
+    *,
+    on_progress: ProgressCb | None = None,
+    resume: bool = True,
+    expected_size: int | None = None,
+    client: httpx.Client | None = None,
+) -> Path:
+    dest.parent.mkdir(parents=True, exist_ok=True)
+    part = dest.with_name(dest.name + ".part")
+
+    owns_client = client is None
+    client = client or httpx.Client(timeout=60.0, follow_redirects=True)
+    downloaded = 0
+    total: int | None = None
+    try:
+        # At most two passes: one resume attempt, then a clean restart if the
+        # server's 206 total disagrees with the known expected size.
+        for _attempt in range(2):
+            existing = part.stat().st_size if (resume and part.exists()) else 0
+            headers = {}
+            mode = "wb"
+            if existing:
+                headers["Range"] = f"bytes={existing}-"
+                mode = "ab"
+            with client.stream("GET", url, headers=headers) as resp:
+                if resp.status_code not in (200, 206):
+                    raise DownloadError(f"HTTP {resp.status_code} downloading {url}")
+                if resp.status_code == 200:
+                    # Server is sending the whole file; ignore any partial .part.
+                    existing = 0
+                    mode = "wb"
+                total = None
+                cl = resp.headers.get("content-length")
+                if cl is not None:
+                    total = int(cl) + existing
+                # Resume guard: a 206 whose total disagrees with the known
+                # expected size means the remote changed under us. Drop the
+                # stale partial and retry once from byte 0.
+                if (
+                    resp.status_code == 206
+                    and existing
+                    and expected_size
+                    and expected_size > 0
+                    and total is not None
+                    and total != expected_size
+                ):
+                    resp.close()
+                    part.unlink(missing_ok=True)
+                    resume = False
+                    continue
+                downloaded = existing
+                with open(part, mode) as fh:
+                    for chunk in resp.iter_bytes():
+                        fh.write(chunk)
+                        downloaded += len(chunk)
+                        if on_progress:
+                            on_progress(downloaded, total)
+            break
+    except httpx.TransportError as exc:
+        raise DownloadError(f"network error: {exc}") from exc
+    finally:
+        if owns_client:
+            client.close()
+
+    # Completeness check: prefer the server's Content-Length total for this
+    # transfer; fall back to the API-provided expected_size. Promote .part to
+    # the final name only after this passes.
+    effective = total if total is not None else (
+        expected_size if expected_size and expected_size > 0 else None
+    )
+    if effective is not None and downloaded != effective:
+        part.unlink(missing_ok=True)
+        raise DownloadError(
+            f"size mismatch downloading {url}: got {downloaded}, expected {effective}"
+        )
+
+    part.replace(dest)
+    return dest
+
+
+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)
+    part = dest.with_name(dest.name + ".part")
+    part.unlink(missing_ok=True)
+    cmd = [ffmpeg, "-y", "-i", url, "-c", "copy", str(part)]
+
+    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(part.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:]
+            part.unlink(missing_ok=True)
+            raise DownloadError(f"ffmpeg failed ({proc.returncode}): {tail}")
+    report()
+    if part.stat().st_size == 0:
+        part.unlink(missing_ok=True)
+        raise DownloadError("ffmpeg produced an empty output file")
+    part.replace(dest)
+    return dest

{mvw_cli-0.1.1 → mvw_cli-0.2.0}/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,103 @@ 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 _fake_writer(calls, *, nbytes):
+    def fake_dl(url, dest, **kwargs):
+        calls.append(url)
+        dest.parent.mkdir(parents=True, exist_ok=True)
+        dest.write_bytes(b"x" * nbytes)
+        return dest
+    return fake_dl
+
+
+def test_download_skips_existing_valid_file(monkeypatch, tmp_path):
+    rows = [_r("Feuer und Flamme (S07/E05)", size=11,
+               url_video="https://v.mp4", url_video_hd="")]
+    monkeypatch.setattr(cli, "_make_client", lambda cfg: FakeClient(rows))
+    calls = []
+    monkeypatch.setattr(cli, "download_file", _fake_writer(calls, nbytes=11))
+    monkeypatch.setattr(cli, "remote_size", lambda url, **kw: 11)
+
+    args = ["download", "#Feuer und Flamme", "--resolution", "medium",
+            "--output", str(tmp_path)]
+    first = runner.invoke(cli.app, args)
+    assert first.exit_code == 0
+    assert len(calls) == 1
+
+    second = runner.invoke(cli.app, args)
+    assert second.exit_code == 0
+    assert len(calls) == 1  # not downloaded again
+    assert "already exists, skipped" in second.stdout
+
+
+def test_download_redownloads_corrupt_file(monkeypatch, tmp_path):
+    rows = [_r("Feuer und Flamme (S07/E05)", size=999,
+               url_video="https://v.mp4", url_video_hd="")]
+    monkeypatch.setattr(cli, "_make_client", lambda cfg: FakeClient(rows))
+    calls = []
+    # Writes only 5 bytes although the server "really" has 11 -> always "corrupt".
+    monkeypatch.setattr(cli, "download_file", _fake_writer(calls, nbytes=5))
+    monkeypatch.setattr(cli, "remote_size", lambda url, **kw: 11)
+
+    args = ["download", "#Feuer und Flamme", "--resolution", "medium",
+            "--output", str(tmp_path)]
+    runner.invoke(cli.app, args)            # first download leaves a 5-byte file
+    second = runner.invoke(cli.app, args)   # sees size mismatch -> redownload
+    assert second.exit_code == 0
+    assert len(calls) == 2
+    assert "corrupted" in second.stdout
+    assert "redownloading" in second.stdout
+
+
+def test_download_force_redownloads_valid_file(monkeypatch, tmp_path):
+    rows = [_r("Feuer und Flamme (S07/E05)", size=11,
+               url_video="https://v.mp4", url_video_hd="")]
+    monkeypatch.setattr(cli, "_make_client", lambda cfg: FakeClient(rows))
+    calls = []
+    monkeypatch.setattr(cli, "download_file", _fake_writer(calls, nbytes=11))
+
+    base = ["download", "#Feuer und Flamme", "--resolution", "medium",
+            "--output", str(tmp_path)]
+    runner.invoke(cli.app, base)                       # 1 download
+    forced = runner.invoke(cli.app, base + ["--force"])
+    assert forced.exit_code == 0
+    assert len(calls) == 2                             # downloaded again
+    assert "already exists" not in forced.stdout
+
+
+def test_download_prints_summary(monkeypatch, tmp_path):
+    rows = [_r("Feuer und Flamme (S07/E05)", size=11,
+               url_video="https://v.mp4", url_video_hd="")]
+    monkeypatch.setattr(cli, "_make_client", lambda cfg: FakeClient(rows))
+    monkeypatch.setattr(cli, "download_file", _fake_writer([], nbytes=11))
+    result = runner.invoke(
+        cli.app,
+        ["download", "#Feuer und Flamme", "--resolution", "medium",
+         "--output", str(tmp_path)],
+    )
+    assert result.exit_code == 0
+    assert "Done:" in result.stdout
+    assert "1 downloaded" in result.stdout
+    assert "0 skipped" in result.stdout
+    assert "0 redownloaded, 0 failed" in result.stdout
+
+
+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.2.0/tests/test_download.py

@@ -0,0 +1,236 @@
+from pathlib import Path
+
+import httpx
+import pytest
+import respx
+
+from mvw.download import DownloadError, download, download_hls, is_hls, pick_resolution, remote_size, verify_size
+from mvw.models import MediathekResult
+
+
+def _r(**over):
+    base = dict(channel="WDR", topic="T", title="x", timestamp=1, duration=1,
+                url_video="https://v/m.mp4", url_video_low="", url_video_hd="https://v/hd.mp4",
+                id="1")
+    base.update(over)
+    return MediathekResult.from_api(base)
+
+
+def test_is_hls():
+    assert is_hls("https://x/playlist.m3u8")
+    assert is_hls("https://x/playlist.m3u8?token=1")
+    assert not is_hls("https://x/v.mp4")
+
+
+def test_pick_resolution_best_and_missing():
+    assert pick_resolution(_r(), "best") == ("https://v/hd.mp4", "high")
+    with pytest.raises(DownloadError):
+        pick_resolution(_r(url_video="", url_video_hd="", url_video_low=""), "best")
+
+
+@respx.mock
+def test_download_streams_and_renames(tmp_path: Path):
+    respx.get("https://v/m.mp4").mock(
+        return_value=httpx.Response(200, content=b"hello world", headers={"content-length": "11"})
+    )
+    dest = tmp_path / "out.mp4"
+    seen = []
+    result = download("https://v/m.mp4", dest, on_progress=lambda d, t: seen.append((d, t)))
+    assert result == dest
+    assert dest.read_bytes() == b"hello world"
+    assert not dest.with_suffix(".mp4.part").exists()
+    assert seen[-1][0] == 11
+
+
+@respx.mock
+def test_download_resumes_with_range(tmp_path: Path):
+    dest = tmp_path / "out.mp4"
+    part = dest.with_suffix(".mp4.part")
+    part.write_bytes(b"hello ")  # 6 bytes already present
+
+    def handler(request):
+        assert request.headers["range"] == "bytes=6-"
+        return httpx.Response(206, content=b"world", headers={"content-range": "bytes 6-10/11"})
+
+    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)
+    dest = tmp_path / "out.mkv"
+    with pytest.raises(DownloadError, match="ffmpeg failed"):
+        download_hls("https://x/playlist.m3u8", dest, ffmpeg=str(ffmpeg))
+    assert not dest.exists()
+    assert not dest.with_name("out.mkv.part").exists()
+
+
+def test_verify_size_missing_file(tmp_path):
+    assert verify_size(tmp_path / "nope.mp4", 10) is False
+
+
+def test_verify_size_zero_byte_file(tmp_path):
+    f = tmp_path / "empty.mp4"
+    f.write_bytes(b"")
+    assert verify_size(f, 10) is False
+    # expected<=0 path also rejects an empty file
+    assert verify_size(f, 0) is False
+
+
+def test_verify_size_exact_match(tmp_path):
+    f = tmp_path / "ok.mp4"
+    f.write_bytes(b"0123456789")  # 10 bytes
+    assert verify_size(f, 10) is True
+
+
+def test_verify_size_off_by_one_mismatch(tmp_path):
+    f = tmp_path / "bad.mp4"
+    f.write_bytes(b"012345678")  # 9 bytes
+    assert verify_size(f, 10) is False
+    assert verify_size(f, 10, tolerance=1) is True
+
+
+def test_verify_size_unknown_expected_accepts_nonempty(tmp_path):
+    f = tmp_path / "hls.mkv"
+    f.write_bytes(b"x")
+    assert verify_size(f, 0) is True
+    assert verify_size(f, -1) is True
+
+
+class _ShortStream(httpx.SyncByteStream):
+    """Yields fewer bytes than the caller's expected_size, with no length header."""
+
+    def __iter__(self):
+        yield b"hello"  # 5 bytes
+
+    def close(self):
+        pass
+
+
+@respx.mock
+def test_download_raises_when_short_of_expected_size(tmp_path: Path):
+    respx.get("https://v/m.mp4").mock(
+        return_value=httpx.Response(200, stream=_ShortStream())
+    )
+    dest = tmp_path / "out.mp4"
+    with pytest.raises(DownloadError, match="size mismatch"):
+        download("https://v/m.mp4", dest, expected_size=11)
+    assert not dest.exists()
+    assert not dest.with_name("out.mp4.part").exists()
+
+
+@respx.mock
+def test_download_restarts_when_remote_total_differs(tmp_path: Path):
+    dest = tmp_path / "out.mp4"
+    part = dest.with_name("out.mp4.part")
+    part.write_bytes(b"OLDOLD")  # 6 stale bytes from a previous run
+
+    seen_ranges: list[str | None] = []
+
+    def handler(request):
+        rng = request.headers.get("range")
+        seen_ranges.append(rng)
+        if rng is not None:
+            # Resume attempt: server reports a different total (11) than the
+            # caller's expected_size (20) -> remote changed, must restart.
+            return httpx.Response(
+                206, content=b"world",
+                headers={"content-range": "bytes 6-10/11", "content-length": "5"},
+            )
+        # Restart attempt: full file from byte 0.
+        return httpx.Response(
+            200, content=b"hello world", headers={"content-length": "11"}
+        )
+
+    respx.get("https://v/m.mp4").mock(side_effect=handler)
+    download("https://v/m.mp4", dest, expected_size=20)
+
+    assert dest.read_bytes() == b"hello world"
+    assert seen_ranges == ["bytes=6-", None]  # tried resume, then restarted clean
+    assert not part.exists()
+
+
+@respx.mock
+def test_download_resume_continues_on_valid_206(tmp_path: Path):
+    dest = tmp_path / "out.mp4"
+    part = dest.with_name("out.mp4.part")
+    part.write_bytes(b"hello ")  # 6 bytes already present
+
+    def handler(request):
+        assert request.headers["range"] == "bytes=6-"
+        return httpx.Response(
+            206, content=b"world",
+            headers={"content-range": "bytes 6-10/11", "content-length": "5"},
+        )
+
+    respx.get("https://v/m.mp4").mock(side_effect=handler)
+    # expected_size matches the server's total (11), so the resume guard stays
+    # inert and the partial is continued, not restarted.
+    download("https://v/m.mp4", dest, expected_size=11)
+    assert dest.read_bytes() == b"hello world"
+    assert not part.exists()
+
+
+@respx.mock
+def test_remote_size_from_head(tmp_path: Path):
+    respx.head("https://v/m.mp4").mock(
+        return_value=httpx.Response(200, headers={"content-length": "4242"})
+    )
+    assert remote_size("https://v/m.mp4") == 4242
+
+
+@respx.mock
+def test_remote_size_falls_back_to_range_when_head_unsupported():
+    respx.head("https://v/m.mp4").mock(return_value=httpx.Response(405))
+    respx.get("https://v/m.mp4").mock(
+        return_value=httpx.Response(206, headers={"content-range": "bytes 0-0/9001"})
+    )
+    assert remote_size("https://v/m.mp4") == 9001
+
+
+@respx.mock
+def test_remote_size_none_when_unknown():
+    respx.head("https://v/m.mp4").mock(return_value=httpx.Response(200))  # no length
+    respx.get("https://v/m.mp4").mock(return_value=httpx.Response(200))   # ignores range
+    assert remote_size("https://v/m.mp4") is None
+
+
+@respx.mock
+def test_remote_size_none_on_network_error():
+    respx.head("https://v/m.mp4").mock(side_effect=httpx.ConnectError("boom"))
+    respx.get("https://v/m.mp4").mock(side_effect=httpx.ConnectError("boom"))
+    assert remote_size("https://v/m.mp4") is None

mvw_cli-0.1.1/src/mvw/download.py

@@ -1,92 +0,0 @@
-from __future__ import annotations
-
-import shutil
-import subprocess
-from pathlib import Path
-from typing import Callable
-
-import httpx
-
-from mvw.models import MediathekResult
-
-ProgressCb = Callable[[int, "int | None"], None]
-
-
-class DownloadError(Exception):
-    pass
-
-
-class FFmpegMissingError(DownloadError):
-    pass
-
-
-def is_hls(url: str) -> bool:
-    return ".m3u8" in url.split("?", 1)[0].lower()
-
-
-def pick_resolution(result: MediathekResult, preference: str) -> tuple[str, str]:
-    url, tier = result.resolve_video(preference)
-    if not url:
-        raise DownloadError("no video URL available for this entry")
-    return url, tier
-
-
-def download(
-    url: str,
-    dest: Path,
-    *,
-    on_progress: ProgressCb | None = None,
-    resume: bool = True,
-    client: httpx.Client | None = None,
-) -> Path:
-    dest.parent.mkdir(parents=True, exist_ok=True)
-    part = dest.with_name(dest.name + ".part")
-    existing = part.stat().st_size if (resume and part.exists()) else 0
-
-    headers = {}
-    mode = "wb"
-    if existing:
-        headers["Range"] = f"bytes={existing}-"
-        mode = "ab"
-
-    owns_client = client is None
-    client = client or httpx.Client(timeout=60.0, follow_redirects=True)
-    try:
-        with client.stream("GET", url, headers=headers) as resp:
-            if resp.status_code not in (200, 206):
-                raise DownloadError(f"HTTP {resp.status_code} downloading {url}")
-            if resp.status_code == 200:
-                existing = 0
-                mode = "wb"
-            total: int | None = None
-            cl = resp.headers.get("content-length")
-            if cl is not None:
-                total = int(cl) + existing
-            downloaded = existing
-            with open(part, mode) as fh:
-                for chunk in resp.iter_bytes():
-                    fh.write(chunk)
-                    downloaded += len(chunk)
-                    if on_progress:
-                        on_progress(downloaded, total)
-    except httpx.TransportError as exc:
-        raise DownloadError(f"network error: {exc}") from exc
-    finally:
-        if owns_client:
-            client.close()
-
-    part.replace(dest)
-    return dest
-
-
-def download_hls(url: str, dest: Path, *, ffmpeg: str = "ffmpeg") -> 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:]}")
-    return dest

mvw_cli-0.1.1/tests/test_download.py

@@ -1,57 +0,0 @@
-from pathlib import Path
-
-import httpx
-import pytest
-import respx
-
-from mvw.download import DownloadError, download, is_hls, pick_resolution
-from mvw.models import MediathekResult
-
-
-def _r(**over):
-    base = dict(channel="WDR", topic="T", title="x", timestamp=1, duration=1,
-                url_video="https://v/m.mp4", url_video_low="", url_video_hd="https://v/hd.mp4",
-                id="1")
-    base.update(over)
-    return MediathekResult.from_api(base)
-
-
-def test_is_hls():
-    assert is_hls("https://x/playlist.m3u8")
-    assert is_hls("https://x/playlist.m3u8?token=1")
-    assert not is_hls("https://x/v.mp4")
-
-
-def test_pick_resolution_best_and_missing():
-    assert pick_resolution(_r(), "best") == ("https://v/hd.mp4", "high")
-    with pytest.raises(DownloadError):
-        pick_resolution(_r(url_video="", url_video_hd="", url_video_low=""), "best")
-
-
-@respx.mock
-def test_download_streams_and_renames(tmp_path: Path):
-    respx.get("https://v/m.mp4").mock(
-        return_value=httpx.Response(200, content=b"hello world", headers={"content-length": "11"})
-    )
-    dest = tmp_path / "out.mp4"
-    seen = []
-    result = download("https://v/m.mp4", dest, on_progress=lambda d, t: seen.append((d, t)))
-    assert result == dest
-    assert dest.read_bytes() == b"hello world"
-    assert not dest.with_suffix(".mp4.part").exists()
-    assert seen[-1][0] == 11
-
-
-@respx.mock
-def test_download_resumes_with_range(tmp_path: Path):
-    dest = tmp_path / "out.mp4"
-    part = dest.with_suffix(".mp4.part")
-    part.write_bytes(b"hello ")  # 6 bytes already present
-
-    def handler(request):
-        assert request.headers["range"] == "bytes=6-"
-        return httpx.Response(206, content=b"world", headers={"content-range": "bytes 6-10/11"})
-
-    respx.get("https://v/m.mp4").mock(side_effect=handler)
-    download("https://v/m.mp4", dest)
-    assert dest.read_bytes() == b"hello world"