ytp-dl 0.6.8__py3-none-any.whl → 0.7.0__py3-none-any.whl

scripts/api.py

@@ -3,15 +3,19 @@ from __future__ import annotations
 
 import json
 import os
+import re
 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 flask import Flask, Response, jsonify, request, send_file, stream_with_context
 
-from .downloader import validate_environment, download_video_stream
+from .downloader import (
+    download_video,
+    download_video_stream,
+    validate_environment,
+)
 
 app = Flask(__name__)
 
@@ -32,6 +36,8 @@ 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()
@@ -50,6 +56,14 @@ def _cleanup_stale_jobs() -> None:
         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):
@@ -67,55 +81,105 @@ def _release_job_slot() -> None:
     _sem.release()
 
 
-def _job_meta_path(job_dir: str) -> str:
-    return os.path.join(job_dir, "job.json")
+@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
 
-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
+    job_dir: str | None = None
+    released = False
 
+    def _release_once() -> None:
+        nonlocal released
+        if not released:
+            released = True
+            _release_job_slot()
 
-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
+        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()
 
-def _sse_message(data: str) -> str:
-    # one "message" event
-    return f"data: {data}\n\n"
+        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
 
-def _sse_event(event_name: str, data: str) -> str:
-    # custom event type
-    return f"event: {event_name}\ndata: {data}\n\n"
+        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,
+        )
 
-@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"}
+        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
 
-    The finished file is retrieved separately via:
-      GET /api/file/<job_id>
+    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
 
-    job_dir: str | None = None
     released = False
 
     def _release_once() -> None:
@@ -128,8 +192,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:
@@ -142,123 +204,121 @@ def handle_download():
                 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)
+        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)
 
-        def stream():
-            nonlocal job_dir
+        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:
-                # ---- yt-dlp streamed logs ----
-                # download_video_stream yields yt-dlp stdout lines.
-                filename_path = yield from download_video_stream(
+                # 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,
                 )
 
-                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.
+                # 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()
 
-                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.")
+                yield f"data: [vps_done] {os.path.basename(file_path)}\n\n"
+                yield "data: [vps_end]\n\n"
                 return
 
-            except RuntimeError as e:
-                if job_dir:
-                    shutil.rmtree(job_dir, ignore_errors=True)
-                _release_once()
+            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)
-                # 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}))
+                # keep it as a single SSE line
+                yield f"data: [vps_error] {msg}\n\n"
+                yield "data: [vps_end]\n\n"
                 return
 
-            except GeneratorExit:
-                # Client disconnected mid-stream; best-effort cleanup.
-                if job_dir:
-                    shutil.rmtree(job_dir, ignore_errors=True)
+            finally:
+                # ensure slot is released even if client disconnects mid-stream
                 _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 = 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:
-        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):
+@app.route("/api/fetch/<job_id>", methods=["GET"])
+def fetch_job_file(job_id: str):
     """
-    After /api/download SSE completes with `event: result`,
-    the caller fetches the finished file here.
+    Fetch the finished file for a job_id created by /api/download_sse.
+    Cleans up the job dir after response is fully consumed.
     """
-    _cleanup_stale_jobs()
-
+    job_id = _safe_job_id(job_id)
     job_dir = os.path.join(BASE_DOWNLOAD_DIR, job_id)
-    if not os.path.isdir(job_dir):
-        return jsonify(error="Job not found"), 404
+    result_path = os.path.join(job_dir, "result.json")
 
-    meta = _read_job_meta(job_dir)
-    if not meta:
-        return jsonify(error="Job metadata missing"), 404
+    if not os.path.exists(result_path):
+        return jsonify(error="Job not found or not complete"), 404
 
-    file_path = meta.get("file_path")
-    filename = meta.get("filename") or (os.path.basename(file_path) if file_path else None)
+    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
 
-    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
+    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, download_name=filename)
+    response = send_file(file_path, as_attachment=True)
 
-    # Cleanup directory after client finishes consuming the response.
     def _cleanup() -> None:
         try:
             shutil.rmtree(job_dir, ignore_errors=True)

scripts/downloader.py

@@ -6,7 +6,8 @@ import shlex
 import shutil
 import subprocess
 import time
-from typing import Optional, List, Tuple, Generator
+from collections import deque
+from typing import Deque, Generator, List, Optional, Tuple
 
 # =========================
 # Config / constants
@@ -60,6 +61,18 @@ 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"))
+
+
 # =========================
 # Environment / Mullvad
 # =========================
@@ -124,31 +137,96 @@ 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",
-        "--sleep-interval", "1",
+        "--embed-metadata",
+        "--sleep-interval",
+        "1",
     ]
 
 
-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 _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)
 
-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}]"
+    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 _newest_non_temp_file(out_dir: str) -> Optional[str]:
+        # 2) Merger line: ... into "path"
+        if "Merging formats into" in line and "\"" in line:
+            try:
+                merged = line.split("Merging formats into", 1)[1].strip()
+                if merged.startswith("\"") and merged.endswith("\""):
+                    merged = merged[1:-1]
+                else:
+                    if merged.startswith("\""):
+                        merged = merged.split("\"", 2)[1]
+                if merged:
+                    if not os.path.isabs(merged):
+                        merged = os.path.join(out_dir, merged)
+                    candidates.append(merged.strip("'\""))
+            except Exception:
+                pass
+            continue
+
+        # 3) Destination lines (download/extractaudio)
+        if "Destination:" in line:
+            try:
+                p = line.split("Destination:", 1)[1].strip().strip("'\"")
+                if p and not os.path.isabs(p):
+                    p = os.path.join(out_dir, p)
+                if p:
+                    candidates.append(p)
+            except Exception:
+                pass
+            continue
+
+        # already downloaded
+        if "] " in line and " has already been downloaded" in line:
+            try:
+                p = (
+                    line.split("] ", 1)[1]
+                    .split(" has already been downloaded", 1)[0]
+                    .strip()
+                    .strip("'\"")
+                )
+                if p and not os.path.isabs(p):
+                    p = os.path.join(out_dir, p)
+                if p:
+                    candidates.append(p)
+            except Exception:
+                pass
+
+    # Prefer existing, newest candidate (reverse traversal)
+    for p in reversed(candidates):
+        if p and os.path.exists(p):
+            return p
+
+    # 4) Fallback: newest non-temp file in out_dir
     try:
         best_path = None
         best_mtime = -1.0
@@ -162,13 +240,75 @@ def _newest_non_temp_file(out_dir: str) -> Optional[str]:
             if mt > best_mtime:
                 best_mtime = mt
                 best_path = full
-        return best_path
+        if best_path:
+            return best_path
     except Exception:
-        return None
+        pass
+
+    return None
+
+
+def _download_with_format(
+    url: str,
+    out_dir: str,
+    fmt: str,
+    merge_output_format: Optional[str] = None,
+    extract_mp3: bool = False,
+) -> str:
+    out_dir = os.path.abspath(out_dir)
+    os.makedirs(out_dir, exist_ok=True)
+
+    out_tpl = os.path.join(out_dir, "%(title)s.%(ext)s")
+
+    argv = [
+        YTDLP_BIN,
+        "-f",
+        fmt,
+        *(_common_flags()),
+        "--output",
+        out_tpl,
+        # Ensure we can reliably pick the final output path.
+        "--print",
+        "after_move:filepath",
+    ]
+
+    if extract_mp3:
+        # Force audio extraction to MP3 (requires ffmpeg)
+        argv.extend(["--extract-audio", "--audio-format", "mp3"])
+
+    # Only force merge container when we actually want MP4 output.
+    if merge_output_format:
+        argv.extend(["--merge-output-format", merge_output_format])
+
+    argv.append(url)
+
+    rc, out = _run_argv_capture(argv)
+    path = _extract_final_path(out, out_dir)
+
+    if path and os.path.exists(path):
+        return os.path.abspath(path)
+
+    tail = _tail(out)
+    if rc != 0:
+        raise RuntimeError(f"yt-dlp failed (format: {fmt})\n{tail}")
+    raise RuntimeError(f"Download completed but output file not found (format: {fmt})\n{tail}")
+
+
+def _fmt_mp4_apple_safe(cap: int) -> str:
+    # Always pick the best Apple-safe MP4/H.264 + M4A/AAC up to cap.
+    return (
+        f"bv*[height<={cap}][ext=mp4][vcodec~='^(avc1|h264)']"
+        f"+ba[ext=m4a][acodec~='^mp4a']"
+        f"/b[height<={cap}][ext=mp4][vcodec~='^(avc1|h264)'][acodec~='^mp4a']"
+    )
+
+
+def _fmt_best(cap: int) -> str:
+    # Best overall up to cap (can yield webm/mkv/etc).
+    return f"bv*[height<={cap}]+ba/b[height<={cap}]"
 
 
 def _download_with_format_stream(
-    *,
     url: str,
     out_dir: str,
     fmt: str,
@@ -176,45 +316,40 @@ def _download_with_format_stream(
     extract_mp3: bool = False,
 ) -> 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).
+    Stream yt-dlp stdout lines in real-time.
+    Yields: raw stdout lines
+    Returns (StopIteration.value): absolute final output path
     """
     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] = [
         YTDLP_BIN,
-        url,
+        "-f",
+        fmt,
+        *(_common_flags()),
+        # ensure progress is emitted as real lines (no carriage-return overwrites)
         "--progress",
         "--newline",
-        "--continue",
-        "-f", fmt,
-        *(_common_flags()),
-        "--output", out_tpl,
-        # 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",
+        "--output",
+        out_tpl,
+        "--print",
+        "after_move:filepath",
     ]
 
     if extract_mp3:
-        argv.extend(
-            [
-                "--extract-audio",
-                "--audio-format", "mp3",
-                "--audio-quality", "0",
-                "--embed-thumbnail",
-                "--add-metadata",
-            ]
-        )
+        argv.extend(["--extract-audio", "--audio-format", "mp3"])
 
     if merge_output_format:
         argv.extend(["--merge-output-format", merge_output_format])
 
+    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,
@@ -224,58 +359,128 @@ def _download_with_format_stream(
         universal_newlines=True,
     )
 
-    final_path: Optional[str] = None
-    tail_lines: List[str] = []
-
     try:
         assert proc.stdout is not None
         for raw in iter(proc.stdout.readline, ""):
-            line = (raw or "").rstrip("\n").rstrip("\r")
+            line = (raw or "").rstrip("\n")
             if not line:
                 continue
 
-            # 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)
-
-            # Emit everything else (yt-dlp progress + [download_complete] line)
+            cap_lines.append(line)
             yield line
 
-        proc.wait()
+        proc.stdout.close()
+        rc = proc.wait()
+
+        out_joined = "\n".join(cap_lines)
+        path = _extract_final_path(out_joined, out_dir)
+
+        if path and os.path.exists(path):
+            return os.path.abspath(path)
+
+        # fallback: newest non-temp file in out_dir
+        try:
+            best_path = None
+            best_mtime = -1.0
+            for name in os.listdir(out_dir):
+                if name.endswith((".part", ".ytdl", ".tmp")):
+                    continue
+                full = os.path.join(out_dir, name)
+                if not os.path.isfile(full):
+                    continue
+                mt = os.path.getmtime(full)
+                if mt > best_mtime:
+                    best_mtime = mt
+                    best_path = full
+            if best_path and os.path.exists(best_path):
+                return os.path.abspath(best_path)
+        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)}")
+
     finally:
         try:
-            if proc.stdout:
-                proc.stdout.close()
+            if proc.poll() is None:
+                proc.kill()
         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}")
 
-    # Resolve final path
-    if final_path and os.path.exists(final_path):
-        return os.path.abspath(final_path)
+# =========================
+# Public API
+# =========================
+def download_video(
+    url: str,
+    resolution: int | None = 1080,
+    extension: Optional[str] = None,
+    out_dir: str = DEFAULT_OUT_DIR,
+) -> str:
+    if not url:
+        raise RuntimeError("Missing URL")
 
-    # 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)
+    out_dir = os.path.abspath(out_dir)
+    os.makedirs(out_dir, exist_ok=True)
 
-    tail = _tail("\n".join(tail_lines))
-    raise RuntimeError(f"Download completed but output file not found (format: {fmt})\n{tail}")
+    validate_environment()
+
+    require_mullvad_login()
+    mullvad_connect(MULLVAD_LOCATION)
+    if not mullvad_wait_connected():
+        raise RuntimeError("Mullvad connection failed")
+
+    try:
+        mode = (extension or "mp4").lower().strip()
+
+        if mode == "mp3":
+            # bestaudio -> ffmpeg -> mp3 (post-processed by yt-dlp)
+            return _download_with_format(
+                url=url,
+                out_dir=out_dir,
+                fmt="bestaudio",
+                merge_output_format=None,
+                extract_mp3=True,
+            )
+
+        cap = int(resolution or 1080)
+
+        if mode == "best":
+            # Try best first (may produce webm/mkv/etc).
+            try:
+                return _download_with_format(
+                    url=url,
+                    out_dir=out_dir,
+                    fmt=_fmt_best(cap),
+                    merge_output_format=None,
+                    extract_mp3=False,
+                )
+            except Exception:
+                # If best fails for any reason, fall back to Apple-safe MP4.
+                return _download_with_format(
+                    url=url,
+                    out_dir=out_dir,
+                    fmt=_fmt_mp4_apple_safe(cap),
+                    merge_output_format="mp4",
+                    extract_mp3=False,
+                )
+
+        # Default / "mp4" mode: force Apple-safe MP4 up to cap.
+        return _download_with_format(
+            url=url,
+            out_dir=out_dir,
+            fmt=_fmt_mp4_apple_safe(cap),
+            merge_output_format="mp4",
+            extract_mp3=False,
+        )
+
+    finally:
+        if _mullvad_present():
+            _run_argv(["mullvad", "disconnect"], check=False)
 
 
-# =========================
-# Public APIs
-# =========================
 def download_video_stream(
     url: str,
     resolution: int | None = 1080,
@@ -283,7 +488,8 @@ def download_video_stream(
     out_dir: str = DEFAULT_OUT_DIR,
 ) -> Generator[str, None, str]:
     """
-    Streams yt-dlp logs and returns final file path (generator return value).
+    Streaming variant for SSE usage.
+    Yields raw yt-dlp stdout lines; returns final file path as StopIteration.value.
     """
     if not url:
         raise RuntimeError("Missing URL")
@@ -313,7 +519,6 @@ def download_video_stream(
         cap = int(resolution or 1080)
 
         if mode == "best":
-            # Try best first (may produce webm/mkv/etc). If it fails, fall back to Apple-safe MP4.
             try:
                 return (yield from _download_with_format_stream(
                     url=url,
@@ -331,7 +536,6 @@ def download_video_stream(
                     extract_mp3=False,
                 ))
 
-        # Default / "mp4" mode
         return (yield from _download_with_format_stream(
             url=url,
             out_dir=out_dir,
@@ -343,27 +547,3 @@ def download_video_stream(
     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.8.dist-info → ytp_dl-0.7.0.dist-info}/METADATA

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

ytp_dl-0.7.0.dist-info/RECORD

@@ -0,0 +1,8 @@
+scripts/__init__.py,sha256=EbAplfCcyLD3Q_9sxemm6owCc5_UJv53vmlxy810p2s,152
+scripts/api.py,sha256=Lwu-Bb1fg6fjKBECyNOtvt3Q6Kna5qwmYUT50X51vUk,10356
+scripts/downloader.py,sha256=Zpjoxcm8HJ2_j7xMXQysfEKXanOHKtbLAFwuYkzqc4w,16049
+ytp_dl-0.7.0.dist-info/METADATA,sha256=KG6IndrPKUI5xOzA3Ldx0iKTqBbwjoqAYDEIxVtXKdU,14547
+ytp_dl-0.7.0.dist-info/WHEEL,sha256=wUyA8OaulRlbfwMtmQsvNngGrxQHAvkKcvRmdizlJi0,92
+ytp_dl-0.7.0.dist-info/entry_points.txt,sha256=QqjqZZAEt3Y7RGrleqZ312sjjboUpbMLdo7qFxuCH30,48
+ytp_dl-0.7.0.dist-info/top_level.txt,sha256=rmzd5mewlrJy4sT608KPib7sM7edoY75AeqJeY3SPB4,8
+ytp_dl-0.7.0.dist-info/RECORD,,

ytp_dl-0.6.8.dist-info/RECORD

@@ -1,8 +0,0 @@
-scripts/__init__.py,sha256=EbAplfCcyLD3Q_9sxemm6owCc5_UJv53vmlxy810p2s,152
-scripts/api.py,sha256=EMpD_vRX5FZQ-ICIxLuRqJxitvlbi1VnUflWMC4yvmw,8560
-scripts/downloader.py,sha256=LT7ANnpf7DRgVuRdNynqIXMKfKaeohy508OCXmltLtA,10529
-ytp_dl-0.6.8.dist-info/METADATA,sha256=g5Q33WgF9ZBJYLdFYSt2cAiyl9QPSD1YpOeXcFUw628,14547
-ytp_dl-0.6.8.dist-info/WHEEL,sha256=wUyA8OaulRlbfwMtmQsvNngGrxQHAvkKcvRmdizlJi0,92
-ytp_dl-0.6.8.dist-info/entry_points.txt,sha256=QqjqZZAEt3Y7RGrleqZ312sjjboUpbMLdo7qFxuCH30,48
-ytp_dl-0.6.8.dist-info/top_level.txt,sha256=rmzd5mewlrJy4sT608KPib7sM7edoY75AeqJeY3SPB4,8
-ytp_dl-0.6.8.dist-info/RECORD,,