morphconv 1.0.1__py3-none-any.whl

morph/converters/xlsx_to_csv.py

@@ -0,0 +1,272 @@
+"""
+converters/xlsx_to_csv.py — xlsx -> csv, a fully self-contained converter.
+
+Sheet handling, merged-cell flattening, and the register() call with its
+full OptionSpec flag surface all live in this one file.
+"""
+
+from __future__ import annotations
+
+import csv
+import warnings
+from pathlib import Path
+from typing import Optional, Union
+
+import pandas as pd
+from openpyxl import load_workbook
+
+from ..registry import ConversionResult, OptionSpec, register
+
+# ─────────────────────────── helpers ────────────────────────────────────────
+
+def _get_sheet_names(path: Path) -> list[str]:
+    wb = load_workbook(path, read_only=True, data_only=True)
+    names = wb.sheetnames
+    wb.close()
+    return names
+
+
+def _get_visible_sheet_names(path: Path) -> list[str]:
+    wb = load_workbook(path, read_only=False, data_only=True)
+    visible = [ws.title for ws in wb.worksheets if ws.sheet_state == "visible"]
+    wb.close()
+    return visible
+
+
+def _flatten_merged_cells(path: Path, sheet: Union[str, int]) -> pd.DataFrame:
+    """Read a sheet and fill every cell in a merged region with the
+    top-left (anchor) value, then return as a DataFrame."""
+    wb = load_workbook(path, data_only=True)
+    ws = wb[sheet] if isinstance(sheet, str) else wb.worksheets[sheet]
+
+    merge_values: dict[tuple[int, int], object] = {}
+    for merge_range in ws.merged_cells.ranges:
+        anchor_val = ws.cell(merge_range.min_row, merge_range.min_col).value
+        for r in range(merge_range.min_row, merge_range.max_row + 1):
+            for c in range(merge_range.min_col, merge_range.max_col + 1):
+                merge_values[(r, c)] = anchor_val
+
+    rows: list[list] = []
+    for row in ws.iter_rows():
+        row_data = []
+        for cell in row:
+            key = (cell.row, cell.column)  # type: ignore[arg-type]
+            row_data.append(merge_values[key] if key in merge_values else cell.value)
+        rows.append(row_data)
+
+    wb.close()
+    if not rows:
+        return pd.DataFrame()
+
+    header = [str(v) if v is not None else f"col_{i}" for i, v in enumerate(rows[0])]
+    return pd.DataFrame(rows[1:], columns=header)
+
+
+def _read_sheet(
+    path: Path, sheet: Union[str, int], *, header_row: Optional[int], skiprows: int,
+    skipfooter: int, usecols: Optional[list], nrows: Optional[int],
+    strip_whitespace: bool, flatten_merges: bool,
+) -> pd.DataFrame:
+    if flatten_merges:
+        df = _flatten_merged_cells(path, sheet)
+        if strip_whitespace:
+            for col in df.select_dtypes(include="object").columns:
+                df[col] = df[col].str.strip()
+        return df
+
+    engine = "openpyxl"
+    suffix = path.suffix.lower()
+    if suffix == ".xls":
+        engine = "xlrd"
+    elif suffix == ".ods":
+        engine = "odf"
+
+    with warnings.catch_warnings():
+        warnings.simplefilter("ignore")
+        df = pd.read_excel(
+            path, sheet_name=sheet, header=header_row,
+            skiprows=skiprows if skiprows else None, skipfooter=skipfooter,
+            usecols=usecols, nrows=nrows, dtype=str, engine=engine, keep_default_na=True,
+        )
+
+    if strip_whitespace:
+        for col in df.select_dtypes(include="object").columns:
+            df[col] = df[col].str.strip()
+
+    return df
+
+
+def _df_to_csv(
+    df: pd.DataFrame, output_path: Path, *, delimiter: str, encoding: str,
+    line_terminator: str, quoting: int, na_rep: str, include_index: bool,
+    date_format: Optional[str] = None,
+) -> None:
+    output_path.parent.mkdir(parents=True, exist_ok=True)
+    df.to_csv(output_path, sep=delimiter, encoding=encoding, lineterminator=line_terminator,
+              quoting=quoting, na_rep=na_rep, index=include_index,
+              date_format=date_format or "%Y-%m-%d %H:%M:%S")
+
+
+def _safe_filename(name: str) -> str:
+    import re
+    return re.sub(r'[\\/*?:"<>|]', "_", name)
+
+
+def preview(
+    input_path: Path, sheet: Union[str, int] = 0, *, nrows: int = 10,
+    header_row: Optional[int] = 0, flatten_merges: bool = False, strip_whitespace: bool = True,
+) -> pd.DataFrame:
+    """First `nrows` rows of a sheet as a DataFrame — no file written."""
+    return _read_sheet(input_path, sheet, header_row=header_row, skiprows=0, skipfooter=0,
+                        usecols=None, nrows=nrows, strip_whitespace=strip_whitespace,
+                        flatten_merges=flatten_merges)
+
+
+def _convert_workbook(
+    input_path: Path, output_path: Path, *, sheets: Optional[list] = None,
+    skip_hidden: bool = True, all_sheets_separate: bool = False, combine_sheets: bool = False,
+    combine_sheet_col: Optional[str] = "__sheet", delimiter: str = ",", encoding: str = "utf-8-sig",
+    line_terminator: str = "\r\n", quoting: int = csv.QUOTE_MINIMAL, na_rep: str = "",
+    date_format: Optional[str] = None, header_row: Optional[int] = 0, skiprows: int = 0,
+    skipfooter: int = 0, usecols: Optional[str] = None, nrows: Optional[int] = None,
+    strip_whitespace: bool = True, include_index: bool = False, flatten_merges: bool = False,
+) -> list[dict]:
+    """Convert an Excel workbook to one or more CSV files. Returns [{rows, cols, sheet, output}, ...]."""
+    input_path = Path(input_path)
+    output_path = Path(output_path)
+
+    suffix = input_path.suffix.lower()
+    if suffix == ".xls":
+        all_sheet_names: list[str] = pd.ExcelFile(input_path, engine="xlrd").sheet_names
+    elif suffix == ".ods":
+        all_sheet_names = pd.ExcelFile(input_path, engine="odf").sheet_names
+    else:
+        all_sheet_names = _get_sheet_names(input_path)
+
+    if skip_hidden and suffix not in (".xls", ".ods"):
+        visible = _get_visible_sheet_names(input_path)
+    else:
+        visible = all_sheet_names
+
+    if sheets:
+        resolved: list[str] = []
+        for s in sheets:
+            if isinstance(s, int):
+                if 0 <= s < len(all_sheet_names):
+                    resolved.append(all_sheet_names[s])
+            else:
+                if s in all_sheet_names:
+                    resolved.append(s)
+        target_sheets = [s for s in resolved if s in visible]
+    else:
+        target_sheets = list(visible)
+
+    if not target_sheets:
+        raise ValueError("No matching visible sheets found in workbook.")
+
+    parsed_usecols: Optional[list] = None
+    if usecols:
+        cols = [c.strip() for c in usecols.split(",")]
+        try:
+            parsed_usecols = [int(c) for c in cols]
+        except ValueError:
+            parsed_usecols = cols
+
+    read_kw = dict(header_row=header_row, skiprows=skiprows, skipfooter=skipfooter,
+                   usecols=parsed_usecols, nrows=nrows, strip_whitespace=strip_whitespace,
+                   flatten_merges=flatten_merges)
+    csv_kw = dict(delimiter=delimiter, encoding=encoding, line_terminator=line_terminator,
+                  quoting=quoting, na_rep=na_rep, include_index=include_index, date_format=date_format)
+
+    results: list[dict] = []
+
+    if combine_sheets:
+        frames: list[pd.DataFrame] = []
+        for sheet in target_sheets:
+            df = _read_sheet(input_path, sheet, **read_kw)  # type: ignore[arg-type]
+            if combine_sheet_col:
+                df.insert(0, combine_sheet_col, str(sheet))
+            frames.append(df)
+        combined = pd.concat(frames, ignore_index=True)
+        _df_to_csv(combined, output_path, **csv_kw)  # type: ignore[arg-type]
+        results.append({"rows": len(combined), "cols": len(combined.columns),
+                         "sheet": f"{len(target_sheets)} sheets combined", "output": output_path})
+        return results
+
+    if all_sheets_separate or len(target_sheets) > 1:
+        stem = output_path.stem
+        parent = output_path.parent
+        for sheet in target_sheets:
+            safe = _safe_filename(str(sheet))
+            out = parent / f"{stem}__{safe}.csv"
+            df = _read_sheet(input_path, sheet, **read_kw)  # type: ignore[arg-type]
+            _df_to_csv(df, out, **csv_kw)  # type: ignore[arg-type]
+            results.append({"rows": len(df), "cols": len(df.columns), "sheet": sheet, "output": out})
+        return results
+
+    sheet = target_sheets[0]
+    df = _read_sheet(input_path, sheet, **read_kw)  # type: ignore[arg-type]
+    _df_to_csv(df, output_path, **csv_kw)  # type: ignore[arg-type]
+    results.append({"rows": len(df), "cols": len(df.columns), "sheet": sheet, "output": output_path})
+    return results
+
+
+# ─────────────────────────── registry wiring ────────────────────────────────
+
+OPTIONS = [
+    OptionSpec("sheets", ("-s", "--sheets"), "Comma-separated sheet names/indices. Default: all visible."),
+    OptionSpec("skip_hidden", ("--include-hidden",), "Include hidden sheets.", default=True, action="store_false"),
+    OptionSpec("all_sheets_separate", ("--all-separate",), "One CSV per sheet even for a single match.",
+               default=False, action="store_true"),
+    OptionSpec("combine_sheets", ("--combine",), "Merge all sheets into one CSV.", default=False, action="store_true"),
+    OptionSpec("combine_sheet_col", ("--combine-col",), "Sheet-identifier column name when combining.", default="__sheet"),
+    OptionSpec("no_combine_col", ("--no-combine-col",), "Omit the sheet column when combining.",
+               default=False, action="store_true"),
+    OptionSpec("header_row", ("--header-row",), "0-based header row index. -1 for none.", default=0, type=int),
+    OptionSpec("skiprows", ("--skip-rows",), "Rows to skip before the header.", default=0, type=int),
+    OptionSpec("skipfooter", ("--skip-footer",), "Rows to skip at the bottom.", default=0, type=int),
+    OptionSpec("nrows", ("--nrows",), "Maximum data rows to read per sheet.", type=int),
+    OptionSpec("usecols", ("--cols",), "Comma-separated column names/indices to include."),
+    OptionSpec("flatten_merges", ("--flatten-merges",), "Fill merged cells with the anchor value.",
+               default=False, action="store_true"),
+    OptionSpec("delimiter", ("-d", "--delimiter"), "Output field delimiter.", default=","),
+    OptionSpec("encoding", ("-e", "--encoding"), "Output CSV encoding.", default="utf-8-sig"),
+    OptionSpec("line_terminator", ("--line-term",), r"Line terminator (\r\n or \n).", default="\\r\\n"),
+    OptionSpec("quoting", ("--quoting",), "minimal | all | nonnumeric | none", default="minimal"),
+    OptionSpec("na_rep", ("--na",), "String to represent NaN / empty cells.", default=""),
+    OptionSpec("date_format", ("--date-fmt",), "strftime format for date columns."),
+    OptionSpec("strip_whitespace", ("--no-strip",), "Disable stripping whitespace from cells.",
+               default=True, action="store_false"),
+    OptionSpec("include_index", ("--index",), "Write row index as first column.", default=False, action="store_true"),
+]
+
+_QUOTING_MAP = {"minimal": csv.QUOTE_MINIMAL, "all": csv.QUOTE_ALL,
+                "nonnumeric": csv.QUOTE_NONNUMERIC, "none": csv.QUOTE_NONE}
+
+
+@register("xlsx", "csv", backend="native", family="data",
+          description="xlsx → csv", lossy=True, options=OPTIONS)
+def xlsx_to_csv(input_path: Path, output_path: Path, **options) -> ConversionResult:
+    # small flag translations live right next to the flags they belong to
+    if options.pop("no_combine_col", False):
+        options["combine_sheet_col"] = None
+
+    sheets = options.get("sheets")
+    if sheets:
+        parsed = []
+        for p in [s.strip() for s in sheets.split(",")]:
+            try:
+                parsed.append(int(p))
+            except ValueError:
+                parsed.append(p)
+        options["sheets"] = parsed
+
+    header_row = options.get("header_row", 0)
+    options["header_row"] = None if header_row == -1 else header_row
+
+    options["line_terminator"] = options.get("line_terminator", "\\r\\n").replace("\\r\\n", "\r\n").replace("\\n", "\n")
+    options["quoting"] = _QUOTING_MAP.get(str(options.get("quoting", "minimal")).lower(), csv.QUOTE_MINIMAL)
+
+    results = _convert_workbook(input_path=input_path, output_path=output_path, **options)
+    r = results[0]
+    return ConversionResult(output=r["output"], rows=r["rows"])

morph/deps.py

@@ -0,0 +1,228 @@
+"""
+deps.py — detects and (with explicit confirmation) installs external binaries
+that converters shell out to, like pandoc and ffmpeg.
+
+Design rules:
+  • morph NEVER installs anything silently. Every install shows the exact
+    command first and asks for a yes.
+  • morph NEVER auto-elevates. If a command needs sudo, it's part of the
+    printed command — the user sees it and approves it explicitly.
+  • Package manager + package name are resolved per-OS, since binary names
+    differ (e.g. ffmpeg on winget is "Gyan.FFmpeg", not "ffmpeg").
+"""
+
+from __future__ import annotations
+
+import platform
+import shlex
+import shutil
+import subprocess
+from dataclasses import dataclass
+from typing import Optional
+
+from rich.console import Console
+from rich.panel import Panel
+from rich.prompt import Confirm
+
+# ── package manager registry ──────────────────────────────────────────────
+
+# order matters: first found wins on a given OS
+_MANAGERS_BY_OS = {
+    "Darwin":  ["brew", "port"],
+    "Linux":   ["apt", "dnf", "pacman", "zypper", "apk"],
+    "Windows": ["winget", "choco", "scoop"],
+}
+
+_INSTALL_CMD = {
+    "brew":   "brew install {pkg}",
+    "port":   "sudo port install {pkg}",
+    "apt":    "sudo apt install -y {pkg}",
+    "dnf":    "sudo dnf install -y {pkg}",
+    "pacman": "sudo pacman -S --noconfirm {pkg}",
+    "zypper": "sudo zypper install -y {pkg}",
+    "apk":    "sudo apk add {pkg}",
+    "winget": "winget install --id {pkg} -e",
+    "choco":  "choco install {pkg} -y",
+    "scoop":  "scoop install {pkg}",
+    "pip":    "playwright install {pkg}", # special case for playwright browsers
+}
+
+# binary -> {package_manager: package_name}, only where it differs from the binary name
+_PACKAGE_NAMES: dict[str, dict[str, str]] = {
+    "ffmpeg": {"winget": "Gyan.FFmpeg", "scoop": "ffmpeg"},
+    "pandoc": {"winget": "JohnMacFarlane.Pandoc"},
+    "tesseract": {"winget": "UB-Mannheim.TesseractOCR"},
+    "ebook-convert": {
+        "apt": "calibre", "dnf": "calibre", "pacman": "calibre",
+        "brew": "calibre", "winget": "calibre.calibre", "choco": "calibre",
+    },
+    "soffice": {  # LibreOffice headless binary
+        "apt": "libreoffice", "dnf": "libreoffice", "pacman": "libreoffice-fresh",
+        "brew": "libreoffice", "winget": "TheDocumentFoundation.LibreOffice",
+        "choco": "libreoffice-fresh",
+    },
+    "playwright": {"winget": "chromium", "apt": "chromium", "brew": "chromium", "dnf": "chromium", "pacman": "chromium", "scoop": "chromium"},
+}
+
+# extra one-line context shown to the user about *why* they need this
+_WHY = {
+    "pandoc": "converts between document formats (docx, md, html, epub, ...)",
+    "ffmpeg": "converts audio and video files",
+    "soffice": "converts legacy office formats pandoc can't read directly",
+    "wkhtmltopdf": "renders documents to PDF (a lightweight PDF engine)",
+    "xelatex": "renders documents to PDF with full LaTeX/typography support",
+    "ebook-convert": "converts ebook formats (epub, mobi, azw3) — ships as part of Calibre",
+    "playwright": "installs a headless Chromium browser to render Javascript (for --js)",
+}
+
+
+@dataclass
+class DependencyStatus:
+    binary: str
+    installed: bool
+    manager: Optional[str]
+    install_cmd: Optional[str]
+
+
+def detect_package_manager() -> Optional[str]:
+    system = platform.system()
+    for mgr in _MANAGERS_BY_OS.get(system, []):
+        if shutil.which(mgr):
+            return mgr
+    return None
+
+
+_path_refreshed = False
+
+def is_installed(binary: str) -> bool:
+    global _path_refreshed
+    if shutil.which(binary):
+        return True
+        
+    if platform.system() == "Windows" and not _path_refreshed:
+        _refresh_windows_path()
+        _path_refreshed = True
+        return shutil.which(binary) is not None
+        
+    return False
+
+
+def check(binary: str) -> DependencyStatus:
+    if binary == "playwright":
+        # Check if the chromium browser folder exists inside playwright's cache.
+        # But a simple proxy is to check if `playwright install chromium` needs to run.
+        # We'll just assume `playwright` is in PATH (installed via pip) and construct the install command.
+        # Since we can't easily detect if the browser is downloaded, we'll try to run the install command.
+        # Actually, let's just make sure the `playwright` CLI exists. 
+        # Wait, if we want to install chromium, we'll return false if we want it to run.
+        # Let's just return True if `playwright` exists, but actually we need the browsers.
+        # If `playwright` is checked, we just return the pip command.
+        return DependencyStatus(binary, is_installed("playwright"), "pip", "playwright install chromium")
+
+    if is_installed(binary):
+        return DependencyStatus(binary, True, None, None)
+    mgr = detect_package_manager()
+    if not mgr:
+        return DependencyStatus(binary, False, None, None)
+    pkg = _PACKAGE_NAMES.get(binary, {}).get(mgr, binary)
+    cmd = _INSTALL_CMD[mgr].format(pkg=pkg)
+    return DependencyStatus(binary, False, mgr, cmd)
+
+
+def ensure(binary: str, console: Optional[Console] = None, *, assume_yes: bool = False) -> bool:
+    """
+    Make sure `binary` is available, prompting to install it if not.
+    Returns True if the binary is usable by the time this returns.
+
+    assume_yes=True skips the confirmation prompt (e.g. `morph convert -y`)
+    but morph still ALWAYS shows the exact command before running it — the
+    only thing -y skips is the interactive "are you sure?", never visibility.
+    """
+    console = console or Console()
+    status = check(binary)
+    if status.installed:
+        return True
+
+    why = _WHY.get(binary, "is required for this conversion")
+    if not status.manager:
+        console.print(Panel.fit(
+            f"[warning]{binary}[/warning] {why}, but it isn't installed and "
+            f"morph couldn't find a supported package manager on this system.\n\n"
+            f"Install it manually, then re-run this command.",
+            title="Missing dependency", border_style="yellow",
+        ))
+        return False
+
+    console.print(Panel.fit(
+        f"[bold white]{binary}[/bold white] {why}, but it isn't installed.\n\n"
+        f"morph can install it with:\n  [accent]{status.install_cmd}[/accent]",
+        title="Missing dependency", border_style="yellow",
+    ))
+
+    if not assume_yes and not Confirm.ask("Run this now?", default=True):
+        console.print(f"[muted]Skipped. Install it yourself with:[/muted] {status.install_cmd}")
+        return False
+
+    console.print(f"[info]→ running:[/info] {status.install_cmd}")
+    try:
+        result = subprocess.run(shlex.split(status.install_cmd))
+    except FileNotFoundError as e:
+        console.print(f"[error]✗ Could not run installer:[/error] {e}")
+        return False
+
+    if result.returncode != 0:
+        console.print(f"[error]✗ Install command exited with status {result.returncode}[/error]")
+        return False
+
+    # The installer might have updated the system PATH registry, but the current terminal 
+    # process won't see it until restarted. Let's force a refresh in the current process.
+    if not is_installed(binary):
+        _refresh_windows_path()
+
+    if is_installed(binary):
+        console.print(f"[success]✓ {binary} installed successfully[/success]")
+        return True
+
+    console.print(f"[error]✗ Install finished but {binary} still isn't on PATH.[/error]")
+    return False
+
+
+def _refresh_windows_path() -> None:
+    """Forces the current Python process to pull the latest PATH from the Windows Registry."""
+    if platform.system() != "Windows":
+        return
+    import os
+    import winreg
+    
+    new_paths = []
+    
+    try:
+        with winreg.OpenKey(winreg.HKEY_LOCAL_MACHINE, r"System\CurrentControlSet\Control\Session Manager\Environment") as key:
+            sys_path, _ = winreg.QueryValueEx(key, "Path")
+            new_paths.extend(sys_path.split(os.pathsep))
+    except Exception:
+        pass
+        
+    try:
+        with winreg.OpenKey(winreg.HKEY_CURRENT_USER, r"Environment") as key:
+            user_path, _ = winreg.QueryValueEx(key, "Path")
+            new_paths.extend(user_path.split(os.pathsep))
+    except Exception:
+        pass
+        
+    # Hardcode well-known locations for badly behaved installers that don't add to PATH at all
+    well_known = [
+        r"C:\Program Files\Tesseract-OCR",
+        r"C:\Program Files (x86)\Tesseract-OCR",
+    ]
+    for p in well_known:
+        if os.path.exists(p) and p not in new_paths:
+            new_paths.append(p)
+            
+    if new_paths:
+        os.environ["PATH"] = os.environ.get("PATH", "") + os.pathsep + os.pathsep.join(new_paths)
+
+
+def ensure_all(binaries: list[str], console: Optional[Console] = None, *, assume_yes: bool = False) -> bool:
+    """Ensure every binary in the list is available. Stops at first failure."""
+    return all(ensure(b, console, assume_yes=assume_yes) for b in binaries)

morph/ffmpeg_utils.py

@@ -0,0 +1,79 @@
+"""
+ffmpeg_utils.py — shared ffmpeg execution with live progress reporting.
+
+ffmpeg supports `-progress pipe:1`, which streams machine-readable
+`key=value` lines as it works (out_time_ms=..., speed=..., progress=end).
+Combined with the total duration from ffprobe, that's enough to compute a
+real fractional progress — not just a spinner — for every audio/video hop.
+"""
+
+from __future__ import annotations
+
+import subprocess
+from pathlib import Path
+from typing import Callable, Optional
+
+ProgressCallback = Callable[[float, str], None]
+
+
+def probe_duration(path: Path) -> Optional[float]:
+    """Total duration in seconds, via ffprobe. None if it can't be determined
+    (e.g. some live/streamed inputs) — callers fall back to a spinner."""
+    try:
+        result = subprocess.run(
+            ["ffprobe", "-v", "error", "-show_entries", "format=duration", "-of", "csv=p=0", str(path)],
+            capture_output=True, text=True, timeout=15,
+        )
+        return float(result.stdout.strip())
+    except Exception:
+        return None
+
+
+def run_ffmpeg(cmd: list[str], *, input_path: Optional[Path] = None,
+               progress: Optional[ProgressCallback] = None) -> None:
+    """Run an ffmpeg command. `cmd[0]` must be 'ffmpeg'.
+
+    If `progress` is given, streams -progress output and calls
+    `progress(fraction_0_to_1, status_text)` as it becomes known. Falls back
+    to a single call at frac=None-equivalent (never called) if duration is
+    unavailable — the caller should already be showing an indeterminate
+    spinner in that case, this just upgrades it when it can.
+    """
+    if progress is None:
+        result = subprocess.run(cmd, capture_output=True, text=True)
+        if result.returncode != 0:
+            tail = "\n".join(result.stderr.strip().splitlines()[-6:])
+            raise RuntimeError(f"ffmpeg failed:\n{tail}")
+        return
+
+    total = probe_duration(input_path) if input_path else None
+    live_cmd = [cmd[0], "-progress", "pipe:1", "-nostats", *cmd[1:]]
+
+    proc = subprocess.Popen(live_cmd, stdout=subprocess.PIPE, stderr=subprocess.PIPE,
+                             text=True, bufsize=1)
+    speed = ""
+    assert proc.stdout is not None
+    try:
+        for line in proc.stdout:
+            line = line.strip()
+            if not line or "=" not in line:
+                continue
+            key, _, value = line.partition("=")
+            if key == "speed":
+                speed = value.strip()
+            elif key == "out_time_ms" and total:
+                try:
+                    seconds = int(value) / 1_000_000
+                    frac = max(0.0, min(seconds / total, 1.0))
+                    progress(frac, speed)
+                except ValueError:
+                    pass
+            elif key == "progress" and value == "end":
+                progress(1.0, speed)
+    finally:
+        stderr_output = proc.stderr.read() if proc.stderr else ""
+        proc.wait()
+
+    if proc.returncode != 0:
+        tail = "\n".join(stderr_output.strip().splitlines()[-6:])
+        raise RuntimeError(f"ffmpeg failed:\n{tail}")