sub2pod 0.2.0__tar.gz

sub2pod-0.2.0/PKG-INFO

@@ -0,0 +1,128 @@
+Metadata-Version: 2.3
+Name: sub2pod
+Version: 0.2.0
+Summary: Convert ytdl-sub output directories into podcast RSS feeds.
+Author: Marvin8
+Author-email: Marvin8 <marvin8@tuta.io>
+License: AGPL-3.0-or-later
+Requires-Dist: cyclopts~=4.16.0
+Requires-Dist: lxml~=6.1.1
+Requires-Python: >=3.12
+Project-URL: Issues, https://codeberg.org/marvin8/sub2pod/issues
+Project-URL: Source, https://codeberg.org/marvin8/sub2pod
+Project-URL: Changelog, https://codeberg.org/marvin8/sub2pod/raw/branch/main/CHANGELOG.md
+Description-Content-Type: text/markdown
+
+# sub2pod
+
+[![Licence: AGPL-3.0-or-later](https://img.shields.io/badge/licence-AGPL--3.0--or--later-blue)](LICENCE)
+[![Python 3.12+](https://img.shields.io/badge/python-3.12%2B-blue)](https://www.python.org/)
+[![Woodpecker CI](https://ci.codeberg.org/api/badges/marvin8/sub2pod/status.svg)](https://ci.codeberg.org/marvin8/sub2pod)
+[![Codestyle: Ruff](https://img.shields.io/badge/codestyle-ruff-green)](https://docs.astral.sh/ruff/)
+
+Convert [ytdl-sub](https://github.com/jmbannon/ytdl-sub) output directories into
+standards-compliant podcast RSS feeds. Point it at a directory full of downloaded
+audio, and it writes `feed.xml` into each channel subdirectory — ready to serve or
+submit to podcast directories.
+
+## What it does
+
+- Reads Kodi `tvshow.nfo` and per-episode `.nfo` sidecars produced by ytdl-sub
+- Discovers date-prefixed audio files (`YYYY-MM-DD - <title>.<ext>`) in each channel directory
+- Generates RSS 2.0 + iTunes namespace `feed.xml` per channel
+- Emits correct MIME types for `.opus`, `.mp3`, and `.m4a` enclosures
+- Produces an `opml.xml` index at the root level for one-click feed import
+- Falls back to filename parsing when `.nfo` sidecars are absent
+
+## What it does not do
+
+- No download or subscription management (that's ytdl-sub's job)
+- No web server — feed files are static XML; serve them however you like
+- No podcast client or player
+
+## Installation
+
+### From PyPI
+
+```bash
+pip install sub2pod
+```
+
+### From source
+
+```bash
+git clone https://codeberg.org/marvin8/sub2pod.git
+cd sub2pod
+uv sync
+uv run sub2pod --help
+```
+
+## Usage
+
+```bash
+sub2pod /path/to/ytdl-sub/output https://podcast.example.com
+```
+
+This walks the parent directory looking for subdirectories containing `tvshow.nfo`
+and generates:
+
+| Output | Location | Description |
+|--------|----------|-------------|
+| `feed.xml` | Each channel subdirectory | RSS 2.0 + iTunes podcast feed |
+| `opml.xml` | Parent directory root | OPML index of all feeds |
+
+### Options
+
+```
+--dry-run    Print paths without writing any files
+--verbose    Log per-episode details during generation
+```
+
+### Example
+
+```bash
+# After ytdl-sub downloads new episodes:
+sub2pod /home/NAS/ytdl-sub/mark/podcast https://podcasts.example.com
+
+# Preview without writing:
+sub2pod /home/NAS/ytdl-sub/mark/podcast https://podcasts.example.com --dry-run
+
+# See what's being generated:
+sub2pod /home/NAS/ytdl-sub/mark/podcast https://podcasts.example.com --verbose
+```
+
+## How it works
+
+1. **Channel discovery** — Walks the parent directory for subdirectories containing `tvshow.nfo`
+2. **Metadata parsing** — Reads channel title and genre from `tvshow.nfo`; reads per-episode title, description, date, runtime, and source URL from `.nfo` sidecars
+3. **Episode discovery** — Finds all date-prefixed audio files, pairs them with their `.nfo` sidecars, sorts newest-first
+4. **Feed generation** — Builds RSS 2.0 XML with iTunes podcast namespace elements (`<itunes:image>`, `<itunes:duration>`, `<itunes:category>`), writes `feed.xml`
+5. **OPML index** — Writes `opml.xml` at the root listing every channel feed
+
+### Input format
+
+Each channel directory is expected to contain:
+
+```
+Links with Friends/
+├── tvshow.nfo              ← Channel metadata (title, genre)
+├── poster.jpg              ← Podcast artwork → <itunes:image>
+├── 2026-05-19 - Episode Title.opus   ← Audio file
+├── 2026-05-19 - Episode Title.nfo    ← Episode metadata sidecar
+└── 2026-05-19 - Episode Title-thumb.jpg  ← Episode thumbnail
+```
+
+## Documentation
+
+- [ytdl-sub Integration Guide](docs/ytdl-sub-integration.md) — Configuring ytdl-sub
+  to produce sub2pod-compatible output: NFO tags, episode thumbnails, trigger
+  strategies, and Opus MIME type guidance.
+
+## Licence
+
+Copyright (C) 2026 Marvin8
+
+This program is free software: you can redistribute it and/or modify it under
+the terms of the GNU Affero General Public License as published by the Free
+Software Foundation, either version 3 of the License, or (at your option) any
+later version.

sub2pod-0.2.0/README.md

@@ -0,0 +1,113 @@
+# sub2pod
+
+[![Licence: AGPL-3.0-or-later](https://img.shields.io/badge/licence-AGPL--3.0--or--later-blue)](LICENCE)
+[![Python 3.12+](https://img.shields.io/badge/python-3.12%2B-blue)](https://www.python.org/)
+[![Woodpecker CI](https://ci.codeberg.org/api/badges/marvin8/sub2pod/status.svg)](https://ci.codeberg.org/marvin8/sub2pod)
+[![Codestyle: Ruff](https://img.shields.io/badge/codestyle-ruff-green)](https://docs.astral.sh/ruff/)
+
+Convert [ytdl-sub](https://github.com/jmbannon/ytdl-sub) output directories into
+standards-compliant podcast RSS feeds. Point it at a directory full of downloaded
+audio, and it writes `feed.xml` into each channel subdirectory — ready to serve or
+submit to podcast directories.
+
+## What it does
+
+- Reads Kodi `tvshow.nfo` and per-episode `.nfo` sidecars produced by ytdl-sub
+- Discovers date-prefixed audio files (`YYYY-MM-DD - <title>.<ext>`) in each channel directory
+- Generates RSS 2.0 + iTunes namespace `feed.xml` per channel
+- Emits correct MIME types for `.opus`, `.mp3`, and `.m4a` enclosures
+- Produces an `opml.xml` index at the root level for one-click feed import
+- Falls back to filename parsing when `.nfo` sidecars are absent
+
+## What it does not do
+
+- No download or subscription management (that's ytdl-sub's job)
+- No web server — feed files are static XML; serve them however you like
+- No podcast client or player
+
+## Installation
+
+### From PyPI
+
+```bash
+pip install sub2pod
+```
+
+### From source
+
+```bash
+git clone https://codeberg.org/marvin8/sub2pod.git
+cd sub2pod
+uv sync
+uv run sub2pod --help
+```
+
+## Usage
+
+```bash
+sub2pod /path/to/ytdl-sub/output https://podcast.example.com
+```
+
+This walks the parent directory looking for subdirectories containing `tvshow.nfo`
+and generates:
+
+| Output | Location | Description |
+|--------|----------|-------------|
+| `feed.xml` | Each channel subdirectory | RSS 2.0 + iTunes podcast feed |
+| `opml.xml` | Parent directory root | OPML index of all feeds |
+
+### Options
+
+```
+--dry-run    Print paths without writing any files
+--verbose    Log per-episode details during generation
+```
+
+### Example
+
+```bash
+# After ytdl-sub downloads new episodes:
+sub2pod /home/NAS/ytdl-sub/mark/podcast https://podcasts.example.com
+
+# Preview without writing:
+sub2pod /home/NAS/ytdl-sub/mark/podcast https://podcasts.example.com --dry-run
+
+# See what's being generated:
+sub2pod /home/NAS/ytdl-sub/mark/podcast https://podcasts.example.com --verbose
+```
+
+## How it works
+
+1. **Channel discovery** — Walks the parent directory for subdirectories containing `tvshow.nfo`
+2. **Metadata parsing** — Reads channel title and genre from `tvshow.nfo`; reads per-episode title, description, date, runtime, and source URL from `.nfo` sidecars
+3. **Episode discovery** — Finds all date-prefixed audio files, pairs them with their `.nfo` sidecars, sorts newest-first
+4. **Feed generation** — Builds RSS 2.0 XML with iTunes podcast namespace elements (`<itunes:image>`, `<itunes:duration>`, `<itunes:category>`), writes `feed.xml`
+5. **OPML index** — Writes `opml.xml` at the root listing every channel feed
+
+### Input format
+
+Each channel directory is expected to contain:
+
+```
+Links with Friends/
+├── tvshow.nfo              ← Channel metadata (title, genre)
+├── poster.jpg              ← Podcast artwork → <itunes:image>
+├── 2026-05-19 - Episode Title.opus   ← Audio file
+├── 2026-05-19 - Episode Title.nfo    ← Episode metadata sidecar
+└── 2026-05-19 - Episode Title-thumb.jpg  ← Episode thumbnail
+```
+
+## Documentation
+
+- [ytdl-sub Integration Guide](docs/ytdl-sub-integration.md) — Configuring ytdl-sub
+  to produce sub2pod-compatible output: NFO tags, episode thumbnails, trigger
+  strategies, and Opus MIME type guidance.
+
+## Licence
+
+Copyright (C) 2026 Marvin8
+
+This program is free software: you can redistribute it and/or modify it under
+the terms of the GNU Affero General Public License as published by the Free
+Software Foundation, either version 3 of the License, or (at your option) any
+later version.

sub2pod-0.2.0/pyproject.toml

@@ -0,0 +1,78 @@
+[build-system]
+requires = ["uv_build>=0.10.0,<0.12.0"]
+build-backend = "uv_build"
+
+[project]
+name = "sub2pod"
+version = "0.2.0"
+authors = [
+    { name = "Marvin8", email = "marvin8@tuta.io" },
+]
+description = "Convert ytdl-sub output directories into podcast RSS feeds."
+readme = "README.md"
+license = { text = "AGPL-3.0-or-later" }
+requires-python = ">=3.12"
+dependencies = [
+    "cyclopts~=4.16.0",
+    "lxml~=6.1.1",
+]
+
+[dependency-groups]
+dev = [
+    "bump-my-version~=1.3.0",
+    "complexipy~=5.6.1",
+    "deptry~=0.25.1",
+    "git-cliff~=2.13.1",
+    "nox-uv~=0.8.0",
+    "prek~=0.4.5",
+    "pysentry-rs~=0.4.6",
+    "ruff~=0.15.17",
+    "tryke~=0.0.29",
+    "ty~=0.0.49",
+    "uv~=0.11.21",
+    "zaojun~=1.6.0",
+]
+
+[project.scripts]
+sub2pod = "sub2pod.cli:app"
+
+[project.urls]
+Issues = "https://codeberg.org/marvin8/sub2pod/issues"
+Source = "https://codeberg.org/marvin8/sub2pod"
+Changelog = "https://codeberg.org/marvin8/sub2pod/raw/branch/main/CHANGELOG.md"
+
+[tool.ruff]
+line-length = 88
+
+[tool.ruff.lint]
+select = ["E", "F", "I", "UP", "B"]
+
+[tool.ruff.lint.isort]
+force-single-line = true
+
+[tool.tryke]
+src = ["src", "."]
+
+[tool.bumpversion]
+commit = true
+tag = true
+tag_name = "{new_version}"
+parse = "(?P<major>\\d+)\\.(?P<minor>\\d+)\\.(?P<patch>\\d+)"
+serialize = ["{major}.{minor}.{patch}"]
+message = ":wrench: bump: version {current_version} → {new_version}"
+pre_commit_hooks = ["uv sync", "git add uv.lock"]
+
+[[tool.bumpversion.files]]
+filename = "pyproject.toml"
+search = 'version = "{current_version}"'
+replace = 'version = "{new_version}"'
+
+[tool.zaojun]
+cache = true
+groups = true
+min-age = 7
+check-licenses = true
+
+[[tool.zaojun.license-ignore]]
+package = "git-cliff"
+reason = "Manually checked, it is licensed as Apache-2.0 OR MIT"

sub2pod-0.2.0/src/sub2pod/__init__.py

@@ -0,0 +1,3 @@
+from importlib.metadata import version
+
+__version__ = version("sub2pod")

sub2pod-0.2.0/src/sub2pod/cli.py

@@ -0,0 +1,46 @@
+# SPDX-License-Identifier: AGPL-3.0-or-later
+from pathlib import Path
+
+import cyclopts
+
+from sub2pod.discovery import discover_episodes
+from sub2pod.feed import write_feed
+from sub2pod.nfo import ChannelInfo
+from sub2pod.nfo import parse_channel_nfo
+from sub2pod.opml import write_opml
+
+app = cyclopts.App()
+
+
+@app.default
+def main(
+    parent_dir: Path,
+    base_url: str,
+    *,
+    dry_run: bool = False,
+    verbose: bool = False,
+) -> None:
+    channel_dirs = sorted(
+        child
+        for child in parent_dir.iterdir()
+        if child.is_dir() and (child / "tvshow.nfo").exists()
+    )
+    channels: list[tuple[ChannelInfo, Path]] = []
+    for channel_dir in channel_dirs:
+        channel_info = parse_channel_nfo(channel_dir / "tvshow.nfo")
+        episodes = discover_episodes(channel_dir)
+        feed_path = channel_dir / "feed.xml"
+        if verbose:
+            print(f"{channel_info.title}: {len(episodes)} episodes")
+            for episode in episodes:
+                print(f"  {episode.date} — {episode.title}")
+        if dry_run:
+            print(str(feed_path))
+        else:
+            write_feed(channel_dir, channel_info, episodes, base_url)
+        channels.append((channel_info, channel_dir))
+    opml_path = parent_dir / "opml.xml"
+    if dry_run:
+        print(str(opml_path))
+    else:
+        write_opml(parent_dir, channels, base_url)

sub2pod-0.2.0/src/sub2pod/discovery.py

@@ -0,0 +1,46 @@
+# SPDX-License-Identifier: AGPL-3.0-or-later
+from dataclasses import dataclass
+from datetime import date
+from pathlib import Path
+
+from sub2pod.nfo import EpisodeInfo
+from sub2pod.nfo import parse_episode_filename
+from sub2pod.nfo import parse_episode_nfo
+
+_AUDIO_SUFFIXES = frozenset({".opus", ".mp3", ".m4a"})
+
+
+@dataclass
+class Episode:
+    audio_path: Path
+    date: date
+    title: str
+    info: EpisodeInfo | None
+
+
+def discover_episodes(channel_dir: Path) -> list[Episode]:
+    episodes: list[Episode] = []
+    for audio_path in channel_dir.iterdir():
+        if not audio_path.is_file() or audio_path.suffix.lower() not in _AUDIO_SUFFIXES:
+            continue
+        parsed = parse_episode_filename(audio_path.name)
+        if parsed is None:
+            continue
+        episode_date, episode_title = parsed
+        nfo_path = audio_path.with_suffix(".nfo")
+        info = None
+        if nfo_path.exists():
+            try:
+                info = parse_episode_nfo(nfo_path)
+            except Exception:
+                pass
+        episodes.append(
+            Episode(
+                audio_path=audio_path,
+                date=episode_date,
+                title=episode_title,
+                info=info,
+            )
+        )
+    episodes.sort(key=lambda episode: episode.date, reverse=True)
+    return episodes

sub2pod-0.2.0/src/sub2pod/feed.py

@@ -0,0 +1,165 @@
+# SPDX-License-Identifier: AGPL-3.0-or-later
+from datetime import UTC
+from datetime import date
+from datetime import datetime
+from pathlib import Path
+from urllib.parse import quote
+
+from lxml import etree  # ty: ignore[unresolved-import]
+
+from sub2pod.discovery import Episode
+from sub2pod.nfo import ChannelInfo
+
+_ITUNES_NS = "http://www.itunes.com/dtds/podcast-1.0.dtd"
+_ITUNES = f"{{{_ITUNES_NS}}}"
+
+_MIME_TYPE_BY_SUFFIX: dict[str, str] = {
+    ".opus": "audio/ogg; codecs=opus",
+    ".mp3": "audio/mpeg",
+    ".m4a": "audio/mp4",
+}
+
+_ARTWORK_CANDIDATES = ("poster.jpg", "fanart.jpg")
+
+
+def find_channel_artwork(channel_dir: Path) -> Path | None:
+    for candidate in _ARTWORK_CANDIDATES:
+        artwork_path = channel_dir / candidate
+        if artwork_path.exists():
+            return artwork_path
+    return None
+
+
+def mime_type_for_audio_file(audio_path: Path) -> str:
+    suffix = audio_path.suffix.lower()
+    mime_type = _MIME_TYPE_BY_SUFFIX.get(suffix)
+    if mime_type is None:
+        raise ValueError(f"Unrecognised audio suffix: {audio_path.suffix!r}")
+    return mime_type
+
+
+def format_pub_date(episode_date: date) -> str:
+    midnight_utc = datetime(
+        episode_date.year,
+        episode_date.month,
+        episode_date.day,
+        tzinfo=UTC,
+    )
+    return midnight_utc.strftime("%a, %d %b %Y %H:%M:%S +0000")
+
+
+def format_itunes_duration(runtime_minutes: int) -> str:
+    total_seconds = runtime_minutes * 60
+    hours = total_seconds // 3600
+    remaining_seconds = total_seconds % 3600
+    minutes = remaining_seconds // 60
+    seconds = remaining_seconds % 60
+    return f"{hours:02d}:{minutes:02d}:{seconds:02d}"
+
+
+def build_enclosure_url(base_url: str, channel_dir: Path, audio_path: Path) -> str:
+    encoded_channel = quote(channel_dir.name, safe="")
+    encoded_filename = quote(audio_path.name, safe="")
+    return f"{base_url.rstrip('/')}/{encoded_channel}/{encoded_filename}"
+
+
+def _populate_channel_metadata(
+    channel_element: etree._Element,
+    channel_info: ChannelInfo,
+    channel_dir: Path,
+    base_url: str,
+    episodes: list[Episode],
+) -> None:
+    etree.SubElement(channel_element, "title").text = channel_info.title
+    etree.SubElement(channel_element, "link").text = base_url
+    etree.SubElement(channel_element, "description").text = channel_info.title
+    etree.SubElement(channel_element, "language").text = "en"
+
+    artwork_path = find_channel_artwork(channel_dir)
+    if artwork_path is not None:
+        artwork_url = (
+            f"{base_url.rstrip('/')}/{quote(channel_dir.name, safe='')}"
+            f"/{quote(artwork_path.name, safe='')}"
+        )
+        itunes_image = etree.SubElement(channel_element, f"{_ITUNES}image")
+        itunes_image.set("href", artwork_url)
+
+    if channel_info.genre is not None:
+        itunes_category = etree.SubElement(channel_element, f"{_ITUNES}category")
+        itunes_category.set("text", channel_info.genre)
+
+    if episodes:
+        etree.SubElement(channel_element, "pubDate").text = format_pub_date(
+            episodes[0].date
+        )
+
+
+def _append_episode_item(
+    channel_element: etree._Element,
+    episode: Episode,
+    channel_dir: Path,
+    base_url: str,
+) -> None:
+    item_element = etree.SubElement(channel_element, "item")
+
+    episode_title = episode.info.title if episode.info is not None else episode.title
+    etree.SubElement(item_element, "title").text = episode_title
+
+    if episode.info is not None and episode.info.plot is not None:
+        etree.SubElement(item_element, "description").text = episode.info.plot
+
+    pub_date = (
+        episode.info.aired
+        if (episode.info is not None and episode.info.aired is not None)
+        else episode.date
+    )
+    etree.SubElement(item_element, "pubDate").text = format_pub_date(pub_date)
+
+    enclosure_url = build_enclosure_url(base_url, channel_dir, episode.audio_path)
+    mime_type = mime_type_for_audio_file(episode.audio_path)
+    file_size = episode.audio_path.stat().st_size if episode.audio_path.exists() else 0
+    enclosure_element = etree.SubElement(item_element, "enclosure")
+    enclosure_element.set("url", enclosure_url)
+    enclosure_element.set("type", mime_type)
+    enclosure_element.set("length", str(file_size))
+
+    guid_element = etree.SubElement(item_element, "guid")
+    guid_element.text = enclosure_url
+    guid_element.set("isPermaLink", "false")
+
+    if episode.info is not None and episode.info.original_url is not None:
+        etree.SubElement(item_element, "link").text = episode.info.original_url
+
+    if episode.info is not None and episode.info.runtime is not None:
+        duration_element = etree.SubElement(item_element, f"{_ITUNES}duration")
+        duration_element.text = format_itunes_duration(episode.info.runtime)
+
+
+def build_feed_xml(
+    channel_dir: Path,
+    channel_info: ChannelInfo,
+    episodes: list[Episode],
+    base_url: str,
+) -> bytes:
+    nsmap = {"itunes": _ITUNES_NS}
+    root = etree.Element("rss", attrib={"version": "2.0"}, nsmap=nsmap)
+    channel_element = etree.SubElement(root, "channel")
+    _populate_channel_metadata(
+        channel_element, channel_info, channel_dir, base_url, episodes
+    )
+    for episode in episodes:
+        _append_episode_item(channel_element, episode, channel_dir, base_url)
+    return etree.tostring(
+        root, xml_declaration=True, encoding="UTF-8", pretty_print=True
+    )
+
+
+def write_feed(
+    channel_dir: Path,
+    channel_info: ChannelInfo,
+    episodes: list[Episode],
+    base_url: str,
+) -> Path:
+    feed_path = channel_dir / "feed.xml"
+    feed_path.write_bytes(build_feed_xml(channel_dir, channel_info, episodes, base_url))
+    return feed_path

sub2pod-0.2.0/src/sub2pod/nfo.py

@@ -0,0 +1,70 @@
+# SPDX-License-Identifier: AGPL-3.0-or-later
+import re
+from dataclasses import dataclass
+from datetime import date
+from pathlib import Path
+
+from lxml import etree  # ty: ignore[unresolved-import]
+
+
+@dataclass
+class ChannelInfo:
+    title: str
+    genre: str | None
+
+
+@dataclass
+class EpisodeInfo:
+    title: str
+    plot: str | None
+    aired: date | None
+    runtime: int | None
+    original_url: str | None
+
+
+def parse_channel_nfo(nfo_path: Path) -> ChannelInfo:
+    root = etree.parse(nfo_path).getroot()
+    return ChannelInfo(
+        title=root.findtext("title") or "",
+        genre=root.findtext("genre"),
+    )
+
+
+def parse_episode_nfo(nfo_path: Path) -> EpisodeInfo:
+    root = etree.parse(nfo_path).getroot()
+    aired_text = root.findtext("aired") or root.findtext("upload_date")
+    runtime_text = root.findtext("runtime")
+    aired = None
+    if aired_text:
+        try:
+            aired = date.fromisoformat(aired_text)
+        except ValueError:
+            pass
+
+    runtime = None
+    if runtime_text:
+        try:
+            runtime = int(runtime_text)
+        except ValueError:
+            pass
+
+    return EpisodeInfo(
+        title=root.findtext("title") or "",
+        plot=root.findtext("plot") or root.findtext("description"),
+        aired=aired,
+        runtime=runtime,
+        original_url=root.findtext("webpage_url"),
+    )
+
+
+EPISODE_FILENAME_PATTERN = re.compile(r"^(\d{4}-\d{2}-\d{2}) - (.+)\.[^.]+$")
+
+
+def parse_episode_filename(filename: str) -> tuple[date, str] | None:
+    match = EPISODE_FILENAME_PATTERN.match(filename)
+    if not match:
+        return None
+    try:
+        return date.fromisoformat(match.group(1)), match.group(2)
+    except ValueError:
+        return None

sub2pod-0.2.0/src/sub2pod/opml.py

@@ -0,0 +1,37 @@
+# SPDX-License-Identifier: AGPL-3.0-or-later
+from pathlib import Path
+from urllib.parse import quote
+
+from lxml import etree  # ty: ignore[unresolved-import]
+
+from sub2pod.nfo import ChannelInfo
+
+
+def build_opml_xml(
+    channels: list[tuple[ChannelInfo, Path]],
+    base_url: str,
+) -> bytes:
+    root = etree.Element("opml", attrib={"version": "2.0"})
+    head = etree.SubElement(root, "head")
+    etree.SubElement(head, "title").text = "Podcasts"
+    body = etree.SubElement(root, "body")
+    for channel_info, channel_dir in channels:
+        feed_url = f"{base_url.rstrip('/')}/{quote(channel_dir.name, safe='')}/feed.xml"
+        outline = etree.SubElement(body, "outline")
+        outline.set("type", "rss")
+        outline.set("text", channel_info.title)
+        outline.set("title", channel_info.title)
+        outline.set("xmlUrl", feed_url)
+    return etree.tostring(
+        root, xml_declaration=True, encoding="UTF-8", pretty_print=True
+    )
+
+
+def write_opml(
+    parent_dir: Path,
+    channels: list[tuple[ChannelInfo, Path]],
+    base_url: str,
+) -> Path:
+    opml_path = parent_dir / "opml.xml"
+    opml_path.write_bytes(build_opml_xml(channels, base_url))
+    return opml_path