polytool 0.2.2__tar.gz → 0.2.4__tar.gz

{polytool-0.2.2 → polytool-0.2.4}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: polytool
-Version: 0.2.2
+Version: 0.2.4
 Summary: One-binary CLI bundling 26 everyday utilities — image/video/PDF conversion, background removal, OCR, QR codes, hashing, downloads, and more
 Project-URL: Homepage, https://github.com/k6w/polytool
 Project-URL: Repository, https://github.com/k6w/polytool

{polytool-0.2.2 → polytool-0.2.4}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "hatchling.build"
 
 [project]
 name = "polytool"
-version = "0.2.2"
+version = "0.2.4"
 description = "One-binary CLI bundling 26 everyday utilities — image/video/PDF conversion, background removal, OCR, QR codes, hashing, downloads, and more"
 readme = "README.md"
 requires-python = ">=3.13"

{polytool-0.2.2 → polytool-0.2.4}/src/polytool/__init__.py

@@ -1,4 +1,4 @@
 """polytool — one-binary CLI bundling 26 everyday utilities."""
 
-__version__ = "0.2.2"
+__version__ = "0.2.4"
 __all__ = ["__version__"]

{polytool-0.2.2 → polytool-0.2.4}/src/polytool/cli/dl.py

@@ -8,6 +8,13 @@ from typing import Annotated
 import typer
 
 from polytool.core import config
+from polytool.core.browsers import (
+    ALL_BROWSERS,
+    FIREFOX_FORK_DIRS,
+    YT_DLP_NATIVE_BROWSERS,
+    find_firefox_fork_data_dir,
+    resolve_firefox_profile_dir,
+)
 from polytool.core.console import console, err_console
 from polytool.core.errors import PolytoolError
 
@@ -17,18 +24,9 @@ app = typer.Typer(
     no_args_is_help=True,
 )
 
-# Browsers yt-dlp's `cookiesfrombrowser` knows about. Used by `pt dl setup`.
-SUPPORTED_BROWSERS = (
-    "chrome",
-    "firefox",
-    "edge",
-    "brave",
-    "chromium",
-    "opera",
-    "safari",
-    "vivaldi",
-    "whale",
-)
+# Browsers `pt dl setup` accepts. Includes yt-dlp's native list plus the
+# Firefox forks we resolve ourselves (zen, librewolf, waterfox, floorp, mullvad).
+SUPPORTED_BROWSERS = ALL_BROWSERS
 
 BOT_CHECK_HINTS = (
     "sign in",
@@ -43,10 +41,15 @@ BOT_CHECK_HINTS = (
 
 
 def _parse_browser_spec(spec: str) -> tuple[str, str | None, str | None, str | None]:
-    """Parse a yt-dlp ``--cookies-from-browser`` spec.
+    """Parse a polytool browser spec and return a yt-dlp-ready tuple.
 
     Format: ``browser[+keyring][:profile][::container]``.
 
+    For yt-dlp's native browsers this is a pass-through. For Firefox forks
+    (zen / librewolf / waterfox / floorp / mullvad), we locate the user's
+    data dir + profile directory and return ``('firefox', <abs-path>, …)`` —
+    yt-dlp's firefox extractor accepts an absolute profile path.
+
     >>> _parse_browser_spec("chrome")
     ('chrome', None, None, None)
     >>> _parse_browser_spec("firefox:default-release")
@@ -70,6 +73,29 @@ def _parse_browser_spec(spec: str) -> tuple[str, str | None, str | None, str | N
             f"Invalid --cookies-from-browser spec: {spec!r}",
             hint="Format: browser[+keyring][:profile][::container].",
         )
+
+    # Firefox forks: resolve profile dir ourselves, pass it to yt-dlp as firefox.
+    if browser in FIREFOX_FORK_DIRS:
+        data_dir = find_firefox_fork_data_dir(browser)
+        if data_dir is None:
+            raise PolytoolError(
+                f"Could not find {browser!r} data directory.",
+                hint=(
+                    f"Make sure {browser} is installed and has been launched at "
+                    f"least once on this machine."
+                ),
+            )
+        try:
+            profile_dir = resolve_firefox_profile_dir(data_dir, profile)
+        except FileNotFoundError as exc:
+            raise PolytoolError(str(exc)) from exc
+        return ("firefox", str(profile_dir), keyring or None, container or None)
+
+    if browser not in YT_DLP_NATIVE_BROWSERS:
+        raise PolytoolError(
+            f"Unknown browser {browser!r}.",
+            hint=f"Supported: {', '.join(SUPPORTED_BROWSERS)}.",
+        )
     return (browser, profile or None, keyring or None, container or None)
 
 
@@ -388,13 +414,36 @@ def cmd_info(
             f"[dim]Using saved cookies-from-browser: {opts['cookiesfrombrowser'][0]}[/dim]"
         )
 
+    # process=False skips yt-dlp's format-selection step. We only want metadata,
+    # and on some sites (YouTube especially) the default format selector
+    # fails with "Requested format is not available" on otherwise-valid videos.
     try:
         with yt_dlp.YoutubeDL(opts) as ydl:
-            info = ydl.extract_info(url, download=False)
+            info = ydl.extract_info(url, download=False, process=False)
     except Exception as exc:
         raise PolytoolError(f"Could not fetch info: {exc}", hint=_bot_check_hint(str(exc))) from exc
 
-    interesting = ("title", "uploader", "duration", "view_count", "upload_date", "webpage_url")
+    if info is None:
+        raise PolytoolError("yt-dlp returned no metadata for this URL.")
+
+    interesting = (
+        "title",
+        "uploader",
+        "channel",
+        "duration",
+        "view_count",
+        "like_count",
+        "upload_date",
+        "live_status",
+        "webpage_url",
+    )
+    shown = False
     for key in interesting:
         if key in info and info[key] is not None:
             console.print(f"[cyan]{key}[/cyan]: {info[key]}")
+            shown = True
+    # Playlists and some sites return only `entries` and a few top-level fields.
+    if not shown and info.get("_type") == "playlist":
+        console.print(f"[cyan]playlist[/cyan]: {info.get('title') or info.get('id')}")
+        entries = info.get("entries") or []
+        console.print(f"[cyan]entries[/cyan]: {len(list(entries))}")

polytool-0.2.4/src/polytool/core/browsers.py

@@ -0,0 +1,162 @@
+"""Cross-platform helpers for finding browser data directories.
+
+yt-dlp natively supports a fixed set of browsers (chrome / firefox / edge /
+brave / chromium / opera / safari / vivaldi / whale). This module fills in
+the gap for **Firefox forks** that aren't in yt-dlp's list — Zen Browser,
+LibreWolf, Waterfox, Floorp, and Mullvad Browser — by:
+
+1. Locating the fork's data directory cross-platform.
+2. Reading its ``profiles.ini`` (standard Firefox format) to find the
+   default profile (or the named profile the user asked for).
+3. Returning the absolute profile path.
+
+We then hand that path to yt-dlp's ``firefox`` extractor, which accepts a
+profile *directory path* (not just a name) — so cookies from Zen et al.
+work transparently.
+"""
+
+from __future__ import annotations
+
+import configparser
+import os
+import sys
+from pathlib import Path
+
+# Browsers that yt-dlp's `cookiesfrombrowser` understands natively.
+YT_DLP_NATIVE_BROWSERS: frozenset[str] = frozenset(
+    {
+        "chrome",
+        "firefox",
+        "edge",
+        "brave",
+        "chromium",
+        "opera",
+        "safari",
+        "vivaldi",
+        "whale",
+    }
+)
+
+# Firefox forks → list of platform basenames to probe (in order).
+# Different installers/distros use different casings, hence the multiple options.
+FIREFOX_FORK_DIRS: dict[str, tuple[str, ...]] = {
+    "zen": ("zen",),
+    "librewolf": ("librewolf", "LibreWolf"),
+    "waterfox": ("waterfox", "Waterfox"),
+    "floorp": ("floorp", "Floorp"),
+    "mullvad": ("MullvadBrowser", "mullvadbrowser"),
+}
+
+# All browser names we accept on the CLI (for help text / interactive picker /
+# validation). Order is stable: native first, then forks.
+ALL_BROWSERS: tuple[str, ...] = (
+    "chrome",
+    "firefox",
+    "edge",
+    "brave",
+    "chromium",
+    "opera",
+    "safari",
+    "vivaldi",
+    "whale",
+    "zen",
+    "librewolf",
+    "waterfox",
+    "floorp",
+    "mullvad",
+)
+
+
+def _platform_data_dirs(basename: str) -> list[Path]:
+    """Return candidate data dirs for *basename* on the current OS."""
+    home = Path.home()
+    if sys.platform == "win32":
+        appdata = Path(os.environ.get("APPDATA") or str(home / "AppData/Roaming"))
+        local = Path(os.environ.get("LOCALAPPDATA") or str(home / "AppData/Local"))
+        return [appdata / basename, local / basename]
+    if sys.platform == "darwin":
+        return [home / "Library/Application Support" / basename]
+    # Linux / BSD / other unix
+    return [home / f".{basename}", home / ".config" / basename]
+
+
+def find_firefox_fork_data_dir(name: str) -> Path | None:
+    """Return the data dir of a Firefox fork, or ``None`` if not installed.
+
+    >>> # find_firefox_fork_data_dir("zen") → e.g. PosixPath('/home/u/.zen')
+    """
+    basenames = FIREFOX_FORK_DIRS.get(name.lower())
+    if not basenames:
+        return None
+    for basename in basenames:
+        for candidate in _platform_data_dirs(basename):
+            if candidate.is_dir():
+                return candidate
+    return None
+
+
+def resolve_firefox_profile_dir(data_dir: Path, profile_name: str | None = None) -> Path:
+    """Resolve a Firefox-style profile directory inside *data_dir*.
+
+    Reads ``data_dir/profiles.ini`` and returns the absolute path of:
+
+    * the profile whose ``Name=`` matches *profile_name* (if given), or
+    * the install's ``Default=`` profile (preferred), or
+    * the first profile with ``Default=1``, or
+    * the first profile listed.
+
+    Falls back to scanning ``data_dir/Profiles/`` directly if ``profiles.ini``
+    is missing — useful for the rare case where a fork doesn't ship one yet.
+
+    Raises ``FileNotFoundError`` if nothing matches.
+    """
+    ini = data_dir / "profiles.ini"
+    if ini.exists():
+        cp = configparser.ConfigParser(strict=False)
+        cp.read(ini, encoding="utf-8")
+
+        profile_sections: list[tuple[str, str, bool, bool]] = []
+        install_default: str | None = None
+        for section in cp.sections():
+            low = section.lower()
+            if low.startswith("profile"):
+                name = cp.get(section, "Name", fallback="")
+                path = cp.get(section, "Path", fallback="")
+                is_relative = cp.getboolean(section, "IsRelative", fallback=True)
+                is_default = cp.getint(section, "Default", fallback=0) == 1
+                if path:
+                    profile_sections.append((name, path, is_relative, is_default))
+            elif low.startswith("install") and install_default is None:
+                d = cp.get(section, "Default", fallback="")
+                if d:
+                    install_default = d
+
+        if profile_name:
+            for name, path, is_relative, _ in profile_sections:
+                if profile_name in (name, path):
+                    return data_dir / path if is_relative else Path(path)
+            raise FileNotFoundError(f"No Firefox profile named {profile_name!r} in {ini}")
+
+        if install_default:
+            return data_dir / install_default
+        for _name, path, is_relative, is_default in profile_sections:
+            if is_default:
+                return data_dir / path if is_relative else Path(path)
+        if profile_sections:
+            _name, path, is_relative, _ = profile_sections[0]
+            return data_dir / path if is_relative else Path(path)
+        raise FileNotFoundError(f"No profiles listed in {ini}")
+
+    # No profiles.ini — try the Profiles/ directory directly.
+    profiles_root = data_dir / "Profiles"
+    if profiles_root.is_dir():
+        children = sorted(p for p in profiles_root.iterdir() if p.is_dir())
+        if profile_name:
+            for c in children:
+                # Profile directories look like xxxxxxxx.<name>
+                if c.name.endswith(f".{profile_name}") or c.name == profile_name:
+                    return c
+            raise FileNotFoundError(f"No Firefox-style profile {profile_name!r} in {profiles_root}")
+        if children:
+            return children[0]
+    raise FileNotFoundError(f"Could not find profiles.ini or Profiles/ in {data_dir}")