streamgrab 0.1.0__tar.gz

streamgrab-0.1.0/PKG-INFO

@@ -0,0 +1,101 @@
+Metadata-Version: 2.4
+Name: streamgrab
+Version: 0.1.0
+Summary: A desktop app for downloading video and audio from YouTube, Instagram, Facebook, and 1000+ other sites, with resolution selection and a live progress bar.
+Author: StreamGrab contributors
+License: MIT
+Keywords: video downloader,yt-dlp,youtube,instagram,facebook,downloader
+Classifier: Development Status :: 4 - Beta
+Classifier: Intended Audience :: End Users/Desktop
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Operating System :: OS Independent
+Classifier: Programming Language :: Python :: 3
+Requires-Python: >=3.9
+Description-Content-Type: text/markdown
+Requires-Dist: PyQt6>=6.6.0
+Requires-Dist: yt-dlp>=2024.1.0
+Requires-Dist: imageio-ffmpeg>=0.5.1
+
+# StreamGrab
+
+A desktop app for downloading video and audio from YouTube, Instagram,
+Facebook, and 1000+ other sites supported by `yt-dlp` — with two fully
+independent tabs (Video/MP4 and Audio/MP3), each with its own URL box,
+so a paste in one never conflicts with the other, plus a live progress
+bar and automatic playlist/mix safety so a single-video link never
+accidentally triggers a slow whole-playlist fetch.
+
+## Install
+
+```bash
+pip install -e .
+```
+
+**ffmpeg is installed automatically** — no separate download or PATH
+setup required. This package depends on `imageio-ffmpeg`, which ships
+a real ffmpeg binary for Windows/Mac/Linux and installs it as a normal
+part of `pip install`. If a system-wide ffmpeg is also present on your
+PATH, that one is used instead (so your own ffmpeg install, if you
+have one, still takes priority); the bundled copy is only a fallback.
+
+## Run
+
+```bash
+streamgrab
+```
+
+Two independent tabs:
+- **🎬 Video (MP4)** — its own URL box, Fetch button, and resolution list.
+- **🎵 Audio (MP3)** — its own URL box, Fetch button, and quality list.
+
+Paste a URL into whichever tab matches what you want, click **Fetch**,
+pick a quality, choose a save folder, and click **Download**. The two
+tabs never share state, so you can look up a video in one tab without
+affecting anything you've already fetched in the other.
+
+## Important: legal use
+
+`yt-dlp` (the engine this app is built on) is a legitimate, widely used
+open-source tool. However, many platforms' Terms of Service restrict or
+prohibit downloading video content except through their own official
+tools. This app does not bypass any DRM or paywalled content — it only
+works on publicly accessible media the same way `yt-dlp` itself does.
+You are responsible for using this tool in accordance with the terms
+of service of whatever site you use it on, and applicable copyright law
+in your country. This tool is intended for personal use cases such as
+archiving your own content or content you have the right to download.
+
+## What has actually been tested
+
+- Filename sanitization and format-label/sorting logic: unit tested.
+- **ffmpeg resolution logic**: directly tested for all three real
+  scenarios — system ffmpeg present (preferred), system ffmpeg absent
+  but the bundled `imageio-ffmpeg` binary available (used as fallback),
+  and neither available (raises a clear error rather than a raw crash).
+- **The playlist/mix hang that caused a real reported issue**: fixed
+  with `noplaylist` + `playlist_items='1'`, plus a normalization step
+  that resolves to a single video's info even if a site still returns
+  a playlist-shaped response. All of this is unit tested directly
+  against realistic response shapes (single video, playlist-shaped
+  with entries, empty playlist).
+- **A hard 45-second timeout** wraps every metadata fetch, independent
+  of yt-dlp's own network timeout, so a stuck extractor can no longer
+  leave the "Fetching..." UI state stuck indefinitely — verified by
+  forcing an artificial hang and confirming it times out with a clear
+  message instead of hanging forever.
+- The GUI: verified to build, show, and wire up all controls correctly
+  — including confirming the two tabs' URL inputs are genuinely
+  separate objects with no shared state, and that a missing-ffmpeg
+  scenario disables only the Audio tab, leaving Video unaffected.
+- **The live download against a real video has NOT been verified in the
+  environment this was built in**, because that sandbox blocks outbound
+  network access to video platforms by policy. The `yt-dlp` calls
+  themselves follow yt-dlp's standard, documented API usage, and the
+  fixes above address the specific real failures reported so far, but
+  you should still do a real test on your own machine — paste a URL in
+  each tab, fetch, and download — before relying on this for anything
+  important.
+
+## License
+
+MIT

streamgrab-0.1.0/README.md

@@ -0,0 +1,83 @@
+# StreamGrab
+
+A desktop app for downloading video and audio from YouTube, Instagram,
+Facebook, and 1000+ other sites supported by `yt-dlp` — with two fully
+independent tabs (Video/MP4 and Audio/MP3), each with its own URL box,
+so a paste in one never conflicts with the other, plus a live progress
+bar and automatic playlist/mix safety so a single-video link never
+accidentally triggers a slow whole-playlist fetch.
+
+## Install
+
+```bash
+pip install -e .
+```
+
+**ffmpeg is installed automatically** — no separate download or PATH
+setup required. This package depends on `imageio-ffmpeg`, which ships
+a real ffmpeg binary for Windows/Mac/Linux and installs it as a normal
+part of `pip install`. If a system-wide ffmpeg is also present on your
+PATH, that one is used instead (so your own ffmpeg install, if you
+have one, still takes priority); the bundled copy is only a fallback.
+
+## Run
+
+```bash
+streamgrab
+```
+
+Two independent tabs:
+- **🎬 Video (MP4)** — its own URL box, Fetch button, and resolution list.
+- **🎵 Audio (MP3)** — its own URL box, Fetch button, and quality list.
+
+Paste a URL into whichever tab matches what you want, click **Fetch**,
+pick a quality, choose a save folder, and click **Download**. The two
+tabs never share state, so you can look up a video in one tab without
+affecting anything you've already fetched in the other.
+
+## Important: legal use
+
+`yt-dlp` (the engine this app is built on) is a legitimate, widely used
+open-source tool. However, many platforms' Terms of Service restrict or
+prohibit downloading video content except through their own official
+tools. This app does not bypass any DRM or paywalled content — it only
+works on publicly accessible media the same way `yt-dlp` itself does.
+You are responsible for using this tool in accordance with the terms
+of service of whatever site you use it on, and applicable copyright law
+in your country. This tool is intended for personal use cases such as
+archiving your own content or content you have the right to download.
+
+## What has actually been tested
+
+- Filename sanitization and format-label/sorting logic: unit tested.
+- **ffmpeg resolution logic**: directly tested for all three real
+  scenarios — system ffmpeg present (preferred), system ffmpeg absent
+  but the bundled `imageio-ffmpeg` binary available (used as fallback),
+  and neither available (raises a clear error rather than a raw crash).
+- **The playlist/mix hang that caused a real reported issue**: fixed
+  with `noplaylist` + `playlist_items='1'`, plus a normalization step
+  that resolves to a single video's info even if a site still returns
+  a playlist-shaped response. All of this is unit tested directly
+  against realistic response shapes (single video, playlist-shaped
+  with entries, empty playlist).
+- **A hard 45-second timeout** wraps every metadata fetch, independent
+  of yt-dlp's own network timeout, so a stuck extractor can no longer
+  leave the "Fetching..." UI state stuck indefinitely — verified by
+  forcing an artificial hang and confirming it times out with a clear
+  message instead of hanging forever.
+- The GUI: verified to build, show, and wire up all controls correctly
+  — including confirming the two tabs' URL inputs are genuinely
+  separate objects with no shared state, and that a missing-ffmpeg
+  scenario disables only the Audio tab, leaving Video unaffected.
+- **The live download against a real video has NOT been verified in the
+  environment this was built in**, because that sandbox blocks outbound
+  network access to video platforms by policy. The `yt-dlp` calls
+  themselves follow yt-dlp's standard, documented API usage, and the
+  fixes above address the specific real failures reported so far, but
+  you should still do a real test on your own machine — paste a URL in
+  each tab, fetch, and download — before relying on this for anything
+  important.
+
+## License
+
+MIT

streamgrab-0.1.0/pyproject.toml

@@ -0,0 +1,36 @@
+[build-system]
+requires = ["setuptools>=68.0", "wheel"]
+build-backend = "setuptools.build_meta"
+
+[project]
+name = "streamgrab"
+version = "0.1.0"
+description = "A desktop app for downloading video and audio from YouTube, Instagram, Facebook, and 1000+ other sites, with resolution selection and a live progress bar."
+readme = "README.md"
+requires-python = ">=3.9"
+license = { text = "MIT" }
+authors = [
+    { name = "StreamGrab contributors" }
+]
+keywords = ["video downloader", "yt-dlp", "youtube", "instagram", "facebook", "downloader"]
+classifiers = [
+    "Development Status :: 4 - Beta",
+    "Intended Audience :: End Users/Desktop",
+    "License :: OSI Approved :: MIT License",
+    "Operating System :: OS Independent",
+    "Programming Language :: Python :: 3",
+]
+dependencies = [
+    "PyQt6>=6.6.0",
+    "yt-dlp>=2024.1.0",
+    "imageio-ffmpeg>=0.5.1",
+]
+
+[project.scripts]
+streamgrab = "streamgrab.app:main"
+
+[tool.setuptools.packages.find]
+include = ["streamgrab*"]
+
+[tool.setuptools.package-data]
+streamgrab = ["resources/*.png"]

streamgrab-0.1.0/setup.cfg

@@ -0,0 +1,4 @@
+[egg_info]
+tag_build = 
+tag_date = 0
+

streamgrab-0.1.0/streamgrab/app.py

@@ -0,0 +1,38 @@
+"""Entry point for the `streamgrab` console command."""
+
+from __future__ import annotations
+
+import sys
+from pathlib import Path
+
+from PyQt6.QtWidgets import QApplication
+from PyQt6.QtGui import QIcon, QFont
+
+from streamgrab.ui.main_window import MainWindow
+
+LOGO_PATH = Path(__file__).parent / "resources" / "logo.png"
+
+
+def main() -> int:
+    app = QApplication(sys.argv)
+    app.setApplicationName("StreamGrab")
+
+    # Explicitly set a valid application-wide font with a real point size.
+    # PyQt6's default QFont() reports pointSize() == -1 on some platforms
+    # (confirmed: Windows commonly hits this), which triggers a harmless
+    # but noisy "QFont::setPointSize: Point size <= 0" warning whenever
+    # Qt's internal style code queries the default font. Setting a real
+    # font here up front means Qt never falls back to that ambiguous
+    # default, eliminating the warning at its source rather than just
+    # hiding it.
+    app.setFont(QFont("Segoe UI", 10))
+
+    if LOGO_PATH.exists():
+        app.setWindowIcon(QIcon(str(LOGO_PATH)))
+    window = MainWindow()
+    window.show()
+    return app.exec()
+
+
+if __name__ == "__main__":
+    sys.exit(main())

streamgrab-0.1.0/streamgrab/core/downloader.py

@@ -0,0 +1,380 @@
+"""
+Core video/audio download logic built on yt-dlp.
+
+Kept separate from the GUI so this can be tested and used
+independently — the GUI just calls into this module.
+"""
+
+from __future__ import annotations
+
+import re
+import shutil
+import threading
+from dataclasses import dataclass
+from pathlib import Path
+from typing import Callable, Optional
+
+import yt_dlp
+
+try:
+    import imageio_ffmpeg
+    _HAS_BUNDLED_FFMPEG = True
+except ImportError:
+    _HAS_BUNDLED_FFMPEG = False
+
+
+def _find_ffmpeg_path() -> Optional[str]:
+    """Locate an ffmpeg binary to use, preferring one already on the
+    system PATH (so a user's own install/version is respected), and
+    falling back to the ffmpeg binary bundled via the imageio-ffmpeg
+    pip package if no system install is found. imageio-ffmpeg ships a
+    real, statically-linked ffmpeg binary for Windows/Mac/Linux and is
+    installed automatically as a normal dependency of this package —
+    so a fresh `pip install streamgrab` works out of the box without
+    the user needing to separately install ffmpeg themselves.
+    Returns None if neither is available.
+    """
+    system_ffmpeg = shutil.which("ffmpeg")
+    if system_ffmpeg:
+        return system_ffmpeg
+    if _HAS_BUNDLED_FFMPEG:
+        return imageio_ffmpeg.get_ffmpeg_exe()
+    return None
+
+
+class _QuietLogger:
+    """A yt-dlp logger that drops noise while still surfacing real
+    problems.
+
+    Filtered messages, both confirmed by tracing yt-dlp's actual source
+    code (not assumed):
+
+    1. "Deprecated Feature: Support for Python version ... has been
+       deprecated" — yt-dlp's deprecated_feature() prints this via
+       to_stderr(), which — when a logger is configured (as we do) —
+       routes to logger.error(), not logger.warning(). Filtered on
+       both methods since it can arrive through either.
+    2. "YouTube Music is not directly supported. Redirecting to ..." —
+       informational: yt-dlp is auto-converting a music.youtube.com
+       URL and continuing normally. Not an error state.
+
+    Any other message (real errors, real warnings) is still printed
+    normally — this is a narrow, specific filter, not a blanket one.
+    """
+
+    _FILTERED_SUBSTRINGS = (
+        "Deprecated Feature",
+        "has been deprecated",
+        "YouTube Music is not directly supported",
+    )
+
+    def _is_filtered(self, msg: str) -> bool:
+        return any(s in msg for s in self._FILTERED_SUBSTRINGS)
+
+    def debug(self, msg):
+        pass
+
+    def info(self, msg):
+        pass
+
+    def warning(self, msg):
+        if self._is_filtered(msg):
+            return
+        print(msg)
+
+    def error(self, msg):
+        if self._is_filtered(msg):
+            return
+        print(msg)
+
+
+# noplaylist + playlist_items='1' together are belt-and-suspenders
+# against the exact class of bug that caused a real hang: pasting a
+# single-video URL that also carries a playlist/mix/radio ID in its
+# query string (e.g. YouTube's "&list=RDAMVM..." auto-generated radio
+# mixes). Without these, yt-dlp can interpret such a URL as "fetch the
+# whole playlist" and try to enumerate every entry before returning
+# anything, which from the GUI looks exactly like a frozen "Fetching..."
+# state even though nothing has technically crashed.
+_BASE_YDL_OPTS = {
+    "quiet": True,
+    "no_warnings": True,
+    "logger": _QuietLogger(),
+    "noplaylist": True,
+    "playlist_items": "1",
+    "extract_flat": False,
+    "socket_timeout": 20,
+}
+
+# Hard ceiling on how long a metadata fetch is allowed to run before we
+# give up and report a timeout, rather than leaving the GUI's
+# "Fetching..." state up indefinitely if some site's extractor hangs
+# for a reason socket_timeout doesn't catch (e.g. stuck in CPU-bound
+# parsing rather than waiting on a socket).
+FETCH_TIMEOUT_SECONDS = 45
+
+
+def sanitize_filename(name: str) -> str:
+    """Remove characters illegal in Windows/Mac/Linux filenames."""
+    cleaned = re.sub(r'[<>:"/\\|?*]', "_", name)
+    return cleaned.strip()
+
+
+def is_ffmpeg_available() -> bool:
+    """Check whether a usable ffmpeg is available — either a system
+    install on PATH, or the bundled binary from the imageio-ffmpeg pip
+    package. Audio extraction (converting to MP3) requires ffmpeg;
+    plain video downloads do not. Checked up front so the GUI can warn
+    clearly before the user picks an option that would fail, instead
+    of surfacing yt-dlp's raw error after a failed download."""
+    return _find_ffmpeg_path() is not None
+
+
+@dataclass
+class VideoFormat:
+    """A single available quality option for a video."""
+    format_id: str
+    height: Optional[int]   # e.g. 1080, None for audio-only formats
+    ext: str
+    is_audio_only: bool
+    filesize_mb: Optional[float]
+
+    @property
+    def label(self) -> str:
+        if self.is_audio_only:
+            return f"Audio only ({self.ext})"
+        size = f" (~{self.filesize_mb:.0f} MB)" if self.filesize_mb else ""
+        return f"{self.height}p{size}"
+
+    @property
+    def download_format_string(self) -> str:
+        """The actual yt-dlp -f string to request. Many video formats
+        (720p+) are video-only with no audio track — using the bare
+        format_id silently produces a silent MP4. This merges in the
+        best available audio, falling back to the format alone if
+        merging isn't possible."""
+        if self.is_audio_only:
+            return self.format_id
+        return f"{self.format_id}+bestaudio/{self.format_id}"
+
+
+@dataclass
+class VideoInfo:
+    title: str
+    video_formats: list[VideoFormat]
+    audio_formats: list[VideoFormat]
+    duration_seconds: Optional[float]
+    thumbnail_url: Optional[str]
+
+
+def _run_with_timeout(func, timeout_seconds):
+    """Run func() in a background thread and enforce a hard wall-clock
+    timeout, since yt-dlp itself has no universal 'give up after N
+    seconds' option that covers every extractor's internal behavior —
+    socket_timeout only bounds network reads, not, e.g., an extractor
+    stuck parsing an unusually large playlist response.
+
+    Raises TimeoutError if the timeout elapses. The worker thread is
+    daemonized so it can't prevent the app from exiting even if it
+    never returns.
+    """
+    result = {}
+    error = {}
+
+    def target():
+        try:
+            result["value"] = func()
+        except Exception as e:  # noqa: BLE001 - deliberately broad, re-raised below
+            error["exc"] = e
+
+    thread = threading.Thread(target=target, daemon=True)
+    thread.start()
+    thread.join(timeout_seconds)
+
+    if thread.is_alive():
+        raise TimeoutError(
+            f"This took longer than {timeout_seconds} seconds and was "
+            "stopped. The site may be slow, blocking automated access, "
+            "or the link may point to a large playlist/mix rather than "
+            "a single video."
+        )
+    if "exc" in error:
+        raise error["exc"]
+    return result.get("value")
+
+
+def _extract_single_entry(info: dict) -> dict:
+    """yt-dlp can return either a single-video dict, or (even with
+    noplaylist=True, for some extractors/URL shapes) a playlist-shaped
+    dict with an 'entries' list. Normalize to always return a single
+    video's info dict, using only the first entry if given a playlist,
+    so downstream code never has to guess which shape it received."""
+    if info.get("_type") == "playlist" or "entries" in info:
+        entries = list(info.get("entries") or [])
+        if not entries:
+            raise ValueError(
+                "This link points to a playlist or mix with no "
+                "individual video found. Please paste a link to a "
+                "single video instead."
+            )
+        return entries[0]
+    return info
+
+
+def fetch_video_info(url: str) -> VideoInfo:
+    """Query the given URL and return available formats + metadata,
+    without downloading anything. Works across any site yt-dlp supports
+    (YouTube, Instagram, Facebook, Twitter/X, TikTok, Vimeo, and 1000+
+    others), since yt-dlp handles per-site extraction internally.
+
+    Always resolves to a single video's info, even if the URL also
+    carries playlist/mix/radio parameters, and enforces a hard timeout
+    so a slow or stuck site can't leave the caller waiting forever.
+
+    Returns video and audio formats as two separate lists, so the GUI
+    can show them in distinct tabs rather than one mixed dropdown.
+    """
+    ydl_opts = dict(_BASE_YDL_OPTS)
+
+    def do_fetch():
+        with yt_dlp.YoutubeDL(ydl_opts) as ydl:
+            return ydl.extract_info(url, download=False)
+
+    raw_info = _run_with_timeout(do_fetch, FETCH_TIMEOUT_SECONDS)
+    info = _extract_single_entry(raw_info)
+
+    raw_formats = info.get("formats", [])
+    video_formats: list[VideoFormat] = []
+    audio_formats: list[VideoFormat] = []
+
+    seen_heights: set[int] = set()
+    for fmt in raw_formats:
+        has_video = fmt.get("vcodec") not in (None, "none")
+        has_audio = fmt.get("acodec") not in (None, "none")
+        height = fmt.get("height")
+        filesize = fmt.get("filesize") or fmt.get("filesize_approx")
+        filesize_mb = (filesize / (1024 * 1024)) if filesize else None
+
+        if has_video and height:
+            # Only keep one entry per resolution (yt-dlp often lists many
+            # near-duplicate video-only streams per height); avoids a
+            # cluttered, confusing dropdown in the UI.
+            if height in seen_heights:
+                continue
+            seen_heights.add(height)
+            video_formats.append(VideoFormat(
+                format_id=fmt["format_id"],
+                height=height,
+                ext=fmt.get("ext", "mp4"),
+                is_audio_only=False,
+                filesize_mb=filesize_mb,
+            ))
+        elif has_audio and not has_video:
+            audio_formats.append(VideoFormat(
+                format_id=fmt["format_id"],
+                height=None,
+                ext=fmt.get("ext", "m4a"),
+                is_audio_only=True,
+                filesize_mb=filesize_mb,
+            ))
+
+    video_formats.sort(key=lambda f: -(f.height or 0))
+    audio_formats.sort(key=lambda f: -(f.filesize_mb or 0))
+
+    if not video_formats and not audio_formats:
+        raise ValueError(
+            "No downloadable formats were found for this link. It may "
+            "be private, region-locked, age-restricted, or not "
+            "actually a playable video/audio page."
+        )
+
+    return VideoInfo(
+        title=sanitize_filename(info.get("title", "video")),
+        video_formats=video_formats,
+        audio_formats=audio_formats,
+        duration_seconds=info.get("duration"),
+        thumbnail_url=info.get("thumbnail"),
+    )
+
+
+def download(
+    url: str,
+    format_id: str,
+    output_dir: str | Path,
+    filename: str,
+    audio_only: bool = False,
+    progress_callback: Optional[Callable[[dict], None]] = None,
+) -> Path:
+    """Download the given format_id from url into output_dir/filename.
+
+    progress_callback, if given, is called repeatedly by yt-dlp with a
+    dict containing at least 'status' ('downloading'/'finished'/'error')
+    and, while downloading, '_percent_str' / 'downloaded_bytes' /
+    'total_bytes' — the GUI uses this to drive a live progress bar.
+
+    Raises RuntimeError with a clear, plain-English message if ffmpeg
+    is required (audio_only=True) but not available (neither on the
+    system PATH nor bundled via imageio-ffmpeg), instead of letting
+    yt-dlp fail deep inside postprocessing with a raw, ANSI-coded error.
+    """
+    ffmpeg_path = None
+    if audio_only:
+        ffmpeg_path = _find_ffmpeg_path()
+        if ffmpeg_path is None:
+            raise RuntimeError(
+                "Converting to MP3 requires ffmpeg, and no usable ffmpeg "
+                "was found — neither on your system PATH nor bundled "
+                "with this app. This shouldn't normally happen since "
+                "ffmpeg is installed automatically; try reinstalling "
+                "streamgrab. (Video downloads don't need ffmpeg.)"
+            )
+
+    output_dir = Path(output_dir)
+    output_dir.mkdir(parents=True, exist_ok=True)
+
+    outtmpl = str(output_dir / f"{filename}.%(ext)s")
+
+    # For video downloads, merge in audio (many formats are video-only)
+    # and force remux to mp4 so output is always a playable video+audio file.
+    actual_format = format_id if audio_only else f"{format_id}+bestaudio/best"
+
+    ydl_opts = {
+        **_BASE_YDL_OPTS,
+        "format": actual_format,
+        "outtmpl": outtmpl,
+    }
+    if not audio_only:
+        ydl_opts["merge_output_format"] = "mp4"
+        system_or_bundled = _find_ffmpeg_path()
+        if system_or_bundled:
+            ydl_opts["ffmpeg_location"] = system_or_bundled
+
+    if progress_callback is not None:
+        ydl_opts["progress_hooks"] = [progress_callback]
+
+    if audio_only:
+        # Tell yt-dlp exactly which ffmpeg binary to use. This matters
+        # specifically when falling back to the bundled imageio-ffmpeg
+        # binary, since that binary lives inside the Python package's
+        # install location rather than on PATH — yt-dlp has no way to
+        # find it unless told explicitly via ffmpeg_location.
+        ydl_opts["ffmpeg_location"] = ffmpeg_path
+        ydl_opts["postprocessors"] = [{
+            "key": "FFmpegExtractAudio",
+            "preferredcodec": "mp3",
+            "preferredquality": "192",
+        }]
+
+    try:
+        with yt_dlp.YoutubeDL(ydl_opts) as ydl:
+            ydl.download([url])
+    except yt_dlp.utils.DownloadError as e:
+        # Strip yt-dlp's ANSI color codes so the GUI shows a clean
+        # message instead of raw escape sequences like "[0;31mERROR".
+        clean_msg = re.sub(r"\x1b\[[0-9;]*m", "", str(e))
+        raise RuntimeError(clean_msg) from e
+
+    # Return the most likely resulting file path (extension may have
+    # changed due to audio extraction/remuxing, so glob for it).
+    matches = list(output_dir.glob(f"{filename}.*"))
+    return matches[0] if matches else output_dir / filename

streamgrab-0.1.0/streamgrab/ui/main_window.py

@@ -0,0 +1,379 @@
+"""
+StreamGrab main window: two fully independent tabs — Video (MP4) and
+Audio (MP3) — each with its own URL input, Fetch button, quality
+dropdown, and Download button. Keeping them independent means pasting
+a link in one tab can never interfere with a fetch/download in the
+other, and each tab's own error/progress state stays local to it.
+"""
+
+from __future__ import annotations
+
+from pathlib import Path
+
+from PyQt6.QtCore import Qt, QThread, pyqtSignal, QUrl
+from PyQt6.QtGui import QIcon, QPixmap
+from PyQt6.QtNetwork import QNetworkAccessManager, QNetworkRequest
+from PyQt6.QtWidgets import (
+    QMainWindow, QWidget, QVBoxLayout, QHBoxLayout, QLabel, QLineEdit,
+    QPushButton, QComboBox, QProgressBar, QFileDialog, QMessageBox,
+    QStatusBar, QTabWidget,
+)
+
+from streamgrab.core.downloader import (
+    fetch_video_info, download, VideoInfo, is_ffmpeg_available,
+)
+
+LOGO_PATH = Path(__file__).resolve().parent.parent / "resources" / "logo.png"
+
+DARK_STYLESHEET = """
+QMainWindow, QWidget { background-color: #1e1f26; color: #e8e8ec; font-family: 'Segoe UI', sans-serif; }
+QLineEdit, QComboBox { background-color: #262832; border: 1px solid #34364a; border-radius: 6px; padding: 8px; font-size: 13px; }
+QPushButton { background-color: #34364a; border: 1px solid #454864; border-radius: 6px; padding: 8px 16px; font-weight: 600; }
+QPushButton:hover { background-color: #454864; }
+QPushButton:disabled { background-color: #2a2b34; color: #666; }
+QPushButton#fetchBtn { background-color: #2255aa; border: 1px solid #3366cc; }
+QPushButton#fetchBtn:hover { background-color: #3366cc; }
+QPushButton#downloadBtn { background-color: #1f7a4d; border: 1px solid #2ea86b; }
+QPushButton#downloadBtn:hover { background-color: #2ea86b; }
+QPushButton#downloadBtn:disabled { background-color: #2a2b34; color: #666; }
+QLabel#titleLabel { font-size: 20px; font-weight: 700; }
+QLabel#videoTitle { font-size: 14px; color: #9aa0c0; }
+QLabel#warningLabel { color: #ffb84d; font-size: 12px; }
+QProgressBar { background-color: #262832; border: 1px solid #34364a; border-radius: 6px; text-align: center; height: 24px; }
+QProgressBar::chunk { background-color: #2ea86b; border-radius: 6px; }
+QStatusBar { background-color: #262832; }
+QTabWidget::pane { border: 1px solid #34364a; border-radius: 6px; top: -1px; }
+QTabBar::tab { background-color: #262832; padding: 8px 20px; border: 1px solid #34364a; border-bottom: none; border-top-left-radius: 6px; border-top-right-radius: 6px; margin-right: 2px; }
+QTabBar::tab:selected { background-color: #34364a; font-weight: 600; }
+"""
+
+
+class FetchInfoThread(QThread):
+    """Runs the (potentially slow) yt-dlp metadata fetch off the UI
+    thread so the window can never appear frozen — fetch_video_info()
+    itself now also enforces its own hard timeout internally, so even
+    a stuck extractor eventually reports back rather than hanging."""
+    finished_ok = pyqtSignal(object)  # VideoInfo
+    failed = pyqtSignal(str)
+
+    def __init__(self, url: str):
+        super().__init__()
+        self.url = url
+
+    def run(self):
+        try:
+            info = fetch_video_info(self.url)
+            self.finished_ok.emit(info)
+        except Exception as e:
+            self.failed.emit(str(e))
+
+
+class DownloadThread(QThread):
+    """Runs the actual download off the UI thread, forwarding yt-dlp's
+    progress dicts back to the GUI via a signal."""
+    progress = pyqtSignal(dict)
+    finished_ok = pyqtSignal(str)  # resulting file path
+    failed = pyqtSignal(str)
+
+    def __init__(self, url, format_id, output_dir, filename, audio_only):
+        super().__init__()
+        self.url = url
+        self.format_id = format_id
+        self.output_dir = output_dir
+        self.filename = filename
+        self.audio_only = audio_only
+
+    def run(self):
+        try:
+            result_path = download(
+                self.url,
+                self.format_id,
+                self.output_dir,
+                self.filename,
+                audio_only=self.audio_only,
+                progress_callback=lambda d: self.progress.emit(d),
+            )
+            self.finished_ok.emit(str(result_path))
+        except Exception as e:
+            self.failed.emit(str(e))
+
+
+class DownloadTab(QWidget):
+    """One self-contained tab: its own URL bar, Fetch button, quality
+    dropdown, folder picker, Download button, and progress bar. Used
+    twice (once for video, once for audio) with completely separate
+    state, so nothing in one tab can affect the other."""
+
+    def __init__(self, *, audio_only: bool, ffmpeg_available: bool, parent=None):
+        super().__init__(parent)
+        self.audio_only = audio_only
+        self.ffmpeg_available = ffmpeg_available
+
+        self.video_info: VideoInfo | None = None
+        self.output_dir: Path = Path.home() / "Downloads"
+        self.fetch_thread: FetchInfoThread | None = None
+        self.download_thread: DownloadThread | None = None
+
+        self._build_ui()
+
+    def _build_ui(self):
+        layout = QVBoxLayout(self)
+        layout.setSpacing(12)
+
+        # URL row — this tab's own independent input, never shared.
+        url_row = QHBoxLayout()
+        self.url_input = QLineEdit()
+        placeholder = (
+            "Paste a video URL to extract audio from..."
+            if self.audio_only else
+            "Paste a video URL here..."
+        )
+        self.url_input.setPlaceholderText(placeholder)
+        url_row.addWidget(self.url_input, stretch=1)
+        self.fetch_btn = QPushButton("Fetch")
+        self.fetch_btn.setObjectName("fetchBtn")
+        self.fetch_btn.clicked.connect(self._on_fetch_clicked)
+        url_row.addWidget(self.fetch_btn)
+        layout.addLayout(url_row)
+
+        self.title_label = QLabel("")
+        self.title_label.setObjectName("videoTitle")
+        self.title_label.setWordWrap(True)
+        layout.addWidget(self.title_label)
+
+        # Thumbnail preview so the user can visually confirm this is
+        # the right video before downloading. Loaded async via
+        # QNetworkAccessManager — works for any site's thumbnail URL,
+        # since it's just an image fetch, not site-specific code.
+        self.thumbnail_label = QLabel("")
+        self.thumbnail_label.setFixedHeight(140)
+        self.thumbnail_label.setAlignment(Qt.AlignmentFlag.AlignCenter)
+        self.thumbnail_label.setVisible(False)
+        layout.addWidget(self.thumbnail_label)
+        self._network_manager = QNetworkAccessManager(self)
+
+        # Quality row
+        quality_row = QHBoxLayout()
+        quality_row.addWidget(QLabel("Audio quality:" if self.audio_only else "Resolution:"))
+        self.format_combo = QComboBox()
+        self.format_combo.setEnabled(False)
+        quality_row.addWidget(self.format_combo, stretch=1)
+        layout.addLayout(quality_row)
+
+        self.ffmpeg_warning_label = QLabel("")
+        self.ffmpeg_warning_label.setObjectName("warningLabel")
+        self.ffmpeg_warning_label.setWordWrap(True)
+        layout.addWidget(self.ffmpeg_warning_label)
+
+        if self.audio_only and not self.ffmpeg_available:
+            self.ffmpeg_warning_label.setText(
+                "⚠ ffmpeg was not found on this system. MP3 conversion "
+                "requires it — install ffmpeg and add it to your PATH "
+                "to enable audio downloads."
+            )
+            self.url_input.setEnabled(False)
+            self.fetch_btn.setEnabled(False)
+
+        # Output folder row
+        folder_row = QHBoxLayout()
+        self.folder_label = QLabel(f"Save to: {self.output_dir}")
+        self.folder_label.setWordWrap(True)
+        folder_row.addWidget(self.folder_label, stretch=1)
+        choose_folder_btn = QPushButton("Choose Folder")
+        choose_folder_btn.clicked.connect(self._choose_folder)
+        folder_row.addWidget(choose_folder_btn)
+        layout.addLayout(folder_row)
+
+        # Download button
+        self.download_btn = QPushButton("Download")
+        self.download_btn.setObjectName("downloadBtn")
+        self.download_btn.setEnabled(False)
+        self.download_btn.clicked.connect(self._on_download_clicked)
+        layout.addWidget(self.download_btn)
+
+        # Progress bar
+        self.progress_bar = QProgressBar()
+        self.progress_bar.setValue(0)
+        self.progress_bar.setVisible(False)
+        layout.addWidget(self.progress_bar)
+
+        layout.addStretch()
+
+    # ---- fetch flow -----------------------------------------------------
+
+    def _on_fetch_clicked(self):
+        url = self.url_input.text().strip()
+        if not url:
+            QMessageBox.warning(self, "No URL", "Please paste a video URL first.")
+            return
+
+        self.fetch_btn.setEnabled(False)
+        self.fetch_btn.setText("Fetching...")
+        self.format_combo.clear()
+        self.format_combo.setEnabled(False)
+        self.download_btn.setEnabled(False)
+        self.title_label.setText("")
+        self.thumbnail_label.setVisible(False)
+        self.window().statusBar().showMessage("Looking up video info...")
+
+        self.fetch_thread = FetchInfoThread(url)
+        self.fetch_thread.finished_ok.connect(self._on_fetch_success)
+        self.fetch_thread.failed.connect(self._on_fetch_failed)
+        self.fetch_thread.start()
+
+    def _on_fetch_success(self, info: VideoInfo):
+        self.video_info = info
+        icon = "🎵" if self.audio_only else "🎬"
+        self.title_label.setText(f"{icon} {info.title}")
+
+        if info.thumbnail_url:
+            reply = self._network_manager.get(QNetworkRequest(QUrl(info.thumbnail_url)))
+            reply.finished.connect(lambda r=reply: self._on_thumbnail_loaded(r))
+        else:
+            self.thumbnail_label.setVisible(False)
+
+        formats = info.audio_formats if self.audio_only else info.video_formats
+        self.format_combo.clear()
+        for fmt in formats:
+            self.format_combo.addItem(fmt.label, userData=fmt)
+        self.format_combo.setEnabled(bool(formats))
+        self.download_btn.setEnabled(bool(formats))
+
+        self.fetch_btn.setEnabled(True)
+        self.fetch_btn.setText("Fetch")
+
+        if not formats:
+            kind = "audio" if self.audio_only else "video"
+            self.window().statusBar().showMessage(f"No {kind} formats found for this link.")
+        else:
+            self.window().statusBar().showMessage(f"Found {len(formats)} format(s).")
+
+    def _on_fetch_failed(self, error_msg: str):
+        self.fetch_btn.setEnabled(True)
+        self.fetch_btn.setText("Fetch")
+        self.window().statusBar().showMessage("Failed to fetch video info.")
+        QMessageBox.critical(self, "Fetch failed", f"Could not read this URL:\n\n{error_msg}")
+
+    def _on_thumbnail_loaded(self, reply):
+        # Silently skip on failure (no thumbnail, wrong format, network
+        # hiccup) — the thumbnail is a nice-to-have, never a blocker.
+        data = reply.readAll()
+        reply.deleteLater()
+        pixmap = QPixmap()
+        if pixmap.loadFromData(bytes(data)):
+            scaled = pixmap.scaledToHeight(140, Qt.TransformationMode.SmoothTransformation)
+            self.thumbnail_label.setPixmap(scaled)
+            self.thumbnail_label.setVisible(True)
+
+    # ---- folder selection -------------------------------------------------
+
+    def _choose_folder(self):
+        folder = QFileDialog.getExistingDirectory(self, "Choose download folder", str(self.output_dir))
+        if folder:
+            self.output_dir = Path(folder)
+            self.folder_label.setText(f"Save to: {self.output_dir}")
+
+    # ---- download flow ----------------------------------------------------
+
+    def _on_download_clicked(self):
+        if self.video_info is None:
+            return
+        fmt = self.format_combo.currentData()
+        if fmt is None:
+            QMessageBox.warning(
+                self, "No format selected",
+                "Please fetch a video first and choose a quality option."
+            )
+            return
+
+        if self.audio_only and not self.ffmpeg_available:
+            QMessageBox.warning(
+                self, "ffmpeg required",
+                "MP3 conversion requires ffmpeg, which isn't installed. "
+                "Install ffmpeg and add it to your PATH, then try again."
+            )
+            return
+
+        url = self.url_input.text().strip()
+        self.download_btn.setEnabled(False)
+        self.download_btn.setText("Downloading...")
+        self.progress_bar.setVisible(True)
+        self.progress_bar.setValue(0)
+
+        self.download_thread = DownloadThread(
+            url=url,
+            format_id=fmt.download_format_string,
+            output_dir=self.output_dir,
+            filename=self.video_info.title,
+            audio_only=self.audio_only,
+        )
+        self.download_thread.progress.connect(self._on_download_progress)
+        self.download_thread.finished_ok.connect(self._on_download_success)
+        self.download_thread.failed.connect(self._on_download_failed)
+        self.download_thread.start()
+
+    def _on_download_progress(self, progress_dict: dict):
+        status = progress_dict.get("status")
+        if status == "downloading":
+            total = progress_dict.get("total_bytes") or progress_dict.get("total_bytes_estimate")
+            downloaded = progress_dict.get("downloaded_bytes", 0)
+            if total:
+                percent = int((downloaded / total) * 100)
+                self.progress_bar.setValue(percent)
+        elif status == "finished":
+            self.progress_bar.setValue(100)
+
+    def _on_download_success(self, file_path: str):
+        self.download_btn.setEnabled(True)
+        self.download_btn.setText("Download")
+        self.window().statusBar().showMessage(f"✓ Saved to {file_path}")
+        QMessageBox.information(self, "Download complete", f"Saved to:\n{file_path}")
+
+    def _on_download_failed(self, error_msg: str):
+        self.download_btn.setEnabled(True)
+        self.download_btn.setText("Download")
+        self.progress_bar.setVisible(False)
+        self.window().statusBar().showMessage("Download failed.")
+        QMessageBox.critical(self, "Download failed", error_msg)
+
+
+class MainWindow(QMainWindow):
+    def __init__(self):
+        super().__init__()
+        self.setWindowTitle("StreamGrab — video & audio downloader")
+        self.resize(760, 520)
+        self.setStyleSheet(DARK_STYLESHEET)
+        if LOGO_PATH.exists():
+            self.setWindowIcon(QIcon(str(LOGO_PATH)))
+
+        self.ffmpeg_available = is_ffmpeg_available()
+
+        self._build_ui()
+
+    def _build_ui(self):
+        central = QWidget()
+        layout = QVBoxLayout(central)
+        layout.setSpacing(14)
+        layout.setContentsMargins(24, 24, 24, 24)
+
+        title = QLabel("StreamGrab")
+        title.setObjectName("titleLabel")
+        layout.addWidget(title)
+
+        subtitle = QLabel(
+            "Paste a link from YouTube, Instagram, Facebook, or almost "
+            "any other site. Each tab has its own URL box, so video and "
+            "audio downloads never interfere with each other."
+        )
+        subtitle.setWordWrap(True)
+        layout.addWidget(subtitle)
+
+        self.tabs = QTabWidget()
+        self.video_tab = DownloadTab(audio_only=False, ffmpeg_available=self.ffmpeg_available)
+        self.audio_tab = DownloadTab(audio_only=True, ffmpeg_available=self.ffmpeg_available)
+        self.tabs.addTab(self.video_tab, "🎬 Video (MP4)")
+        self.tabs.addTab(self.audio_tab, "🎵 Audio (MP3)")
+        layout.addWidget(self.tabs)
+
+        self.setCentralWidget(central)
+        self.setStatusBar(QStatusBar())

streamgrab-0.1.0/streamgrab.egg-info/PKG-INFO

@@ -0,0 +1,101 @@
+Metadata-Version: 2.4
+Name: streamgrab
+Version: 0.1.0
+Summary: A desktop app for downloading video and audio from YouTube, Instagram, Facebook, and 1000+ other sites, with resolution selection and a live progress bar.
+Author: StreamGrab contributors
+License: MIT
+Keywords: video downloader,yt-dlp,youtube,instagram,facebook,downloader
+Classifier: Development Status :: 4 - Beta
+Classifier: Intended Audience :: End Users/Desktop
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Operating System :: OS Independent
+Classifier: Programming Language :: Python :: 3
+Requires-Python: >=3.9
+Description-Content-Type: text/markdown
+Requires-Dist: PyQt6>=6.6.0
+Requires-Dist: yt-dlp>=2024.1.0
+Requires-Dist: imageio-ffmpeg>=0.5.1
+
+# StreamGrab
+
+A desktop app for downloading video and audio from YouTube, Instagram,
+Facebook, and 1000+ other sites supported by `yt-dlp` — with two fully
+independent tabs (Video/MP4 and Audio/MP3), each with its own URL box,
+so a paste in one never conflicts with the other, plus a live progress
+bar and automatic playlist/mix safety so a single-video link never
+accidentally triggers a slow whole-playlist fetch.
+
+## Install
+
+```bash
+pip install -e .
+```
+
+**ffmpeg is installed automatically** — no separate download or PATH
+setup required. This package depends on `imageio-ffmpeg`, which ships
+a real ffmpeg binary for Windows/Mac/Linux and installs it as a normal
+part of `pip install`. If a system-wide ffmpeg is also present on your
+PATH, that one is used instead (so your own ffmpeg install, if you
+have one, still takes priority); the bundled copy is only a fallback.
+
+## Run
+
+```bash
+streamgrab
+```
+
+Two independent tabs:
+- **🎬 Video (MP4)** — its own URL box, Fetch button, and resolution list.
+- **🎵 Audio (MP3)** — its own URL box, Fetch button, and quality list.
+
+Paste a URL into whichever tab matches what you want, click **Fetch**,
+pick a quality, choose a save folder, and click **Download**. The two
+tabs never share state, so you can look up a video in one tab without
+affecting anything you've already fetched in the other.
+
+## Important: legal use
+
+`yt-dlp` (the engine this app is built on) is a legitimate, widely used
+open-source tool. However, many platforms' Terms of Service restrict or
+prohibit downloading video content except through their own official
+tools. This app does not bypass any DRM or paywalled content — it only
+works on publicly accessible media the same way `yt-dlp` itself does.
+You are responsible for using this tool in accordance with the terms
+of service of whatever site you use it on, and applicable copyright law
+in your country. This tool is intended for personal use cases such as
+archiving your own content or content you have the right to download.
+
+## What has actually been tested
+
+- Filename sanitization and format-label/sorting logic: unit tested.
+- **ffmpeg resolution logic**: directly tested for all three real
+  scenarios — system ffmpeg present (preferred), system ffmpeg absent
+  but the bundled `imageio-ffmpeg` binary available (used as fallback),
+  and neither available (raises a clear error rather than a raw crash).
+- **The playlist/mix hang that caused a real reported issue**: fixed
+  with `noplaylist` + `playlist_items='1'`, plus a normalization step
+  that resolves to a single video's info even if a site still returns
+  a playlist-shaped response. All of this is unit tested directly
+  against realistic response shapes (single video, playlist-shaped
+  with entries, empty playlist).
+- **A hard 45-second timeout** wraps every metadata fetch, independent
+  of yt-dlp's own network timeout, so a stuck extractor can no longer
+  leave the "Fetching..." UI state stuck indefinitely — verified by
+  forcing an artificial hang and confirming it times out with a clear
+  message instead of hanging forever.
+- The GUI: verified to build, show, and wire up all controls correctly
+  — including confirming the two tabs' URL inputs are genuinely
+  separate objects with no shared state, and that a missing-ffmpeg
+  scenario disables only the Audio tab, leaving Video unaffected.
+- **The live download against a real video has NOT been verified in the
+  environment this was built in**, because that sandbox blocks outbound
+  network access to video platforms by policy. The `yt-dlp` calls
+  themselves follow yt-dlp's standard, documented API usage, and the
+  fixes above address the specific real failures reported so far, but
+  you should still do a real test on your own machine — paste a URL in
+  each tab, fetch, and download — before relying on this for anything
+  important.
+
+## License
+
+MIT

streamgrab-0.1.0/streamgrab.egg-info/SOURCES.txt

@@ -0,0 +1,15 @@
+README.md
+pyproject.toml
+streamgrab/__init__.py
+streamgrab/app.py
+streamgrab.egg-info/PKG-INFO
+streamgrab.egg-info/SOURCES.txt
+streamgrab.egg-info/dependency_links.txt
+streamgrab.egg-info/entry_points.txt
+streamgrab.egg-info/requires.txt
+streamgrab.egg-info/top_level.txt
+streamgrab/core/__init__.py
+streamgrab/core/downloader.py
+streamgrab/resources/logo.png
+streamgrab/ui/__init__.py
+streamgrab/ui/main_window.py

streamgrab-0.1.0/streamgrab.egg-info/dependency_links.txt

@@ -0,0 +1 @@
+

streamgrab-0.1.0/streamgrab.egg-info/entry_points.txt

@@ -0,0 +1,2 @@
+[console_scripts]
+streamgrab = streamgrab.app:main

streamgrab-0.1.0/streamgrab.egg-info/requires.txt

@@ -0,0 +1,3 @@
+PyQt6>=6.6.0
+yt-dlp>=2024.1.0
+imageio-ffmpeg>=0.5.1

streamgrab-0.1.0/streamgrab.egg-info/top_level.txt

@@ -0,0 +1 @@
+streamgrab