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

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: ytp-dl
-Version: 0.6.7
+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.7 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.7` + `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.7 + 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.7" "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.7 → 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.7 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.7` + `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.7 + 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.7" "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()