Create README.md

README.md

@@ -0,0 +1,235 @@
+---
+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()
+```