ytp-dl 0.6.9__py3-none-any.whl → 0.7.1__py3-none-any.whl

scripts/api.py

@@ -1,15 +1,17 @@
 #!/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
+from flask import Flask, request, send_file, jsonify, Response, stream_with_context
 
-from .downloader import validate_environment, download_video
+from .downloader import validate_environment, download_video, download_video_stream
 
 app = Flask(__name__)
 
@@ -65,8 +67,51 @@ def _release_job_slot() -> None:
     _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():
@@ -85,8 +130,6 @@ def handle_download():
         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:
@@ -145,6 +188,129 @@ def handle_download():
         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:
@@ -159,4 +325,4 @@ def main():
 
 
 if __name__ == "__main__":
-    main()
+    main()

scripts/downloader.py

@@ -6,7 +6,8 @@ import shlex
 import shutil
 import subprocess
 import time
-from typing import Optional, List, Tuple
+from collections import deque
+from typing import Optional, List, Tuple, Deque, Generator
 
 # =========================
 # Config / constants
@@ -278,6 +279,100 @@ def _download_with_format(
     raise RuntimeError(f"Download completed but output file not found (format: {fmt})\n{tail}")
 
 
+def _download_with_format_stream(
+    url: str,
+    out_dir: str,
+    fmt: str,
+    merge_output_format: Optional[str] = None,
+    extract_mp3: bool = False,
+) -> Generator[str, None, str]:
+    """
+    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 = [
+        YTDLP_BIN,
+        "-f", fmt,
+        *(_common_flags()),
+        "--output", out_tpl,
+
+        # Make progress lines flush as newline-terminated output
+        "--progress",
+        "--newline",
+
+        # Ensure we can reliably obtain the post-processed final path
+        "--print", "after_move:filepath",
+    ]
+
+    if extract_mp3:
+        argv.extend(["--extract-audio", "--audio-format", "mp3"])
+
+    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,
+    )
+
+    assert proc.stdout is not None
+
+    tail_buf: Deque[str] = deque(maxlen=_MAX_ERR_LINES)
+    final_path: Optional[str] = None
+
+    try:
+        for raw in iter(proc.stdout.readline, ""):
+            line = (raw or "").rstrip("\n")
+            if not line:
+                continue
+
+            tail_buf.append(line)
+
+            # 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
+
+            yield line
+
+    finally:
+        try:
+            proc.stdout.close()
+        except Exception:
+            pass
+
+    rc = proc.wait()
+
+    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 (
@@ -361,3 +456,81 @@ def download_video(
     finally:
         if _mullvad_present():
             _run_argv(["mullvad", "disconnect"], check=False)
+
+
+def download_video_stream(
+    url: str,
+    resolution: int | None = 1080,
+    extension: Optional[str] = None,
+    out_dir: str = DEFAULT_OUT_DIR,
+) -> Generator[str, None, str]:
+    """
+    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")
+
+    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":
+            g = _download_with_format_stream(
+                url=url,
+                out_dir=out_dir,
+                fmt="bestaudio",
+                merge_output_format=None,
+                extract_mp3=True,
+            )
+
+        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,
+                )
+
+        # 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)

{ytp_dl-0.6.9.dist-info → ytp_dl-0.7.1.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: ytp-dl
-Version: 0.6.9
+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.6.9 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.6.9` + `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.6.9 + 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.6.9" "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.dist-info/RECORD

@@ -0,0 +1,8 @@
+scripts/__init__.py,sha256=EbAplfCcyLD3Q_9sxemm6owCc5_UJv53vmlxy810p2s,152
+scripts/api.py,sha256=dqVcS1niL2ziv3w3WipiDH8T0peNlSzRCBfm1xxR4N0,9562
+scripts/downloader.py,sha256=Fo8srnATM9Eee0yWvGsr5LKp6Zg8KTpsW7TFk24YZlg,15916
+ytp_dl-0.7.1.dist-info/METADATA,sha256=8WsJ-TM4orFucsTAEck6S95dAuh5P2eRLVpurKlFhDk,14547
+ytp_dl-0.7.1.dist-info/WHEEL,sha256=wUyA8OaulRlbfwMtmQsvNngGrxQHAvkKcvRmdizlJi0,92
+ytp_dl-0.7.1.dist-info/entry_points.txt,sha256=QqjqZZAEt3Y7RGrleqZ312sjjboUpbMLdo7qFxuCH30,48
+ytp_dl-0.7.1.dist-info/top_level.txt,sha256=rmzd5mewlrJy4sT608KPib7sM7edoY75AeqJeY3SPB4,8
+ytp_dl-0.7.1.dist-info/RECORD,,

ytp_dl-0.6.9.dist-info/RECORD

@@ -1,8 +0,0 @@
-scripts/__init__.py,sha256=EbAplfCcyLD3Q_9sxemm6owCc5_UJv53vmlxy810p2s,152
-scripts/api.py,sha256=cyLjHmelLwzh8-GOjqXsQdhm6wLX8bOkADZ_qU1naRQ,4331
-scripts/downloader.py,sha256=vvHasu-41DGPDUzOTA4kz52tijTkaii1NnuU4cHQxg8,10825
-ytp_dl-0.6.9.dist-info/METADATA,sha256=Z4H5XVsQIQgU3hFXdF-Lp2Yf6-sSzTjwpHAptrGeMYg,14547
-ytp_dl-0.6.9.dist-info/WHEEL,sha256=wUyA8OaulRlbfwMtmQsvNngGrxQHAvkKcvRmdizlJi0,92
-ytp_dl-0.6.9.dist-info/entry_points.txt,sha256=QqjqZZAEt3Y7RGrleqZ312sjjboUpbMLdo7qFxuCH30,48
-ytp_dl-0.6.9.dist-info/top_level.txt,sha256=rmzd5mewlrJy4sT608KPib7sM7edoY75AeqJeY3SPB4,8
-ytp_dl-0.6.9.dist-info/RECORD,,