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

scripts/api.py

@@ -1,15 +1,23 @@
 #!/usr/bin/env python3
 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 flask import Flask, request, send_file, jsonify
+from flask import Flask, request, jsonify, Response, send_file
 
-from .downloader import validate_environment, download_video
+from .downloader import (
+    validate_environment,
+    prepare_network,
+    cleanup_network,
+    build_download_plan,
+)
 
 app = Flask(__name__)
 
@@ -65,8 +73,49 @@ def _release_job_slot() -> None:
     _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[str, Any]) -> 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[str, Any]]:
+    p = _job_meta_path(job_dir)
+    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
+
+
+def _touch(path: str) -> None:
+    try:
+        os.utime(path, None)
+    except Exception:
+        pass
+
+
+def _sse(data: str) -> str:
+    # Minimal SSE formatting
+    return f"data: {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=...
+    """
     _cleanup_stale_jobs()
 
     if not _try_acquire_job_slot():
@@ -100,33 +149,126 @@ def handle_download():
             ), 400
 
         job_dir = tempfile.mkdtemp(prefix="ytpdl_", dir=BASE_DOWNLOAD_DIR)
+        job_id = os.path.basename(job_dir)
+        token = secrets.token_urlsafe(24)
 
-        # yt-dlp work (guarded by semaphore)
-        filename = download_video(
-            url=url,
-            resolution=resolution,
-            extension=extension,
-            out_dir=job_dir,
-        )
+        def stream() -> Iterable[str]:
+            nonlocal job_dir
+            assert job_dir is not None
 
-        if not (filename and os.path.exists(filename)):
-            raise RuntimeError("Download failed")
+            # Internal control info (caller should NOT forward to browser).
+            yield _sse(f"[internal] job={job_id} token={token}")
 
-        # 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
+                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(
+                    url=url,
+                    resolution=resolution,
+                    extension=extension,
+                    out_dir=out_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,
+                    )
+
+                    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_once()
+
+                # Signal ready to caller (do NOT forward to browser).
+                yield _sse("[internal] ready")
+
+            finally:
+                cleanup_network()
+
+        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:
@@ -145,6 +287,48 @@ 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):
+    """
+    Fetch the finished file after /api/download completes.
+
+    Requires:
+      /api/fetch/<job_id>?token=...
+    """
+    token = (request.args.get("token") or "").strip()
+    if not token:
+        return jsonify(error="Missing token"), 400
+
+    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
+
+    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
+
+    download_name = meta.get("file_name") or os.path.basename(file_path)
+
+    resp = send_file(file_path, as_attachment=True, download_name=download_name)
+
+    # Cleanup after caller 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
+
+
 @app.route("/healthz", methods=["GET"])
 def healthz():
     with _in_use_lock:

scripts/downloader.py

@@ -6,7 +6,7 @@ import shlex
 import shutil
 import subprocess
 import time
-from typing import Optional, List, Tuple
+from typing import Optional, List, Tuple, Any
 
 # =========================
 # Config / constants
@@ -29,6 +29,8 @@ 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
@@ -60,11 +62,6 @@ def _tail(out: str) -> str:
     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
 # =========================
@@ -122,6 +119,25 @@ 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
 # =========================
@@ -135,148 +151,28 @@ def _common_flags() -> List[str]:
         "--user-agent", MODERN_UA,
         "--no-cache-dir",
         "--ignore-config",
-        "--embed-metadata",
         "--sleep-interval", "1",
     ]
 
 
-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)
-
-    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
-
-        # 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
-        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:
-            return best_path
-    except Exception:
-        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",
+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.]+$",
+        "",
     ]
 
-    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.
@@ -292,8 +188,85 @@ def _fmt_best(cap: int) -> str:
     return f"bv*[height<={cap}]+ba/b[height<={cap}]"
 
 
+def _base_argv(out_dir: str) -> List[str]:
+    out_dir = os.path.abspath(out_dir)
+    out_tpl = os.path.join(out_dir, "%(title)s.%(ext)s")
+
+    return [
+        YTDLP_BIN,
+        "--progress",
+        "--newline",
+        "--continue",
+        *_common_flags(),
+        *_sanitize_title_flags(),
+        "--output", out_tpl,
+        # Internal: absolute final path (API server filters this from browser).
+        "--print", "after_move:filepath",
+        # Visible: local-style completion marker.
+        "--print", "after_move:[download_complete] %(title)s.%(ext)s",
+    ]
+
+
+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")
+
+    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,
+    ]]
+
+
 # =========================
-# Public API
+# Legacy (keep for compatibility)
 # =========================
 def download_video(
     url: str,
@@ -301,63 +274,38 @@ def download_video(
     extension: Optional[str] = None,
     out_dir: str = DEFAULT_OUT_DIR,
 ) -> str:
+    """
+    Original blocking API (kept so existing imports don't break).
+    The VPS API server now uses build_download_plan + Popen streaming instead.
+    """
+    import os
+
     if not url:
         raise RuntimeError("Missing URL")
 
     out_dir = os.path.abspath(out_dir)
     os.makedirs(out_dir, exist_ok=True)
 
-    validate_environment()
+    prepare_network()
+    try:
+        plan = build_download_plan(url=url, resolution=resolution, extension=extension, out_dir=out_dir)
 
-    require_mullvad_login()
-    mullvad_connect(MULLVAD_LOCATION)
-    if not mullvad_wait_connected():
-        raise RuntimeError("Mullvad connection failed")
+        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)
 
-    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,
-        )
+            if rc == 0:
+                break
+
+        tail = _tail(last_out)
+        raise RuntimeError(f"Download completed but output file not found\n{tail}")
 
     finally:
-        if _mullvad_present():
-            _run_argv(["mullvad", "disconnect"], check=False)
+        cleanup_network()

{ytp_dl-0.6.5.dist-info → ytp_dl-0.6.7.dist-info}/METADATA

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

ytp_dl-0.6.7.dist-info/RECORD

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

{ytp_dl-0.6.5.dist-info → ytp_dl-0.6.7.dist-info}/WHEEL

@@ -1,5 +1,5 @@
 Wheel-Version: 1.0
-Generator: setuptools (75.8.0)
+Generator: setuptools (80.10.2)
 Root-Is-Purelib: true
 Tag: py3-none-any
 

ytp_dl-0.6.5.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.5.dist-info/METADATA,sha256=XVL2522dMVIjIPh8cHZXSkkJM-7GRb-KyS_lfAwcOBI,14547
-ytp_dl-0.6.5.dist-info/WHEEL,sha256=In9FTNxeP60KnTkGw7wk6mJPYd_dQSjEZmXdBdMCI-8,91
-ytp_dl-0.6.5.dist-info/entry_points.txt,sha256=QqjqZZAEt3Y7RGrleqZ312sjjboUpbMLdo7qFxuCH30,48
-ytp_dl-0.6.5.dist-info/top_level.txt,sha256=rmzd5mewlrJy4sT608KPib7sM7edoY75AeqJeY3SPB4,8
-ytp_dl-0.6.5.dist-info/RECORD,,