mpup 0.1.0__py3-none-any.whl

mpup/lyrics.py

@@ -0,0 +1,190 @@
+"""Decode and normalize synchronized LRC lyrics."""
+
+from __future__ import annotations
+
+import json
+import re
+from collections.abc import Callable
+from dataclasses import asdict, dataclass
+from pathlib import Path
+from typing import Literal, Protocol, Sequence
+
+from mpup.metadata import AudioMetadata
+
+
+_TIMESTAMP = re.compile(r"\[(?P<minutes>\d+):(?P<seconds>[0-5]\d)(?:[.:](?P<fraction>\d{2,3}))?\]")
+_OFFSET = re.compile(r"^\s*\[offset:(?P<offset>[+-]?\d+)\]\s*$", re.IGNORECASE)
+
+
+@dataclass(frozen=True)
+class LyricCue:
+    text: str
+    start_ms: int
+    end_ms: int
+    timestamp_ms: None = None
+    confidence: None = None
+
+    def as_caption(self) -> dict[str, str | int | None]:
+        values = asdict(self)
+        return {
+            "text": values["text"],
+            "startMs": values["start_ms"],
+            "endMs": values["end_ms"],
+            "timestampMs": None,
+            "confidence": None,
+        }
+
+
+class LyricsProvider(Protocol):
+    def fetch(self, metadata: AudioMetadata) -> str | None:
+        """Return LRC text or no match."""
+
+
+class NullLyricsProvider:
+    """Default provider that deliberately performs no network access."""
+
+    def fetch(self, metadata: AudioMetadata) -> None:
+        del metadata
+        return None
+
+
+class PlatformLyricsProvider:
+    """Retrieve lyrics from a selected music platform without leaking failures."""
+
+    def __init__(self, source: str = "qq") -> None:
+        if source != "qq":
+            raise ValueError(f"Unsupported lyrics source: {source}")
+        self.source = source
+
+    def fetch(self, metadata: AudioMetadata) -> str | None:
+        try:
+            from mpup.lyrics_from_qq import fetch_lyrics
+
+            return fetch_lyrics(metadata)
+        except Exception:
+            return None
+
+
+LyricsSource = Literal["local", "embedded", "provider", "none"]
+
+
+@dataclass(frozen=True)
+class LyricsResolution:
+    cues: tuple[LyricCue, ...] | None
+    source: LyricsSource
+    warnings: tuple[str, ...] = ()
+
+
+def decode_lrc(payload: bytes) -> str:
+    """Decode local lyrics using the supported deterministic encoding order."""
+    for encoding in ("utf-8-sig", "gb18030"):
+        try:
+            return payload.decode(encoding)
+        except UnicodeDecodeError:
+            continue
+    raise RuntimeError("歌词文件不是 UTF-8 或 GB18030 编码")
+
+
+def _timestamp_ms(match: re.Match[str]) -> int:
+    fraction = match.group("fraction") or ""
+    milliseconds = int(fraction) * (10 if len(fraction) == 2 else 1) if fraction else 0
+    return (int(match.group("minutes")) * 60 + int(match.group("seconds"))) * 1000 + milliseconds
+
+
+def parse_lrc(text: str, duration_ms: int) -> tuple[LyricCue, ...]:
+    """Convert LRC text into sorted, bounded caption-compatible cues."""
+    if duration_ms <= 0:
+        raise ValueError("音频时长必须大于 0")
+
+    offset_ms = 0
+    for line in text.splitlines():
+        match = _OFFSET.match(line)
+        if match is not None:
+            offset_ms = int(match.group("offset"))
+
+    events: list[tuple[int, int, str]] = []
+    ordinal = 0
+    for line in text.splitlines():
+        timestamps = list(_TIMESTAMP.finditer(line))
+        if not timestamps:
+            continue
+        lyric = _TIMESTAMP.sub("", line).strip()
+        if not lyric:
+            continue
+        for timestamp in timestamps:
+            start_ms = max(0, _timestamp_ms(timestamp) + offset_ms)
+            if start_ms < duration_ms:
+                events.append((start_ms, ordinal, lyric))
+                ordinal += 1
+
+    events.sort(key=lambda event: (event[0], event[1]))
+    cues: list[LyricCue] = []
+    for index, (start_ms, _ordinal, lyric) in enumerate(events):
+        if index + 1 < len(events):
+            end_ms = min(duration_ms, events[index + 1][0])
+        else:
+            end_ms = min(duration_ms, start_ms + 6000)
+        cues.append(LyricCue(lyric, start_ms, max(start_ms, end_ms)))
+    return tuple(cues)
+
+
+def lyrics_json(cues: Sequence[LyricCue]) -> str:
+    """Serialize cues with the shared camelCase renderer contract."""
+    return json.dumps(
+        [cue.as_caption() for cue in cues],
+        ensure_ascii=False,
+        separators=(",", ":"),
+    )
+
+
+def _lyrics_warning(prefix: str, error: Exception | None = None) -> str:
+    if error is None:
+        return prefix
+    detail = str(error).strip() or error.__class__.__name__
+    return f"{prefix}：{detail[-1000:]}"
+
+
+def resolve_lyrics(
+    audio_path: Path,
+    metadata: AudioMetadata,
+    *,
+    provider: LyricsProvider | None = None,
+    is_file: Callable[[Path], bool] = Path.is_file,
+    reader: Callable[[Path], bytes] = Path.read_bytes,
+) -> LyricsResolution:
+    """Resolve local, embedded, then provider LRC without failing the song."""
+    duration_ms = max(1, round(metadata.duration * 1000))
+    warnings: list[str] = []
+
+    for suffix in (".lrc", ".LRC"):
+        candidate = audio_path.with_suffix(suffix)
+        if not is_file(candidate):
+            continue
+        try:
+            cues = parse_lrc(decode_lrc(reader(candidate)), duration_ms)
+        except Exception as error:
+            warnings.append(_lyrics_warning(f"歌词文件 {candidate.name} 不可用", error))
+            continue
+        if cues:
+            return LyricsResolution(cues, "local", tuple(warnings))
+        warnings.append(_lyrics_warning(f"歌词文件 {candidate.name} 没有同步时间戳"))
+
+    if metadata.embedded_lyrics:
+        cues = parse_lrc(metadata.embedded_lyrics, duration_ms)
+        if cues:
+            return LyricsResolution(cues, "embedded", tuple(warnings))
+        warnings.append(_lyrics_warning("内嵌歌词没有同步时间戳"))
+
+    active_provider = provider or NullLyricsProvider()
+    if metadata.title and metadata.artist:
+        try:
+            provider_text = active_provider.fetch(metadata)
+            if provider_text:
+                cues = parse_lrc(provider_text, duration_ms)
+                if cues:
+                    return LyricsResolution(cues, "provider", tuple(warnings))
+                warnings.append(_lyrics_warning("歌词 Provider 返回内容没有同步时间戳"))
+        except Exception as error:
+            warnings.append(_lyrics_warning("歌词 Provider 不可用", error))
+
+    return LyricsResolution(None, "none", tuple(warnings))

mpup/lyrics_from_qq.py

@@ -0,0 +1,46 @@
+"""Resolve raw synchronized lyrics from QQ Music metadata."""
+from __future__ import annotations
+import base64, json, re
+from urllib.parse import urlencode
+from urllib.request import Request, urlopen
+from mpup.metadata import AudioMetadata
+
+_SEARCH = "https://u.y.qq.com/cgi-bin/musicu.fcg"
+_LYRIC = "https://c.y.qq.com/lyric/fcgi-bin/fcg_query_lyric_new.fcg"
+_JSONP = re.compile(r"^[^(]+\((?P<payload>.*)\)\s*$", re.DOTALL)
+_BRACKETS = re.compile(r"[（(].*?[)）]")
+_SPLIT = re.compile(r"[/,&，、]")
+_CLEAN = re.compile(r"[\s\W_]+", re.UNICODE)
+
+def fetch_lyrics(metadata: AudioMetadata, source: str = "qq") -> str | None:
+    if source != "qq": raise ValueError(f"Unsupported lyrics source: {source}")
+    if not metadata.title or not metadata.artist: return None
+    song = _find_song(metadata)
+    return _fetch_raw_lrc(song["mid"]) if song else None
+
+def _find_song(metadata: AudioMetadata) -> dict[str, object] | None:
+    data = {"req_1": {"method":"DoSearchForQQMusicDesktop", "module":"music.search.SearchCgiService", "param":{"num_per_page":20,"page_num":1,"query":f"{metadata.title} {metadata.artist}","search_type":0}}}
+    try: songs = _request_json(_SEARCH, json.dumps(data).encode(), {"Referer":"https://y.qq.com","Content-Type":"application/json"})["req_1"]["data"]["body"]["song"]["list"]
+    except (KeyError, TypeError): return None
+    expected_title, expected_artists = _title(metadata.title), _artists(metadata.artist)
+    for song in songs:
+        if not isinstance(song, dict) or _title(str(song.get("title", ""))) != expected_title: continue
+        artists = _artists("/".join(str(x.get("name", "")) for x in song.get("singer", []) if isinstance(x, dict)))
+        if expected_artists & artists and isinstance(song.get("mid"), str): return song
+    return None
+
+def _fetch_raw_lrc(mid: str) -> str | None:
+    query = urlencode({"songmid":mid,"g_tk":"5381","loginUin":"0","hostUin":"0","inCharset":"utf8","outCharset":"utf-8","notice":"0","platform":"yqq","needNewCode":"0"})
+    match = _JSONP.match(_request_text(f"{_LYRIC}?{query}", {"Referer":"https://y.qq.com","Cookie":"uin="}))
+    if match is None: return None
+    try:
+        value = json.loads(match.group("payload")).get("lyric", "")
+        return base64.b64decode(value, validate=True).decode("utf-8") if value else None
+    except (UnicodeDecodeError, ValueError, json.JSONDecodeError, AttributeError): return None
+
+def _request_json(url: str, data: bytes, headers: dict[str, str]) -> object: return json.loads(_request(url, data, headers))
+def _request_text(url: str, headers: dict[str, str]) -> str: return _request(url, None, headers)
+def _request(url: str, data: bytes | None, headers: dict[str, str]) -> str:
+    with urlopen(Request(url, data=data, headers=headers, method="POST" if data else "GET"), timeout=10) as response: return response.read().decode("utf-8")
+def _title(value: str) -> str: return _CLEAN.sub("", _BRACKETS.sub("", value).casefold())
+def _artists(value: str) -> set[str]: return {_CLEAN.sub("", x.casefold()) for x in _SPLIT.split(value) if _CLEAN.sub("", x.casefold())}

mpup/metadata.py

@@ -0,0 +1,159 @@
+"""Read audio metadata and validate media tool availability."""
+
+from __future__ import annotations
+
+import json
+import math
+import shutil
+import subprocess
+from collections.abc import Callable
+from dataclasses import dataclass
+from pathlib import Path
+from typing import Any
+
+
+Runner = Callable[..., subprocess.CompletedProcess[str]]
+REMOTION_ENTRY = Path(__file__).resolve().parents[2] / "renderer" / "src" / "index.ts"
+
+
+@dataclass(frozen=True)
+class AudioMetadata:
+    duration: float
+    title: str | None
+    artist: str | None
+    cover_stream_index: int | None = None
+    embedded_lyrics: str | None = None
+
+
+def require_media_tools(
+    which: Callable[[str], str | None] = shutil.which,
+) -> tuple[str, str]:
+    """Return FFmpeg and FFprobe paths or report the first missing tool."""
+    resolved: list[str] = []
+    for name in ("ffmpeg", "ffprobe"):
+        path = which(name)
+        if path is None:
+            raise RuntimeError(f"找不到 {name}，请先安装 FFmpeg 并加入 PATH")
+        resolved.append(path)
+    return resolved[0], resolved[1]
+
+
+def require_remotion_runtime(
+    entry: Path = REMOTION_ENTRY,
+    *,
+    which: Callable[[str], str | None] = shutil.which,
+    is_file: Callable[[Path], bool] = Path.is_file,
+) -> tuple[str, Path]:
+    """Return the Node executable and Remotion composition entrypoint."""
+    node = which("node")
+    if node is None:
+        raise RuntimeError("找不到 Node.js，请先安装 Node.js 并加入 PATH")
+    if not is_file(entry):
+        raise RuntimeError(f"找不到 Remotion 渲染入口：{entry}")
+    return node, entry
+
+
+def _normalized_tags(container: object) -> dict[str, str]:
+    if not isinstance(container, dict):
+        return {}
+    raw_tags = container.get("tags", {})
+    if not isinstance(raw_tags, dict):
+        return {}
+    tags: dict[str, str] = {}
+    for key, value in raw_tags.items():
+        if not isinstance(key, str) or not isinstance(value, str):
+            continue
+        cleaned = value.strip()
+        if cleaned:
+            tags[key.casefold()] = cleaned
+    return tags
+
+
+def _load_payload(stdout: str) -> dict[str, Any]:
+    try:
+        payload = json.loads(stdout)
+    except (json.JSONDecodeError, TypeError) as error:
+        raise RuntimeError("FFprobe 返回了无效 JSON") from error
+    if not isinstance(payload, dict):
+        raise RuntimeError("FFprobe 返回了无效 JSON 对象")
+    return payload
+
+
+def _cover_stream_index(streams: list[object]) -> int | None:
+    for stream in streams:
+        if not isinstance(stream, dict) or stream.get("codec_type") != "video":
+            continue
+        disposition = stream.get("disposition")
+        if not isinstance(disposition, dict) or disposition.get("attached_pic") != 1:
+            continue
+        index = stream.get("index")
+        if type(index) is int and index >= 0:
+            return index
+    return None
+
+
+def _embedded_lyrics(tags: dict[str, str]) -> str | None:
+    for name in ("syncedlyrics", "synced lyrics", "lyrics", "unsyncedlyrics"):
+        if name in tags:
+            return tags[name]
+    for name, value in tags.items():
+        if name.startswith(("lyrics-", "syncedlyrics-", "unsyncedlyrics-")):
+            return value
+    return None
+
+
+def probe_audio(
+    path: Path,
+    ffprobe: str = "ffprobe",
+    runner: Runner = subprocess.run,
+) -> AudioMetadata:
+    """Read duration, title, and artist from an audio file header."""
+    command = [
+        ffprobe,
+        "-v",
+        "error",
+        "-show_entries",
+        "format=duration:format_tags:stream=index,codec_type:"
+        "stream_tags:stream_disposition=attached_pic",
+        "-of",
+        "json",
+        str(path),
+    ]
+    result = runner(command, capture_output=True, text=True, check=False)
+    if result.returncode != 0:
+        detail = result.stderr.strip() or "未知错误"
+        raise RuntimeError(f"FFprobe 读取失败：{detail[-2000:]}")
+
+    payload = _load_payload(result.stdout)
+    raw_streams = payload.get("streams", [])
+    streams = raw_streams if isinstance(raw_streams, list) else []
+    audio_stream = next(
+        (
+            stream
+            for stream in streams
+            if isinstance(stream, dict) and stream.get("codec_type") == "audio"
+        ),
+        None,
+    )
+    if audio_stream is None:
+        raise RuntimeError("输入文件不包含音频流")
+
+    format_info = payload.get("format", {})
+    if not isinstance(format_info, dict):
+        format_info = {}
+    try:
+        duration = float(format_info.get("duration"))
+    except (TypeError, ValueError) as error:
+        raise RuntimeError("输入文件缺少有效时长") from error
+    if not math.isfinite(duration) or duration <= 0:
+        raise RuntimeError("输入文件缺少有效时长")
+
+    tags = _normalized_tags(audio_stream)
+    tags.update(_normalized_tags(format_info))
+    return AudioMetadata(
+        duration=duration,
+        title=tags.get("title"),
+        artist=tags.get("artist"),
+        cover_stream_index=_cover_stream_index(streams),
+        embedded_lyrics=_embedded_lyrics(tags),
+    )

mpup/pipeline.py

@@ -0,0 +1,305 @@
+"""Process audio files independently and summarize batch outcomes."""
+
+from __future__ import annotations
+
+from collections.abc import Callable, Sequence
+from dataclasses import dataclass
+from pathlib import Path
+from typing import Literal
+
+from mpup.background import render_background
+from mpup.config import TemplateConfig
+from mpup.cover import BatchCoverResolver
+from mpup.enriched_audio import enriched_mp3_path, write_enriched_mp3
+from mpup.lyrics import resolve_lyrics
+from mpup.metadata import AudioMetadata, probe_audio
+from mpup.remotion_bridge import RenderRequest, run_remotion_batch
+from mpup.video import publish_remotion_video
+from mpup.workspace import BatchWorkspace
+
+
+Status = Literal["success", "skipped", "failed"]
+ProbeFn = Callable[[Path, str], AudioMetadata]
+BackgroundRenderer = Callable[..., None]
+
+
+@dataclass(frozen=True)
+class SongResult:
+    input_path: Path
+    status: Status
+    message: str
+    background_path: Path | None = None
+    video_path: Path | None = None
+    cover_source: str | None = None
+    lyrics_source: str | None = None
+    warnings: tuple[str, ...] = ()
+    enriched_audio_path: Path | None = None
+
+
+@dataclass(frozen=True)
+class BatchResult:
+    results: tuple[SongResult, ...]
+
+    @property
+    def successes(self) -> tuple[SongResult, ...]:
+        return tuple(item for item in self.results if item.status == "success")
+
+    @property
+    def skipped(self) -> tuple[SongResult, ...]:
+        return tuple(item for item in self.results if item.status == "skipped")
+
+    @property
+    def failed(self) -> tuple[SongResult, ...]:
+        return tuple(item for item in self.results if item.status == "failed")
+
+    @property
+    def exit_code(self) -> int:
+        return 0 if len(self.successes) == len(self.results) else 1
+
+
+@dataclass(frozen=True)
+class ProgressEvent:
+    """A visible processing milestone for one song or the entire batch."""
+
+    stage: str
+    input_path: Path | None = None
+    status: Status | None = None
+
+
+ProgressReporter = Callable[[ProgressEvent], None]
+
+
+def _report(
+    reporter: ProgressReporter,
+    stage: str,
+    input_path: Path | None = None,
+    status: Status | None = None,
+) -> None:
+    reporter(ProgressEvent(stage, input_path, status))
+
+
+def _missing_fields(metadata: AudioMetadata) -> list[str]:
+    missing: list[str] = []
+    if not metadata.title:
+        missing.append("title")
+    if not metadata.artist:
+        missing.append("artist")
+    return missing
+
+
+@dataclass(frozen=True)
+class _PreparedSong:
+    index: int
+    request: RenderRequest
+    background_path: Path
+    video_path: Path
+    cover_source: str
+    lyrics_source: str
+    warnings: tuple[str, ...]
+    enriched_audio_path: Path
+
+
+def process_batch(
+    audio_paths: Sequence[Path],
+    background_path: Path,
+    config: TemplateConfig,
+    output_dir: Path,
+    font_path: Path,
+    ffmpeg: str,
+    ffprobe: str,
+    overwrite: bool,
+    *,
+    probe: ProbeFn = probe_audio,
+    background_renderer: BackgroundRenderer = render_background,
+    node: str = "node",
+    cover_resolver: object | None = None,
+    lyrics_resolver: Callable[..., object] = resolve_lyrics,
+    batch_renderer: Callable[..., object] = run_remotion_batch,
+    publisher: Callable[..., None] = publish_remotion_video,
+    audio_writer: Callable[..., Path] = write_enriched_mp3,
+    workspace_factory: Callable[..., BatchWorkspace] = BatchWorkspace,
+    progress: ProgressReporter | None = None,
+) -> BatchResult:
+    """Preprocess songs, render one Remotion batch, then validate and publish."""
+    reporter = progress or (lambda _event: None)
+    _report(reporter, "batch_start")
+    output_dir.mkdir(parents=True, exist_ok=True)
+    resolver = cover_resolver or BatchCoverResolver()
+    slots: list[SongResult | None] = [None] * len(audio_paths)
+    prepared: list[_PreparedSong] = []
+    with workspace_factory(output_dir) as workspace:
+        renders_dir = workspace.root / "renders"
+        renders_dir.mkdir()
+        for index, audio_path in enumerate(audio_paths):
+            job_id = f"song-{index + 1:04d}"
+            try:
+                _report(reporter, "metadata", audio_path)
+                metadata = probe(audio_path, ffprobe)
+                missing = _missing_fields(metadata)
+                if missing:
+                    slots[index] = SongResult(
+                        audio_path,
+                        "skipped",
+                        f"缺少文件头字段：{', '.join(missing)}",
+                    )
+                    _report(reporter, "completed", audio_path, "skipped")
+                    continue
+
+                enriched_audio_path = enriched_mp3_path(
+                    audio_path,
+                    metadata.title,
+                    metadata.artist,
+                )
+                video_output = output_dir / f"{enriched_audio_path.stem}.mp4"
+                if video_output.exists() and not overwrite:
+                    slots[index] = SongResult(
+                        audio_path,
+                        "skipped",
+                        f"视频已存在：{video_output}",
+                        video_path=video_output,
+                        enriched_audio_path=enriched_audio_path
+                    )
+                    _report(reporter, "completed", audio_path, "skipped")
+                    continue
+
+                _report(reporter, "cover", audio_path)
+                cover = resolver.resolve(
+                    audio_path,
+                    metadata,
+                    workspace.root / "covers" / f"{job_id}.png",
+                    ffmpeg=ffmpeg,
+                )
+                _report(reporter, "lyrics", audio_path)
+                lyrics = lyrics_resolver(audio_path, metadata)
+                if not enriched_audio_path.exists():
+                    _report(reporter, "enriched_audio", audio_path)
+                    enriched_audio_path = audio_writer(
+                        audio_path,
+                        metadata.title,
+                        metadata.artist,
+                        cover.cover_path,
+                        lyrics.cues,
+                        ffmpeg=ffmpeg,
+                        overwrite=False,
+                    )
+                background_output = output_dir / f"{enriched_audio_path.stem}-background.png"
+                if not background_output.exists():
+                    _report(reporter, "background", audio_path)
+                    background_renderer(
+                        background_path,
+                        background_output,
+                        config,
+                        metadata.title,
+                        metadata.artist,
+                        font_path,
+                        False,
+                    )
+                _report(reporter, "render_prepare", audio_path)
+                job = workspace.stage_job(
+                    job_id,
+                    enriched_audio_path,
+                    background_path,
+                    cover.cover_path,
+                    font_path,
+                    metadata,
+                    lyrics.cues,
+                )
+                request = RenderRequest(job, renders_dir / f"{job_id}.mp4")
+                prepared.append(
+                    _PreparedSong(
+                        index,
+                        request,
+                        background_output,
+                        video_output,
+                        cover.source,
+                        lyrics.source,
+                        tuple(cover.warnings) + tuple(lyrics.warnings),
+                        enriched_audio_path,
+                    )
+                )
+            except Exception as error:
+                slots[index] = SongResult(audio_path, "failed", str(error))
+                _report(reporter, "completed", audio_path, "failed")
+
+        if prepared:
+            try:
+                for item in prepared:
+                    _report(reporter, "remotion", audio_paths[item.index])
+                outcomes = batch_renderer(
+                    tuple(item.request for item in prepared),
+                    workspace.public_dir,
+                    node=node,
+                )
+                outcome_by_id = {outcome.job_id: outcome for outcome in outcomes}
+            except Exception as error:
+                outcome_by_id = {}
+                process_error = str(error)
+            else:
+                process_error = None
+
+            for item in prepared:
+                audio_path = audio_paths[item.index]
+                outcome = outcome_by_id.get(item.request.job.job_id)
+                if process_error is not None:
+                    slots[item.index] = SongResult(
+                        audio_path,
+                        "failed",
+                        process_error,
+                        item.background_path,
+                        cover_source=item.cover_source,
+                        lyrics_source=item.lyrics_source,
+                        warnings=item.warnings,
+                    )
+                    continue
+                if outcome is None or outcome.status == "failed":
+                    message = (
+                        "Remotion 未返回该歌曲的渲染结果"
+                        if outcome is None
+                        else outcome.error or "Remotion 渲染失败"
+                    )
+                    slots[item.index] = SongResult(
+                        audio_path,
+                        "failed",
+                        message,
+                        item.background_path,
+                        cover_source=item.cover_source,
+                        lyrics_source=item.lyrics_source,
+                        warnings=item.warnings,
+                    )
+                    continue
+                try:
+                    _report(reporter, "publish", audio_path)
+                    publisher(
+                        outcome.output_path,
+                        item.video_path,
+                        ffmpeg,
+                        ffprobe,
+                        overwrite,
+                    )
+                    item.background_path.unlink(missing_ok=True)
+                    slots[item.index] = SongResult(
+                        audio_path,
+                        "success",
+                        "生成完成",
+                        item.background_path,
+                        item.video_path,
+                        item.cover_source,
+                        item.lyrics_source,
+                        item.warnings,
+                        item.enriched_audio_path,
+                    )
+                except Exception as error:
+                    slots[item.index] = SongResult(
+                        audio_path,
+                        "failed",
+                        str(error),
+                        item.background_path,
+                        cover_source=item.cover_source,
+                        lyrics_source=item.lyrics_source,
+                        warnings=item.warnings,
+                    )
+                _report(reporter, "completed", audio_path, slots[item.index].status)
+
+    result = BatchResult(tuple(item for item in slots if item is not None))
+    _report(reporter, "batch_completed")
+    return result