| --- |
| task_categories: |
| - text-to-video |
| language: |
| - en |
| tags: |
| - art |
| size_categories: |
| - n<1K |
| --- |
| |
| # 🔵 ZackDFilms / YT Shorts |
| ## Script Used to create this: |
| ```python |
| import os |
| import re |
| import json |
| from pathlib import Path |
| from typing import Optional, Dict, Any, List |
| |
| import yt_dlp |
| |
| |
| CHANNEL_SHORTS_URL = "https://www.youtube.com/@zackdfilms/shorts" |
| |
| BASE_DIR = Path(r"C:\Users\User\Desktop\zackdfilms") |
| SHORTS_DIR = BASE_DIR / "shorts" |
| DATASET_PATH = BASE_DIR / "data.json" |
| |
| TARGET_COUNT = 576 |
| |
| |
| def round_to_thousands(n: Optional[int]) -> Optional[int]: |
| if n is None: |
| return None |
| # "с точностью до тысяч" -> округление до ближайшей 1000 |
| return int(round(n / 1000.0) * 1000) |
| |
| |
| _vtt_timestamp = re.compile(r"^\d{2}:\d{2}:\d{2}\.\d{3}\s-->\s\d{2}:\d{2}:\d{2}\.\d{3}") |
| _vtt_header = re.compile(r"^WEBVTT") |
| |
| |
| def vtt_to_text(vtt_content: str) -> str: |
| """ |
| Простой VTT -> текст: |
| - убирает заголовок/таймкоды/служебные строки |
| - чистит теги <...> |
| - склеивает в одну строку |
| - убирает подряд идущие дубликаты |
| """ |
| lines = [] |
| for raw in vtt_content.splitlines(): |
| s = raw.strip() |
| if not s: |
| continue |
| if _vtt_header.match(s): |
| continue |
| if _vtt_timestamp.match(s): |
| continue |
| if s.isdigit(): # номер cue |
| continue |
| if s.startswith("NOTE") or s.startswith("STYLE") or s.startswith("REGION"): |
| continue |
| s = re.sub(r"<[^>]+>", "", s) # убрать теги |
| s = s.replace("\u200b", "").strip() |
| if s: |
| lines.append(s) |
| |
| # убрать подряд повторяющиеся строки |
| dedup = [] |
| prev = None |
| for s in lines: |
| if s != prev: |
| dedup.append(s) |
| prev = s |
| |
| text = " ".join(dedup) |
| text = re.sub(r"\s+", " ", text).strip() |
| return text |
| |
| |
| def read_text_file(path: Path) -> str: |
| # VTT обычно UTF-8, но бывает с BOM |
| return path.read_text(encoding="utf-8-sig", errors="replace") |
| |
| |
| def pick_subtitle_path(info: Dict[str, Any], expected_basename: str, out_dir: Path) -> Optional[Path]: |
| """ |
| yt-dlp создаст файл субтитров рядом с видео по шаблону outtmpl. |
| Мы используем отдельный outtmpl под каждый ролик, поэтому ожидаем: |
| - <basename>.en.vtt |
| - <basename>.en-US.vtt (и т.п.) |
| - иногда .en.auto.vtt / похожие варианты |
| """ |
| candidates = list(out_dir.glob(f"{expected_basename}.en*.vtt")) |
| if not candidates: |
| return None |
| # предпочтение: не auto (если есть) |
| non_auto = [p for p in candidates if ".auto." not in p.name] |
| return non_auto[0] if non_auto else candidates[0] |
| |
| |
| def extract_playlist_entries(url: str, limit: int) -> List[Dict[str, Any]]: |
| ydl_opts = { |
| "quiet": True, |
| "no_warnings": True, |
| "extract_flat": "in_playlist", |
| "playlistend": limit, |
| # для стабильности |
| "noplaylist": False, |
| } |
| with yt_dlp.YoutubeDL(ydl_opts) as ydl: |
| info = ydl.extract_info(url, download=False) |
| entries = info.get("entries") or [] |
| return [e for e in entries if e] # убрать None |
| |
| |
| def download_one(video_url: str, out_mp4: Path) -> Dict[str, Any]: |
| """ |
| Скачивает видео+аудио (до 720p) и субтитры (en, обычные или авто). |
| Возвращает info_dict (с метаданными). |
| """ |
| out_base = out_mp4.with_suffix("") # без расширения |
| outtmpl = str(out_base) + ".%(ext)s" |
| |
| ydl_opts = { |
| "quiet": True, |
| "no_warnings": True, |
| |
| # видео до 720p + звук, с попыткой mp4/m4a |
| "format": "bestvideo[height<=720][ext=mp4]+bestaudio[ext=m4a]/best[height<=720][ext=mp4]/best[height<=720]", |
| |
| # принудительно mp4 на выходе (если возможно через remux) |
| "merge_output_format": "mp4", |
| "outtmpl": outtmpl, |
| |
| # субтитры: сначала обычные, иначе авто |
| "writesubtitles": True, |
| "writeautomaticsub": True, |
| "subtitleslangs": ["en", "en.*"], |
| "subtitlesformat": "vtt", |
| |
| # меньше мусора |
| "postprocessors": [ |
| {"key": "FFmpegVideoRemuxer", "preferedformat": "mp4"}, |
| ], |
| |
| # сеть/ретраи |
| "retries": 10, |
| "fragment_retries": 10, |
| "concurrent_fragment_downloads": 4, |
| |
| # иногда полезно: |
| # "cookiesfrombrowser": ("chrome",), # если нужно (авторизация/ограничения) |
| } |
| |
| with yt_dlp.YoutubeDL(ydl_opts) as ydl: |
| info = ydl.extract_info(video_url, download=True) |
| return info |
| |
| |
| def main(): |
| BASE_DIR.mkdir(parents=True, exist_ok=True) |
| SHORTS_DIR.mkdir(parents=True, exist_ok=True) |
| |
| entries = extract_playlist_entries(CHANNEL_SHORTS_URL, TARGET_COUNT) |
| if not entries: |
| raise RuntimeError("Не удалось получить список Shorts. Проверь URL или доступность YouTube.") |
| |
| dataset = [] |
| downloaded = 0 |
| seq = 1 |
| |
| for e in entries: |
| if downloaded >= TARGET_COUNT: |
| break |
| |
| # e может быть с id и url |
| video_id = e.get("id") |
| video_url = e.get("url") or (f"https://www.youtube.com/watch?v={video_id}" if video_id else None) |
| if not video_url: |
| continue |
| |
| filename = f"{seq:04d}.mp4" |
| out_mp4 = SHORTS_DIR / filename |
| |
| # если уже есть файл — пропускаем и всё равно пишем запись (по возможности) |
| if out_mp4.exists() and out_mp4.stat().st_size > 0: |
| # метаданные в этом случае не знаем; лучше всё же извлечь info без скачивания |
| with yt_dlp.YoutubeDL({"quiet": True, "no_warnings": True}) as ydl: |
| info = ydl.extract_info(video_url, download=False) |
| else: |
| try: |
| info = download_one(video_url, out_mp4) |
| except Exception as ex: |
| print(f"[SKIP] Ошибка скачивания {video_url}: {ex}") |
| continue |
| |
| # subtitles: ищем созданный vtt рядом с видео и парсим |
| base_name = f"{seq:04d}" |
| sub_path = pick_subtitle_path(info, base_name, SHORTS_DIR) |
| subtitles_text = "" |
| if sub_path and sub_path.exists(): |
| try: |
| subtitles_text = vtt_to_text(read_text_file(sub_path)) |
| except Exception: |
| subtitles_text = "" |
| # можно удалить .vtt, если не нужен |
| try: |
| sub_path.unlink(missing_ok=True) |
| except Exception: |
| pass |
| |
| view_count = info.get("view_count") |
| views_rounded = round_to_thousands(view_count if isinstance(view_count, int) else None) |
| |
| dataset.append({ |
| "subtitles": subtitles_text, |
| "filepath": f"shorts/{filename}", |
| "views": views_rounded, |
| }) |
| |
| downloaded += 1 |
| seq += 1 |
| |
| print(f"[OK] {downloaded}/{TARGET_COUNT} -> {filename}") |
| |
| DATASET_PATH.write_text(json.dumps(dataset, ensure_ascii=False, indent=2), encoding="utf-8") |
| print(f"\nГотово. Скачано: {downloaded}. Dataset: {DATASET_PATH}") |
| |
| |
| if __name__ == "__main__": |
| main() |
| ``` |
|
|
