#!/usr/bin/env python3 """Download YouTube Shorts as cover-video candidates (raw MP4 + metadata) for StegoReels. Usage: python yt_scrapper.py --source "ytsearch50:cats" --output-dir ../raw python yt_scrapper.py --input-file sources.txt --max-videos 1000 Output: /.mp4 + /.meta.json. """ from __future__ import annotations import argparse import json import logging from dataclasses import dataclass from pathlib import Path import yt_dlp from yt_dlp.postprocessor.common import PostProcessor LOGGER = logging.getLogger("yt_scrapper") DEFAULT_MIN_DURATION_S = 3 DEFAULT_MAX_DURATION_S = 60 # YouTube Shorts cutoff @dataclass class ScrapeConfig: output_dir: Path archive_file: Path max_videos: int | None min_duration: int max_duration: int require_vertical: bool sleep_interval: float max_sleep_interval: float cookies_from_browser: str | None verbose: bool dry_run: bool def build_match_filter(cfg: ScrapeConfig): """Pre-download filter; only duration is reliably known at this stage.""" def _match_filter(info_dict, *, incomplete: bool = False): duration = info_dict.get("duration") if duration is None: return None if duration < cfg.min_duration: return f"duration {duration}s below --min-duration {cfg.min_duration}s" if duration > cfg.max_duration: return f"duration {duration}s above --max-duration {cfg.max_duration}s" return None return _match_filter def extract_compact_metadata(info: dict, source: str, extra: dict | None = None) -> dict: """Stable metadata schema written as the .meta.json sidecar.""" meta = { "id": info.get("id"), "title": info.get("title"), "webpage_url": info.get("webpage_url"), "source_query": source, "uploader": info.get("uploader"), "channel_id": info.get("channel_id"), "upload_date": info.get("upload_date"), "duration_s": info.get("duration"), "width": info.get("width"), "height": info.get("height"), "fps": info.get("fps"), "view_count": info.get("view_count"), "like_count": info.get("like_count"), "license": info.get("license"), "tags": info.get("tags"), "ext": info.get("ext"), } if extra: meta.update(extra) return meta class ShortsFilterPostProcessor(PostProcessor): """Post-download gate: enforce final duration/aspect ratio, write metadata, delete rejects.""" def __init__(self, cfg: ScrapeConfig, source: str, extra_meta: dict | None = None): super().__init__() self._cfg = cfg self._source = source self._extra_meta = extra_meta def run(self, info): filepath = info.get("filepath") or info.get("_filename") duration = info.get("duration") width, height = info.get("width"), info.get("height") reasons = [] if duration is not None and not ( self._cfg.min_duration <= duration <= self._cfg.max_duration ): reasons.append(f"duration={duration}s outside range") if self._cfg.require_vertical and width and height and height < width: reasons.append(f"not vertical ({width}x{height})") if reasons: LOGGER.info("Rejecting %s: %s", info.get("id"), "; ".join(reasons)) if filepath and Path(filepath).exists(): Path(filepath).unlink() return [], info meta = extract_compact_metadata(info, self._source, self._extra_meta) if filepath: Path(filepath).with_suffix(".meta.json").write_text( json.dumps(meta, indent=2, ensure_ascii=False) ) LOGGER.info("Kept %s -> %s", info.get("id"), filepath) return [], info def load_sources(source_args: list[str] | None, input_file: str | None) -> list[str]: sources: list[str] = list(source_args or []) if input_file: for line in Path(input_file).read_text(encoding="utf-8").splitlines(): line = line.strip() if line and not line.startswith("#"): sources.append(line) if not sources: raise SystemExit("No sources given. Use --source and/or --input-file.") return sources def build_ydl_opts(cfg: ScrapeConfig) -> dict: cfg.output_dir.mkdir(parents=True, exist_ok=True) cfg.archive_file.parent.mkdir(parents=True, exist_ok=True) opts = { # Force H.264/AAC: cover videos must play in any standard player, # and YouTube serves AV1 (undecodable in QuickTime on many Macs) # for its highest-res mp4 formats. "format": "bv*[ext=mp4][vcodec^=avc1]+ba[ext=m4a]/b[ext=mp4][vcodec^=avc1]/bv*[ext=mp4]+ba[ext=m4a]/b[ext=mp4]/best", # noqa: E501 "merge_output_format": "mp4", "outtmpl": str(cfg.output_dir / "%(id)s.%(ext)s"), "download_archive": str(cfg.archive_file), "match_filter": build_match_filter(cfg), "sleep_interval": cfg.sleep_interval, "max_sleep_interval": cfg.max_sleep_interval, # Throttles per-video metadata/API requests too, not just downloads -- # channel-listing pagination is what actually triggers YouTube's # "rate-limited for up to an hour" block on long multi-channel runs. "sleep_interval_requests": cfg.sleep_interval, "ignoreerrors": True, "noprogress": not cfg.verbose, "quiet": not cfg.verbose, "no_warnings": not cfg.verbose, "retries": 3, "simulate": cfg.dry_run, } if cfg.max_videos: opts["max_downloads"] = cfg.max_videos if cfg.cookies_from_browser: opts["cookiesfrombrowser"] = (cfg.cookies_from_browser,) return opts def run(cfg: ScrapeConfig, sources: list[str], extra_meta: dict | None = None) -> None: ydl_opts = build_ydl_opts(cfg) for source in sources: LOGGER.info("Scraping source: %s", source) with yt_dlp.YoutubeDL(ydl_opts) as ydl: if not cfg.dry_run: ydl.add_post_processor( ShortsFilterPostProcessor(cfg, source, extra_meta), when="after_move" ) try: ydl.download([source]) except yt_dlp.utils.MaxDownloadsReached: LOGGER.info("Reached --max-videos limit (%s); stopping.", cfg.max_videos) return except yt_dlp.utils.DownloadError as exc: LOGGER.warning("Source %s failed: %s", source, exc) continue def parse_args(argv: list[str] | None = None) -> argparse.Namespace: parser = argparse.ArgumentParser( description="Download YouTube Shorts as cover-video candidates via yt-dlp.", formatter_class=argparse.ArgumentDefaultsHelpFormatter, ) parser.add_argument( "--source", action="append", help="Channel/Shorts-tab URL, playlist URL, video URL, or yt-dlp search " "pseudo-URL (e.g. 'ytsearch50:cats'). Repeatable.", ) parser.add_argument("--input-file", help="File with one source per line (# comments allowed).") parser.add_argument( "--output-dir", type=Path, default=Path(__file__).resolve().parent.parent / "raw", help="Where to write clips + metadata sidecars.", ) parser.add_argument( "--archive-file", type=Path, default=Path(__file__).resolve().parent.parent / "raw" / ".yt_dlp_archive.txt", help="yt-dlp download-archive file, to skip already-seen video ids.", ) parser.add_argument("--max-videos", type=int, default=None, help="Cap on download attempts.") parser.add_argument("--min-duration", type=int, default=DEFAULT_MIN_DURATION_S) parser.add_argument("--max-duration", type=int, default=DEFAULT_MAX_DURATION_S) parser.add_argument( "--no-require-vertical", dest="require_vertical", action="store_false", help="Disable the post-download vertical-aspect-ratio filter.", ) parser.add_argument("--sleep-interval", type=float, default=1.0) parser.add_argument("--max-sleep-interval", type=float, default=3.0) parser.add_argument( "--cookies-from-browser", default=None, help="Browser to read cookies from (e.g. 'chrome'), for age-restricted videos.", ) parser.add_argument( "--dry-run", action="store_true", help="Simulate only; no downloads or writes." ) parser.add_argument("-v", "--verbose", action="store_true") parser.set_defaults(require_vertical=True) return parser.parse_args(argv) def main(argv: list[str] | None = None) -> None: args = parse_args(argv) logging.basicConfig( level=logging.DEBUG if args.verbose else logging.INFO, format="%(asctime)s [%(levelname)s] %(message)s", ) cfg = ScrapeConfig( output_dir=args.output_dir, archive_file=args.archive_file, max_videos=args.max_videos, min_duration=args.min_duration, max_duration=args.max_duration, require_vertical=args.require_vertical, sleep_interval=args.sleep_interval, max_sleep_interval=args.max_sleep_interval, cookies_from_browser=args.cookies_from_browser, verbose=args.verbose, dry_run=args.dry_run, ) sources = load_sources(args.source, args.input_file) run(cfg, sources) if __name__ == "__main__": main()