ytp-dl 0.6.7__tar.gz → 0.6.9__tar.gz

{ytp_dl-0.6.7 → ytp_dl-0.6.9}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: ytp-dl
-Version: 0.6.7
+Version: 0.6.9
 Summary: YouTube video downloader with Mullvad VPN integration and Flask API
 Home-page: https://github.com/yourusername/ytp-dl
 Author: dumgum82
@@ -57,7 +57,7 @@ A lightweight YouTube downloader with Mullvad VPN integration and an HTTP API.
 ## Installation
 
 ```bash
-pip install ytp-dl==0.6.7 yt-dlp[default]
+pip install ytp-dl==0.6.9 yt-dlp[default]
 ```
 
 Requirements:
@@ -242,7 +242,7 @@ When Mullvad connects/disconnects, Linux routing can change in a way that breaks
 
 * Installs Python, FFmpeg, Mullvad CLI, and Deno
 * Creates a virtualenv at `/opt/yt-dlp-mullvad/venv`
-* Installs `ytp-dl==0.6.7` + `yt-dlp[default]` + `gunicorn`
+* Installs `ytp-dl==0.6.9` + `yt-dlp[default]` + `gunicorn`
 * Installs a policy-routing oneshot service to keep the public API reachable
 * Sets up a systemd service on port 5000
 * Runs Gunicorn with `gthread` (threaded) workers
@@ -258,7 +258,7 @@ Note: `gthread` is a built-in Gunicorn worker class (no extra Python dependency)
 #   - Installs Deno system-wide (JS runtime required for modern YouTube extraction via yt-dlp)
 #   - Configures policy routing so the public API stays reachable while Mullvad toggles
 #   - Creates a virtualenv at /opt/yt-dlp-mullvad/venv
-#   - Installs ytp-dl==0.6.7 + yt-dlp[default] + gunicorn in that venv
+#   - Installs ytp-dl==0.6.9 + yt-dlp[default] + gunicorn in that venv
 #   - Creates a systemd service ytp-dl-api.service on port 5000
 #
 # Mullvad connect/disconnect is handled per-job by downloader.py.
@@ -394,7 +394,7 @@ mkdir -p "${APP_DIR}"
 python3 -m venv "${VENV_DIR}"
 source "${VENV_DIR}/bin/activate"
 pip install --upgrade pip
-pip install "ytp-dl==0.6.7" "yt-dlp[default]" gunicorn
+pip install "ytp-dl==0.6.9" "yt-dlp[default]" gunicorn
 deactivate
 
 echo "==> 3) API environment file (/etc/default/ytp-dl-api)"

{ytp_dl-0.6.7 → ytp_dl-0.6.9}/README.md

@@ -24,7 +24,7 @@ A lightweight YouTube downloader with Mullvad VPN integration and an HTTP API.
 ## Installation
 
 ```bash
-pip install ytp-dl==0.6.7 yt-dlp[default]
+pip install ytp-dl==0.6.9 yt-dlp[default]
 ```
 
 Requirements:
@@ -209,7 +209,7 @@ When Mullvad connects/disconnects, Linux routing can change in a way that breaks
 
 * Installs Python, FFmpeg, Mullvad CLI, and Deno
 * Creates a virtualenv at `/opt/yt-dlp-mullvad/venv`
-* Installs `ytp-dl==0.6.7` + `yt-dlp[default]` + `gunicorn`
+* Installs `ytp-dl==0.6.9` + `yt-dlp[default]` + `gunicorn`
 * Installs a policy-routing oneshot service to keep the public API reachable
 * Sets up a systemd service on port 5000
 * Runs Gunicorn with `gthread` (threaded) workers
@@ -225,7 +225,7 @@ Note: `gthread` is a built-in Gunicorn worker class (no extra Python dependency)
 #   - Installs Deno system-wide (JS runtime required for modern YouTube extraction via yt-dlp)
 #   - Configures policy routing so the public API stays reachable while Mullvad toggles
 #   - Creates a virtualenv at /opt/yt-dlp-mullvad/venv
-#   - Installs ytp-dl==0.6.7 + yt-dlp[default] + gunicorn in that venv
+#   - Installs ytp-dl==0.6.9 + yt-dlp[default] + gunicorn in that venv
 #   - Creates a systemd service ytp-dl-api.service on port 5000
 #
 # Mullvad connect/disconnect is handled per-job by downloader.py.
@@ -361,7 +361,7 @@ mkdir -p "${APP_DIR}"
 python3 -m venv "${VENV_DIR}"
 source "${VENV_DIR}/bin/activate"
 pip install --upgrade pip
-pip install "ytp-dl==0.6.7" "yt-dlp[default]" gunicorn
+pip install "ytp-dl==0.6.9" "yt-dlp[default]" gunicorn
 deactivate
 
 echo "==> 3) API environment file (/etc/default/ytp-dl-api)"

ytp_dl-0.6.9/scripts/api.py

@@ -0,0 +1,162 @@
+#!/usr/bin/env python3
+from __future__ import annotations
+
+import os
+import shutil
+import tempfile
+import time
+from threading import BoundedSemaphore, Lock
+
+from flask import Flask, request, send_file, jsonify
+
+from .downloader import validate_environment, download_video
+
+app = Flask(__name__)
+
+BASE_DOWNLOAD_DIR = os.environ.get("YTPDL_JOB_BASE_DIR", "/root/ytpdl_jobs")
+os.makedirs(BASE_DOWNLOAD_DIR, exist_ok=True)
+
+MAX_CONCURRENT = int(os.environ.get("YTPDL_MAX_CONCURRENT", "1"))
+
+# Thread-safe concurrency gate (caps actual download jobs).
+_sem = BoundedSemaphore(MAX_CONCURRENT)
+
+# Track in-flight jobs for /healthz reporting.
+_in_use = 0
+_in_use_lock = Lock()
+
+# Failsafe: delete abandoned job dirs older than this many seconds.
+STALE_JOB_TTL_S = int(os.environ.get("YTPDL_STALE_JOB_TTL_S", "3600"))
+
+_ALLOWED_EXTENSIONS = {"mp3", "mp4", "best"}
+
+
+def _cleanup_stale_jobs() -> None:
+    now = time.time()
+    try:
+        for name in os.listdir(BASE_DOWNLOAD_DIR):
+            p = os.path.join(BASE_DOWNLOAD_DIR, name)
+            if not os.path.isdir(p):
+                continue
+            try:
+                age = now - os.path.getmtime(p)
+            except Exception:
+                continue
+            if age > STALE_JOB_TTL_S:
+                shutil.rmtree(p, ignore_errors=True)
+    except Exception:
+        pass
+
+
+def _try_acquire_job_slot() -> bool:
+    global _in_use
+    if not _sem.acquire(blocking=False):
+        return False
+    with _in_use_lock:
+        _in_use += 1
+    return True
+
+
+def _release_job_slot() -> None:
+    global _in_use
+    with _in_use_lock:
+        if _in_use > 0:
+            _in_use -= 1
+    _sem.release()
+
+
+@app.route("/api/download", methods=["POST"])
+def handle_download():
+    _cleanup_stale_jobs()
+
+    if not _try_acquire_job_slot():
+        return jsonify(error="Server busy, try again later"), 503
+
+    job_dir: str | None = None
+    released = False
+
+    def _release_once() -> None:
+        nonlocal released
+        if not released:
+            released = True
+            _release_job_slot()
+
+    try:
+        data = request.get_json(force=True)
+        url = (data.get("url") or "").strip()
+        resolution = data.get("resolution")
+
+        # extension is now a "mode": mp3 | mp4 | best
+        extension = (data.get("extension") or "mp4").strip().lower()
+
+        if not url:
+            _release_once()
+            return jsonify(error="Missing 'url'"), 400
+
+        if extension not in _ALLOWED_EXTENSIONS:
+            _release_once()
+            return jsonify(
+                error=f"Invalid 'extension'. Allowed: {sorted(_ALLOWED_EXTENSIONS)}"
+            ), 400
+
+        job_dir = tempfile.mkdtemp(prefix="ytpdl_", dir=BASE_DOWNLOAD_DIR)
+
+        # yt-dlp work (guarded by semaphore)
+        filename = download_video(
+            url=url,
+            resolution=resolution,
+            extension=extension,
+            out_dir=job_dir,
+        )
+
+        if not (filename and os.path.exists(filename)):
+            raise RuntimeError("Download failed")
+
+        # Release slot as soon as yt-dlp is done.
+        _release_once()
+
+        response = send_file(filename, as_attachment=True)
+
+        # Cleanup directory after client finishes consuming the response.
+        def _cleanup() -> None:
+            try:
+                if job_dir:
+                    shutil.rmtree(job_dir, ignore_errors=True)
+            except Exception:
+                pass
+
+        response.call_on_close(_cleanup)
+        return response
+
+    except RuntimeError as e:
+        if job_dir:
+            shutil.rmtree(job_dir, ignore_errors=True)
+        _release_once()
+
+        msg = str(e)
+        if "Mullvad not logged in" in msg:
+            return jsonify(error=msg), 503
+        return jsonify(error=f"Download failed: {msg}"), 500
+
+    except Exception as e:
+        if job_dir:
+            shutil.rmtree(job_dir, ignore_errors=True)
+        _release_once()
+        return jsonify(error=f"Download failed: {str(e)}"), 500
+
+
+@app.route("/healthz", methods=["GET"])
+def healthz():
+    with _in_use_lock:
+        in_use = _in_use
+    return jsonify(ok=True, in_use=in_use, capacity=MAX_CONCURRENT), 200
+
+
+def main():
+    validate_environment()
+    print("Starting ytp-dl API server...")
+    app.run(host="0.0.0.0", port=5000)
+
+
+if __name__ == "__main__":
+    main()

ytp_dl-0.6.9/scripts/downloader.py

@@ -0,0 +1,363 @@
+#!/usr/bin/env python3
+from __future__ import annotations
+
+import os
+import shlex
+import shutil
+import subprocess
+import time
+from typing import Optional, List, Tuple
+
+# =========================
+# Config / constants
+# =========================
+VENV_PATH = os.environ.get("YTPDL_VENV", "/opt/yt-dlp-mullvad/venv")
+YTDLP_BIN = os.path.join(VENV_PATH, "bin", "yt-dlp")
+MULLVAD_LOCATION = os.environ.get("YTPDL_MULLVAD_LOCATION", "us")
+
+MODERN_UA = os.environ.get(
+    "YTPDL_USER_AGENT",
+    "Mozilla/5.0 (Windows NT 10.0; Win64; x64) "
+    "AppleWebKit/537.36 (KHTML, like Gecko) "
+    "Chrome/124.0.0.0 Safari/537.36",
+)
+
+FFMPEG_BIN = shutil.which("ffmpeg") or "ffmpeg"
+DEFAULT_OUT_DIR = os.environ.get("YTPDL_DOWNLOAD_DIR", "/root")
+
+# Keep error payloads readable (your web UI prints these).
+_MAX_ERR_LINES = 80
+_MAX_ERR_CHARS = 4000
+
+
+# =========================
+# Shell helpers
+# =========================
+def _run_argv_capture(argv: List[str]) -> Tuple[int, str]:
+    res = subprocess.run(
+        argv,
+        stdout=subprocess.PIPE,
+        stderr=subprocess.STDOUT,
+        text=True,
+    )
+    return res.returncode, (res.stdout or "")
+
+
+def _run_argv(argv: List[str], check: bool = True) -> str:
+    rc, out = _run_argv_capture(argv)
+    if check and rc != 0:
+        cmd = " ".join(shlex.quote(p) for p in argv)
+        raise RuntimeError(f"Command failed: {cmd}\n{out}")
+    return out
+
+
+def _tail(out: str) -> str:
+    lines = (out or "").splitlines()
+    tail_lines = lines[-_MAX_ERR_LINES:]
+    txt = "\n".join(tail_lines)
+    if len(txt) > _MAX_ERR_CHARS:
+        txt = txt[-_MAX_ERR_CHARS:]
+    return txt.strip()
+
+
+def _is_youtube_url(url: str) -> bool:
+    u = (url or "").lower()
+    return any(h in u for h in ("youtube.com", "youtu.be", "youtube-nocookie.com"))
+
+
+# =========================
+# Environment / Mullvad
+# =========================
+def validate_environment() -> None:
+    if not os.path.exists(YTDLP_BIN):
+        raise RuntimeError(f"yt-dlp not found at {YTDLP_BIN}")
+    if shutil.which(FFMPEG_BIN) is None:
+        raise RuntimeError("ffmpeg not found on PATH")
+
+
+def _mullvad_present() -> bool:
+    return shutil.which("mullvad") is not None
+
+
+def mullvad_logged_in() -> bool:
+    if not _mullvad_present():
+        return False
+    res = subprocess.run(
+        ["mullvad", "account", "get"],
+        stdout=subprocess.PIPE,
+        stderr=subprocess.STDOUT,
+        text=True,
+    )
+    return "not logged in" not in (res.stdout or "").lower()
+
+
+def require_mullvad_login() -> None:
+    if _mullvad_present() and not mullvad_logged_in():
+        raise RuntimeError("Mullvad not logged in. Run: mullvad account login <ACCOUNT>")
+
+
+def mullvad_connect(location: Optional[str] = None) -> None:
+    if not _mullvad_present():
+        return
+    loc = (location or MULLVAD_LOCATION).strip()
+    _run_argv(["mullvad", "disconnect"], check=False)
+    if loc:
+        _run_argv(["mullvad", "relay", "set", "location", loc], check=False)
+    _run_argv(["mullvad", "connect"], check=False)
+
+
+def mullvad_wait_connected(timeout: int = 20) -> bool:
+    if not _mullvad_present():
+        return True
+    for _ in range(timeout):
+        res = subprocess.run(
+            ["mullvad", "status"],
+            stdout=subprocess.PIPE,
+            stderr=subprocess.STDOUT,
+            text=True,
+        )
+        if "Connected" in (res.stdout or ""):
+            return True
+        time.sleep(1)
+    return False
+
+
+# =========================
+# yt-dlp helpers
+# =========================
+def _common_flags() -> List[str]:
+    # --no-playlist prevents accidental channel/playlist pulls (and disk blowups)
+    return [
+        "--no-playlist",
+        "--retries", "10",
+        "--fragment-retries", "10",
+        "--retry-sleep", "exp=1:30",
+        "--user-agent", MODERN_UA,
+        "--no-cache-dir",
+        "--ignore-config",
+        "--embed-metadata",
+        "--sleep-interval", "1",
+    ]
+
+
+def _extract_final_path(stdout: str, out_dir: str) -> Optional[str]:
+    """
+    Robustly derive the final output file path from yt-dlp output.
+
+    Priority:
+      1) --print after_move:filepath lines (absolute paths)
+      2) [Merger] Merging formats into "..."
+      3) Any Destination: lines that still exist
+      4) Newest non-temp file in out_dir
+    """
+    candidates: List[str] = []
+    out_dir = os.path.abspath(out_dir)
+
+    for raw in (stdout or "").splitlines():
+        line = (raw or "").strip()
+        if not line:
+            continue
+
+        # 1) --print after_move:filepath (usually an absolute path)
+        if os.path.isabs(line) and line.startswith(out_dir):
+            candidates.append(line.strip("'\""))
+            continue
+
+        # 2) Merger line: ... into "path"
+        if "Merging formats into" in line and "\"" in line:
+            try:
+                merged = line.split("Merging formats into", 1)[1].strip()
+                if merged.startswith("\"") and merged.endswith("\""):
+                    merged = merged[1:-1]
+                else:
+                    if merged.startswith("\""):
+                        merged = merged.split("\"", 2)[1]
+                if merged:
+                    if not os.path.isabs(merged):
+                        merged = os.path.join(out_dir, merged)
+                    candidates.append(merged.strip("'\""))
+            except Exception:
+                pass
+            continue
+
+        # 3) Destination lines (download/extractaudio)
+        if "Destination:" in line:
+            try:
+                p = line.split("Destination:", 1)[1].strip().strip("'\"")
+                if p and not os.path.isabs(p):
+                    p = os.path.join(out_dir, p)
+                if p:
+                    candidates.append(p)
+            except Exception:
+                pass
+            continue
+
+        # already downloaded
+        if "] " in line and " has already been downloaded" in line:
+            try:
+                p = (
+                    line.split("] ", 1)[1]
+                    .split(" has already been downloaded", 1)[0]
+                    .strip()
+                    .strip("'\"")
+                )
+                if p and not os.path.isabs(p):
+                    p = os.path.join(out_dir, p)
+                if p:
+                    candidates.append(p)
+            except Exception:
+                pass
+
+    # Prefer existing, newest candidate (reverse traversal)
+    for p in reversed(candidates):
+        if p and os.path.exists(p):
+            return p
+
+    # 4) Fallback: newest non-temp file in out_dir
+    try:
+        best_path = None
+        best_mtime = -1.0
+        for name in os.listdir(out_dir):
+            if name.endswith((".part", ".ytdl", ".tmp")):
+                continue
+            full = os.path.join(out_dir, name)
+            if not os.path.isfile(full):
+                continue
+            mt = os.path.getmtime(full)
+            if mt > best_mtime:
+                best_mtime = mt
+                best_path = full
+        if best_path:
+            return best_path
+    except Exception:
+        pass
+
+    return None
+
+
+def _download_with_format(
+    url: str,
+    out_dir: str,
+    fmt: str,
+    merge_output_format: Optional[str] = None,
+    extract_mp3: bool = False,
+) -> str:
+    out_dir = os.path.abspath(out_dir)
+    os.makedirs(out_dir, exist_ok=True)
+
+    out_tpl = os.path.join(out_dir, "%(title)s.%(ext)s")
+
+    argv = [
+        YTDLP_BIN,
+        "-f", fmt,
+        *(_common_flags()),
+        "--output", out_tpl,
+        # Ensure we can reliably pick the final output path.
+        "--print", "after_move:filepath",
+    ]
+
+    if extract_mp3:
+        # Force audio extraction to MP3 (requires ffmpeg)
+        argv.extend(["--extract-audio", "--audio-format", "mp3"])
+
+    # Only force merge container when we actually want MP4 output.
+    if merge_output_format:
+        argv.extend(["--merge-output-format", merge_output_format])
+
+    argv.append(url)
+
+    rc, out = _run_argv_capture(argv)
+    path = _extract_final_path(out, out_dir)
+
+    if path and os.path.exists(path):
+        return os.path.abspath(path)
+
+    tail = _tail(out)
+    if rc != 0:
+        raise RuntimeError(f"yt-dlp failed (format: {fmt})\n{tail}")
+    raise RuntimeError(f"Download completed but output file not found (format: {fmt})\n{tail}")
+
+
+def _fmt_mp4_apple_safe(cap: int) -> str:
+    # Always pick the best Apple-safe MP4/H.264 + M4A/AAC up to cap.
+    return (
+        f"bv*[height<={cap}][ext=mp4][vcodec~='^(avc1|h264)']"
+        f"+ba[ext=m4a][acodec~='^mp4a']"
+        f"/b[height<={cap}][ext=mp4][vcodec~='^(avc1|h264)'][acodec~='^mp4a']"
+    )
+
+
+def _fmt_best(cap: int) -> str:
+    # Best overall up to cap (can yield webm/mkv/etc).
+    return f"bv*[height<={cap}]+ba/b[height<={cap}]"
+
+
+# =========================
+# Public API
+# =========================
+def download_video(
+    url: str,
+    resolution: int | None = 1080,
+    extension: Optional[str] = None,
+    out_dir: str = DEFAULT_OUT_DIR,
+) -> str:
+    if not url:
+        raise RuntimeError("Missing URL")
+
+    out_dir = os.path.abspath(out_dir)
+    os.makedirs(out_dir, exist_ok=True)
+
+    validate_environment()
+
+    require_mullvad_login()
+    mullvad_connect(MULLVAD_LOCATION)
+    if not mullvad_wait_connected():
+        raise RuntimeError("Mullvad connection failed")
+
+    try:
+        mode = (extension or "mp4").lower().strip()
+
+        if mode == "mp3":
+            # bestaudio -> ffmpeg -> mp3 (post-processed by yt-dlp)
+            return _download_with_format(
+                url=url,
+                out_dir=out_dir,
+                fmt="bestaudio",
+                merge_output_format=None,
+                extract_mp3=True,
+            )
+
+        cap = int(resolution or 1080)
+
+        if mode == "best":
+            # Try best first (may produce webm/mkv/etc).
+            try:
+                return _download_with_format(
+                    url=url,
+                    out_dir=out_dir,
+                    fmt=_fmt_best(cap),
+                    merge_output_format=None,
+                    extract_mp3=False,
+                )
+            except Exception:
+                # If best fails for any reason, fall back to Apple-safe MP4.
+                return _download_with_format(
+                    url=url,
+                    out_dir=out_dir,
+                    fmt=_fmt_mp4_apple_safe(cap),
+                    merge_output_format="mp4",
+                    extract_mp3=False,
+                )
+
+        # Default / "mp4" mode: force Apple-safe MP4 up to cap.
+        return _download_with_format(
+            url=url,
+            out_dir=out_dir,
+            fmt=_fmt_mp4_apple_safe(cap),
+            merge_output_format="mp4",
+            extract_mp3=False,
+        )
+
+    finally:
+        if _mullvad_present():
+            _run_argv(["mullvad", "disconnect"], check=False)

{ytp_dl-0.6.7 → ytp_dl-0.6.9}/setup.py

@@ -8,7 +8,7 @@ with open("requirements.txt", "r", encoding="utf-8") as fh:
 
 setup(
     name="ytp-dl",
-    version="0.6.7", 
+    version="0.6.9", 
     author="dumgum82",
     author_email="dumgum42@gmail.com",
     description="YouTube video downloader with Mullvad VPN integration and Flask API",

{ytp_dl-0.6.7 → ytp_dl-0.6.9}/ytp_dl.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: ytp-dl
-Version: 0.6.7
+Version: 0.6.9
 Summary: YouTube video downloader with Mullvad VPN integration and Flask API
 Home-page: https://github.com/yourusername/ytp-dl
 Author: dumgum82
@@ -57,7 +57,7 @@ A lightweight YouTube downloader with Mullvad VPN integration and an HTTP API.
 ## Installation
 
 ```bash
-pip install ytp-dl==0.6.7 yt-dlp[default]
+pip install ytp-dl==0.6.9 yt-dlp[default]
 ```
 
 Requirements:
@@ -242,7 +242,7 @@ When Mullvad connects/disconnects, Linux routing can change in a way that breaks
 
 * Installs Python, FFmpeg, Mullvad CLI, and Deno
 * Creates a virtualenv at `/opt/yt-dlp-mullvad/venv`
-* Installs `ytp-dl==0.6.7` + `yt-dlp[default]` + `gunicorn`
+* Installs `ytp-dl==0.6.9` + `yt-dlp[default]` + `gunicorn`
 * Installs a policy-routing oneshot service to keep the public API reachable
 * Sets up a systemd service on port 5000
 * Runs Gunicorn with `gthread` (threaded) workers
@@ -258,7 +258,7 @@ Note: `gthread` is a built-in Gunicorn worker class (no extra Python dependency)
 #   - Installs Deno system-wide (JS runtime required for modern YouTube extraction via yt-dlp)
 #   - Configures policy routing so the public API stays reachable while Mullvad toggles
 #   - Creates a virtualenv at /opt/yt-dlp-mullvad/venv
-#   - Installs ytp-dl==0.6.7 + yt-dlp[default] + gunicorn in that venv
+#   - Installs ytp-dl==0.6.9 + yt-dlp[default] + gunicorn in that venv
 #   - Creates a systemd service ytp-dl-api.service on port 5000
 #
 # Mullvad connect/disconnect is handled per-job by downloader.py.
@@ -394,7 +394,7 @@ mkdir -p "${APP_DIR}"
 python3 -m venv "${VENV_DIR}"
 source "${VENV_DIR}/bin/activate"
 pip install --upgrade pip
-pip install "ytp-dl==0.6.7" "yt-dlp[default]" gunicorn
+pip install "ytp-dl==0.6.9" "yt-dlp[default]" gunicorn
 deactivate
 
 echo "==> 3) API environment file (/etc/default/ytp-dl-api)"

ytp_dl-0.6.7/scripts/api.py

@@ -1,346 +0,0 @@
-#!/usr/bin/env python3
-from __future__ import annotations
-
-import json
-import os
-import secrets
-import shutil
-import tempfile
-import time
-from threading import BoundedSemaphore, Lock
-from typing import Optional, Dict, Any, Iterable
-
-from flask import Flask, request, jsonify, Response, send_file
-
-from .downloader import (
-    validate_environment,
-    prepare_network,
-    cleanup_network,
-    build_download_plan,
-)
-
-app = Flask(__name__)
-
-BASE_DOWNLOAD_DIR = os.environ.get("YTPDL_JOB_BASE_DIR", "/root/ytpdl_jobs")
-os.makedirs(BASE_DOWNLOAD_DIR, exist_ok=True)
-
-MAX_CONCURRENT = int(os.environ.get("YTPDL_MAX_CONCURRENT", "1"))
-
-# Thread-safe concurrency gate (caps actual download jobs).
-_sem = BoundedSemaphore(MAX_CONCURRENT)
-
-# Track in-flight jobs for /healthz reporting.
-_in_use = 0
-_in_use_lock = Lock()
-
-# Failsafe: delete abandoned job dirs older than this many seconds.
-STALE_JOB_TTL_S = int(os.environ.get("YTPDL_STALE_JOB_TTL_S", "3600"))
-
-_ALLOWED_EXTENSIONS = {"mp3", "mp4", "best"}
-
-
-def _cleanup_stale_jobs() -> None:
-    now = time.time()
-    try:
-        for name in os.listdir(BASE_DOWNLOAD_DIR):
-            p = os.path.join(BASE_DOWNLOAD_DIR, name)
-            if not os.path.isdir(p):
-                continue
-            try:
-                age = now - os.path.getmtime(p)
-            except Exception:
-                continue
-            if age > STALE_JOB_TTL_S:
-                shutil.rmtree(p, ignore_errors=True)
-    except Exception:
-        pass
-
-
-def _try_acquire_job_slot() -> bool:
-    global _in_use
-    if not _sem.acquire(blocking=False):
-        return False
-    with _in_use_lock:
-        _in_use += 1
-    return True
-
-
-def _release_job_slot() -> None:
-    global _in_use
-    with _in_use_lock:
-        if _in_use > 0:
-            _in_use -= 1
-    _sem.release()
-
-
-def _job_meta_path(job_dir: str) -> str:
-    return os.path.join(job_dir, "job.json")
-
-
-def _write_job_meta(job_dir: str, meta: Dict[str, Any]) -> None:
-    try:
-        with open(_job_meta_path(job_dir), "w", encoding="utf-8") as f:
-            json.dump(meta, f, ensure_ascii=False)
-    except Exception:
-        pass
-
-
-def _read_job_meta(job_dir: str) -> Optional[Dict[str, Any]]:
-    p = _job_meta_path(job_dir)
-    if not os.path.exists(p):
-        return None
-    try:
-        with open(p, "r", encoding="utf-8") as f:
-            return json.load(f)
-    except Exception:
-        return None
-
-
-def _touch(path: str) -> None:
-    try:
-        os.utime(path, None)
-    except Exception:
-        pass
-
-
-def _sse(data: str) -> str:
-    # Minimal SSE formatting
-    return f"data: {data}\n\n"
-
-
-@app.route("/api/download", methods=["POST"])
-def handle_download():
-    """
-    VPS-side downloader:
-    - returns SSE logs (real yt-dlp output) to caller
-    - stores completed file in a job dir
-    - caller then fetches the file via /api/fetch/<job_id>?token=...
-    """
-    _cleanup_stale_jobs()
-
-    if not _try_acquire_job_slot():
-        return jsonify(error="Server busy, try again later"), 503
-
-    job_dir: str | None = None
-    released = False
-
-    def _release_once() -> None:
-        nonlocal released
-        if not released:
-            released = True
-            _release_job_slot()
-
-    try:
-        data = request.get_json(force=True)
-        url = (data.get("url") or "").strip()
-        resolution = data.get("resolution")
-
-        # extension is now a "mode": mp3 | mp4 | best
-        extension = (data.get("extension") or "mp4").strip().lower()
-
-        if not url:
-            _release_once()
-            return jsonify(error="Missing 'url'"), 400
-
-        if extension not in _ALLOWED_EXTENSIONS:
-            _release_once()
-            return jsonify(
-                error=f"Invalid 'extension'. Allowed: {sorted(_ALLOWED_EXTENSIONS)}"
-            ), 400
-
-        job_dir = tempfile.mkdtemp(prefix="ytpdl_", dir=BASE_DOWNLOAD_DIR)
-        job_id = os.path.basename(job_dir)
-        token = secrets.token_urlsafe(24)
-
-        def stream() -> Iterable[str]:
-            nonlocal job_dir
-            assert job_dir is not None
-
-            # Internal control info (caller should NOT forward to browser).
-            yield _sse(f"[internal] job={job_id} token={token}")
-
-            try:
-                validate_environment()
-                prepare_network()
-
-                out_dir = job_dir
-                out_dir_abs = os.path.abspath(out_dir)
-
-                # Track final file path without printing it to the client.
-                final_path: Optional[str] = None
-                # Track "pretty" filename from [download_complete] marker.
-                final_name: Optional[str] = None
-
-                plan = build_download_plan(
-                    url=url,
-                    resolution=resolution,
-                    extension=extension,
-                    out_dir=out_dir,
-                )
-
-                for step_idx, argv in enumerate(plan, start=1):
-                    # Let caller know about fallback attempt (still safe to forward).
-                    if step_idx > 1:
-                        yield _sse("Retrying with fallback format...")
-
-                    import subprocess
-
-                    proc = subprocess.Popen(
-                        argv,
-                        stdout=subprocess.PIPE,
-                        stderr=subprocess.STDOUT,
-                        text=True,
-                        bufsize=1,
-                    )
-
-                    assert proc.stdout is not None
-
-                    for raw in iter(proc.stdout.readline, ""):
-                        line = (raw or "").strip()
-                        if not line:
-                            continue
-
-                        # yt-dlp --print after_move:filepath outputs an absolute path.
-                        # Keep it internal so browser logs match local.
-                        if os.path.isabs(line) and line.startswith(out_dir_abs):
-                            final_path = line.strip("'\"")
-                            continue
-
-                        # Capture local-style marker for filename.
-                        if line.startswith("[download_complete]"):
-                            # same semantics as your local parser
-                            try:
-                                final_name = line.split("[download_complete]", 1)[1].strip()
-                            except Exception:
-                                final_name = None
-
-                        yield _sse(line)
-
-                    proc.stdout.close()
-                    rc = proc.wait()
-
-                    if rc == 0:
-                        break
-
-                # Validate output
-                if not final_path:
-                    # Try to discover any output file in job dir if filepath line wasn't produced.
-                    try:
-                        for name in os.listdir(job_dir):
-                            if name.endswith((".part", ".ytdl", ".tmp")):
-                                continue
-                            p = os.path.join(job_dir, name)
-                            if os.path.isfile(p):
-                                final_path = os.path.abspath(p)
-                                break
-                    except Exception:
-                        pass
-
-                if not (final_path and os.path.exists(final_path)):
-                    yield _sse("ERROR: Download completed but output file not found")
-                    return
-
-                # Persist meta for /api/fetch
-                meta = {
-                    "job_id": job_id,
-                    "token": token,
-                    "file_path": os.path.abspath(final_path),
-                    "file_name": final_name or os.path.basename(final_path),
-                    "created_at": time.time(),
-                }
-                _write_job_meta(job_dir, meta)
-                _touch(job_dir)
-
-                # Release slot as soon as yt-dlp is done (do NOT hold during fetch).
-                _release_once()
-
-                # Signal ready to caller (do NOT forward to browser).
-                yield _sse("[internal] ready")
-
-            finally:
-                cleanup_network()
-
-        return Response(
-            stream(),
-            content_type="text/event-stream",
-            headers={
-                "Cache-Control": "no-cache",
-                "X-Accel-Buffering": "no",
-                "Connection": "close",
-            },
-        )
-
-    except RuntimeError as e:
-        if job_dir:
-            shutil.rmtree(job_dir, ignore_errors=True)
-        _release_once()
-
-        msg = str(e)
-        if "Mullvad not logged in" in msg:
-            return jsonify(error=msg), 503
-        return jsonify(error=f"Download failed: {msg}"), 500
-
-    except Exception as e:
-        if job_dir:
-            shutil.rmtree(job_dir, ignore_errors=True)
-        _release_once()
-        return jsonify(error=f"Download failed: {str(e)}"), 500
-
-
-@app.route("/api/fetch/<job_id>", methods=["GET"])
-def fetch(job_id: str):
-    """
-    Fetch the finished file after /api/download completes.
-
-    Requires:
-      /api/fetch/<job_id>?token=...
-    """
-    token = (request.args.get("token") or "").strip()
-    if not token:
-        return jsonify(error="Missing token"), 400
-
-    job_dir = os.path.join(BASE_DOWNLOAD_DIR, job_id)
-    if not os.path.isdir(job_dir):
-        return jsonify(error="Job not found"), 404
-
-    meta = _read_job_meta(job_dir)
-    if not meta:
-        return jsonify(error="Job metadata missing"), 404
-
-    if meta.get("token") != token:
-        return jsonify(error="Invalid token"), 403
-
-    file_path = meta.get("file_path")
-    if not (file_path and os.path.exists(file_path)):
-        return jsonify(error="File not found"), 404
-
-    download_name = meta.get("file_name") or os.path.basename(file_path)
-
-    resp = send_file(file_path, as_attachment=True, download_name=download_name)
-
-    # Cleanup after caller finishes consuming the response.
-    def _cleanup() -> None:
-        try:
-            shutil.rmtree(job_dir, ignore_errors=True)
-        except Exception:
-            pass
-
-    resp.call_on_close(_cleanup)
-    return resp
-
-
-@app.route("/healthz", methods=["GET"])
-def healthz():
-    with _in_use_lock:
-        in_use = _in_use
-    return jsonify(ok=True, in_use=in_use, capacity=MAX_CONCURRENT), 200
-
-
-def main():
-    validate_environment()
-    print("Starting ytp-dl API server...")
-    app.run(host="0.0.0.0", port=5000)
-
-
-if __name__ == "__main__":
-    main()

ytp_dl-0.6.7/scripts/downloader.py

@@ -1,311 +0,0 @@
-#!/usr/bin/env python3
-from __future__ import annotations
-
-import os
-import shlex
-import shutil
-import subprocess
-import time
-from typing import Optional, List, Tuple, Any
-
-# =========================
-# Config / constants
-# =========================
-VENV_PATH = os.environ.get("YTPDL_VENV", "/opt/yt-dlp-mullvad/venv")
-YTDLP_BIN = os.path.join(VENV_PATH, "bin", "yt-dlp")
-MULLVAD_LOCATION = os.environ.get("YTPDL_MULLVAD_LOCATION", "us")
-
-MODERN_UA = os.environ.get(
-    "YTPDL_USER_AGENT",
-    "Mozilla/5.0 (Windows NT 10.0; Win64; x64) "
-    "AppleWebKit/537.36 (KHTML, like Gecko) "
-    "Chrome/124.0.0.0 Safari/537.36",
-)
-
-FFMPEG_BIN = shutil.which("ffmpeg") or "ffmpeg"
-DEFAULT_OUT_DIR = os.environ.get("YTPDL_DOWNLOAD_DIR", "/root")
-
-# Keep error payloads readable (your web UI prints these).
-_MAX_ERR_LINES = 80
-_MAX_ERR_CHARS = 4000
-
-_ALLOWED_EXTENSIONS = {"mp3", "mp4", "best"}
-
-
-# =========================
-# Shell helpers
-# =========================
-def _run_argv_capture(argv: List[str]) -> Tuple[int, str]:
-    res = subprocess.run(
-        argv,
-        stdout=subprocess.PIPE,
-        stderr=subprocess.STDOUT,
-        text=True,
-    )
-    return res.returncode, (res.stdout or "")
-
-
-def _run_argv(argv: List[str], check: bool = True) -> str:
-    rc, out = _run_argv_capture(argv)
-    if check and rc != 0:
-        cmd = " ".join(shlex.quote(p) for p in argv)
-        raise RuntimeError(f"Command failed: {cmd}\n{out}")
-    return out
-
-
-def _tail(out: str) -> str:
-    lines = (out or "").splitlines()
-    tail_lines = lines[-_MAX_ERR_LINES:]
-    txt = "\n".join(tail_lines)
-    if len(txt) > _MAX_ERR_CHARS:
-        txt = txt[-_MAX_ERR_CHARS:]
-    return txt.strip()
-
-
-# =========================
-# Environment / Mullvad
-# =========================
-def validate_environment() -> None:
-    if not os.path.exists(YTDLP_BIN):
-        raise RuntimeError(f"yt-dlp not found at {YTDLP_BIN}")
-    if shutil.which(FFMPEG_BIN) is None:
-        raise RuntimeError("ffmpeg not found on PATH")
-
-
-def _mullvad_present() -> bool:
-    return shutil.which("mullvad") is not None
-
-
-def mullvad_logged_in() -> bool:
-    if not _mullvad_present():
-        return False
-    res = subprocess.run(
-        ["mullvad", "account", "get"],
-        stdout=subprocess.PIPE,
-        stderr=subprocess.STDOUT,
-        text=True,
-    )
-    return "not logged in" not in (res.stdout or "").lower()
-
-
-def require_mullvad_login() -> None:
-    if _mullvad_present() and not mullvad_logged_in():
-        raise RuntimeError("Mullvad not logged in. Run: mullvad account login <ACCOUNT>")
-
-
-def mullvad_connect(location: Optional[str] = None) -> None:
-    if not _mullvad_present():
-        return
-    loc = (location or MULLVAD_LOCATION).strip()
-    _run_argv(["mullvad", "disconnect"], check=False)
-    if loc:
-        _run_argv(["mullvad", "relay", "set", "location", loc], check=False)
-    _run_argv(["mullvad", "connect"], check=False)
-
-
-def mullvad_wait_connected(timeout: int = 20) -> bool:
-    if not _mullvad_present():
-        return True
-    for _ in range(timeout):
-        res = subprocess.run(
-            ["mullvad", "status"],
-            stdout=subprocess.PIPE,
-            stderr=subprocess.STDOUT,
-            text=True,
-        )
-        if "Connected" in (res.stdout or ""):
-            return True
-        time.sleep(1)
-    return False
-
-
-def prepare_network() -> None:
-    """
-    Called by VPS API server before launching yt-dlp.
-    """
-    validate_environment()
-    require_mullvad_login()
-    mullvad_connect(MULLVAD_LOCATION)
-    if not mullvad_wait_connected():
-        raise RuntimeError("Mullvad connection failed")
-
-
-def cleanup_network() -> None:
-    """
-    Called by VPS API server after yt-dlp finishes.
-    """
-    if _mullvad_present():
-        _run_argv(["mullvad", "disconnect"], check=False)
-
-
-# =========================
-# yt-dlp helpers
-# =========================
-def _common_flags() -> List[str]:
-    # --no-playlist prevents accidental channel/playlist pulls (and disk blowups)
-    return [
-        "--no-playlist",
-        "--retries", "10",
-        "--fragment-retries", "10",
-        "--retry-sleep", "exp=1:30",
-        "--user-agent", MODERN_UA,
-        "--no-cache-dir",
-        "--ignore-config",
-        "--sleep-interval", "1",
-    ]
-
-
-def _sanitize_title_flags() -> List[str]:
-    # Mirrors your local downloader's title sanitization intent.
-    return [
-        "--replace-in-metadata",
-        "title",
-        "[\\U0001F600-\\U0001F64F\\U0001F300-\\U0001F5FF"
-        "\\U0001F680-\\U0001F6FF\\U0001F700-\\U0001F77F"
-        "\\U0001F780-\\U0001F7FF\\U0001F800-\\U0001F8FF"
-        "\\U0001F900-\\U0001F9FF\\U0001FA00-\\U0001FA6F"
-        "\\U0001FA70-\\U0001FAFF\\U00002702-\\U000027B0"
-        "\\U000024C2-\\U0001F251]",
-        "",
-        "--replace-in-metadata",
-        "title",
-        r"[\\\/:*?\"<>|]|[\s.]+$",
-        "",
-    ]
-
-
-def _fmt_mp4_apple_safe(cap: int) -> str:
-    # Always pick the best Apple-safe MP4/H.264 + M4A/AAC up to cap.
-    return (
-        f"bv*[height<={cap}][ext=mp4][vcodec~='^(avc1|h264)']"
-        f"+ba[ext=m4a][acodec~='^mp4a']"
-        f"/b[height<={cap}][ext=mp4][vcodec~='^(avc1|h264)'][acodec~='^mp4a']"
-    )
-
-
-def _fmt_best(cap: int) -> str:
-    # Best overall up to cap (can yield webm/mkv/etc).
-    return f"bv*[height<={cap}]+ba/b[height<={cap}]"
-
-
-def _base_argv(out_dir: str) -> List[str]:
-    out_dir = os.path.abspath(out_dir)
-    out_tpl = os.path.join(out_dir, "%(title)s.%(ext)s")
-
-    return [
-        YTDLP_BIN,
-        "--progress",
-        "--newline",
-        "--continue",
-        *_common_flags(),
-        *_sanitize_title_flags(),
-        "--output", out_tpl,
-        # Internal: absolute final path (API server filters this from browser).
-        "--print", "after_move:filepath",
-        # Visible: local-style completion marker.
-        "--print", "after_move:[download_complete] %(title)s.%(ext)s",
-    ]
-
-
-def build_download_plan(
-    url: str,
-    resolution: Any | None = 1080,
-    extension: Optional[str] = None,
-    out_dir: str = DEFAULT_OUT_DIR,
-) -> List[List[str]]:
-    """
-    Returns a list of argv arrays to try in order.
-    The VPS API server will run them with Popen and stream stdout.
-    """
-    if not url:
-        raise RuntimeError("Missing URL")
-
-    mode = (extension or "mp4").lower().strip()
-    if mode not in _ALLOWED_EXTENSIONS:
-        raise RuntimeError(f"Invalid extension/mode: {mode}")
-
-    cap = int(resolution or 1080)
-    base = _base_argv(out_dir)
-
-    if mode == "mp3":
-        return [[
-            *base,
-            "-f", "bestaudio",
-            "--extract-audio",
-            "--audio-format", "mp3",
-            "--audio-quality", "0",
-            "--embed-thumbnail",
-            "--add-metadata",
-            "--metadata-from-title", "%(artist)s - %(title)s",
-            url,
-        ]]
-
-    if mode == "best":
-        # Try best first, then fallback to Apple-safe MP4.
-        return [
-            [
-                *base,
-                "-f", _fmt_best(cap),
-                url,
-            ],
-            [
-                *base,
-                "-f", _fmt_mp4_apple_safe(cap),
-                "--merge-output-format", "mp4",
-                url,
-            ],
-        ]
-
-    # mode == "mp4" (default)
-    return [[
-        *base,
-        "-f", _fmt_mp4_apple_safe(cap),
-        "--merge-output-format", "mp4",
-        url,
-    ]]
-
-
-# =========================
-# Legacy (keep for compatibility)
-# =========================
-def download_video(
-    url: str,
-    resolution: int | None = 1080,
-    extension: Optional[str] = None,
-    out_dir: str = DEFAULT_OUT_DIR,
-) -> str:
-    """
-    Original blocking API (kept so existing imports don't break).
-    The VPS API server now uses build_download_plan + Popen streaming instead.
-    """
-    import os
-
-    if not url:
-        raise RuntimeError("Missing URL")
-
-    out_dir = os.path.abspath(out_dir)
-    os.makedirs(out_dir, exist_ok=True)
-
-    prepare_network()
-    try:
-        plan = build_download_plan(url=url, resolution=resolution, extension=extension, out_dir=out_dir)
-
-        last_out = ""
-        for argv in plan:
-            rc, out = _run_argv_capture(argv)
-            last_out = out or ""
-            # Find the printed after_move:filepath absolute path (first matching line).
-            for raw in (last_out or "").splitlines():
-                line = (raw or "").strip()
-                if os.path.isabs(line) and line.startswith(out_dir):
-                    if os.path.exists(line):
-                        return os.path.abspath(line)
-
-            if rc == 0:
-                break
-
-        tail = _tail(last_out)
-        raise RuntimeError(f"Download completed but output file not found\n{tail}")
-
-    finally:
-        cleanup_network()