| |
| |
| |
| |
| |
| |
| |
| |
| |
| """Build a Hugging Face dataset from the downloaded transcript archive. |
| |
| Run with uv so the script's optional dependencies are installed automatically. |
| This script reads SQLite metadata without changing the database and never uploads. |
| """ |
|
|
| from __future__ import annotations |
|
|
| import argparse |
| import hashlib |
| import json |
| import re |
| import shutil |
| import sqlite3 |
| import tarfile |
| from collections import Counter |
| from contextlib import closing |
| from datetime import UTC, datetime |
| from html import unescape |
| from pathlib import Path |
| from typing import TYPE_CHECKING, cast |
| from xml.etree import ElementTree |
|
|
| import pyarrow as pa |
| import pyarrow.parquet as pq |
| from bs4 import BeautifulSoup |
| from charset_normalizer import from_bytes |
| from pypdf import PdfReader |
| from pypdf.errors import PyPdfError |
|
|
| if TYPE_CHECKING: |
| from collections.abc import Iterator |
|
|
| type Record = dict[str, str | None] |
|
|
| _TIMING = re.compile(r"^\s*(?:\d+:)?\d{2}:\d{2}[.,]\d+\s*-->\s*", re.MULTILINE) |
| _SCHEMA = pa.schema( |
| [ |
| pa.field(name, pa.string()) |
| for name in ( |
| "id", |
| "podcast", |
| "episode", |
| "text", |
| "source_url", |
| "feed_url", |
| "episode_url", |
| "published_at", |
| "format", |
| "raw_path", |
| "sha256", |
| "extraction_status", |
| "extraction_method", |
| "extraction_error", |
| ) |
| ], |
| ) |
| _BATCH_SIZE = 100 |
| _MIN_HTML_TRANSCRIPT_LENGTH = 200 |
|
|
|
|
| def normalize_text(text: str) -> str: |
| return "\n".join( |
| cleaned for line in text.splitlines() if (cleaned := " ".join(line.split())) |
| ) |
|
|
|
|
| def decode_text(content: bytes) -> str: |
| try: |
| return content.decode("utf-8-sig") |
| except (UnicodeError,): |
| if match := from_bytes(content).best(): |
| return str(match) |
| msg = "Could not detect the text encoding" |
| raise ValueError(msg) from None |
|
|
|
|
| def text_format(text: str, suffix: str) -> str: |
| start = text.lstrip() |
| if start.startswith("WEBVTT"): |
| return "vtt" |
| if _TIMING.search(text): |
| return "srt" |
| if suffix == ".json" or (start.startswith("{") and '"segments"' in start[:2000]): |
| return "json" |
| if start.startswith("<"): |
| return ( |
| "podlove" |
| if "http://podlove.org/simple-transcripts" in text[:2000] |
| else "html" |
| ) |
| if "\x00" in text: |
| msg = "Unsupported binary content" |
| raise ValueError(msg) |
| return "txt" |
|
|
|
|
| def detect_format(content: bytes, suffix: str) -> tuple[str, str]: |
| if content.startswith(b"%PDF-") or suffix.lower() == ".pdf": |
| return "pdf", "" |
| text = decode_text(content) |
| return text_format(text, suffix.lower()), text |
|
|
|
|
| def subtitle_text(text: str) -> str: |
| cues: list[str] = [] |
| for block in re.split(r"\n\s*\n", text.replace("\r\n", "\n")): |
| lines = block.splitlines() |
| if ( |
| timing_index := next( |
| (index for index, line in enumerate(lines) if _TIMING.match(line)), |
| None, |
| ) |
| ) is None: |
| continue |
| cue = " ".join(lines[timing_index + 1 :]) |
| cue = re.sub(r"<v(?:\.[^ >]+)?\s+([^>]+)>", r"\1: ", cue) |
| cue = re.sub(r"<[^>]+>", "", cue) |
| if cleaned := normalize_text(unescape(cue)): |
| cues.append(cleaned) |
| if not cues: |
| msg = "No subtitle cues found" |
| raise ValueError(msg) |
| return "\n".join(cues) |
|
|
|
|
| def json_segment_text(segment: object) -> str: |
| if not isinstance(segment, dict): |
| msg = "A transcript segment is not an object" |
| raise TypeError(msg) |
| fields = cast("dict[str, object]", segment) |
| body = fields.get("body", fields.get("text")) |
| if not isinstance(body, str): |
| msg = "A transcript segment has no body or text" |
| raise TypeError(msg) |
| if isinstance(speaker := fields.get("speaker"), str) and speaker: |
| return f"{speaker}: {body}" |
| return body |
|
|
|
|
| def json_text(text: str) -> str: |
| data: object = json.loads(text) |
| if isinstance(data, dict): |
| fields = cast("dict[str, object]", data) |
| if isinstance(body := fields.get("text"), str) and body.strip(): |
| return body |
| data = fields.get("segments") |
| if isinstance(data, list) and data: |
| return "\n".join(json_segment_text(segment) for segment in data) |
| msg = "No transcript text or segments found in JSON" |
| raise ValueError(msg) |
|
|
|
|
| def html_text(text: str) -> tuple[str, str]: |
| soup = BeautifulSoup(text, "html.parser") |
| for element in soup.select( |
| "script, style, nav, header, footer, aside, noscript, form, button, " |
| "svg, iframe, time", |
| ): |
| element.decompose() |
| candidates = soup.select( |
| '[itemprop="transcript"], [id*="transcript"], [class*="transcript"]', |
| ) |
| if ( |
| candidates |
| and len( |
| body := max( |
| (element.get_text("\n", strip=True) for element in candidates), |
| key=len, |
| ), |
| ) |
| >= _MIN_HTML_TRANSCRIPT_LENGTH |
| ): |
| return body, "html_transcript" |
| if article := soup.select_one("article, main, [role='main']"): |
| return article.get_text("\n", strip=True), "html_article" |
| return soup.get_text("\n", strip=True), "html_body" |
|
|
|
|
| def extract_text(path: Path, content: bytes) -> tuple[str, str, str]: |
| file_format, text = detect_format(content, path.suffix) |
| method = file_format |
| match file_format: |
| case "pdf": |
| text = "\n".join( |
| page.extract_text() or "" for page in PdfReader(path).pages |
| ) |
| case "srt" | "vtt": |
| text = subtitle_text(text) |
| case "json": |
| text = json_text(text) |
| case "podlove": |
| root = ElementTree.fromstring(text) |
| text = "\n".join( |
| "".join(item.itertext()) |
| for item in root.iter() |
| if item.tag.rsplit("}", 1)[-1] == "item" |
| ) |
| case "html": |
| text, method = html_text(text) |
| if not (text := normalize_text(text)): |
| msg = "No readable transcript text extracted" |
| raise ValueError(msg) |
| return text, file_format, method |
|
|
|
|
| def archive_files(source: Path) -> Iterator[Path]: |
| for path in sorted(source.rglob("*")): |
| if path.is_file() and not any( |
| part in {".DS_Store", ".git", ".cache", "__pycache__"} |
| or part.startswith("._") |
| for part in path.relative_to(source).parts |
| ): |
| if path.is_symlink(): |
| msg = f"Symlinked transcript is not supported: {path}" |
| raise ValueError(msg) |
| yield path |
|
|
|
|
| def load_metadata(database: Path | None) -> dict[str, Record]: |
| if database is None: |
| return {} |
| metadata: dict[str, Record] = {} |
| with closing( |
| sqlite3.connect(f"{database.resolve().as_uri()}?mode=ro", uri=True), |
| ) as connection: |
| connection.row_factory = sqlite3.Row |
| rows = connection.execute( |
| "SELECT e.transcriptDownloadPath AS path, e.title AS episode, " |
| 'f.title AS podcast, e."podcast:transcript:url" AS source_url, ' |
| "e.feedXmlUrl AS feed_url, e.link AS episode_url, " |
| "e.pubDate AS published_at FROM episodes_extended AS e " |
| "LEFT JOIN feeds_extended AS f ON f.xmlUrl = e.feedXmlUrl " |
| "WHERE e.transcriptDownloadPath IS NOT NULL ORDER BY e.enclosureUrl", |
| ) |
| for row in rows: |
| if not isinstance(stored_path := row["path"], str): |
| continue |
| key = Path(*Path(stored_path).parts[-2:]).as_posix() |
| metadata.setdefault( |
| key, |
| { |
| name: value if isinstance(value := row[name], str) else None |
| for name in ( |
| "podcast", |
| "episode", |
| "source_url", |
| "feed_url", |
| "episode_url", |
| "published_at", |
| ) |
| }, |
| ) |
| return metadata |
|
|
|
|
| def transcript_record(path: Path, source: Path, metadata: dict[str, Record]) -> Record: |
| relative = path.relative_to(source).as_posix() |
| content = path.read_bytes() |
| record: Record = { |
| "id": hashlib.sha256(relative.encode()).hexdigest(), |
| "podcast": path.parent.name, |
| "episode": path.stem if path.suffix else path.name, |
| "text": None, |
| "source_url": None, |
| "feed_url": None, |
| "episode_url": None, |
| "published_at": None, |
| "format": path.suffix.lstrip(".") or "unknown", |
| "raw_path": f"raw/{relative}", |
| "sha256": hashlib.sha256(content).hexdigest(), |
| "extraction_status": "ok", |
| "extraction_method": None, |
| "extraction_error": None, |
| } |
| record.update( |
| {key: value for key, value in metadata.get(relative, {}).items() if value}, |
| ) |
| try: |
| record["text"], record["format"], record["extraction_method"] = extract_text( |
| path, |
| content, |
| ) |
| except ( |
| OSError, |
| ValueError, |
| TypeError, |
| UnicodeError, |
| ElementTree.ParseError, |
| PyPdfError, |
| ) as error: |
| record["extraction_status"] = "error" |
| record["extraction_error"] = f"{type(error).__name__}: {error}" |
| return record |
|
|
|
|
| def dataset_card(summary: dict[str, object], repo_id: str) -> str: |
| return f"""--- |
| pretty_name: Podcast Transcripts |
| tags: |
| - podcasts |
| - transcripts |
| configs: |
| - config_name: default |
| data_files: |
| - split: train |
| path: data/train.parquet |
| --- |
| |
| # Podcast Transcripts |
| |
| Downloaded podcast transcripts, with original files and extracted text. Generated |
| with [overcast-to-sqlite](https://github.com/hbmartin/overcast-to-sqlite) on |
| {summary['generated_at']}. This snapshot contains {summary['files']} archived files, |
| of which {summary['extracted']} have extracted text and {summary['failed']} have |
| extraction errors. `{summary['metadata_matched']}` rows have original source URLs. |
| |
| ## Contents and schema |
| |
| `data/train.parquet` contains one row per archived file. `raw-transcripts.tar.gz` |
| preserves all original files under `raw/`, including their directory structure. |
| Multiple files can describe the same |
| episode, and identical content can occur in different rows. `train` is a single |
| collection, not a curated training/evaluation split. |
| |
| | Column | Meaning | |
| | --- | --- | |
| | id | SHA-256 of the relative archive path; stable for a given path | |
| | podcast / episode | SQLite titles when matched, otherwise directory/filename | |
| | text | Extracted UTF-8 text; null when extraction fails | |
| | source_url | Original transcript URL when available | |
| | feed_url / episode_url | RSS feed and episode page URLs when available | |
| | published_at | Publication date as recorded in the feed, without date normalization | |
| | format | Detected content format; extension fallback for extraction failures | |
| | raw_path | Original file's path inside `raw-transcripts.tar.gz` | |
| | sha256 | SHA-256 of the original file bytes; usable for deduplication | |
| | extraction_status | `ok` or `error` | |
| | extraction_method | Text extraction strategy, including HTML selection strategy | |
| | extraction_error | Error description when extraction fails | |
| |
| ## Processing and limitations |
| |
| Formats are detected from content and filename hints, including subtitle content |
| stored as `.bin` and PDFs stored as `.octet-stream`. Subtitle indices and timing |
| lines are removed; WebVTT voice labels are retained when present. JSON full text |
| or segments and Podlove XML items are read. PDFs use embedded text extraction |
| without OCR. HTML scripts and common navigation elements are removed; transcript |
| containers are preferred, then article/main content, then the remaining body. |
| `html_article` and `html_body` rows can include episode notes or other page text. |
| Plain text preserves speaker labels and any timing markers already in its text. |
| Whitespace is normalized. No translation, content deduplication, or transcript |
| accuracy correction is performed. Failed extractions remain as rows with null |
| text, and their original files remain available. See `extraction-report.json`. |
| |
| Metadata uses an explicit selection of feed/episode fields from a read-only SQLite |
| connection. Source URLs and dates are null when no matching metadata is available. |
| |
| ## Loading |
| |
| ```python |
| from datasets import load_dataset |
| |
| dataset = load_dataset("{repo_id}", split="train") |
| readable = dataset.filter(lambda row: row["extraction_status"] == "ok") |
| ``` |
| |
| To download and unpack all original files: |
| |
| ```sh |
| uvx --from huggingface_hub hf download {repo_id} raw-transcripts.tar.gz \\ |
| --repo-type dataset --local-dir . |
| tar -xzf raw-transcripts.tar.gz |
| ``` |
| |
| Each row's `raw_path` points to its file in the extracted `raw/` directory. The |
| bundle avoids thousands of individual file commits when publishing updates. |
| |
| ## Regeneration |
| |
| The standalone generator and its dependency declarations are included in |
| `scripts/generate_transcript_dataset.py`. With the original archive and optional |
| Overcast SQLite database available, run: |
| |
| ```sh |
| uv run scripts/generate_transcript_dataset.py archive/transcripts \\ |
| --database overcast.db --output archive/huggingface/podcast-transcripts \\ |
| --repo-id {repo_id} |
| ``` |
| |
| Generation is local. Upload the generated output directory to this dataset repo |
| using `hf upload --repo-type dataset`. |
| |
| ## Licensing and provenance |
| |
| Transcripts originate from the podcasts identified in each row. Copyright and |
| any applicable licenses remain with their respective owners; this collection |
| does not grant a blanket license to the transcript content. The generator code |
| is covered by the project's Apache-2.0 license, included as `scripts/LICENSE`. |
| """ |
|
|
|
|
| def write_raw_archive(files: list[Path], source: Path, output: Path) -> None: |
| archive_path = output / "raw-transcripts.tar.gz" |
| temporary_archive = archive_path.with_suffix(".gz.tmp") |
| with tarfile.open(temporary_archive, "w:gz", compresslevel=6) as archive: |
| for path in files: |
| member = tarfile.TarInfo(f"raw/{path.relative_to(source).as_posix()}") |
| member.size = path.stat().st_size |
| member.mode = 0o644 |
| with path.open("rb") as content: |
| archive.addfile(member, content) |
| temporary_archive.replace(archive_path) |
| if (raw_directory := output / "raw").is_dir(): |
| shutil.rmtree(raw_directory) |
|
|
|
|
| def generate_dataset( |
| source: Path, |
| output: Path, |
| database: Path | None, |
| repo_id: str = "YOUR_USERNAME/podcast-transcripts", |
| ) -> dict[str, object]: |
| source, output = source.resolve(), output.resolve() |
| if not source.is_dir(): |
| msg = f"Transcript directory does not exist: {source}" |
| raise ValueError(msg) |
| if output.is_relative_to(source) or source.is_relative_to(output): |
| msg = "Source and output directories must not overlap" |
| raise ValueError(msg) |
| files = list(archive_files(source)) |
| if not files: |
| msg = "No transcript files found" |
| raise ValueError(msg) |
| metadata = load_metadata(database) |
| (output / "data").mkdir(parents=True, exist_ok=True) |
| formats: Counter[str] = Counter() |
| methods: Counter[str] = Counter() |
| failures: list[Record] = [] |
| batch: list[Record] = [] |
| matched = 0 |
| parquet_path = output / "data/train.parquet" |
| temporary_parquet = parquet_path.with_suffix(".parquet.tmp") |
| with pq.ParquetWriter( |
| temporary_parquet, |
| _SCHEMA, |
| compression="zstd", |
| ) as writer: |
| for index, path in enumerate(files, start=1): |
| record = transcript_record(path, source, metadata) |
| formats[cast("str", record["format"])] += 1 |
| methods[record["extraction_method"] or "error"] += 1 |
| matched += bool(record["source_url"]) |
| if record["extraction_status"] == "error": |
| failures.append( |
| {key: record[key] for key in ("raw_path", "extraction_error")}, |
| ) |
| batch.append(record) |
| if len(batch) >= _BATCH_SIZE: |
| writer.write_table(pa.Table.from_pylist(batch, schema=_SCHEMA)) |
| batch.clear() |
| if index % 500 == 0: |
| print(f"Processed {index}/{len(files)} transcripts", flush=True) |
| if batch: |
| writer.write_table(pa.Table.from_pylist(batch, schema=_SCHEMA)) |
| temporary_parquet.replace(parquet_path) |
| print("Bundling original transcripts", flush=True) |
| write_raw_archive(files, source, output) |
| summary: dict[str, object] = { |
| "generated_at": datetime.now(UTC).isoformat(), |
| "files": len(files), |
| "extracted": len(files) - len(failures), |
| "failed": len(failures), |
| "metadata_matched": matched, |
| "formats": dict(sorted(formats.items())), |
| "methods": dict(sorted(methods.items())), |
| "failures": failures, |
| } |
| (output / "extraction-report.json").write_text( |
| json.dumps(summary, ensure_ascii=False, indent=2) + "\n", |
| encoding="utf-8", |
| ) |
| (output / "README.md").write_text(dataset_card(summary, repo_id), encoding="utf-8") |
| (output / ".gitattributes").write_text( |
| "*.tar.gz filter=lfs diff=lfs merge=lfs -text\n" |
| "*.parquet filter=lfs diff=lfs merge=lfs -text\n", |
| encoding="utf-8", |
| ) |
| (output / "scripts").mkdir(exist_ok=True) |
| script = Path(__file__).resolve() |
| shutil.copy2(script, output / "scripts" / script.name) |
| if (license_path := script.parent.parent / "LICENSE").is_file(): |
| shutil.copy2(license_path, output / "scripts/LICENSE") |
| return summary |
|
|
|
|
| def main() -> None: |
| parser = argparse.ArgumentParser(description=__doc__) |
| parser.add_argument( |
| "source", |
| nargs="?", |
| type=Path, |
| default=Path("archive/transcripts"), |
| ) |
| parser.add_argument( |
| "--output", |
| type=Path, |
| default=Path("archive/huggingface/podcast-transcripts"), |
| ) |
| parser.add_argument( |
| "--repo-id", |
| default="YOUR_USERNAME/podcast-transcripts", |
| help="Hugging Face dataset ID used in the generated loading example", |
| ) |
| group = parser.add_mutually_exclusive_group() |
| group.add_argument( |
| "--database", |
| type=Path, |
| help="Optional read-only metadata database", |
| ) |
| group.add_argument( |
| "--no-database", |
| action="store_true", |
| help="Use directory/filename metadata only", |
| ) |
| args = parser.parse_args() |
| database = args.database |
| if database is None and not args.no_database and Path("overcast.db").is_file(): |
| database = Path("overcast.db") |
| try: |
| summary = generate_dataset(args.source, args.output, database, args.repo_id) |
| except (OSError, ValueError, sqlite3.Error) as error: |
| parser.exit(1, f"Dataset generation failed: {error}\n") |
| print( |
| json.dumps( |
| {key: value for key, value in summary.items() if key != "failures"}, |
| indent=2, |
| ), |
| ) |
| print(f"Dataset written to {args.output.resolve()}") |
|
|
|
|
| if __name__ == "__main__": |
| main() |
|
|
