ytp-dl 0.6.6__tar.gz → 0.6.8__tar.gz

{ytp_dl-0.6.6 → ytp_dl-0.6.8}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: ytp-dl
-Version: 0.6.6
+Version: 0.6.8
 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.5 yt-dlp[default]
+pip install ytp-dl==0.6.8 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.5` + `yt-dlp[default]` + `gunicorn`
+* Installs `ytp-dl==0.6.8` + `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.5 + yt-dlp[default] + gunicorn in that venv
+#   - Installs ytp-dl==0.6.8 + 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.5" "yt-dlp[default]" gunicorn
+pip install "ytp-dl==0.6.8" "yt-dlp[default]" gunicorn
 deactivate
 
 echo "==> 3) API environment file (/etc/default/ytp-dl-api)"

{ytp_dl-0.6.6 → ytp_dl-0.6.8}/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.5 yt-dlp[default]
+pip install ytp-dl==0.6.8 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.5` + `yt-dlp[default]` + `gunicorn`
+* Installs `ytp-dl==0.6.8` + `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.5 + yt-dlp[default] + gunicorn in that venv
+#   - Installs ytp-dl==0.6.8 + 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.5" "yt-dlp[default]" gunicorn
+pip install "ytp-dl==0.6.8" "yt-dlp[default]" gunicorn
 deactivate
 
 echo "==> 3) API environment file (/etc/default/ytp-dl-api)"

ytp_dl-0.6.8/scripts/api.py

@@ -0,0 +1,286 @@
+#!/usr/bin/env python3
+from __future__ import annotations
+
+import json
+import os
+import shutil
+import tempfile
+import time
+from threading import BoundedSemaphore, Lock
+from typing import Optional
+
+from flask import Flask, request, send_file, jsonify, Response, stream_with_context
+
+from .downloader import validate_environment, download_video_stream
+
+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) -> 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]:
+    path = _job_meta_path(job_dir)
+    if not os.path.exists(path):
+        return None
+    try:
+        with open(path, "r", encoding="utf-8") as f:
+            return json.load(f)
+    except Exception:
+        return None
+
+
+def _sse_message(data: str) -> str:
+    # one "message" event
+    return f"data: {data}\n\n"
+
+
+def _sse_event(event_name: str, data: str) -> str:
+    # custom event type
+    return f"event: {event_name}\ndata: {data}\n\n"
+
+
+@app.route("/api/download", methods=["POST"])
+def handle_download():
+    """
+    Streams yt-dlp logs via SSE (real-time), then emits a final custom `result` event:
+      event: result
+      data: {"job_id":"ytpdl_xxx","filename":"file.mp4"}
+
+    The finished file is retrieved separately via:
+      GET /api/file/<job_id>
+    """
+    _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)
+
+        def stream():
+            nonlocal job_dir
+            try:
+                # ---- yt-dlp streamed logs ----
+                # download_video_stream yields yt-dlp stdout lines.
+                filename_path = yield from download_video_stream(
+                    url=url,
+                    resolution=resolution,
+                    extension=extension,
+                    out_dir=job_dir,
+                )
+
+                if not (filename_path and os.path.exists(filename_path)):
+                    yield _sse_message("ERROR: Download failed (file missing).")
+                    yield _sse_event(
+                        "error",
+                        json.dumps({"error": "Download failed (file missing)"}),
+                    )
+                    return
+
+                # Release slot as soon as yt-dlp is done.
+                _release_once()
+
+                out_name = os.path.basename(filename_path)
+
+                # Persist meta for /api/file/<job_id>
+                _write_job_meta(
+                    job_dir,
+                    {
+                        "job_id": job_id,
+                        "filename": out_name,
+                        "file_path": filename_path,
+                        "created_at": time.time(),
+                    },
+                )
+
+                # Result event (custom type) so your browser log UI won't display it
+                yield _sse_event(
+                    "result",
+                    json.dumps({"job_id": job_id, "filename": out_name}),
+                )
+
+                # keep-alive tail
+                yield _sse_message("All downloads complete.")
+                return
+
+            except RuntimeError as e:
+                if job_dir:
+                    shutil.rmtree(job_dir, ignore_errors=True)
+                _release_once()
+
+                msg = str(e)
+                # make it visible in logs
+                yield _sse_message(f"ERROR: {msg}")
+                # also machine-readable
+                code = 503 if "Mullvad not logged in" in msg else 500
+                yield _sse_event("error", json.dumps({"error": msg, "code": code}))
+                return
+
+            except GeneratorExit:
+                # Client disconnected mid-stream; best-effort cleanup.
+                if job_dir:
+                    shutil.rmtree(job_dir, ignore_errors=True)
+                _release_once()
+                raise
+
+            except Exception as e:
+                if job_dir:
+                    shutil.rmtree(job_dir, ignore_errors=True)
+                _release_once()
+
+                msg = f"Download failed: {str(e)}"
+                yield _sse_message(f"ERROR: {msg}")
+                yield _sse_event("error", json.dumps({"error": msg, "code": 500}))
+                return
+
+        resp = Response(stream_with_context(stream()), content_type="text/event-stream")
+        resp.headers["Cache-Control"] = "no-cache"
+        resp.headers["X-Accel-Buffering"] = "no"
+        return resp
+
+    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/file/<job_id>", methods=["GET"])
+def fetch_file(job_id: str):
+    """
+    After /api/download SSE completes with `event: result`,
+    the caller fetches the finished file here.
+    """
+    _cleanup_stale_jobs()
+
+    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
+
+    file_path = meta.get("file_path")
+    filename = meta.get("filename") or (os.path.basename(file_path) if file_path else None)
+
+    if not file_path or not os.path.exists(file_path):
+        shutil.rmtree(job_dir, ignore_errors=True)
+        return jsonify(error="File not found"), 404
+
+    response = send_file(file_path, as_attachment=True, download_name=filename)
+
+    # Cleanup directory after client finishes consuming the response.
+    def _cleanup() -> None:
+        try:
+            shutil.rmtree(job_dir, ignore_errors=True)
+        except Exception:
+            pass
+
+    response.call_on_close(_cleanup)
+    return response
+
+
+@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.6 → ytp_dl-0.6.8}/scripts/downloader.py

@@ -6,7 +6,7 @@ import shlex
 import shutil
 import subprocess
 import time
-from typing import Optional, List, Tuple
+from typing import Optional, List, Tuple, Generator
 
 # =========================
 # Config / constants
@@ -60,11 +60,6 @@ def _tail(out: str) -> str:
     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
 # =========================
@@ -135,85 +130,25 @@ def _common_flags() -> List[str]:
         "--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
+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']"
+    )
 
-        # 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
+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}]"
 
-    # 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
+def _newest_non_temp_file(out_dir: str) -> Optional[str]:
     try:
         best_path = None
         best_mtime = -1.0
@@ -227,80 +162,129 @@ def _extract_final_path(stdout: str, out_dir: str) -> Optional[str]:
             if mt > best_mtime:
                 best_mtime = mt
                 best_path = full
-        if best_path:
-            return best_path
+        return best_path
     except Exception:
-        pass
-
-    return None
+        return None
 
 
-def _download_with_format(
+def _download_with_format_stream(
+    *,
     url: str,
     out_dir: str,
     fmt: str,
     merge_output_format: Optional[str] = None,
     extract_mp3: bool = False,
-) -> str:
+) -> Generator[str, None, str]:
+    """
+    Stream yt-dlp stdout lines (same style as local: --progress --newline),
+    while capturing final output path reliably.
+
+    Returns absolute file path (generator return value).
+    """
     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 = [
+    argv: List[str] = [
         YTDLP_BIN,
+        url,
+        "--progress",
+        "--newline",
+        "--continue",
         "-f", fmt,
         *(_common_flags()),
         "--output", out_tpl,
-        # Ensure we can reliably pick the final output path.
+        # Absolute final path for internal capture (we do NOT emit this line).
         "--print", "after_move:filepath",
+        # Local parity signal:
+        "--print", "after_move:[download_complete] %(title)s.%(ext)s",
     ]
 
     if extract_mp3:
-        # Force audio extraction to MP3 (requires ffmpeg)
-        argv.extend(["--extract-audio", "--audio-format", "mp3"])
+        argv.extend(
+            [
+                "--extract-audio",
+                "--audio-format", "mp3",
+                "--audio-quality", "0",
+                "--embed-thumbnail",
+                "--add-metadata",
+            ]
+        )
 
-    # 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)
+    proc = subprocess.Popen(
+        argv,
+        stdout=subprocess.PIPE,
+        stderr=subprocess.STDOUT,
+        text=True,
+        bufsize=1,
+        universal_newlines=True,
+    )
 
-    rc, out = _run_argv_capture(argv)
-    path = _extract_final_path(out, out_dir)
+    final_path: Optional[str] = None
+    tail_lines: List[str] = []
 
-    if path and os.path.exists(path):
-        return os.path.abspath(path)
+    try:
+        assert proc.stdout is not None
+        for raw in iter(proc.stdout.readline, ""):
+            line = (raw or "").rstrip("\n").rstrip("\r")
+            if not line:
+                continue
 
-    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}")
+            # Capture absolute final path from after_move:filepath (do not emit to logs)
+            if os.path.isabs(line) and line.startswith(out_dir):
+                final_path = line.strip("'\"")
+                continue
 
+            # Keep a small tail buffer for error reporting
+            tail_lines.append(line)
+            if len(tail_lines) > _MAX_ERR_LINES:
+                tail_lines.pop(0)
 
-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']"
-    )
+            # Emit everything else (yt-dlp progress + [download_complete] line)
+            yield line
 
+        proc.wait()
+    finally:
+        try:
+            if proc.stdout:
+                proc.stdout.close()
+        except Exception:
+            pass
+
+    if proc.returncode != 0:
+        tail = "\n".join(tail_lines)
+        tail = _tail(tail)
+        raise RuntimeError(f"yt-dlp failed (format: {fmt})\n{tail}")
 
-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}]"
+    # Resolve final path
+    if final_path and os.path.exists(final_path):
+        return os.path.abspath(final_path)
+
+    # Fallback: newest output in out_dir
+    newest = _newest_non_temp_file(out_dir)
+    if newest and os.path.exists(newest):
+        return os.path.abspath(newest)
+
+    tail = _tail("\n".join(tail_lines))
+    raise RuntimeError(f"Download completed but output file not found (format: {fmt})\n{tail}")
 
 
 # =========================
-# Public API
+# Public APIs
 # =========================
-def download_video(
+def download_video_stream(
     url: str,
     resolution: int | None = 1080,
     extension: Optional[str] = None,
     out_dir: str = DEFAULT_OUT_DIR,
-) -> str:
+) -> Generator[str, None, str]:
+    """
+    Streams yt-dlp logs and returns final file path (generator return value).
+    """
     if not url:
         raise RuntimeError("Missing URL")
 
@@ -318,46 +302,68 @@ def download_video(
         mode = (extension or "mp4").lower().strip()
 
         if mode == "mp3":
-            # bestaudio -> ffmpeg -> mp3 (post-processed by yt-dlp)
-            return _download_with_format(
+            return (yield from _download_with_format_stream(
                 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 best first (may produce webm/mkv/etc). If it fails, fall back to Apple-safe MP4.
             try:
-                return _download_with_format(
+                return (yield from _download_with_format_stream(
                     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(
+                return (yield from _download_with_format_stream(
                     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(
+        # Default / "mp4" mode
+        return (yield from _download_with_format_stream(
             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)
+
+
+def download_video(
+    url: str,
+    resolution: int | None = 1080,
+    extension: Optional[str] = None,
+    out_dir: str = DEFAULT_OUT_DIR,
+) -> str:
+    """
+    Backward-compatible non-streaming wrapper.
+    """
+    gen = download_video_stream(
+        url=url,
+        resolution=resolution,
+        extension=extension,
+        out_dir=out_dir,
+    )
+    try:
+        for _ in gen:
+            pass
+    except StopIteration as si:
+        return si.value  # type: ignore[attr-defined]
+    # Should never happen
+    raise RuntimeError("Download failed (no result)")

{ytp_dl-0.6.6 → ytp_dl-0.6.8}/setup.py

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

{ytp_dl-0.6.6 → ytp_dl-0.6.8}/ytp_dl.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: ytp-dl
-Version: 0.6.6
+Version: 0.6.8
 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.5 yt-dlp[default]
+pip install ytp-dl==0.6.8 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.5` + `yt-dlp[default]` + `gunicorn`
+* Installs `ytp-dl==0.6.8` + `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.5 + yt-dlp[default] + gunicorn in that venv
+#   - Installs ytp-dl==0.6.8 + 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.5" "yt-dlp[default]" gunicorn
+pip install "ytp-dl==0.6.8" "yt-dlp[default]" gunicorn
 deactivate
 
 echo "==> 3) API environment file (/etc/default/ytp-dl-api)"

ytp_dl-0.6.6/scripts/api.py

@@ -1,162 +0,0 @@
-#!/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()