mpup 0.1.0__py3-none-any.whl

mpup/remotion_bridge.py

@@ -0,0 +1,130 @@
+"""Invoke the Node Remotion batch renderer and map its JSON-line results."""
+
+from __future__ import annotations
+
+import json
+import subprocess
+import tempfile
+from collections.abc import Callable, Sequence
+from dataclasses import dataclass
+from pathlib import Path
+from typing import Literal
+
+from mpup.metadata import REMOTION_ENTRY
+from mpup.render_job import RenderJob
+
+
+RENDERER_SCRIPT = REMOTION_ENTRY.parents[1] / "render-batch.mjs"
+Runner = Callable[..., subprocess.CompletedProcess[str]]
+RenderStatus = Literal["success", "failed"]
+
+
+@dataclass(frozen=True)
+class RenderRequest:
+    job: RenderJob
+    output_path: Path
+
+
+@dataclass(frozen=True)
+class RenderOutcome:
+    job_id: str
+    status: RenderStatus
+    output_path: Path
+    error: str | None = None
+
+
+def _bounded(value: object) -> str:
+    text = str(value).strip()
+    return text[-2000:]
+
+
+def run_remotion_batch(
+    requests: Sequence[RenderRequest],
+    public_dir: Path,
+    *,
+    node: str = "node",
+    renderer_script: Path = RENDERER_SCRIPT,
+    composition_entry: Path = REMOTION_ENTRY,
+    runner: Runner = subprocess.run,
+) -> tuple[RenderOutcome, ...]:
+    """Render one manifest with Node and preserve the input request order."""
+    if not requests:
+        return ()
+
+    public_dir.parent.mkdir(parents=True, exist_ok=True)
+    manifest_path: Path | None = None
+    try:
+        manifest = {
+            "entryPoint": str(composition_entry.resolve()),
+            "publicDir": str(public_dir.resolve()),
+            "jobs": [
+                {
+                    "props": request.job.to_dict(),
+                    "outputPath": str(request.output_path.resolve()),
+                }
+                for request in requests
+            ],
+        }
+        with tempfile.NamedTemporaryFile(
+            mode="w",
+            encoding="utf-8",
+            dir=public_dir.parent,
+            prefix="manifest-",
+            suffix=".json",
+            delete=False,
+        ) as temporary:
+            manifest_path = Path(temporary.name)
+            json.dump(manifest, temporary, ensure_ascii=False, separators=(",", ":"))
+
+        command = [node, str(renderer_script), str(manifest_path)]
+        result = runner(command, capture_output=True, text=True, check=False)
+        if result.returncode != 0:
+            detail = _bounded(result.stderr) or "Node 渲染进程异常退出"
+            raise RuntimeError(f"Remotion 批次渲染失败：{detail}")
+
+        expected = {request.job.job_id: request for request in requests}
+        parsed: dict[str, RenderOutcome] = {}
+        for line in result.stdout.splitlines():
+            if not line.strip():
+                continue
+            try:
+                value = json.loads(line)
+            except json.JSONDecodeError as error:
+                raise RuntimeError("Remotion 返回了无效 JSON 行") from error
+            if not isinstance(value, dict):
+                raise RuntimeError("Remotion 返回了无效 JSON 结果")
+            job_id = value.get("jobId")
+            status = value.get("status")
+            if (
+                not isinstance(job_id, str)
+                or job_id not in expected
+                or job_id in parsed
+                or status not in ("success", "failed")
+            ):
+                raise RuntimeError("Remotion 返回了未知、重复或无效的歌曲结果")
+            request = expected[job_id]
+            error_text = None
+            if status == "failed":
+                error_text = _bounded(value.get("error") or "Remotion 渲染失败")
+            parsed[job_id] = RenderOutcome(
+                job_id,
+                status,
+                request.output_path,
+                error_text,
+            )
+
+        outcomes: list[RenderOutcome] = []
+        for request in requests:
+            outcome = parsed.get(request.job.job_id)
+            if outcome is None:
+                outcome = RenderOutcome(
+                    request.job.job_id,
+                    "failed",
+                    request.output_path,
+                    "Remotion 未返回该歌曲的渲染结果",
+                )
+            outcomes.append(outcome)
+        return tuple(outcomes)
+    finally:
+        if manifest_path is not None:
+            manifest_path.unlink(missing_ok=True)

mpup/render_job.py

@@ -0,0 +1,118 @@
+"""Shared JSON contract for Python staging and the Remotion composition."""
+
+from __future__ import annotations
+
+import re
+from dataclasses import dataclass
+from pathlib import PurePosixPath
+from typing import Any
+
+from mpup.lyrics import LyricCue
+
+
+_JOB_ID = re.compile(r"^[A-Za-z0-9_-]+$")
+_FIELDS = {
+    "jobId",
+    "audioPath",
+    "backgroundPath",
+    "coverPath",
+    "fontPath",
+    "title",
+    "artist",
+    "durationMs",
+    "lyrics",
+}
+
+
+def _public_path(field: str, value: object, job_id: str) -> str:
+    if not isinstance(value, str) or not value or "\\" in value:
+        raise ValueError(f"{field} 必须是安全的 public 相对路径")
+    path = PurePosixPath(value)
+    if path.is_absolute() or any(part in (".", "..") for part in path.parts):
+        raise ValueError(f"{field} 必须是安全的 public 相对路径")
+    if len(path.parts) < 3 or path.parts[:2] != ("jobs", job_id):
+        raise ValueError(f"{field} 必须位于 jobs/{job_id}/ 内")
+    return value
+
+
+def _required_text(field: str, value: object) -> str:
+    if not isinstance(value, str) or not value.strip():
+        raise ValueError(f"{field} 不能为空")
+    return value
+
+
+def _cue(value: object) -> LyricCue:
+    if not isinstance(value, dict) or set(value) != {
+        "text",
+        "startMs",
+        "endMs",
+        "timestampMs",
+        "confidence",
+    }:
+        raise ValueError("lyrics cue 字段无效")
+    text = _required_text("lyrics.text", value["text"])
+    start = value["startMs"]
+    end = value["endMs"]
+    if type(start) is not int or type(end) is not int or start < 0 or end <= start:
+        raise ValueError("lyrics cue 时间无效")
+    if value["timestampMs"] is not None or value["confidence"] is not None:
+        raise ValueError("lyrics cue 可空字段无效")
+    return LyricCue(text, start, end)
+
+
+@dataclass(frozen=True)
+class RenderJob:
+    job_id: str
+    audio_path: str
+    background_path: str
+    cover_path: str | None
+    font_path: str
+    title: str
+    artist: str
+    duration_ms: int
+    lyrics: tuple[LyricCue, ...] | None
+
+    @classmethod
+    def from_dict(cls, payload: object) -> RenderJob:
+        if not isinstance(payload, dict) or set(payload) != _FIELDS:
+            raise ValueError("RenderJob JSON 字段不完整或包含未知字段")
+        job_id = _required_text("jobId", payload["jobId"])
+        if _JOB_ID.fullmatch(job_id) is None:
+            raise ValueError("jobId 只能包含字母、数字、下划线和连字符")
+        duration = payload["durationMs"]
+        if type(duration) is not int or duration <= 0:
+            raise ValueError("durationMs 必须是正整数")
+        cover_value = payload["coverPath"]
+        if cover_value is not None:
+            cover_value = _public_path("coverPath", cover_value, job_id)
+        lyrics_value = payload["lyrics"]
+        if lyrics_value is not None and not isinstance(lyrics_value, list):
+            raise ValueError("lyrics 必须是数组或 null")
+        return cls(
+            job_id=job_id,
+            audio_path=_public_path("audioPath", payload["audioPath"], job_id),
+            background_path=_public_path(
+                "backgroundPath", payload["backgroundPath"], job_id
+            ),
+            cover_path=cover_value,
+            font_path=_public_path("fontPath", payload["fontPath"], job_id),
+            title=_required_text("title", payload["title"]),
+            artist=_required_text("artist", payload["artist"]),
+            duration_ms=duration,
+            lyrics=None if lyrics_value is None else tuple(_cue(item) for item in lyrics_value),
+        )
+
+    def to_dict(self) -> dict[str, Any]:
+        return {
+            "jobId": self.job_id,
+            "audioPath": self.audio_path,
+            "backgroundPath": self.background_path,
+            "coverPath": self.cover_path,
+            "fontPath": self.font_path,
+            "title": self.title,
+            "artist": self.artist,
+            "durationMs": self.duration_ms,
+            "lyrics": None
+            if self.lyrics is None
+            else [cue.as_caption() for cue in self.lyrics],
+        }

mpup/video.py

@@ -0,0 +1,160 @@
+"""Validate and publish Remotion-generated song videos."""
+
+from __future__ import annotations
+
+import json
+import math
+import os
+import subprocess
+import tempfile
+from collections.abc import Callable
+from pathlib import Path
+from typing import Any
+
+
+Runner = Callable[..., subprocess.CompletedProcess[str]]
+
+
+def build_faststart_command(
+    rendered_path: Path,
+    output_path: Path,
+    ffmpeg: str = "ffmpeg",
+) -> list[str]:
+    """Build a stream-copy remux command that moves MP4 metadata to the front."""
+    return [
+        ffmpeg,
+        "-hide_banner",
+        "-loglevel",
+        "error",
+        "-y",
+        "-i",
+        str(rendered_path),
+        "-map",
+        "0",
+        "-c",
+        "copy",
+        "-movflags",
+        "+faststart",
+        str(output_path),
+    ]
+
+
+def _probe_payload(
+    path: Path,
+    ffprobe: str,
+    runner: Runner,
+) -> dict[str, Any]:
+    command = [
+        ffprobe,
+        "-v",
+        "error",
+        "-show_entries",
+        "stream=codec_type,codec_name,width,height,pix_fmt,duration",
+        "-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"输出验证失败：{detail[-2000:]}")
+    try:
+        payload = json.loads(result.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 _stream_duration(stream: dict[str, Any], kind: str) -> float:
+    try:
+        duration = float(stream.get("duration"))
+    except (TypeError, ValueError) as error:
+        raise RuntimeError(f"输出验证失败：{kind}流缺少有效时长") from error
+    if not math.isfinite(duration) or duration <= 0:
+        raise RuntimeError(f"输出验证失败：{kind}流缺少有效时长")
+    return duration
+
+
+def validate_video(
+    path: Path,
+    ffprobe: str = "ffprobe",
+    runner: Runner = subprocess.run,
+) -> None:
+    """Require a compatible 1080P H.264/AAC MP4."""
+    payload = _probe_payload(path, ffprobe, runner)
+    raw_streams = payload.get("streams", [])
+    streams = raw_streams if isinstance(raw_streams, list) else []
+    video = next(
+        (
+            stream
+            for stream in streams
+            if isinstance(stream, dict) and stream.get("codec_type") == "video"
+        ),
+        None,
+    )
+    audio = next(
+        (
+            stream
+            for stream in streams
+            if isinstance(stream, dict) and stream.get("codec_type") == "audio"
+        ),
+        None,
+    )
+    if video is None:
+        raise RuntimeError("输出验证失败：缺少 H.264 视频流")
+    if video.get("codec_name") != "h264":
+        raise RuntimeError("输出验证失败：视频必须使用 H.264")
+    if video.get("width") != 1920 or video.get("height") != 1080:
+        raise RuntimeError("输出验证失败：视频尺寸必须为 1920x1080")
+    if video.get("pix_fmt") != "yuv420p":
+        raise RuntimeError(
+            "输出验证失败：像素格式必须为 yuv420p，"
+            f"实际为 {video.get('pix_fmt')!r}"
+        )
+    if audio is None or audio.get("codec_name") != "aac":
+        raise RuntimeError("输出验证失败：音频必须使用 AAC")
+
+    video_duration = _stream_duration(video, "视频")
+    audio_duration = _stream_duration(audio, "音频")
+    if abs(video_duration - audio_duration) > 0.1:
+        raise RuntimeError("输出验证失败：音画时长差必须不超过 0.1 秒")
+
+
+def publish_remotion_video(
+    rendered_path: Path,
+    output_path: Path,
+    ffmpeg: str,
+    ffprobe: str,
+    overwrite: bool = False,
+    runner: Runner = subprocess.run,
+) -> None:
+    """Fast-start remux, validate, and atomically publish a Remotion MP4."""
+    if output_path.exists() and not overwrite:
+        raise FileExistsError(f"视频已存在：{output_path}")
+    if not rendered_path.is_file():
+        raise RuntimeError(f"Remotion 未生成临时视频：{rendered_path}")
+    output_path.parent.mkdir(parents=True, exist_ok=True)
+    temporary = tempfile.NamedTemporaryFile(
+        prefix=f".{output_path.stem}.",
+        suffix=".tmp.mp4",
+        dir=output_path.parent,
+        delete=False,
+    )
+    temporary_path = Path(temporary.name)
+    temporary.close()
+    try:
+        result = runner(
+            build_faststart_command(rendered_path, temporary_path, ffmpeg),
+            capture_output=True,
+            text=True,
+            check=False,
+        )
+        if result.returncode != 0:
+            detail = result.stderr.strip() or "未知错误"
+            raise RuntimeError(f"FFmpeg fast-start 封装失败：{detail[-2000:]}")
+        validate_video(temporary_path, ffprobe, runner)
+        os.replace(temporary_path, output_path)
+    finally:
+        temporary_path.unlink(missing_ok=True)

mpup/workspace.py

@@ -0,0 +1,92 @@
+"""Lifecycle-managed public asset workspace for a Remotion batch."""
+
+from __future__ import annotations
+
+import json
+import shutil
+import tempfile
+from collections.abc import Callable, Sequence
+from pathlib import Path
+
+from mpup.lyrics import LyricCue
+from mpup.metadata import AudioMetadata
+from mpup.render_job import RenderJob
+
+
+Copier = Callable[[Path, Path], object]
+
+
+class BatchWorkspace:
+    """Stage per-song assets and remove the whole temporary batch on exit."""
+
+    def __init__(self, output_dir: Path, *, copier: Copier = shutil.copyfile) -> None:
+        self._output_dir = output_dir
+        self._copier = copier
+        self._temporary: tempfile.TemporaryDirectory[str] | None = None
+
+    def __enter__(self) -> BatchWorkspace:
+        self._output_dir.parent.mkdir(parents=True, exist_ok=True)
+        self._temporary = tempfile.TemporaryDirectory(
+            prefix=".mpup-v2-",
+            dir=self._output_dir.parent,
+        )
+        self.root = Path(self._temporary.name)
+        self.public_dir = self.root / "public"
+        (self.public_dir / "jobs").mkdir(parents=True)
+        return self
+
+    def __exit__(self, *_error: object) -> None:
+        if self._temporary is not None:
+            self._temporary.cleanup()
+            self._temporary = None
+
+    def stage_job(
+        self,
+        job_id: str,
+        audio_path: Path,
+        background_path: Path,
+        cover_path: Path | None,
+        font_path: Path,
+        metadata: AudioMetadata,
+        lyrics: Sequence[LyricCue] | None,
+    ) -> RenderJob:
+        """Copy one song's assets into an isolated job and write its JSON props."""
+        if self._temporary is None:
+            raise RuntimeError("BatchWorkspace 必须在 with 语句中使用")
+
+        job_dir = self.public_dir / "jobs" / job_id
+        try:
+            job_dir.mkdir(parents=False)
+            audio_name = f"audio{audio_path.suffix.lower()}"
+            background_name = f"background{background_path.suffix.lower()}"
+            font_name = f"font{font_path.suffix.lower()}"
+            self._copier(audio_path, job_dir / audio_name)
+            self._copier(background_path, job_dir / background_name)
+            staged_cover: str | None = None
+            if cover_path is not None:
+                self._copier(cover_path, job_dir / "cover.png")
+                staged_cover = f"jobs/{job_id}/cover.png"
+            self._copier(font_path, job_dir / font_name)
+
+            job = RenderJob(
+                job_id=job_id,
+                audio_path=f"jobs/{job_id}/{audio_name}",
+                background_path=f"jobs/{job_id}/{background_name}",
+                cover_path=staged_cover,
+                font_path=f"jobs/{job_id}/{font_name}",
+                title=metadata.title or "",
+                artist=metadata.artist or "",
+                duration_ms=round(metadata.duration * 1000),
+                lyrics=None if lyrics is None else tuple(lyrics),
+            )
+            # Reuse the deserializer as the single Python-side contract validator.
+            job = RenderJob.from_dict(job.to_dict())
+            (job_dir / "job.json").write_text(
+                json.dumps(job.to_dict(), ensure_ascii=False, separators=(",", ":")),
+                encoding="utf-8",
+            )
+            return job
+        except BaseException:
+            if job_dir.exists():
+                shutil.rmtree(job_dir)
+            raise

mpup-0.1.0.dist-info/METADATA

@@ -0,0 +1,135 @@
+Metadata-Version: 2.5
+Name: mpup
+Version: 0.1.0
+Summary: Generate song background images and MP4 videos from audio metadata
+Requires-Python: >=3.11
+Requires-Dist: pillow<13,>=11
+Requires-Dist: tqdm<5,>=4.67
+Description-Content-Type: text/markdown
+
+# MPUp
+
+MPUp 从 MP3/M4A 文件头读取歌名和歌手，解析封面与同步歌词，先在原音频目录写入带元数据的 `<歌名>-<歌手>.mp3`，再用该 MP3 作为 Remotion 的视频音轨。旧版 `*-background.png` 仅作为可复用的中间产物，视频成功发布后会删除。
+
+## 环境与安装
+
+- Python 3.11 或更高版本
+- [uv](https://docs.astral.sh/uv/)
+- Node.js 22 或更高版本与 npm
+- FFmpeg 与 FFprobe（需要 H.264/AAC 支持）
+- 带中文字符的 TrueType/OpenType 字体；也可通过 `--font` 显式指定
+
+```bash
+uv sync
+cd renderer
+npm ci
+cd ..
+```
+
+所有 `remotion` 与 `@remotion/*` 包都锁定为同一版本。首次渲染会准备 Remotion 使用的 Chromium，下载体积和首次启动时间会明显高于后续批次；缓存位于项目 `.remotion/`。
+
+## 使用
+
+```bash
+uv run mpup assets \
+  --background assets/background.png \
+  --config assets/bg-cfg.json \
+  --output-dir output
+
+uv run mpup assets/春.m4a --output-dir output
+```
+
+完整参数：
+
+```text
+mpup INPUT
+  [--background PATH]
+  [--config PATH]
+  [--output-dir PATH]
+  [--font PATH]
+  [--overwrite]
+```
+
+默认背景为 `assets/background.png`，默认布局为 `assets/bg-cfg.json`，默认输出目录为 `output`。增强 MP3 和背景 PNG 已存在时会直接复用；背景 PNG 会在对应视频成功发布后删除。已有最终视频不会被覆盖，需要重新生成视频时添加 `--overwrite`。
+
+## 音频元数据
+
+每个音频必须在 MP3 ID3 或 M4A 容器标签中同时包含 `title`（歌名）和 `artist`（歌手）。MPUp 不会根据文件名猜测；缺少字段的歌曲会被跳过，其余歌曲继续。支持 `.mp3` 和 `.m4a`，目录模式只扫描直接子文件并稳定排序。
+
+命令行会在缺少 FFmpeg、FFprobe、Node.js 或 Remotion 渲染入口时于批次开始前报错。
+
+## V2 画面布局
+
+- 画布固定为 1920×1080、30 fps；默认背景铺满全帧。
+- 有封面时保持原比例，优先占满 880 px 高度。宽图可跨过半屏，但最大宽度为 1280 px（总画面三分之二），不会裁切或拉伸。
+- 右侧内容固定在 x=1080–1800。歌名位于上方，歌手在其右下方轻微错位；遮罩保证封面跨中线时文字仍可读。
+- 歌词窗口固定在 y=300–840，当前句居中高亮，相邻句降低透明度，切句约用 0.35 秒逐帧移动。
+- 没有同步歌词时布局不移动，只在歌词窗口中央显示“暂无歌词”。
+
+## 封面来源与 iTunes 回退
+
+封面按以下固定顺序解析，并写入生成 MP3 的 ID3 attached-picture：
+
+1. 音频 attached-picture 内嵌封面；
+2. 现有 `search_track(title, artist)` iTunes 查询返回的 600×600 artwork；
+3. 默认背景，不生成空白封面卡片。
+
+同一批次会按规范化歌名/歌手缓存查询，并按 artwork URL 缓存下载。iTunes 查询、限流重试最终失败、下载超过 10 MiB 或图片无法完整解码时，只输出警告并回退默认背景，不会把歌曲标记为失败。内嵌封面有效时不会访问 iTunes。
+
+iTunes 接口遇到 HTTP `429 Too Many Requests` 时最多重试 3 次，按 1、2、4 秒退避。详见 [Apple iTunes Search API 文档](https://performance-partners.apple.com/resources/documentation/itunes-store-web-service-search-api/)。
+
+## 同步歌词
+
+歌词按“同目录同主名 `.lrc`/`.LRC`、音频内嵌歌词、可注入远程 Provider”解析。默认 Provider 是空实现，不访问歌词网络服务。解析到同步歌词后会写入生成 MP3 的 `syncedlyrics` 标签；没有同步歌词时不会写入该标签。
+
+LRC 支持 `[mm:ss]`、两位/三位小数、一行多个时间戳和 `[offset:+/-毫秒]`；本地文件依次支持 UTF-8、UTF-8 BOM 与 GB18030。无时间戳纯文本不会被伪造成同步歌词。最后一句最长显示 6 秒且不会超过音频结尾。
+
+## 输出与媒体规格
+
+输入 `assets/春.m4a`（歌名“春”、歌手“黄龄”）会生成：
+
+```text
+assets/春-黄龄.mp3
+output/春-黄龄.mp4
+```
+
+渲染期间会生成 `output/春-黄龄-background.png` 作为可复用的中间文件；MP4 成功发布后会自动删除，渲染或发布失败时则保留，以便下次重试。
+
+背景 PNG 继续使用 `bg-cfg.json` 的旧版布局。V2 MP4 直接读取默认背景、封面、字体、歌词 props 和带元数据的 MP3。
+
+- H.264（CRF 20）
+- AAC
+- 1920×1080，30 fps，`yuv420p`
+- MP4 fast-start
+
+Remotion 先生成临时 MP4，随后 FFmpeg 使用 `-c copy -movflags +faststart` 封装，不重复编码。FFprobe 验证尺寸、编码、像素格式及不超过 0.1 秒的音画时长差后原子发布。失败或中断时会清理批次 public 工作集和临时媒体。
+
+## 批处理结果和退出码
+
+```text
+完成 assets/春.m4a -> assets/春-黄龄.mp3 -> output/春-黄龄.mp4（封面=itunes，歌词=local）
+警告 assets/啊.mp3：iTunes 封面查询失败：429 Too Many Requests
+完成：5，跳过：3，失败：0
+```
+
+- `0`：全部歌曲成功
+- `1`：至少一首歌曲跳过或失败，其余歌曲已继续
+- `2`：输入、配置、字体或工具错误导致批次无法开始
+- `130`：用户中断
+
+## 测试
+
+```bash
+uv run -m unittest discover -s tests -v
+cd renderer
+npm test
+npm run typecheck
+```
+
+真实集成测试会合成“内嵌封面 + 同名 LRC”“无封面 + 无歌词”“超宽内嵌封面”三类音频，批量生成 MP4，并校验关键帧布局、歌词切句、编解码、尺寸、像素格式、音画时长和临时文件清理。
+
+## 字体、许可与内容权利
+
+渲染会把选定字体暂存到每首歌曲的隔离目录，并在加载完成后测量文字。要获得可重复画面，请在不同机器显式传入同一字体文件。
+
+Remotion 使用自己的双层许可；商用前请根据组织类型和规模核对锁定版本附带的 `renderer/node_modules/remotion/LICENSE.md` 以及 [Remotion License](https://www.remotion.dev/license)。使用者还需自行确认音频、歌词、封面、iTunes artwork 和字体的下载、复制、合成与发布权利。

mpup-0.1.0.dist-info/RECORD

@@ -0,0 +1,21 @@
+mpup/__init__.py,sha256=o77gKDJG6GeysLgRFdS9JV9y-XY4WmU72DXyz6G5kc4,71
+mpup/__main__.py,sha256=Z3hULgGc5tGvs1YzlSaftKGDumxDxFzxbkz0smro088,78
+mpup/background.py,sha256=oS4kmr02aaDFtTnDSVX096NcXsYvbmiGOLiBZSuvhq4,4211
+mpup/cli.py,sha256=RufEqPEB4KROBavcWXK6VP4fE52YRI67wpElruyxPZ4,5269
+mpup/config.py,sha256=xmQSyAtiJxaSPyGZSHpHUGGITmQF32EjNLTdLDVSzyM,5877
+mpup/cover.py,sha256=eUsKTX6wvEAoyRzJ8L7vCGKyNk0PKRqaRdhsk1FTJ3w,8111
+mpup/discovery.py,sha256=qkxaqUlkiPZPh_RSqjKwCyqDNQ1sYd3FuV3Gu9Wq1iw,1121
+mpup/enriched_audio.py,sha256=OtBrGqzbzTB9SlOSWK5tCqcDovJFH1PbQ6dlOQZt8U0,4529
+mpup/itunes.py,sha256=wtb2iw8cw9jqEj0SwIsp1q5tPvEkAa6cqtFTykF2JJo,3458
+mpup/lyrics.py,sha256=NsBUPippA-b7IBCVyXjKs1_oODzk0JrHyHtWGRGx_yQ,6319
+mpup/lyrics_from_qq.py,sha256=s588DukOCPsZr5pQfiJYqNKlCpXSjkKYTnIp91fWprM,3093
+mpup/metadata.py,sha256=kz49S5HNHDTe_3fEdRKAxue1jqfbt9ZAUdIacDZu8Ao,5114
+mpup/pipeline.py,sha256=gda8EhMstzAiBb79cfKh-L2gEKq5T_Mlew_ETLFDVwE,11239
+mpup/remotion_bridge.py,sha256=pZK73CweMRHOXmHNhPzKKdLPHbNCO4Ouu6CSIIaFJd8,4296
+mpup/render_job.py,sha256=ACEX1IiNbF7ERWNFDJzy04N2-uhvvL4-Yrn2dhYsymE,4138
+mpup/video.py,sha256=9lj-Xnj7JqgQMPfjQronoIfYEWrxloLYIze-2hOOj0k,5086
+mpup/workspace.py,sha256=ubMVUCSxXAvkjky02rW_SunCxwoUMaxvQY8Try7wlLc,3418
+mpup-0.1.0.dist-info/METADATA,sha256=JKdP5lH6XBtcX_S8ycPi-Wt0q7CbKmJMG06xYDQvMKM,6357
+mpup-0.1.0.dist-info/WHEEL,sha256=zOwg4jB6zX2kU910N-cMawjivD6tO8NEWvE12je1bVk,87
+mpup-0.1.0.dist-info/entry_points.txt,sha256=kVBcRx8pJdkJ3wDExZPb-Lpu4laRKVqvDdUkGRCp9XU,45
+mpup-0.1.0.dist-info/RECORD,,

mpup-0.1.0.dist-info/WHEEL

@@ -0,0 +1,4 @@
+Wheel-Version: 1.0
+Generator: hatchling 1.32.0
+Root-Is-Purelib: true
+Tag: py3-none-any

mpup-0.1.0.dist-info/entry_points.txt

@@ -0,0 +1,2 @@
+[console_scripts]
+mpup = mpup.cli:entrypoint