ytp-dl 0.7.0__tar.gz → 0.7.1__tar.gz

{ytp_dl-0.7.0 → ytp_dl-0.7.1}/PKG-INFO

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

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

ytp_dl-0.7.1/scripts/api.py

@@ -0,0 +1,328 @@
+#!/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, 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 _safe_job_id(raw: str) -> str:
+    """Keep job ids filesystem-safe and predictable."""
+    s = (raw or "").strip()
+    if not s:
+        return str(int(time.time() * 1000))
+    # Only allow basic chars; everything else becomes "_"
+    out = []
+    for ch in s:
+        if ch.isalnum() or ch in ("-", "_"):
+            out.append(ch)
+        else:
+            out.append("_")
+    return "".join(out)[:120] or str(int(time.time() * 1000))
+
+
+def _write_result(job_dir: str, final_path: str) -> None:
+    """Persist the final file path so /api/fetch can retrieve it."""
+    meta = {
+        "path": final_path,
+        "filename": os.path.basename(final_path),
+        "ts": time.time(),
+    }
+    with open(os.path.join(job_dir, "result.json"), "w", encoding="utf-8") as f:
+        json.dump(meta, f, ensure_ascii=False)
+
+
+def _read_result(job_dir: str) -> Optional[dict]:
+    """Load persisted result metadata."""
+    p = os.path.join(job_dir, "result.json")
+    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
+
+
+@app.route("/api/download", methods=["POST"])
+def handle_download():
+    """
+    Legacy endpoint (unchanged):
+    - Runs yt-dlp to completion
+    - Returns the file as the HTTP response body
+    """
+    _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 = (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("/api/download_sse", methods=["POST"])
+def handle_download_sse():
+    """
+    NEW:
+    - Streams raw yt-dlp stdout lines as SSE in real time.
+    - Persists the final path to job_dir/result.json.
+    - Does NOT stream the file in this response.
+    """
+    _cleanup_stale_jobs()
+
+    if not _try_acquire_job_slot():
+        return jsonify(error="Server busy, try again later"), 503
+
+    released = False
+
+    def _release_once() -> None:
+        nonlocal released
+        if not released:
+            released = True
+            _release_job_slot()
+
+    data = request.get_json(force=True) or {}
+    url = (data.get("url") or "").strip()
+    resolution = data.get("resolution")
+    extension = (data.get("extension") or "mp4").strip().lower()
+    job_id = _safe_job_id(str(data.get("job_id") or ""))
+
+    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 = os.path.join(BASE_DOWNLOAD_DIR, job_id)
+    os.makedirs(job_dir, exist_ok=True)
+
+    def gen():
+        try:
+            # download_video_stream is a generator that yields yt-dlp lines and
+            # returns final_path via StopIteration.value
+            g = download_video_stream(
+                url=url,
+                resolution=resolution,
+                extension=extension,
+                out_dir=job_dir,
+            )
+
+            final_path: Optional[str] = None
+
+            while True:
+                try:
+                    line = next(g)
+                except StopIteration as si:
+                    final_path = si.value  # type: ignore[assignment]
+                    break
+
+                line = (line or "").strip()
+                if not line:
+                    continue
+                yield f"data: {line}\n\n"
+
+            if not final_path or not os.path.exists(final_path):
+                raise RuntimeError("Download completed but output file not found")
+
+            _write_result(job_dir, final_path)
+
+            # Marker consumed by your Render app (not forwarded to the browser).
+            yield f"data: [vps_ready] {os.path.basename(final_path)}\n\n"
+
+        except Exception as e:
+            msg = str(e)
+            yield f"data: VPS error: {msg}\n\n"
+        finally:
+            _release_once()
+
+    resp = Response(stream_with_context(gen()), content_type="text/event-stream")
+    resp.headers["Cache-Control"] = "no-cache"
+    resp.headers["X-Accel-Buffering"] = "no"
+    return resp
+
+
+@app.route("/api/fetch/<job_id>", methods=["GET"])
+def fetch_job(job_id: str):
+    """
+    NEW:
+    - Returns the completed file for a prior /api/download_sse job.
+    - Deletes the job dir after the client finishes consuming the response.
+    """
+    job_id = _safe_job_id(job_id)
+    job_dir = os.path.join(BASE_DOWNLOAD_DIR, job_id)
+    meta = _read_result(job_dir)
+    if not meta:
+        return jsonify(error="Job not found or not ready"), 404
+
+    path = (meta.get("path") or "").strip()
+    if not path:
+        return jsonify(error="Job result missing path"), 500
+
+    # Prevent path traversal: ensure file lives inside job_dir
+    try:
+        job_dir_abs = os.path.abspath(job_dir)
+        path_abs = os.path.abspath(path)
+        if os.path.commonpath([job_dir_abs, path_abs]) != job_dir_abs:
+            return jsonify(error="Invalid job result path"), 500
+    except Exception:
+        return jsonify(error="Invalid job result path"), 500
+
+    if not os.path.exists(path):
+        return jsonify(error="File not found"), 404
+
+    response = send_file(path, as_attachment=True)
+
+    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.7.0 → ytp_dl-0.7.1}/scripts/downloader.py

@@ -7,7 +7,7 @@ import shutil
 import subprocess
 import time
 from collections import deque
-from typing import Deque, Generator, List, Optional, Tuple
+from typing import Optional, List, Tuple, Deque, Generator
 
 # =========================
 # Config / constants
@@ -61,13 +61,6 @@ def _tail(out: str) -> str:
     return txt.strip()
 
 
-def _tail_deque(lines: Deque[str]) -> str:
-    txt = "\n".join(list(lines)[-_MAX_ERR_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"))
@@ -137,19 +130,14 @@ 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,
+        "--retries", "10",
+        "--fragment-retries", "10",
+        "--retry-sleep", "exp=1:30",
+        "--user-agent", MODERN_UA,
         "--no-cache-dir",
         "--ignore-config",
         "--embed-metadata",
-        "--sleep-interval",
-        "1",
+        "--sleep-interval", "1",
     ]
 
 
@@ -262,14 +250,11 @@ def _download_with_format(
 
     argv = [
         YTDLP_BIN,
-        "-f",
-        fmt,
+        "-f", fmt,
         *(_common_flags()),
-        "--output",
-        out_tpl,
+        "--output", out_tpl,
         # Ensure we can reliably pick the final output path.
-        "--print",
-        "after_move:filepath",
+        "--print", "after_move:filepath",
     ]
 
     if extract_mp3:
@@ -294,20 +279,6 @@ def _download_with_format(
     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}]"
-
-
 def _download_with_format_stream(
     url: str,
     out_dir: str,
@@ -316,26 +287,26 @@ def _download_with_format_stream(
     extract_mp3: bool = False,
 ) -> Generator[str, None, str]:
     """
-    Stream yt-dlp stdout lines in real-time.
-    Yields: raw stdout lines
-    Returns (StopIteration.value): absolute final output path
+    Stream yt-dlp output line-by-line (stdout+stderr merged),
+    and return the final output path via StopIteration.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: List[str] = [
+    argv = [
         YTDLP_BIN,
-        "-f",
-        fmt,
+        "-f", fmt,
         *(_common_flags()),
-        # ensure progress is emitted as real lines (no carriage-return overwrites)
+        "--output", out_tpl,
+
+        # Make progress lines flush as newline-terminated output
         "--progress",
         "--newline",
-        "--output",
-        out_tpl,
-        "--print",
-        "after_move:filepath",
+
+        # Ensure we can reliably obtain the post-processed final path
+        "--print", "after_move:filepath",
     ]
 
     if extract_mp3:
@@ -346,10 +317,6 @@ def _download_with_format_stream(
 
     argv.append(url)
 
-    tail_lines: Deque[str] = deque(maxlen=_MAX_ERR_LINES)
-    # Keep only a bounded capture for path extraction.
-    cap_lines: Deque[str] = deque(maxlen=2000)
-
     proc = subprocess.Popen(
         argv,
         stdout=subprocess.PIPE,
@@ -359,55 +326,65 @@ def _download_with_format_stream(
         universal_newlines=True,
     )
 
+    assert proc.stdout is not None
+
+    tail_buf: Deque[str] = deque(maxlen=_MAX_ERR_LINES)
+    final_path: Optional[str] = None
+
     try:
-        assert proc.stdout is not None
         for raw in iter(proc.stdout.readline, ""):
             line = (raw or "").rstrip("\n")
             if not line:
                 continue
 
-            tail_lines.append(line)
-            cap_lines.append(line)
-            yield line
+            tail_buf.append(line)
 
-        proc.stdout.close()
-        rc = proc.wait()
-
-        out_joined = "\n".join(cap_lines)
-        path = _extract_final_path(out_joined, out_dir)
+            # Capture after_move:filepath lines (absolute paths under out_dir)
+            cand = line.strip().strip("'\"")
+            try:
+                if os.path.isabs(cand):
+                    cand_abs = os.path.abspath(cand)
+                    if os.path.commonpath([out_dir, cand_abs]) == out_dir:
+                        final_path = cand_abs
+            except Exception:
+                pass
 
-        if path and os.path.exists(path):
-            return os.path.abspath(path)
+            yield line
 
-        # fallback: newest non-temp file in out_dir
+    finally:
         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 and os.path.exists(best_path):
-                return os.path.abspath(best_path)
+            proc.stdout.close()
         except Exception:
             pass
 
-        if rc != 0:
-            raise RuntimeError(f"yt-dlp failed (format: {fmt})\n{_tail_deque(tail_lines)}")
-        raise RuntimeError(f"Download completed but output file not found (format: {fmt})\n{_tail_deque(tail_lines)}")
+    rc = proc.wait()
 
-    finally:
-        try:
-            if proc.poll() is None:
-                proc.kill()
-        except Exception:
-            pass
+    if rc != 0:
+        raise RuntimeError(f"yt-dlp failed (format: {fmt})\n{_tail('\n'.join(tail_buf))}")
+
+    if final_path and os.path.exists(final_path):
+        return os.path.abspath(final_path)
+
+    # Fallback: newest non-temp file in out_dir
+    fallback = _extract_final_path("\n".join(tail_buf), out_dir)
+    if fallback and os.path.exists(fallback):
+        return os.path.abspath(fallback)
+
+    raise RuntimeError(f"Download completed but output file not found (format: {fmt})\n{_tail('\n'.join(tail_buf))}")
+
+
+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}]"
 
 
 # =========================
@@ -488,8 +465,8 @@ def download_video_stream(
     out_dir: str = DEFAULT_OUT_DIR,
 ) -> Generator[str, None, str]:
     """
-    Streaming variant for SSE usage.
-    Yields raw yt-dlp stdout lines; returns final file path as StopIteration.value.
+    Stream raw yt-dlp output lines and return the final file path.
+    Mirrors download_video(), but line-streaming instead of capture.
     """
     if not url:
         raise RuntimeError("Missing URL")
@@ -508,42 +485,52 @@ def download_video_stream(
         mode = (extension or "mp4").lower().strip()
 
         if mode == "mp3":
-            return (yield from _download_with_format_stream(
+            g = _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:
-                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:
-                return (yield from _download_with_format_stream(
+        else:
+            cap = int(resolution or 1080)
+
+            if mode == "best":
+                # Try best; on failure fall back to Apple-safe mp4 (same logic as download_video)
+                try:
+                    g = _download_with_format_stream(
+                        url=url,
+                        out_dir=out_dir,
+                        fmt=_fmt_best(cap),
+                        merge_output_format=None,
+                        extract_mp3=False,
+                    )
+                except Exception:
+                    g = _download_with_format_stream(
+                        url=url,
+                        out_dir=out_dir,
+                        fmt=_fmt_mp4_apple_safe(cap),
+                        merge_output_format="mp4",
+                        extract_mp3=False,
+                    )
+            else:
+                g = _download_with_format_stream(
                     url=url,
                     out_dir=out_dir,
                     fmt=_fmt_mp4_apple_safe(cap),
                     merge_output_format="mp4",
                     extract_mp3=False,
-                ))
+                )
 
-        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,
-        ))
+        # Forward all lines; return final path via StopIteration.value
+        while True:
+            try:
+                line = next(g)
+            except StopIteration as si:
+                return si.value  # final path
+            yield line
 
     finally:
         if _mullvad_present():
-            _run_argv(["mullvad", "disconnect"], check=False)
+            _run_argv(["mullvad", "disconnect"], check=False)

{ytp_dl-0.7.0 → ytp_dl-0.7.1}/setup.py

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

{ytp_dl-0.7.0 → ytp_dl-0.7.1}/ytp_dl.egg-info/PKG-INFO

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

ytp_dl-0.7.0/scripts/api.py

@@ -1,346 +0,0 @@
-#!/usr/bin/env python3
-from __future__ import annotations
-
-import json
-import os
-import re
-import shutil
-import tempfile
-import time
-from threading import BoundedSemaphore, Lock
-
-from flask import Flask, Response, jsonify, request, send_file, stream_with_context
-
-from .downloader import (
-    download_video,
-    download_video_stream,
-    validate_environment,
-)
-
-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"}
-
-_JOB_ID_RX = re.compile(r"^[A-Za-z0-9_-]{1,64}$")
-
-
-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 _safe_job_id(raw: str | None) -> str:
-    s = (raw or "").strip()
-    if _JOB_ID_RX.match(s):
-        return s
-    # fallback to timestamp-based id (stable & filesystem-safe)
-    return str(int(time.time() * 1000))
-
-
-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():
-    """
-    Backwards-compatible direct download endpoint:
-      - runs yt-dlp
-      - returns the file body directly
-    """
-    _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("/api/download_sse", methods=["POST"])
-def handle_download_sse():
-    """
-    New SSE endpoint:
-      - streams raw yt-dlp stdout lines in real-time (SSE)
-      - stores result.json with the final file path in a stable job dir
-      - releases concurrency slot immediately when yt-dlp completes
-      - client fetches the final file via /api/fetch/<job_id>
-    """
-    _cleanup_stale_jobs()
-
-    if not _try_acquire_job_slot():
-        return jsonify(error="Server busy, try again later"), 503
-
-    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 = (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_id = _safe_job_id(data.get("job_id"))
-        job_dir = os.path.join(BASE_DOWNLOAD_DIR, job_id)
-        shutil.rmtree(job_dir, ignore_errors=True)
-        os.makedirs(job_dir, exist_ok=True)
-
-        result_path = os.path.join(job_dir, "result.json")
-        err_path = os.path.join(job_dir, "error.txt")
-
-        def gen():
-            file_path: str | None = None
-            try:
-                # optional "ready" marker
-                yield f"data: [vps_ready] {job_id}\n\n"
-
-                dl = download_video_stream(
-                    url=url,
-                    resolution=resolution,
-                    extension=extension,
-                    out_dir=job_dir,
-                )
-
-                # manually iterate so we can capture StopIteration.value (the final path)
-                while True:
-                    try:
-                        line = next(dl)
-                    except StopIteration as si:
-                        file_path = si.value
-                        break
-
-                    if line:
-                        yield f"data: {line}\n\n"
-
-                if not (file_path and os.path.exists(file_path)):
-                    raise RuntimeError("Download completed but output file not found")
-
-                # Persist result for /api/fetch/<job_id>
-                try:
-                    with open(result_path, "w", encoding="utf-8") as f:
-                        json.dump(
-                            {
-                                "job_id": job_id,
-                                "file_path": os.path.abspath(file_path),
-                                "basename": os.path.basename(file_path),
-                                "created_ts": time.time(),
-                            },
-                            f,
-                            ensure_ascii=False,
-                        )
-                except Exception:
-                    pass
-
-                # Release slot as soon as yt-dlp is done (do NOT hold slot for fetch transfer)
-                _release_once()
-
-                yield f"data: [vps_done] {os.path.basename(file_path)}\n\n"
-                yield "data: [vps_end]\n\n"
-                return
-
-            except Exception as e:
-                try:
-                    with open(err_path, "w", encoding="utf-8") as f:
-                        f.write(str(e))
-                except Exception:
-                    pass
-
-                _release_once()
-                msg = str(e)
-                # keep it as a single SSE line
-                yield f"data: [vps_error] {msg}\n\n"
-                yield "data: [vps_end]\n\n"
-                return
-
-            finally:
-                # ensure slot is released even if client disconnects mid-stream
-                _release_once()
-
-        resp = Response(stream_with_context(gen()), content_type="text/event-stream")
-        resp.headers["Cache-Control"] = "no-cache"
-        resp.headers["X-Accel-Buffering"] = "no"
-        return resp
-
-    except Exception as e:
-        _release_once()
-        return jsonify(error=f"Download failed: {str(e)}"), 500
-
-
-@app.route("/api/fetch/<job_id>", methods=["GET"])
-def fetch_job_file(job_id: str):
-    """
-    Fetch the finished file for a job_id created by /api/download_sse.
-    Cleans up the job dir after response is fully consumed.
-    """
-    job_id = _safe_job_id(job_id)
-    job_dir = os.path.join(BASE_DOWNLOAD_DIR, job_id)
-    result_path = os.path.join(job_dir, "result.json")
-
-    if not os.path.exists(result_path):
-        return jsonify(error="Job not found or not complete"), 404
-
-    try:
-        with open(result_path, "r", encoding="utf-8") as f:
-            meta = json.load(f)
-        file_path = meta.get("file_path") or ""
-    except Exception:
-        return jsonify(error="Job metadata unreadable"), 500
-
-    file_path = os.path.abspath(file_path)
-    if not file_path.startswith(os.path.abspath(job_dir) + os.sep):
-        return jsonify(error="Invalid job file path"), 500
-
-    if not os.path.exists(file_path):
-        return jsonify(error="Job file missing"), 404
-
-    response = send_file(file_path, as_attachment=True)
-
-    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()