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

scripts/api.py

@@ -3,21 +3,15 @@ from __future__ import annotations
 
 import json
 import os
-import secrets
 import shutil
 import tempfile
 import time
 from threading import BoundedSemaphore, Lock
-from typing import Optional, Dict, Any, Iterable
+from typing import Optional
 
-from flask import Flask, request, jsonify, Response, send_file
+from flask import Flask, request, send_file, jsonify, Response, stream_with_context
 
-from .downloader import (
-    validate_environment,
-    prepare_network,
-    cleanup_network,
-    build_download_plan,
-)
+from .downloader import validate_environment, download_video_stream
 
 app = Flask(__name__)
 
@@ -77,7 +71,7 @@ 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[str, Any]) -> None:
+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)
@@ -85,36 +79,36 @@ def _write_job_meta(job_dir: str, meta: Dict[str, Any]) -> None:
         pass
 
 
-def _read_job_meta(job_dir: str) -> Optional[Dict[str, Any]]:
-    p = _job_meta_path(job_dir)
-    if not os.path.exists(p):
+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(p, "r", encoding="utf-8") as f:
+        with open(path, "r", encoding="utf-8") as f:
             return json.load(f)
     except Exception:
         return None
 
 
-def _touch(path: str) -> None:
-    try:
-        os.utime(path, None)
-    except Exception:
-        pass
+def _sse_message(data: str) -> str:
+    # one "message" event
+    return f"data: {data}\n\n"
 
 
-def _sse(data: str) -> str:
-    # Minimal SSE formatting
-    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():
     """
-    VPS-side downloader:
-    - returns SSE logs (real yt-dlp output) to caller
-    - stores completed file in a job dir
-    - caller then fetches the file via /api/fetch/<job_id>?token=...
+    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()
 
@@ -150,135 +144,87 @@ def handle_download():
 
         job_dir = tempfile.mkdtemp(prefix="ytpdl_", dir=BASE_DOWNLOAD_DIR)
         job_id = os.path.basename(job_dir)
-        token = secrets.token_urlsafe(24)
 
-        def stream() -> Iterable[str]:
+        def stream():
             nonlocal job_dir
-            assert job_dir is not None
-
-            # Internal control info (caller should NOT forward to browser).
-            yield _sse(f"[internal] job={job_id} token={token}")
-
             try:
-                validate_environment()
-                prepare_network()
-
-                out_dir = job_dir
-                out_dir_abs = os.path.abspath(out_dir)
-
-                # Track final file path without printing it to the client.
-                final_path: Optional[str] = None
-                # Track "pretty" filename from [download_complete] marker.
-                final_name: Optional[str] = None
-
-                plan = build_download_plan(
+                # ---- 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=out_dir,
+                    out_dir=job_dir,
                 )
 
-                for step_idx, argv in enumerate(plan, start=1):
-                    # Let caller know about fallback attempt (still safe to forward).
-                    if step_idx > 1:
-                        yield _sse("Retrying with fallback format...")
-
-                    import subprocess
-
-                    proc = subprocess.Popen(
-                        argv,
-                        stdout=subprocess.PIPE,
-                        stderr=subprocess.STDOUT,
-                        text=True,
-                        bufsize=1,
+                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)"}),
                     )
-
-                    assert proc.stdout is not None
-
-                    for raw in iter(proc.stdout.readline, ""):
-                        line = (raw or "").strip()
-                        if not line:
-                            continue
-
-                        # yt-dlp --print after_move:filepath outputs an absolute path.
-                        # Keep it internal so browser logs match local.
-                        if os.path.isabs(line) and line.startswith(out_dir_abs):
-                            final_path = line.strip("'\"")
-                            continue
-
-                        # Capture local-style marker for filename.
-                        if line.startswith("[download_complete]"):
-                            # same semantics as your local parser
-                            try:
-                                final_name = line.split("[download_complete]", 1)[1].strip()
-                            except Exception:
-                                final_name = None
-
-                        yield _sse(line)
-
-                    proc.stdout.close()
-                    rc = proc.wait()
-
-                    if rc == 0:
-                        break
-
-                # Validate output
-                if not final_path:
-                    # Try to discover any output file in job dir if filepath line wasn't produced.
-                    try:
-                        for name in os.listdir(job_dir):
-                            if name.endswith((".part", ".ytdl", ".tmp")):
-                                continue
-                            p = os.path.join(job_dir, name)
-                            if os.path.isfile(p):
-                                final_path = os.path.abspath(p)
-                                break
-                    except Exception:
-                        pass
-
-                if not (final_path and os.path.exists(final_path)):
-                    yield _sse("ERROR: Download completed but output file not found")
                     return
 
-                # Persist meta for /api/fetch
-                meta = {
-                    "job_id": job_id,
-                    "token": token,
-                    "file_path": os.path.abspath(final_path),
-                    "file_name": final_name or os.path.basename(final_path),
-                    "created_at": time.time(),
-                }
-                _write_job_meta(job_dir, meta)
-                _touch(job_dir)
-
-                # Release slot as soon as yt-dlp is done (do NOT hold during fetch).
+                # Release slot as soon as yt-dlp is done.
                 _release_once()
 
-                # Signal ready to caller (do NOT forward to browser).
-                yield _sse("[internal] ready")
+                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}),
+                )
 
-            finally:
-                cleanup_network()
+                # keep-alive tail
+                yield _sse_message("All downloads complete.")
+                return
 
-        return Response(
-            stream(),
-            content_type="text/event-stream",
-            headers={
-                "Cache-Control": "no-cache",
-                "X-Accel-Buffering": "no",
-                "Connection": "close",
-            },
-        )
+            except RuntimeError as e:
+                if job_dir:
+                    shutil.rmtree(job_dir, ignore_errors=True)
+                _release_once()
 
-    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
 
-        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()
+
+                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:
@@ -287,17 +233,13 @@ def handle_download():
         return jsonify(error=f"Download failed: {str(e)}"), 500
 
 
-@app.route("/api/fetch/<job_id>", methods=["GET"])
-def fetch(job_id: str):
+@app.route("/api/file/<job_id>", methods=["GET"])
+def fetch_file(job_id: str):
     """
-    Fetch the finished file after /api/download completes.
-
-    Requires:
-      /api/fetch/<job_id>?token=...
+    After /api/download SSE completes with `event: result`,
+    the caller fetches the finished file here.
     """
-    token = (request.args.get("token") or "").strip()
-    if not token:
-        return jsonify(error="Missing token"), 400
+    _cleanup_stale_jobs()
 
     job_dir = os.path.join(BASE_DOWNLOAD_DIR, job_id)
     if not os.path.isdir(job_dir):
@@ -307,26 +249,24 @@ def fetch(job_id: str):
     if not meta:
         return jsonify(error="Job metadata missing"), 404
 
-    if meta.get("token") != token:
-        return jsonify(error="Invalid token"), 403
-
     file_path = meta.get("file_path")
-    if not (file_path and os.path.exists(file_path)):
-        return jsonify(error="File not found"), 404
+    filename = meta.get("filename") or (os.path.basename(file_path) if file_path else None)
 
-    download_name = meta.get("file_name") or os.path.basename(file_path)
+    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
 
-    resp = send_file(file_path, as_attachment=True, download_name=download_name)
+    response = send_file(file_path, as_attachment=True, download_name=filename)
 
-    # Cleanup after caller finishes consuming the response.
+    # Cleanup directory after client finishes consuming the response.
     def _cleanup() -> None:
         try:
             shutil.rmtree(job_dir, ignore_errors=True)
         except Exception:
             pass
 
-    resp.call_on_close(_cleanup)
-    return resp
+    response.call_on_close(_cleanup)
+    return response
 
 
 @app.route("/healthz", methods=["GET"])

scripts/downloader.py

@@ -6,7 +6,7 @@ import shlex
 import shutil
 import subprocess
 import time
-from typing import Optional, List, Tuple, Any
+from typing import Optional, List, Tuple, Generator
 
 # =========================
 # Config / constants
@@ -29,8 +29,6 @@ DEFAULT_OUT_DIR = os.environ.get("YTPDL_DOWNLOAD_DIR", "/root")
 _MAX_ERR_LINES = 80
 _MAX_ERR_CHARS = 4000
 
-_ALLOWED_EXTENSIONS = {"mp3", "mp4", "best"}
-
 
 # =========================
 # Shell helpers
@@ -119,25 +117,6 @@ def mullvad_wait_connected(timeout: int = 20) -> bool:
     return False
 
 
-def prepare_network() -> None:
-    """
-    Called by VPS API server before launching yt-dlp.
-    """
-    validate_environment()
-    require_mullvad_login()
-    mullvad_connect(MULLVAD_LOCATION)
-    if not mullvad_wait_connected():
-        raise RuntimeError("Mullvad connection failed")
-
-
-def cleanup_network() -> None:
-    """
-    Called by VPS API server after yt-dlp finishes.
-    """
-    if _mullvad_present():
-        _run_argv(["mullvad", "disconnect"], check=False)
-
-
 # =========================
 # yt-dlp helpers
 # =========================
@@ -155,25 +134,6 @@ def _common_flags() -> List[str]:
     ]
 
 
-def _sanitize_title_flags() -> List[str]:
-    # Mirrors your local downloader's title sanitization intent.
-    return [
-        "--replace-in-metadata",
-        "title",
-        "[\\U0001F600-\\U0001F64F\\U0001F300-\\U0001F5FF"
-        "\\U0001F680-\\U0001F6FF\\U0001F700-\\U0001F77F"
-        "\\U0001F780-\\U0001F7FF\\U0001F800-\\U0001F8FF"
-        "\\U0001F900-\\U0001F9FF\\U0001FA00-\\U0001FA6F"
-        "\\U0001FA70-\\U0001FAFF\\U00002702-\\U000027B0"
-        "\\U000024C2-\\U0001F251]",
-        "",
-        "--replace-in-metadata",
-        "title",
-        r"[\\\/:*?\"<>|]|[\s.]+$",
-        "",
-    ]
-
-
 def _fmt_mp4_apple_safe(cap: int) -> str:
     # Always pick the best Apple-safe MP4/H.264 + M4A/AAC up to cap.
     return (
@@ -188,124 +148,222 @@ def _fmt_best(cap: int) -> str:
     return f"bv*[height<={cap}]+ba/b[height<={cap}]"
 
 
-def _base_argv(out_dir: str) -> List[str]:
+def _newest_non_temp_file(out_dir: str) -> Optional[str]:
+    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
+        return best_path
+    except Exception:
+        return None
+
+
+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 stdout lines (same style as local: --progress --newline),
+    while capturing final output path reliably.
+
+    Returns absolute file path (generator return value).
+    """
     out_dir = os.path.abspath(out_dir)
+    os.makedirs(out_dir, exist_ok=True)
+
     out_tpl = os.path.join(out_dir, "%(title)s.%(ext)s")
 
-    return [
+    argv: List[str] = [
         YTDLP_BIN,
+        url,
         "--progress",
         "--newline",
         "--continue",
-        *_common_flags(),
-        *_sanitize_title_flags(),
+        "-f", fmt,
+        *(_common_flags()),
         "--output", out_tpl,
-        # Internal: absolute final path (API server filters this from browser).
+        # Absolute final path for internal capture (we do NOT emit this line).
         "--print", "after_move:filepath",
-        # Visible: local-style completion marker.
+        # Local parity signal:
         "--print", "after_move:[download_complete] %(title)s.%(ext)s",
     ]
 
+    if extract_mp3:
+        argv.extend(
+            [
+                "--extract-audio",
+                "--audio-format", "mp3",
+                "--audio-quality", "0",
+                "--embed-thumbnail",
+                "--add-metadata",
+            ]
+        )
 
-def build_download_plan(
-    url: str,
-    resolution: Any | None = 1080,
-    extension: Optional[str] = None,
-    out_dir: str = DEFAULT_OUT_DIR,
-) -> List[List[str]]:
-    """
-    Returns a list of argv arrays to try in order.
-    The VPS API server will run them with Popen and stream stdout.
-    """
-    if not url:
-        raise RuntimeError("Missing URL")
+    if merge_output_format:
+        argv.extend(["--merge-output-format", merge_output_format])
 
-    mode = (extension or "mp4").lower().strip()
-    if mode not in _ALLOWED_EXTENSIONS:
-        raise RuntimeError(f"Invalid extension/mode: {mode}")
-
-    cap = int(resolution or 1080)
-    base = _base_argv(out_dir)
-
-    if mode == "mp3":
-        return [[
-            *base,
-            "-f", "bestaudio",
-            "--extract-audio",
-            "--audio-format", "mp3",
-            "--audio-quality", "0",
-            "--embed-thumbnail",
-            "--add-metadata",
-            "--metadata-from-title", "%(artist)s - %(title)s",
-            url,
-        ]]
-
-    if mode == "best":
-        # Try best first, then fallback to Apple-safe MP4.
-        return [
-            [
-                *base,
-                "-f", _fmt_best(cap),
-                url,
-            ],
-            [
-                *base,
-                "-f", _fmt_mp4_apple_safe(cap),
-                "--merge-output-format", "mp4",
-                url,
-            ],
-        ]
-
-    # mode == "mp4" (default)
-    return [[
-        *base,
-        "-f", _fmt_mp4_apple_safe(cap),
-        "--merge-output-format", "mp4",
-        url,
-    ]]
+    proc = subprocess.Popen(
+        argv,
+        stdout=subprocess.PIPE,
+        stderr=subprocess.STDOUT,
+        text=True,
+        bufsize=1,
+        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")
+            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)
+            yield line
+
+        proc.wait()
+    finally:
+        try:
+            if proc.stdout:
+                proc.stdout.close()
+        except Exception:
+            pass
+
+    if proc.returncode != 0:
+        tail = "\n".join(tail_lines)
+        tail = _tail(tail)
+        raise RuntimeError(f"yt-dlp failed (format: {fmt})\n{tail}")
+
+    # Resolve final path
+    if final_path and os.path.exists(final_path):
+        return os.path.abspath(final_path)
+
+    # Fallback: newest output in out_dir
+    newest = _newest_non_temp_file(out_dir)
+    if newest and os.path.exists(newest):
+        return os.path.abspath(newest)
+
+    tail = _tail("\n".join(tail_lines))
+    raise RuntimeError(f"Download completed but output file not found (format: {fmt})\n{tail}")
 
 
 # =========================
-# Legacy (keep for compatibility)
+# Public APIs
 # =========================
-def download_video(
+def download_video_stream(
     url: str,
     resolution: int | None = 1080,
     extension: Optional[str] = None,
     out_dir: str = DEFAULT_OUT_DIR,
-) -> str:
+) -> Generator[str, None, str]:
     """
-    Original blocking API (kept so existing imports don't break).
-    The VPS API server now uses build_download_plan + Popen streaming instead.
+    Streams yt-dlp logs and returns final file path (generator return value).
     """
-    import os
-
     if not url:
         raise RuntimeError("Missing URL")
 
     out_dir = os.path.abspath(out_dir)
     os.makedirs(out_dir, exist_ok=True)
 
-    prepare_network()
-    try:
-        plan = build_download_plan(url=url, resolution=resolution, extension=extension, out_dir=out_dir)
-
-        last_out = ""
-        for argv in plan:
-            rc, out = _run_argv_capture(argv)
-            last_out = out or ""
-            # Find the printed after_move:filepath absolute path (first matching line).
-            for raw in (last_out or "").splitlines():
-                line = (raw or "").strip()
-                if os.path.isabs(line) and line.startswith(out_dir):
-                    if os.path.exists(line):
-                        return os.path.abspath(line)
+    validate_environment()
 
-            if rc == 0:
-                break
+    require_mullvad_login()
+    mullvad_connect(MULLVAD_LOCATION)
+    if not mullvad_wait_connected():
+        raise RuntimeError("Mullvad connection failed")
 
-        tail = _tail(last_out)
-        raise RuntimeError(f"Download completed but output file not found\n{tail}")
+    try:
+        mode = (extension or "mp4").lower().strip()
+
+        if mode == "mp3":
+            return (yield from _download_with_format_stream(
+                url=url,
+                out_dir=out_dir,
+                fmt="bestaudio",
+                merge_output_format=None,
+                extract_mp3=True,
+            ))
+
+        cap = int(resolution or 1080)
+
+        if mode == "best":
+            # Try best first (may produce webm/mkv/etc). If it fails, fall back to Apple-safe MP4.
+            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(
+                    url=url,
+                    out_dir=out_dir,
+                    fmt=_fmt_mp4_apple_safe(cap),
+                    merge_output_format="mp4",
+                    extract_mp3=False,
+                ))
+
+        # Default / "mp4" mode
+        return (yield from _download_with_format_stream(
+            url=url,
+            out_dir=out_dir,
+            fmt=_fmt_mp4_apple_safe(cap),
+            merge_output_format="mp4",
+            extract_mp3=False,
+        ))
 
     finally:
-        cleanup_network()
+        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.7.dist-info → ytp_dl-0.6.8.dist-info}/METADATA

@@ -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.8.dist-info/RECORD

@@ -0,0 +1,8 @@
+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,,

ytp_dl-0.6.7.dist-info/RECORD

@@ -1,8 +0,0 @@
-scripts/__init__.py,sha256=EbAplfCcyLD3Q_9sxemm6owCc5_UJv53vmlxy810p2s,152
-scripts/api.py,sha256=gHVQgAJE2x0V1UpE0UTuBr1HU5yleYv7uhLmjN-2HXA,10454
-scripts/downloader.py,sha256=NWPJPP2WcXUt4X2yr4EPEqHG5e6N2GMdNufDgzhwDDg,8768
-ytp_dl-0.6.7.dist-info/METADATA,sha256=JvG6aK5Z4VEshRBy0FWpDmh3Dcr3ro5c49kOsnOT3do,14547
-ytp_dl-0.6.7.dist-info/WHEEL,sha256=wUyA8OaulRlbfwMtmQsvNngGrxQHAvkKcvRmdizlJi0,92
-ytp_dl-0.6.7.dist-info/entry_points.txt,sha256=QqjqZZAEt3Y7RGrleqZ312sjjboUpbMLdo7qFxuCH30,48
-ytp_dl-0.6.7.dist-info/top_level.txt,sha256=rmzd5mewlrJy4sT608KPib7sM7edoY75AeqJeY3SPB4,8
-ytp_dl-0.6.7.dist-info/RECORD,,