lumenfetch 2.0.0__py3-none-any.whl

core/errors.py

@@ -0,0 +1,118 @@
+"""errors.py - Taxonomy error terpusat.
+
+Sebelumnya logic klasifikasi error duplikat di detector.py dan
+downloader.py dengan pola string yang bisa drift (mis. satu modul
+kenal "429", satunya tidak). Sekarang satu fungsi klasifikasi dipakai
+bersama, dengan pesan ramah yang konsisten.
+"""
+
+from __future__ import annotations
+
+from core.constants import CONNECTION_ERROR_HINTS
+
+
+class DetectionError(Exception):
+    """Error ramah untuk ditampilkan ke user (bukan traceback mentah)."""
+
+
+class DownloadCancelled(Exception):
+    """User cancel download (Ctrl+C)."""
+
+
+class DownloadFailed(Exception):
+    """Error fatal yang gak perlu di-retry (pesan sudah ramah)."""
+
+
+# Kind yang dikenal classify_error().
+ERROR_KIND_CONNECTION = "connection"
+ERROR_KIND_PRIVATE = "private"
+ERROR_KIND_FORMAT = "format"
+ERROR_KIND_DISK = "disk"
+ERROR_KIND_RATE_LIMIT = "rate_limit"
+ERROR_KIND_REMOVED = "removed"
+ERROR_KIND_UNSUPPORTED = "unsupported"
+ERROR_KIND_BLOCKED = "blocked"
+ERROR_KIND_COOKIES = "cookies"
+ERROR_KIND_UNKNOWN = "unknown"
+
+_FRIENDLY_MESSAGES = {
+    ERROR_KIND_CONNECTION: "❌ Koneksi internet bermasalah, coba lagi",
+    ERROR_KIND_PRIVATE: "❌ Konten ini private / tidak bisa diakses - coba aktifkan Cookies dari Browser di settings",
+    ERROR_KIND_FORMAT: "❌ Format tidak tersedia untuk konten ini",
+    ERROR_KIND_DISK: "❌ Tidak cukup ruang disk",
+    ERROR_KIND_RATE_LIMIT: "❌ Terlalu banyak request ke platform ini - tunggu sebentar lalu coba lagi",
+    ERROR_KIND_REMOVED: "❌ Konten ini sudah dihapus / tidak lagi tersedia",
+    ERROR_KIND_UNSUPPORTED: "❌ URL tidak valid atau tidak didukung",
+    ERROR_KIND_BLOCKED: (
+        "❌ Platform memblokir request otomatis (bot-check) - update yt-dlp "
+        "(pip install --upgrade yt-dlp) lalu aktifkan Cookies dari Browser di settings"
+    ),
+    ERROR_KIND_COOKIES: (
+        "❌ Gagal membaca cookies dari browser - tutup browser-nya sampai "
+        "benar-benar tertutup (cek Task Manager), lalu coba lagi"
+    ),
+    ERROR_KIND_UNKNOWN: "❌ Terjadi kesalahan saat download",
+}
+
+
+def classify_error(exc: Exception) -> str:
+    """Klasifikasikan exception (terutama dari yt-dlp) jadi kind string."""
+    msg = str(exc).lower()
+    if any(hint in msg for hint in CONNECTION_ERROR_HINTS):
+        return ERROR_KIND_CONNECTION
+    if "could not copy" in msg and "cookie" in msg:
+        # File cookies dikunci browser yang masih terbuka (yt-dlp #7271).
+        # Bukan URL rusak - harus ditangani khusus (coba tanpa cookies).
+        return ERROR_KIND_COOKIES
+    if "failed to decrypt" in msg or "dpapi" in msg or "failed to load cookies" in msg:
+        # Cookies terenkripsi tak bisa didekripsi (yt-dlp #10927, umum di
+        # Edge/Chrome Windows) - sama: bukan URL rusak, fallback tanpa cookies.
+        return ERROR_KIND_COOKIES
+    if "unexpected response from webpage request" in msg or "confirm you are on the latest version" in msg:
+        # Challenge bot-check yang cuma lolos pakai impersonation + cookies,
+        # bukan URL rusak.
+        return ERROR_KIND_BLOCKED
+    if "private" in msg or "login required" in msg or "login" in msg or "unavailable" in msg:
+        return ERROR_KIND_PRIVATE
+    if "unsupported url" in msg:
+        return ERROR_KIND_UNSUPPORTED
+    if "requested format is not available" in msg or "no video formats" in msg:
+        return ERROR_KIND_FORMAT
+    if "no space left" in msg:
+        return ERROR_KIND_DISK
+    if "429" in msg or "too many requests" in msg or "rate-limit" in msg or "rate limit" in msg:
+        return ERROR_KIND_RATE_LIMIT
+    if "404" in msg or "not found" in msg or "removed" in msg or "deleted" in msg or "no longer available" in msg:
+        return ERROR_KIND_REMOVED
+    return ERROR_KIND_UNKNOWN
+
+
+def _curl_cffi_available() -> bool:
+    import importlib.util
+
+    return importlib.util.find_spec("curl_cffi") is not None
+
+
+def blocked_message() -> str:
+    """Pesan blocked yang adaptif: sebut curl_cffi hanya bila belum terinstall."""
+    base = _FRIENDLY_MESSAGES[ERROR_KIND_BLOCKED]
+    if not _curl_cffi_available():
+        base += " + install paket 'curl_cffi' (pip install curl_cffi)"
+    return base
+
+
+def friendly_message(kind: str) -> str:
+    """Pesan ramah untuk kind hasil classify_error()."""
+    if kind == ERROR_KIND_BLOCKED:
+        return blocked_message()
+    return _FRIENDLY_MESSAGES.get(kind, _FRIENDLY_MESSAGES[ERROR_KIND_UNKNOWN])
+
+
+def detection_message(exc: Exception) -> str:
+    """Pesan deteksi: sama dengan friendly, tapi unknown -> URL YouTube tidak valid."""
+    kind = classify_error(exc)
+    if kind == ERROR_KIND_FORMAT:
+        return "Konten ini tidak berisi video yang bisa didownload"
+    if kind == ERROR_KIND_UNKNOWN:
+        return "URL bukan link YouTube yang valid atau tidak didukung"
+    return friendly_message(kind).lstrip("❌ ").strip()

core/ffmpeg.py

@@ -0,0 +1,74 @@
+"""ffmpeg.py - Deteksi & penyiapan ffmpeg (sistem dulu, bundled fallback)."""
+
+from __future__ import annotations
+
+import shutil
+import subprocess
+
+from core.constants import FFMPEG_TIMEOUT_SECONDS
+
+
+def find_system_ffmpeg() -> str | None:
+    """Return path ffmpeg sistem kalau ada di PATH, else None."""
+    return shutil.which("ffmpeg")
+
+
+def is_available() -> bool:
+    return find_system_ffmpeg() is not None
+
+
+def exe() -> str:
+    """Nama/path executable ffmpeg yang dipakai yt-dlp (merge MP4 / ekstrak MP3)."""
+    return find_system_ffmpeg() or "ffmpeg"
+
+
+def ensure() -> bool:
+    """Pastikan ffmpeg bisa dipanggil.
+
+    1. Kalau ffmpeg sistem ada -> langsung True (tanpa download apa pun).
+    2. Kalau tidak ada -> coba static_ffmpeg bundled (lazy import).
+    3. Verifikasi dengan `ffmpeg -version` (cepat, timeout 10s).
+    """
+    if is_available():
+        return _verify(exe())
+    try:
+        import static_ffmpeg  # noqa: PLC0415
+    except ImportError:
+        return False
+    try:
+        static_ffmpeg.add_paths()
+    except Exception:  # noqa: BLE001
+        return False
+    return _verify(exe())
+
+
+def _verify(ffmpeg_exe: str, timeout: int = 10) -> bool:
+    try:
+        subprocess.run(
+            [ffmpeg_exe, "-version"],
+            check=True,
+            stdout=subprocess.DEVNULL,
+            stderr=subprocess.DEVNULL,
+            timeout=timeout,
+        )
+        return True
+    except (subprocess.CalledProcessError, FileNotFoundError, OSError, subprocess.TimeoutExpired):
+        return False
+
+
+def version() -> str | None:
+    """Versi ffmpeg (baris pertama `ffmpeg -version`), None kalau tak tersedia."""
+    try:
+        out = subprocess.run(
+            [exe(), "-version"],
+            check=True,
+            capture_output=True,
+            text=True,
+            timeout=10,
+        ).stdout
+        return out.splitlines()[0].strip() if out else None
+    except (subprocess.CalledProcessError, FileNotFoundError, OSError, subprocess.TimeoutExpired):
+        return None
+
+
+__all__ = ["find_system_ffmpeg", "is_available", "exe", "ensure", "version", "FFMPEG_TIMEOUT_SECONDS"]

core/log.py

@@ -0,0 +1,75 @@
+"""log.py - Logging file terpusat (console tetap ramah via rich)."""
+
+from __future__ import annotations
+
+import logging
+import sys
+from pathlib import Path
+
+_LOGGER_NAME = "lumenfetch"
+_configured = False
+
+
+def log_file_path() -> Path:
+    """Lokasi file log (sefolder dengan config user)."""
+    from core.utils import _user_data_dir  # noqa: PLC0415 - hindari circular import
+
+    d = _user_data_dir()
+    try:
+        d.mkdir(parents=True, exist_ok=True)
+    except OSError:
+        pass
+    return d / "lumenfetch.log"
+
+
+def setup(verbose: bool = False) -> logging.Logger:
+    """Setup handler file + stderr. Aman dipanggil berkali-kali."""
+    global _configured
+    logger = logging.getLogger(_LOGGER_NAME)
+    level = logging.DEBUG if verbose else logging.INFO
+    logger.setLevel(level)
+    if _configured:
+        return logger
+    fmt = logging.Formatter("%(asctime)s %(levelname)s %(name)s: %(message)s")
+    try:
+        fh = logging.FileHandler(str(log_file_path()), encoding="utf-8")
+        fh.setLevel(logging.DEBUG)
+        fh.setFormatter(fmt)
+        logger.addHandler(fh)
+    except OSError:
+        pass
+    # Error ke stderr agar tidak hilang saat rich console di-redirect.
+    sh = logging.StreamHandler(sys.stderr)
+    sh.setLevel(logging.WARNING)
+    sh.setFormatter(fmt)
+    logger.addHandler(sh)
+    _configured = True
+    return logger
+
+
+def get_logger(name: str = _LOGGER_NAME) -> logging.Logger:
+    return logging.getLogger(name)
+
+
+def get_ydl_logger() -> logging.Logger:
+    """Logger khusus untuk yt-dlp: semua output mentahnya (termasuk baris
+    `ERROR:` yang tidak bisa dimatikan via `quiet`) dialihkan ke file log,
+    TIDAK ke terminal. Terminal hanya menampilkan pesan ramah via rich."""
+    name = f"{_LOGGER_NAME}.ydl"
+    logger = logging.getLogger(name)
+    if getattr(logger, "_lumenfetch_configured", False):
+        return logger
+    logger.setLevel(logging.DEBUG)
+    logger.propagate = False
+    try:
+        fh = logging.FileHandler(str(log_file_path()), encoding="utf-8")
+        fh.setLevel(logging.DEBUG)
+        fh.setFormatter(logging.Formatter("%(asctime)s %(levelname)s %(name)s: %(message)s"))
+        logger.addHandler(fh)
+    except OSError:
+        logger.addHandler(logging.NullHandler())
+    logger._lumenfetch_configured = True  # type: ignore[attr-defined]
+    return logger
+
+
+__all__ = ["setup", "get_logger", "get_ydl_logger", "log_file_path"]

core/options.py

@@ -0,0 +1,292 @@
+"""
+options.py
+Semua prompt/menu interaktif (pilih output, quality, dll) memakai Rich.
+Tidak ada logic download di sini.
+"""
+
+from __future__ import annotations
+
+from dataclasses import dataclass
+
+from rich.console import Console
+from rich.panel import Panel
+from rich.prompt import Confirm, Prompt
+from rich.table import Table
+
+from core.constants import (
+    AUDIO_FORMAT,
+    AUDIO_QUALITIES,
+    PLAYLIST_MODES,
+    SUBTITLE_LANGS_DEFAULT,
+    VERSION,
+    VIDEO_FORMAT,
+    VIDEO_QUALITIES,
+)
+from core.detector import DetectedContent
+from core.utils import estimate_audio_size_bytes, estimate_video_size_bytes, format_duration, format_eta, format_size
+
+console = Console()
+
+__all__ = [
+    "DownloadChoice",
+    "VIDEO_QUALITIES",
+    "AUDIO_QUALITIES",
+    "PLAYLIST_MODES",
+]
+
+
+@dataclass
+class DownloadChoice:
+    output_kind: str  # "video" | "audio"
+    quality: str = "Best"
+    fmt: str = ""  # "mp4" untuk video, "mp3" untuk audio
+    playlist_mode: str = "single"  # "single" | "all"
+    write_subs: bool = False
+    sub_langs: list[str] | None = None
+    embed_subs: bool = False
+    embed_metadata: bool = False
+
+
+def show_header(version: str = VERSION) -> None:
+    console.print(
+        Panel.fit(
+            f"[bold cyan]Lumenfetch[/bold cyan]  v{version}\n[dim]YouTube downloader (MP4/MP3)[/dim]",
+            border_style="cyan",
+        )
+    )
+
+
+def show_update_notice(installed_version: str, latest_version: str) -> None:
+    console.print(
+        Panel(
+            f"yt-dlp kamu versi [bold]{installed_version}[/bold], "
+            f"versi terbaru [bold green]{latest_version}[/bold green] sudah tersedia.\n"
+            "[dim]YouTube sering ubah sistemnya, jadi update disarankan biar tetap kompatibel:[/dim]\n"
+            "[bold cyan]pip install --upgrade yt-dlp[/bold cyan]",
+            title="🔔 Update yt-dlp tersedia",
+            border_style="yellow",
+        )
+    )
+
+
+def show_content_panel(content: DetectedContent) -> None:
+    count_text = f" ({len(content.entries)} video)" if content.entries else ""
+    lines = [
+        f"[bold]Judul[/bold]     : {content.title}",
+        f"[bold]Tipe[/bold]      : {content.content_type}{count_text}",
+    ]
+    if content.duration:
+        lines.append(f"[bold]Durasi[/bold]    : {format_duration(content.duration)}")
+    console.print(Panel("\n".join(lines), title="✅ Video Terdeteksi", border_style="green"))
+
+
+def _select_from_list(
+    prompt_text: str,
+    choices: list[str],
+    default_index: int = 0,
+    extra: list[str] | None = None,
+) -> str:
+    console.print(f"\n{prompt_text}")
+    for i, c in enumerate(choices):
+        line = f"  [{i + 1}] {c}"
+        if i == default_index:
+            line += "  (default)"
+        if extra and extra[i]:
+            line += f"  [dim]{extra[i]}[/dim]"
+        console.print(line)
+
+    raw = Prompt.ask("→", default=str(default_index + 1))
+    try:
+        idx = int(str(raw).strip()) - 1
+        if 0 <= idx < len(choices):
+            return choices[idx]
+    except (ValueError, TypeError):
+        pass
+    return choices[default_index]
+
+
+def ask_output_type() -> str:
+    console.print("\nPilih tipe output:")
+    console.print("  [1] Video (MP4)")
+    console.print("  [2] Audio (MP3)")
+    raw = Prompt.ask("→", default="1")
+    return "audio" if str(raw).strip() == "2" else "video"
+
+
+def _build_size_labels(
+    formats: list[dict],
+    qualities: list[str],
+    duration: float | None,
+    avg_speed_bps: float | None,
+    estimator,
+) -> list[str]:
+    labels = []
+    for quality in qualities:
+        size_bytes = estimator(formats, quality, duration)
+        if size_bytes is None:
+            labels.append("")
+            continue
+        size_text = f"~{format_size(size_bytes)}"
+        eta_text = format_eta(size_bytes, avg_speed_bps)
+        labels.append(f"({size_text}, {eta_text})" if eta_text else f"({size_text})")
+    return labels
+
+
+def ask_video_choice(content: DetectedContent | None = None, avg_speed_bps: float | None = None) -> DownloadChoice:
+    extra = None
+    if content is not None:
+        formats = content.raw_info.get("formats") or []
+        extra = _build_size_labels(formats, VIDEO_QUALITIES, content.duration, avg_speed_bps, estimate_video_size_bytes)
+
+    quality = _select_from_list("Pilih Quality:", VIDEO_QUALITIES, default_index=0, extra=extra)
+    return DownloadChoice(output_kind="video", quality=quality, fmt=VIDEO_FORMAT)
+
+
+def ask_audio_choice(content: DetectedContent | None = None, avg_speed_bps: float | None = None) -> DownloadChoice:
+    extra = None
+    if content is not None:
+        formats = content.raw_info.get("formats") or []
+        extra = _build_size_labels(formats, AUDIO_QUALITIES, content.duration, avg_speed_bps, estimate_audio_size_bytes)
+
+    quality = _select_from_list("Pilih Quality (bitrate MP3):", AUDIO_QUALITIES, default_index=0, extra=extra)
+    return DownloadChoice(output_kind="audio", quality=quality, fmt=AUDIO_FORMAT)
+
+
+def ask_playlist_mode(total: int) -> str:
+    """Tanya mode playlist: 1 video pertama (default) atau semua."""
+    console.print(f"\nURL ini playlist berisi {total} video:")
+    console.print("  [1] Download video pertama saja  (default)")
+    console.print(f"  [2] Download semua ({total} video)")
+    raw = Prompt.ask("→", default="1")
+    return "all" if str(raw).strip() == "2" else "single"
+
+
+def ask_subtitle_options() -> tuple[bool, list[str] | None, bool]:
+    """Return (write_subs, sub_langs, embed_subs). Default mati."""
+    console.print("\nDownload subtitle?")
+    console.print("  [1] Tidak  (default)")
+    console.print("  [2] Ya, download file subtitle")
+    raw = Prompt.ask("→", default="1")
+    if str(raw).strip() != "2":
+        return False, None, False
+    langs_raw = Prompt.ask("Bahasa subtitle (koma, mis. en,id)", default=",".join(SUBTITLE_LANGS_DEFAULT))
+    langs = [p.strip().lower() for p in str(langs_raw).replace(",", " ").split() if p.strip()]
+    embed = Confirm.ask("Embed subtitle ke file MP4?", default=False)
+    return True, langs or list(SUBTITLE_LANGS_DEFAULT), bool(embed)
+
+
+def ask_embed_metadata() -> bool:
+    return Confirm.ask("Embed metadata (judul/artis) ke file hasil?", default=False)
+
+
+def resolve_choice(content: DetectedContent, avg_speed_bps: float | None = None) -> DownloadChoice:
+    """Alur pilihan dinamis: video YouTube -> tanya output, lalu quality."""
+    if content.content_type == "AUDIO":
+        return ask_audio_choice(content, avg_speed_bps)
+    kind = ask_output_type()
+    if kind == "audio":
+        return ask_audio_choice(content, avg_speed_bps)
+    return ask_video_choice(content, avg_speed_bps)
+
+
+def confirm_filename(filename: str) -> bool:
+    console.print(f"\n📄 Nama file: [bold]{filename}[/bold]")
+    return Confirm.ask("Lanjutkan?", default=True)
+
+
+def ask_again_or_url() -> bool | str:
+    """Prompt lanjutan yang toleran terhadap paste URL langsung."""
+    from core.detector import is_valid_url  # noqa: PLC0415 - hindari circular import
+
+    while True:
+        raw = Prompt.ask("\nDownload lagi? [y/n] [dim](atau paste URL langsung)[/dim]", default="y").strip()
+        if is_valid_url(raw):
+            return raw
+        low = raw.lower()
+        if low in ("y", "yes") or low.startswith("y"):
+            return True
+        if low in ("n", "no", "q", "quit") or low.startswith("n"):
+            return False
+        console.print("[red]Jawab y/n, atau paste URL langsung.[/red]")
+
+
+def ask_again() -> bool:
+    return Confirm.ask("\nDownload lagi?", default=True)
+
+
+def show_history_table(history: list[dict]) -> None:
+    if not history:
+        console.print("[dim]Belum ada riwayat download.[/dim]")
+        return
+
+    table = Table(title="Riwayat Download (20 terakhir)")
+    for col in ("No", "Tanggal", "Judul", "Format", "Ukuran", "Status"):
+        table.add_column(col)
+
+    for i, entry in enumerate(history, start=1):
+        if not isinstance(entry, dict):
+            continue
+        status = "✅" if entry.get("success") else "❌"
+        table.add_row(
+            str(i),
+            str(entry.get("date") or "-"),
+            str(entry.get("title") or "-")[:40],
+            str(entry.get("format") or "-"),
+            str(entry.get("size") or "-"),
+            status,
+        )
+    console.print(table)
+
+
+def show_help() -> None:
+    console.print(
+        Panel(
+            "[bold]COMMAND TERSEDIA[/bold]\n"
+            "history   Lihat riwayat download\n"
+            "settings  Buka pengaturan\n"
+            "help      Tampilkan halaman ini\n"
+            "q/quit    Keluar dari aplikasi\n\n"
+            "[bold]CARA PAKAI[/bold]\n"
+            "1. Paste link video YouTube\n"
+            "2. Pilih output Video (MP4) / Audio (MP3)\n"
+            "3. Pilih quality\n"
+            "4. Tunggu download selesai\n\n"
+            "[bold]CANCEL DOWNLOAD[/bold]\n"
+            "Tekan Ctrl+C saat download berjalan",
+            title="📖 Lumenfetch Help",
+            border_style="blue",
+        )
+    )
+
+
+def show_settings_menu(config: dict) -> str:
+    cookies_status = config.get("cookies_browser") or config.get("cookies_file") or "none"
+    console.print("\n[bold]Settings[/bold]")
+    console.print(f"  [1] Ganti folder download default  [dim](saat ini: {config['download_folder']})[/dim]")
+    console.print(f"  [2] Ganti max retry  [dim](saat ini: {config['max_retry']})[/dim]")
+    console.print(f"  [3] Toggle auto-paste clipboard  [dim](saat ini: {'ON' if config['auto_paste'] else 'OFF'})[/dim]")
+    console.print(f"  [4] Ganti naming template  [dim](saat ini: {config['naming_template']})[/dim]")
+    console.print(f"  [5] Pakai cookies dari browser/file  [dim](saat ini: {cookies_status})[/dim]")
+    console.print("  [6] Reset ke default")
+    console.print("  [7] Kembali")
+    return Prompt.ask("→", default="7")
+
+
+def ask_cookies_browser() -> str | None:
+    """Minta user pilih browser buat ambil cookies (konten age-restricted/private)."""
+    console.print(
+        "\n[dim]Dipakai buat video yang minta login / age-restricted.[/dim]\n"
+        "[dim]Pastikan kamu sudah login ke YouTube di browser pilihanmu.[/dim]"
+    )
+    labels = ["Nonaktifkan", "Chrome", "Firefox", "Edge", "Brave", "Opera", "Vivaldi", "Safari"]
+    values: list[str | None] = [None, "chrome", "firefox", "edge", "brave", "opera", "vivaldi", "safari"]
+    for i, label in enumerate(labels):
+        console.print(f"  [{i + 1}] {label}")
+    raw = Prompt.ask("→", default="1")
+    try:
+        idx = int(str(raw).strip()) - 1
+        if 0 <= idx < len(values):
+            return values[idx]
+    except (ValueError, TypeError):
+        pass
+    return None

core/update_checker.py

@@ -0,0 +1,63 @@
+"""
+update_checker.py
+Cek versi terbaru yt-dlp di PyPI, buat kasih notice kalau versi lokal ketinggalan.
+Gagal diam-diam kalau tidak ada internet / PyPI tidak bisa diakses - proses
+pengecekan TIDAK BOLEH menghalangi atau memperlambat user pakai aplikasi.
+"""
+
+from __future__ import annotations
+
+import json
+import urllib.request
+from urllib.error import URLError
+
+import yt_dlp
+
+from core.constants import UPDATE_CHECK_TIMEOUT_SECONDS
+
+PYPI_URL = "https://pypi.org/pypi/yt-dlp/json"
+TIMEOUT_SECONDS = UPDATE_CHECK_TIMEOUT_SECONDS
+
+
+def get_installed_version() -> str:
+    return yt_dlp.version.__version__
+
+
+def get_latest_version(timeout: float = TIMEOUT_SECONDS) -> str | None:
+    """Return versi terbaru yt-dlp di PyPI, atau None kalau gagal cek (mis. tidak ada internet)."""
+    try:
+        with urllib.request.urlopen(PYPI_URL, timeout=timeout) as response:  # noqa: S310
+            data = json.loads(response.read().decode("utf-8"))
+        version = data.get("info", {}).get("version")
+        return str(version) if version else None
+    except (URLError, TimeoutError, json.JSONDecodeError, OSError, ValueError):
+        return None
+
+
+def _version_tuple(version: str) -> tuple[int, ...]:
+    """yt-dlp pakai format versi YYYY.MM.DD[.rev] - urutkan sebagai angka biar perbandingan benar."""
+    parts = []
+    for part in str(version).split("."):
+        try:
+            parts.append(int(part))
+        except ValueError:
+            parts.append(0)
+    return tuple(parts)
+
+
+def check_for_update() -> tuple[bool, str, str | None]:
+    """
+    Cek apakah ada versi yt-dlp yang lebih baru dari yang terinstall.
+
+    Return (ada_update, versi_terinstall, versi_terbaru_atau_None).
+    ada_update selalu False kalau sudah versi terbaru ATAU kalau pengecekan
+    gagal (fail-safe - tidak ada internet bukan berarti "ada update").
+    """
+    installed = get_installed_version()
+    latest = get_latest_version()
+
+    if latest is None:
+        return False, installed, None
+
+    has_update = _version_tuple(latest) > _version_tuple(installed)
+    return has_update, installed, latest