lumenfetch 2.0.0__py3-none-any.whl

core/__init__.py

@@ -0,0 +1,6 @@
+"""core - logic inti Lumenfetch."""
+
+from core.constants import VERSION
+
+__version__ = VERSION
+__all__ = ["__version__"]

core/constants.py

@@ -0,0 +1,99 @@
+"""constants.py - Single source of truth untuk nilai-nilai shared."""
+
+from __future__ import annotations
+
+VERSION = "2.0.0"
+
+# --- Config ---
+HISTORY_LIMIT = 20
+CONFIG_VERSION = 2
+UPDATE_CHECK_TIMEOUT_SECONDS = 2
+DOWNLOAD_TIMEOUT_SECONDS = 30
+FFMPEG_TIMEOUT_SECONDS = 120
+APP_NAME = "lumenfetch"
+
+# --- Retry (backoff eksponensial) ---
+RETRY_BASE_DELAY_SECONDS = 2.0
+RETRY_MAX_DELAY_SECONDS = 30.0
+RETRY_JITTER_SECONDS = 1.0
+
+# --- Playlist ---
+PLAYLIST_MODE_SINGLE = "single"
+PLAYLIST_MODE_ALL = "all"
+PLAYLIST_MODES = [PLAYLIST_MODE_SINGLE, PLAYLIST_MODE_ALL]
+
+# --- Subtitle ---
+SUBTITLE_LANGS_DEFAULT = ["en", "id"]
+
+# --- Batch ---
+BATCH_DEFAULT_JOBS = 1
+BATCH_MAX_JOBS = 4
+
+# --- YouTube ---
+YOUTUBE_HOSTS = ("youtube.com", "youtu.be", "music.youtube.com", "youtube-nocookie.com")
+VIDEO_QUALITIES = ["Best", "1080p", "720p", "480p", "360p", "Worst"]
+VIDEO_FORMAT = "mp4"
+AUDIO_FORMAT = "mp3"
+AUDIO_QUALITIES = ["Best", "320kbps", "192kbps", "128kbps"]
+
+# Container video yang didukung EmbedThumbnailPP milik yt-dlp.
+EMBEDDABLE_VIDEO_FORMATS = frozenset({"mp4"})
+
+# --- Download ---
+CONNECTION_ERROR_HINTS = (
+    "timed out",
+    "timeout",
+    "connection",
+    "network",
+    "temporary failure",
+    "reset by peer",
+)
+
+# Batas tinggi per label quality (None = tanpa batas / ambil terbaik).
+HEIGHT_LIMITS = {
+    "1080p": 1080,
+    "720p": 720,
+    "480p": 480,
+    "360p": 360,
+}
+
+# Target bitrate (kbps) untuk opsi audio lossy.
+AUDIO_TARGET_KBPS = {
+    "320kbps": 320,
+    "192kbps": 192,
+    "128kbps": 128,
+}
+
+# Browser yang didukung yt-dlp untuk cookiesfrombrowser.
+SUPPORTED_COOKIE_BROWSERS = ["none", "chrome", "firefox", "edge", "brave", "opera", "vivaldi", "safari"]
+
+# --- Filenames ---
+ILLEGAL_CHARS = r'[\\/:*?"<>|]'
+MAX_TITLE_LEN = 80
+# Nama reserved Windows (case-insensitive) yang tidak boleh jadi nama file.
+WINDOWS_RESERVED_NAMES = frozenset(
+    {
+        "CON",
+        "PRN",
+        "AUX",
+        "NUL",
+        "COM1",
+        "COM2",
+        "COM3",
+        "COM4",
+        "COM5",
+        "COM6",
+        "COM7",
+        "COM8",
+        "COM9",
+        "LPT1",
+        "LPT2",
+        "LPT3",
+        "LPT4",
+        "LPT5",
+        "LPT6",
+        "LPT7",
+        "LPT8",
+        "LPT9",
+    }
+)

core/detector.py

@@ -0,0 +1,167 @@
+"""
+detector.py
+Deteksi info video YouTube (judul, durasi, playlist) dari URL memakai yt-dlp,
+tanpa mendownload.
+"""
+
+from __future__ import annotations
+
+import re
+from dataclasses import dataclass, field
+from urllib.parse import parse_qsl, urlencode, urlsplit, urlunsplit
+
+import yt_dlp
+
+from core.constants import YOUTUBE_HOSTS
+from core.errors import DetectionError, classify_error, detection_message
+from core.log import get_ydl_logger
+
+__all__ = [
+    "DetectionError",
+    "DetectedContent",
+    "is_youtube_url",
+    "is_valid_url",
+    "strip_playlist_context",
+    "detect",
+]
+
+URL_PATTERN = re.compile(r"^https?://[^\s]+$", re.IGNORECASE)
+
+
+@dataclass
+class DetectedContent:
+    url: str
+    title: str
+    content_type: str = "VIDEO"  # "VIDEO" | "AUDIO" (audio = stream audio YouTube)
+    duration: float | None = None
+    entries: list = field(default_factory=list)  # untuk playlist
+    raw_info: dict = field(default_factory=dict)
+
+    @property
+    def platform(self) -> str:
+        return "YouTube"
+
+
+def _host(url: str) -> str:
+    try:
+        return urlsplit(url).netloc.lower().split(":")[0]
+    except ValueError:
+        return ""
+
+
+def is_youtube_url(url: str) -> bool:
+    """True bila URL http(s) dengan host domain YouTube yang dikenal."""
+    if not isinstance(url, str):
+        return False
+    url = url.strip()
+    if not url.lower().startswith(("http://", "https://")):
+        return False
+    host = _host(url)
+    return any(host == h or host.endswith("." + h) for h in YOUTUBE_HOSTS)
+
+
+def is_valid_url(text: str) -> bool:
+    """URL YouTube yang valid (http/https + host YouTube)."""
+    if not isinstance(text, str):
+        return False
+    text = text.strip()
+    return bool(URL_PATTERN.match(text)) and is_youtube_url(text)
+
+
+def strip_playlist_context(url: str) -> str:
+    """
+    Buang parameter "list" (dan "index") dari URL kalau URL itu jelas
+    menunjuk ke SATU video spesifik (ada "v=", /shorts/, /embed/, youtu.be),
+    bukan link playlist murni. Tanpa ini, video biasa yang kebawa "list="
+    salah narik metadata playlist-nya (judul salah, lambat, rawan 429).
+    """
+    parts = urlsplit(url)
+    pairs = parse_qsl(parts.query, keep_blank_values=True)
+
+    if not any(k == "list" for k, _ in pairs):
+        return url
+
+    query_dict = dict(pairs)
+    has_specific_video = (
+        "v" in query_dict
+        or "/shorts/" in parts.path
+        or "/embed/" in parts.path
+        or ((parts.netloc == "youtu.be" or parts.netloc.endswith(".youtu.be")) and parts.path.strip("/") != "")
+    )
+    if not has_specific_video:
+        return url
+
+    filtered = [(k, v) for k, v in pairs if k not in ("list", "index")]
+    new_query = urlencode(filtered)
+    return urlunsplit((parts.scheme, parts.netloc, parts.path, new_query, parts.fragment))
+
+
+def _base_ydl_opts() -> dict:
+    return {
+        "quiet": True,
+        "no_warnings": True,
+        # Alihkan noise mentah yt-dlp (baris ERROR:/WARNING:) ke file log,
+        # terminal hanya menampilkan pesan ramah via rich.
+        "logger": get_ydl_logger(),
+        "extractor_args": {"youtube": {"player_client": ["android", "web"]}},
+    }
+
+
+def _with_cookies_note(text: str) -> str:
+    from core.errors import friendly_message  # noqa: PLC0415
+
+    note = friendly_message("cookies").lstrip("❌ ").strip()
+    return f"{note}. {text}"
+
+
+def detect(url: str, cookies_browser: str | None = None, cookies_file: str | None = None) -> DetectedContent:
+    """Ekstrak info video YouTube dari URL tanpa mendownload."""
+    from core.utils import apply_cookie_opts  # noqa: PLC0415 - hindari circular import
+
+    if not is_valid_url(url):
+        raise DetectionError("URL bukan link YouTube yang valid")
+
+    url = strip_playlist_context(url)
+
+    ydl_opts = _base_ydl_opts()
+    ydl_opts.update({"skip_download": True, "noplaylist": False})
+
+    has_cookies = apply_cookie_opts(ydl_opts, cookies_browser, cookies_file)
+
+    def _extract(opts: dict):
+        with yt_dlp.YoutubeDL(opts) as ydl:
+            return ydl.extract_info(url, download=False)
+
+    try:
+        info = _extract(ydl_opts)
+    except yt_dlp.utils.DownloadError as e:
+        if has_cookies and classify_error(e) == "cookies":
+            # Cookies gagal dibaca (browser terkunci/DPAPI): coba tanpa cookies.
+            ydl_opts.pop("cookiesfrombrowser", None)
+            ydl_opts.pop("cookiefile", None)
+            try:
+                info = _extract(ydl_opts)
+            except yt_dlp.utils.DownloadError as e2:
+                raise DetectionError(_with_cookies_note(detection_message(e2))) from e2
+            except Exception as e2:  # noqa: BLE001
+                raise DetectionError("URL bukan link YouTube yang valid") from e2
+        else:
+            raise DetectionError(detection_message(e)) from e
+    except Exception as e:  # noqa: BLE001
+        raise DetectionError("URL bukan link YouTube yang valid") from e
+
+    if info is None:
+        raise DetectionError("URL bukan link YouTube yang valid")
+
+    raw_entries = info.get("entries") or []
+    entries = raw_entries if isinstance(raw_entries, list) else list(raw_entries)
+    vcodec = info.get("vcodec")
+
+    return DetectedContent(
+        url=url,
+        title=info.get("title") or info.get("id") or "untitled",
+        content_type="AUDIO" if vcodec == "none" else "VIDEO",
+        duration=info.get("duration"),
+        entries=entries,
+        raw_info=info,
+    )

core/downloader.py

@@ -0,0 +1,323 @@
+"""
+downloader.py
+Download video YouTube (MP4) / ekstrak audio (MP3) memakai yt-dlp,
+dengan progress hook Rich, resume otomatis, dan retry backoff eksponensial.
+"""
+
+from __future__ import annotations
+
+import time
+from dataclasses import dataclass
+from pathlib import Path
+
+import yt_dlp
+from rich.console import Console
+from rich.progress import (
+    BarColumn,
+    DownloadColumn,
+    Progress,
+    TextColumn,
+    TimeRemainingColumn,
+    TransferSpeedColumn,
+)
+
+from core.constants import (
+    EMBEDDABLE_VIDEO_FORMATS,
+    PLAYLIST_MODE_ALL,
+    RETRY_BASE_DELAY_SECONDS,
+    RETRY_JITTER_SECONDS,
+    RETRY_MAX_DELAY_SECONDS,
+    SUBTITLE_LANGS_DEFAULT,
+)
+from core.detector import DetectedContent
+from core.errors import (
+    DownloadCancelled,
+    DownloadFailed,
+    classify_error,
+    friendly_message,
+)
+from core.log import get_ydl_logger
+from core.options import DownloadChoice
+from core.utils import (
+    _iter_dir_files,
+    apply_cookie_opts,
+    build_filename,
+    find_indexed_files,
+    resolve_duplicate,
+)
+
+__all__ = [
+    "DownloadCancelled",
+    "DownloadFailed",
+    "DownloadResult",
+    "CONNECTION_ERROR_HINTS",
+    "EMBEDDABLE_VIDEO_FORMATS",
+    "backoff_delay",
+    "download",
+]
+
+console = Console()
+
+CONNECTION_ERROR_HINTS = tuple(__import__("core.constants", fromlist=["CONNECTION_ERROR_HINTS"]).CONNECTION_ERROR_HINTS)
+
+_HEIGHT_FILTERS = {
+    "Best": "",
+    "1080p": "[height<=1080]",
+    "720p": "[height<=720]",
+    "480p": "[height<=480]",
+    "360p": "[height<=360]",
+    "Worst": "",
+}
+
+_AUDIO_KBPS = {"Best": "0", "320kbps": "320", "192kbps": "192", "128kbps": "128"}
+
+
+@dataclass
+class DownloadResult:
+    filepath: Path
+    size_bytes: int
+    elapsed_seconds: float
+    file_count: int = 1  # >1 kalau --playlist all
+
+
+def _quality_to_format_selector(quality: str, ext: str = "mp4") -> str:
+    """
+    Selector video: prioritaskan kombinasi video+audio yang codec-nya sudah
+    kompatibel dengan MP4 (h264+aac) biar ffmpeg tinggal remux tanpa re-encode.
+    """
+    hf = _HEIGHT_FILTERS.get(quality, "")
+
+    if quality == "Worst":
+        return f"worstvideo*{hf}+worstaudio/worst{hf}"
+
+    if ext == "mp4":
+        return f"bestvideo[ext=mp4]{hf}+bestaudio[ext=m4a]/bestvideo*{hf}+bestaudio/best{hf}"
+    return f"bestvideo*{hf}+bestaudio/best{hf}"
+
+
+def _audio_quality_to_kbps(quality: str) -> str:
+    return _AUDIO_KBPS.get(quality, "0")
+
+
+def _make_progress_hook(progress: Progress, task_id):
+    def hook(d: dict):
+        if d.get("status") == "downloading":
+            total = d.get("total_bytes") or d.get("total_bytes_estimate")
+            downloaded = d.get("downloaded_bytes", 0)
+            if total:
+                progress.update(task_id, total=total, completed=downloaded)
+            filename = d.get("filename") or "Downloading"
+            progress.update(task_id, description=filename[:40])
+        elif d.get("status") == "finished":
+            try:
+                total = progress.tasks[task_id].total
+            except (IndexError, AttributeError):
+                total = None
+            if total:
+                progress.update(task_id, completed=total)
+
+    return hook
+
+
+def _classify_error(e: Exception) -> str:
+    """Wrapper kompatibel - logika kanonis di core.errors.classify_error."""
+    return classify_error(e)
+
+
+def _friendly_message(kind: str) -> str:
+    return friendly_message(kind)
+
+
+def backoff_delay(attempt: int) -> float:
+    """Delay eksponensial untuk retry ke-`attempt` (1-indexed), dibatasi max + jitter."""
+    import random
+
+    base = RETRY_BASE_DELAY_SECONDS * (2.0 ** max(0, attempt - 1))
+    capped = min(base, RETRY_MAX_DELAY_SECONDS)
+    return capped + random.uniform(0, RETRY_JITTER_SECONDS)
+
+
+def download(
+    content: DetectedContent,
+    choice: DownloadChoice,
+    output_folder: Path,
+    naming_template: str,
+    max_retry: int = 3,
+    cookies_browser: str | None = None,
+    cookies_file: str | None = None,
+) -> DownloadResult:
+    """Download video/audio YouTube sesuai pilihan, retry backoff untuk error koneksi."""
+    output_folder.mkdir(parents=True, exist_ok=True)
+
+    ext = choice.fmt
+    filename = build_filename(content.platform, content.title, ext, naming_template)
+
+    entries_count = len(getattr(content, "entries", None) or [])
+    playlist_all = getattr(choice, "playlist_mode", "single") == PLAYLIST_MODE_ALL and entries_count > 1
+    # "noplaylist" tidak berefek untuk URL playlist murni (yt-dlp #5215):
+    # paksa entry pertama bila mode single.
+    force_single_item = not playlist_all and entries_count > 1
+
+    dest = resolve_duplicate(output_folder / filename, multi_item=playlist_all)
+
+    ydl_opts = _build_ydl_opts(
+        choice,
+        dest,
+        cookies_browser,
+        cookies_file,
+        force_single_item=force_single_item,
+        playlist_all=playlist_all,
+    )
+
+    attempt = 0
+    start_time = time.time()
+
+    with Progress(
+        TextColumn("[progress.description]{task.description}"),
+        BarColumn(),
+        DownloadColumn(),
+        TransferSpeedColumn(),
+        TimeRemainingColumn(),
+        console=console,
+    ) as progress:
+        task_id = progress.add_task(f"📥 {content.title[:40]}", total=None)
+        ydl_opts["progress_hooks"] = [_make_progress_hook(progress, task_id)]
+
+        while True:
+            try:
+                with yt_dlp.YoutubeDL(ydl_opts) as ydl:
+                    ydl.download([content.url])
+                break
+            except KeyboardInterrupt:
+                raise DownloadCancelled("Download dibatalkan oleh user") from None
+            except yt_dlp.utils.DownloadError as e:
+                kind = _classify_error(e)
+                if kind == "cookies" and ("cookiesfrombrowser" in ydl_opts or "cookiefile" in ydl_opts):
+                    ydl_opts.pop("cookiesfrombrowser", None)
+                    ydl_opts.pop("cookiefile", None)
+                    console.print(
+                        "[yellow]⚠️  Cookies browser gagal dibaca (tutup browser-nya) - lanjut tanpa cookies...[/yellow]"
+                    )
+                    continue
+                if kind == "connection" and attempt < max_retry:
+                    attempt += 1
+                    delay = backoff_delay(attempt)
+                    console.print(f"🔄 Retry {attempt}/{max_retry} dalam {delay:.0f}s...")
+                    time.sleep(delay)
+                    continue
+                raise DownloadFailed(_friendly_message(kind)) from e
+            except Exception as e:  # noqa: BLE001
+                raise DownloadFailed(_friendly_message(_classify_error(e))) from e
+
+    elapsed = time.time() - start_time
+    final_path, total_size, file_count = _resolve_final_path(dest, multi_item=playlist_all)
+
+    return DownloadResult(filepath=final_path, size_bytes=total_size, elapsed_seconds=elapsed, file_count=file_count)
+
+
+def _find_result_files(dest: Path, multi_item: bool = False) -> list[Path]:
+    """Cari file hasil download yang cocok dengan `dest` (aman dari karakter glob di judul)."""
+    if multi_item:
+        return find_indexed_files(dest)
+
+    if dest.exists():
+        return [dest]
+
+    image_exts = {".jpg", ".jpeg", ".png", ".webp"}
+    stem = dest.stem
+    matches: list[Path] = []
+    non_image_matches: list[Path] = []
+    for p in _iter_dir_files(dest.parent):
+        if not p.is_file() or p.stem != stem:
+            continue
+        matches.append(p)
+        if p.suffix.lower() not in image_exts:
+            non_image_matches.append(p)
+
+    if non_image_matches:
+        return [sorted(non_image_matches, key=lambda p: p.name)[0]]
+    if matches:
+        return [sorted(matches, key=lambda p: p.name)[0]]
+    return []
+
+
+def _resolve_final_path(dest: Path, multi_item: bool = False) -> tuple[Path, int, int]:
+    """Return (path_representatif, total_size_bytes, jumlah_file)."""
+    matches = _find_result_files(dest, multi_item=multi_item)
+    if not matches:
+        return dest, 0, 0
+    total_size = sum(m.stat().st_size for m in matches if m.exists())
+    return matches[0], total_size, len(matches)
+
+
+def _build_ydl_opts(
+    choice: DownloadChoice,
+    dest: Path,
+    cookies_browser: str | None = None,
+    cookies_file: str | None = None,
+    force_single_item: bool = False,
+    playlist_all: bool = False,
+) -> dict:
+    if playlist_all:
+        outtmpl = f"{dest.with_suffix('')}-%(playlist_index,autonumber)d"
+    else:
+        outtmpl = str(dest.with_suffix(""))  # ekstensi diserahkan ke yt-dlp/postprocessor
+
+    opts = {
+        "outtmpl": outtmpl + ".%(ext)s",
+        "quiet": True,
+        "no_warnings": True,
+        "noprogress": True,
+        # Lihat detector._base_ydl_opts: noise mentah ke file log saja.
+        "logger": get_ydl_logger(),
+        "retries": 0,  # retry koneksi ditangani manual (backoff) di download()
+        "fragment_retries": 3,
+        "continuedl": True,  # resume file parsial (.part)
+        "skip_unavailable_fragments": False,
+        "noplaylist": not playlist_all,
+        "extractor_args": {"youtube": {"player_client": ["android", "web"]}},
+    }
+
+    if force_single_item:
+        opts["playlist_items"] = "1"
+
+    apply_cookie_opts(opts, cookies_browser, cookies_file)
+
+    if choice.output_kind == "video":
+        opts["format"] = _quality_to_format_selector(choice.quality, choice.fmt)
+        opts["merge_output_format"] = choice.fmt
+        postprocessors: list[dict] = []
+        if choice.fmt in EMBEDDABLE_VIDEO_FORMATS:
+            postprocessors.append({"key": "EmbedThumbnail"})
+            opts["writethumbnail"] = True
+        else:
+            opts["writethumbnail"] = False
+        _apply_subs_metadata_opts(opts, postprocessors, choice)
+        opts["postprocessors"] = postprocessors
+
+    else:  # audio -> MP3
+        opts["format"] = "bestaudio/best"
+        postprocessors = [
+            {
+                "key": "FFmpegExtractAudio",
+                "preferredcodec": "mp3",
+                "preferredquality": _audio_quality_to_kbps(choice.quality),
+            }
+        ]
+        _apply_subs_metadata_opts(opts, postprocessors, choice, audio=True)
+        opts["postprocessors"] = postprocessors
+
+    return opts
+
+
+def _apply_subs_metadata_opts(opts: dict, postprocessors: list[dict], choice, audio: bool = False) -> None:
+    """Tambahkan opsi subtitle & metadata ke ydl opts (default mati)."""
+    write_subs = bool(getattr(choice, "write_subs", False))
+    if write_subs:
+        langs = getattr(choice, "sub_langs", None) or list(SUBTITLE_LANGS_DEFAULT)
+        opts["writesubtitles"] = True
+        opts["subtitleslangs"] = langs
+        if bool(getattr(choice, "embed_subs", False)) and not audio:
+            opts["embedsubtitles"] = True
+    if bool(getattr(choice, "embed_metadata", False)):
+        postprocessors.append({"key": "FFmpegMetadata", "add_metadata": True})