polytool 0.2.0__tar.gz → 0.2.2__tar.gz

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: polytool
-Version: 0.2.0
+Version: 0.2.2
 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.0 → polytool-0.2.2}/docs/README.md

@@ -7,6 +7,7 @@ Detailed reference for every command in `polytool` (binary `pt`).
 ## Quick links
 
 - **[Install](install.md)** — `uv tool install`, slim vs full, extras, Windows quoting
+- **[Auth & external services](auth.md)** — which verbs touch the network and how to authenticate
 - **[Troubleshooting](troubleshooting.md)** — every common gotcha with a fix
 - **[Architecture](architecture.md)** — package layout, lazy imports, error model
 

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

@@ -4,7 +4,7 @@ build-backend = "hatchling.build"
 
 [project]
 name = "polytool"
-version = "0.2.0"
+version = "0.2.2"
 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"
@@ -76,8 +76,8 @@ dev = [
 ]
 
 [project.scripts]
-polytool = "polytool.cli:app"
-pt = "polytool.cli:app"
+polytool = "polytool.cli:run"
+pt = "polytool.cli:run"
 
 [project.urls]
 Homepage = "https://github.com/k6w/polytool"

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

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

{polytool-0.2.0 → polytool-0.2.2}/src/polytool/__main__.py

@@ -1,6 +1,6 @@
 """Allow `python -m polytool` invocation."""
 
-from polytool.cli import app
+from polytool.cli import run
 
 if __name__ == "__main__":
-    app()
+    run()

{polytool-0.2.0 → polytool-0.2.2}/src/polytool/cli/__init__.py

@@ -7,6 +7,8 @@ Heavy imports (Pillow, ffmpeg, rembg) happen inside command bodies via
 
 from __future__ import annotations
 
+import sys
+
 import typer
 
 from polytool import __version__
@@ -28,9 +30,7 @@ from polytool.cli import (
     text,
     vid,
 )
-from polytool.core.errors import install_excepthook
-
-install_excepthook()
+from polytool.core.errors import PolytoolError, render_panel
 
 app = typer.Typer(
     name="polytool",
@@ -38,9 +38,25 @@ app = typer.Typer(
     no_args_is_help=True,
     add_completion=False,
     rich_markup_mode="rich",
+    # We handle PolytoolError ourselves via the `main()` wrapper below; disable
+    # Typer's pretty-traceback so it doesn't squash our hints.
+    pretty_exceptions_enable=False,
 )
 
 
+def run() -> None:
+    """Console-script entry point — runs the Typer app and renders PolytoolError nicely.
+
+    (Defined with a unique name to avoid clashing with the ``@app.callback()``
+    function below — both would otherwise be named ``main`` in this module.)
+    """
+    try:
+        app()
+    except PolytoolError as exc:
+        render_panel(exc.message, exc.hint)
+        sys.exit(1)
+
+
 def _version_callback(value: bool) -> None:
     if value:
         typer.echo(f"polytool {__version__}")

polytool-0.2.2/src/polytool/cli/dl.py

@@ -0,0 +1,400 @@
+"""Download media from YouTube and 1000+ sites via yt-dlp."""
+
+from __future__ import annotations
+
+from pathlib import Path
+from typing import Annotated
+
+import typer
+
+from polytool.core import config
+from polytool.core.console import console, err_console
+from polytool.core.errors import PolytoolError
+
+app = typer.Typer(
+    name="dl",
+    help="Download media from YouTube and 1000+ sites (yt-dlp).",
+    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",
+)
+
+BOT_CHECK_HINTS = (
+    "sign in",
+    "confirm you",
+    "not a bot",
+    "captcha",
+    "private video",
+    "members-only",
+    "login required",
+    "rate limit",
+)
+
+
+def _parse_browser_spec(spec: str) -> tuple[str, str | None, str | None, str | None]:
+    """Parse a yt-dlp ``--cookies-from-browser`` spec.
+
+    Format: ``browser[+keyring][:profile][::container]``.
+
+    >>> _parse_browser_spec("chrome")
+    ('chrome', None, None, None)
+    >>> _parse_browser_spec("firefox:default-release")
+    ('firefox', 'default-release', None, None)
+    >>> _parse_browser_spec("firefox+gnomekeyring:default::personal")
+    ('firefox', 'default', 'gnomekeyring', 'personal')
+    """
+    rest = spec
+    container: str | None = None
+    if "::" in rest:
+        rest, _, container = rest.partition("::")
+    profile: str | None = None
+    if ":" in rest:
+        rest, _, profile = rest.partition(":")
+    keyring: str | None = None
+    if "+" in rest:
+        rest, _, keyring = rest.partition("+")
+    browser = rest.strip().lower()
+    if not browser:
+        raise PolytoolError(
+            f"Invalid --cookies-from-browser spec: {spec!r}",
+            hint="Format: browser[+keyring][:profile][::container].",
+        )
+    return (browser, profile or None, keyring or None, container or None)
+
+
+def _resolve_cookies(
+    cookies_from_browser: str | None,
+    cookies_file: Path | None,
+) -> tuple[str | None, Path | None]:
+    """Pick the active cookie source: explicit flags first, then saved config."""
+    if cookies_from_browser and cookies_file:
+        raise PolytoolError("Use --cookies-from-browser OR --cookies, not both.")
+    if cookies_from_browser:
+        return cookies_from_browser, None
+    if cookies_file:
+        return None, cookies_file
+    saved_browser = config.get("dl", "cookies_from_browser")
+    saved_file = config.get("dl", "cookies_file")
+    if saved_browser:
+        return saved_browser, None
+    if saved_file:
+        return None, Path(saved_file)
+    return None, None
+
+
+def _apply_cookie_opts(
+    opts: dict,
+    cookies_from_browser: str | None,
+    cookies_file: Path | None,
+) -> None:
+    """Mutate *opts* in-place to add yt-dlp cookie options."""
+    browser_spec, file_path = _resolve_cookies(cookies_from_browser, cookies_file)
+    if browser_spec:
+        opts["cookiesfrombrowser"] = _parse_browser_spec(browser_spec)
+    elif file_path:
+        if not file_path.exists():
+            raise PolytoolError(f"Cookie file not found: {file_path}")
+        opts["cookiefile"] = str(file_path)
+
+
+def _bot_check_hint(message: str) -> str | None:
+    low = message.lower()
+    if not any(s in low for s in BOT_CHECK_HINTS):
+        return None
+    if config.get("dl", "cookies_from_browser") or config.get("dl", "cookies_file"):
+        return (
+            "Saved cookies didn't satisfy the site. "
+            "Re-run [cyan]pt dl setup[/cyan] (maybe pick a different browser/profile)."
+        )
+    return (
+        "This site is blocking unauthenticated requests. "
+        "Run [cyan]pt dl setup[/cyan] once to configure cookies, "
+        "or pass [cyan]--cookies-from-browser BROWSER[/cyan] per call."
+    )
+
+
+@app.command("setup")
+def cmd_setup(
+    browser: Annotated[
+        str | None,
+        typer.Option(
+            "--browser",
+            "-b",
+            help=f"Save a default browser ({', '.join(SUPPORTED_BROWSERS)}). "
+            "Accepts the same browser[+keyring][:profile][::container] format as yt-dlp.",
+        ),
+    ] = None,
+    cookies_file: Annotated[
+        Path | None,
+        typer.Option("--cookies", help="Save the path to a Netscape-format cookies.txt file."),
+    ] = None,
+    clear: Annotated[bool, typer.Option("--clear", help="Remove the saved cookie config.")] = False,
+    show: Annotated[bool, typer.Option("--show", help="Print the saved cookie config.")] = False,
+) -> None:
+    """One-time setup: tell `pt dl` where to fetch cookies from.
+
+    After running this, [cyan]pt dl get[/cyan] and [cyan]pt dl info[/cyan] will
+    automatically use your saved cookies — no need to pass flags every time.
+
+    Examples:
+
+        pt dl setup                       # interactive prompt
+        pt dl setup --browser firefox     # save firefox as the default
+        pt dl setup --browser chrome:Default
+        pt dl setup --cookies cookies.txt
+        pt dl setup --show                # print current saved config
+        pt dl setup --clear               # forget saved cookies
+    """
+    from polytool.core.config import CONFIG_PATH
+
+    if show:
+        b = config.get("dl", "cookies_from_browser")
+        f = config.get("dl", "cookies_file")
+        if not b and not f:
+            console.print("[dim]No saved dl cookie config.[/dim]")
+            return
+        if b:
+            console.print(f"[cyan]cookies-from-browser[/cyan]: {b}")
+        if f:
+            console.print(f"[cyan]cookies-file[/cyan]: {f}")
+        console.print(f"[dim](stored at {CONFIG_PATH})[/dim]")
+        return
+
+    if clear:
+        config.unset("dl", "cookies_from_browser")
+        config.unset("dl", "cookies_file")
+        console.print("[green]Cleared saved dl cookie config.[/green]")
+        return
+
+    if browser is not None and cookies_file is not None:
+        raise PolytoolError("Use --browser OR --cookies, not both.")
+
+    if browser is None and cookies_file is None:
+        # Interactive prompt.
+        console.print("Which browser should [cyan]pt dl[/cyan] pull cookies from?\n")
+        for i, name in enumerate(SUPPORTED_BROWSERS, 1):
+            console.print(f"  [cyan]{i}[/cyan]) {name}")
+        console.print(f"  [cyan]{len(SUPPORTED_BROWSERS) + 1}[/cyan]) [dim]none / not now[/dim]")
+        choice_s = typer.prompt("\nPick a number", type=str)
+        try:
+            choice = int(choice_s.strip())
+        except ValueError as exc:
+            raise PolytoolError(f"Not a number: {choice_s!r}") from exc
+        if choice == len(SUPPORTED_BROWSERS) + 1:
+            console.print("[dim]Skipped. Run pt dl setup any time to configure.[/dim]")
+            return
+        if not 1 <= choice <= len(SUPPORTED_BROWSERS):
+            raise PolytoolError("Out of range.")
+        browser = SUPPORTED_BROWSERS[choice - 1]
+
+    if browser is not None:
+        # Validate the spec parses (catches typos before the user hits a real error later).
+        _parse_browser_spec(browser)
+        config.set_(browser, "dl", "cookies_from_browser")
+        config.unset("dl", "cookies_file")
+        console.print(
+            f"[green]Saved.[/green] [cyan]pt dl[/cyan] will use cookies from "
+            f"[bold]{browser}[/bold] from now on."
+        )
+        console.print(f"[dim](config at {CONFIG_PATH})[/dim]")
+        return
+
+    assert cookies_file is not None
+    if not cookies_file.exists():
+        raise PolytoolError(f"Cookie file not found: {cookies_file}")
+    resolved = cookies_file.resolve()
+    config.set_(str(resolved), "dl", "cookies_file")
+    config.unset("dl", "cookies_from_browser")
+    console.print(f"[green]Saved.[/green] [cyan]pt dl[/cyan] will use cookies from {resolved}.")
+    console.print(f"[dim](config at {CONFIG_PATH})[/dim]")
+
+
+@app.command("get")
+def cmd_get(
+    url: Annotated[str, typer.Argument(help="Media URL")],
+    output_dir: Annotated[Path, typer.Option("--output", "-o", help="Output directory")] = Path(),
+    audio_only: Annotated[
+        bool,
+        typer.Option("--audio-only", "-a", help="Download audio (mp3) only"),
+    ] = False,
+    format_: Annotated[
+        str | None,
+        typer.Option("--format", "-f", help="yt-dlp format selector (e.g. 'best', '720p')"),
+    ] = None,
+    template: Annotated[
+        str,
+        typer.Option(
+            "--template",
+            "-t",
+            help="Output filename template (yt-dlp syntax)",
+        ),
+    ] = "%(title)s.%(ext)s",
+    cookies_from_browser: Annotated[
+        str | None,
+        typer.Option(
+            "--cookies-from-browser",
+            help="Override saved config: load cookies from BROWSER[+keyring][:profile][::container].",
+        ),
+    ] = None,
+    cookies_file: Annotated[
+        Path | None,
+        typer.Option(
+            "--cookies",
+            help="Override saved config: path to a Netscape-format cookies.txt file.",
+        ),
+    ] = None,
+    username: Annotated[
+        str | None,
+        typer.Option("--username", "-u", help="Account username (for sites with login auth)."),
+    ] = None,
+    password: Annotated[
+        str | None,
+        typer.Option(
+            "--password",
+            "-p",
+            help="Account password. Tip: omit and yt-dlp will prompt securely.",
+        ),
+    ] = None,
+    video_password: Annotated[
+        str | None,
+        typer.Option("--video-password", help="Per-video password (Vimeo etc.)."),
+    ] = None,
+) -> None:
+    """Download a video or audio file.
+
+    Cookies are taken from your [cyan]pt dl setup[/cyan] config by default;
+    override per-call with --cookies-from-browser / --cookies.
+
+    Examples:
+
+        pt dl get 'https://www.youtube.com/watch?v=dQw4w9WgXcQ'
+        pt dl get URL --audio-only
+        pt dl get URL --format 720p -o ./downloads/
+        pt dl get URL --cookies-from-browser firefox     # one-off override
+        pt dl get URL --username alice --password 'hunter2'
+        pt dl get URL --video-password 'secret'          # Vimeo-style per-video pwd
+    """
+    from polytool.core.lazy import require_extra
+
+    yt_dlp = require_extra("yt_dlp", extra="dl")
+
+    output_dir.mkdir(parents=True, exist_ok=True)
+    opts: dict = {
+        "outtmpl": str(output_dir / template),
+        "noplaylist": False,
+        "quiet": False,
+        "no_warnings": False,
+        "progress": True,
+    }
+    if audio_only:
+        opts["format"] = "bestaudio/best"
+        opts["postprocessors"] = [
+            {"key": "FFmpegExtractAudio", "preferredcodec": "mp3", "preferredquality": "192"}
+        ]
+    elif format_:
+        opts["format"] = format_
+
+    _apply_cookie_opts(opts, cookies_from_browser, cookies_file)
+    if username is not None:
+        opts["username"] = username
+    if password is not None:
+        opts["password"] = password
+    if video_password is not None:
+        opts["videopassword"] = video_password
+    if "cookiesfrombrowser" in opts and not (cookies_from_browser or cookies_file):
+        err_console.print(
+            f"[dim]Using saved cookies-from-browser: {opts['cookiesfrombrowser'][0]}[/dim]"
+        )
+
+    try:
+        with yt_dlp.YoutubeDL(opts) as ydl:
+            ydl.download([url])
+    except yt_dlp.utils.DownloadError as exc:
+        raise PolytoolError(f"Download failed: {exc}", hint=_bot_check_hint(str(exc))) from exc
+    except Exception as exc:
+        raise PolytoolError(f"Download failed: {exc}", hint=_bot_check_hint(str(exc))) from exc
+    console.print("[green]Done.[/green]")
+
+
+@app.command("info")
+def cmd_info(
+    url: Annotated[str, typer.Argument(help="Media URL")],
+    cookies_from_browser: Annotated[
+        str | None,
+        typer.Option(
+            "--cookies-from-browser",
+            help="Override saved config: load cookies from BROWSER[+keyring][:profile][::container].",
+        ),
+    ] = None,
+    cookies_file: Annotated[
+        Path | None,
+        typer.Option(
+            "--cookies",
+            help="Override saved config: path to a Netscape-format cookies.txt file.",
+        ),
+    ] = None,
+    username: Annotated[
+        str | None,
+        typer.Option("--username", "-u", help="Account username (for sites with login auth)."),
+    ] = None,
+    password: Annotated[
+        str | None,
+        typer.Option(
+            "--password",
+            "-p",
+            help="Account password. Tip: omit and yt-dlp will prompt securely.",
+        ),
+    ] = None,
+    video_password: Annotated[
+        str | None,
+        typer.Option("--video-password", help="Per-video password (Vimeo etc.)."),
+    ] = None,
+) -> None:
+    """Show metadata about a URL without downloading.
+
+    Cookies are taken from your [cyan]pt dl setup[/cyan] config by default.
+
+    Examples:
+
+        pt dl info 'https://www.youtube.com/watch?v=dQw4w9WgXcQ'
+        pt dl info URL --cookies-from-browser chrome
+        pt dl info URL --username alice --password hunter2
+    """
+    from polytool.core.lazy import require_extra
+
+    yt_dlp = require_extra("yt_dlp", extra="dl")
+
+    opts: dict = {"quiet": True, "no_warnings": True}
+    _apply_cookie_opts(opts, cookies_from_browser, cookies_file)
+    if username is not None:
+        opts["username"] = username
+    if password is not None:
+        opts["password"] = password
+    if video_password is not None:
+        opts["videopassword"] = video_password
+    if "cookiesfrombrowser" in opts and not (cookies_from_browser or cookies_file):
+        err_console.print(
+            f"[dim]Using saved cookies-from-browser: {opts['cookiesfrombrowser'][0]}[/dim]"
+        )
+
+    try:
+        with yt_dlp.YoutubeDL(opts) as ydl:
+            info = ydl.extract_info(url, download=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")
+    for key in interesting:
+        if key in info and info[key] is not None:
+            console.print(f"[cyan]{key}[/cyan]: {info[key]}")

{polytool-0.2.0 → polytool-0.2.2}/src/polytool/cli/img.py

@@ -41,7 +41,7 @@ def _open_image(source: Path):
         except ImportError as exc:
             raise PolytoolError(
                 "HEIC support missing.",
-                hint="Install: [cyan]uv tool install 'polytool[img]'[/cyan]",
+                hint="Install: [cyan]uv tool install 'polytool\\[img]'[/cyan]",
             ) from exc
     if suffix == ".avif":
         try:
@@ -49,7 +49,7 @@ def _open_image(source: Path):
         except ImportError as exc:
             raise PolytoolError(
                 "AVIF support missing.",
-                hint="Install: [cyan]uv tool install 'polytool[img]'[/cyan]",
+                hint="Install: [cyan]uv tool install 'polytool\\[img]'[/cyan]",
             ) from exc
 
     try:

{polytool-0.2.0 → polytool-0.2.2}/src/polytool/cli/shot.py

@@ -121,7 +121,7 @@ def cmd_install() -> None:
     except FileNotFoundError as exc:
         raise PolytoolError(
             "Playwright not found.",
-            hint="Install: [cyan]uv tool install 'polytool[shot]'[/cyan]",
+            hint="Install: [cyan]uv tool install 'polytool\\[shot]'[/cyan]",
         ) from exc
     except subprocess.CalledProcessError as exc:
         raise PolytoolError(f"playwright install failed (exit {exc.returncode})") from exc

polytool-0.2.2/src/polytool/core/config.py

@@ -0,0 +1,85 @@
+"""Persistent user config for polytool, stored as TOML at ``~/.polytool/config.toml``.
+
+Tiny stdlib-only key-value store (read with ``tomllib``, write with ``tomli_w``).
+Used so per-user preferences survive across invocations — e.g. which browser
+``pt dl`` should pull cookies from.
+"""
+
+from __future__ import annotations
+
+import tomllib
+from pathlib import Path
+from typing import Any
+
+import tomli_w
+
+CONFIG_DIR = Path.home() / ".polytool"
+CONFIG_PATH = CONFIG_DIR / "config.toml"
+
+
+def _resolve() -> tuple[Path, Path]:
+    """Return the (dir, file) pair currently in use.
+
+    Indirection so tests can monkeypatch CONFIG_PATH and have ``save()`` honor it.
+    """
+    return CONFIG_PATH.parent, CONFIG_PATH
+
+
+def load() -> dict[str, Any]:
+    """Read the config file. Returns ``{}`` if missing or unreadable."""
+    _, path = _resolve()
+    if not path.exists():
+        return {}
+    try:
+        with path.open("rb") as f:
+            return tomllib.load(f)
+    except (OSError, tomllib.TOMLDecodeError):
+        return {}
+
+
+def save(data: dict[str, Any]) -> None:
+    """Write the full config dict (creates parent dir if needed)."""
+    parent, path = _resolve()
+    parent.mkdir(parents=True, exist_ok=True)
+    path.write_text(tomli_w.dumps(data), encoding="utf-8")
+
+
+def get(*keys: str, default: Any = None) -> Any:
+    """Read a nested key. ``get("dl", "cookies_from_browser")`` returns
+    ``data['dl']['cookies_from_browser']`` or ``default``.
+    """
+    cur: Any = load()
+    for k in keys:
+        if not isinstance(cur, dict) or k not in cur:
+            return default
+        cur = cur[k]
+    return cur
+
+
+def set_(value: Any, *keys: str) -> None:
+    """Set a nested key, creating intermediate tables as needed."""
+    if not keys:
+        raise ValueError("At least one key required")
+    data = load()
+    cur: dict[str, Any] = data
+    for k in keys[:-1]:
+        if k not in cur or not isinstance(cur[k], dict):
+            cur[k] = {}
+        cur = cur[k]
+    cur[keys[-1]] = value
+    save(data)
+
+
+def unset(*keys: str) -> None:
+    """Delete a nested key. Silent no-op if the key is missing."""
+    if not keys:
+        return
+    data = load()
+    cur: Any = data
+    for k in keys[:-1]:
+        if not isinstance(cur, dict) or k not in cur:
+            return
+        cur = cur[k]
+    if isinstance(cur, dict) and keys[-1] in cur:
+        del cur[keys[-1]]
+        save(data)

{polytool-0.2.0 → polytool-0.2.2}/src/polytool/core/errors.py

@@ -2,7 +2,6 @@
 
 from __future__ import annotations
 
-import sys
 from typing import NoReturn
 
 import typer
@@ -11,8 +10,20 @@ from rich.panel import Panel
 from polytool.core.console import err_console
 
 
+def render_panel(message: str, hint: str | None) -> None:
+    """Render the standard red error panel to stderr."""
+    body = f"[red bold]{message}[/red bold]"
+    if hint:
+        body += f"\n\n[dim]Hint:[/dim] {hint}"
+    err_console.print(Panel(body, border_style="red", title="Error"))
+
+
 class PolytoolError(Exception):
-    """A user-facing error with an optional fix hint."""
+    """A user-facing error with an optional fix hint.
+
+    The CLI entry point (``polytool.cli.main``) catches this and renders
+    ``render_panel`` instead of letting Python or Typer print a stack trace.
+    """
 
     def __init__(self, message: str, hint: str | None = None) -> None:
         super().__init__(message)
@@ -24,10 +35,16 @@ class MissingExtraError(PolytoolError):
     """Raised when an optional dependency group isn't installed."""
 
     def __init__(self, module: str, extra: str) -> None:
+        from rich.markup import escape
+
         message = f"Missing optional dependency: '{module}' (from the '{extra}' extra)."
+        # rich.markup.escape only escapes `[` — `]` is left literal because
+        # Rich only treats `[` as the markup-tag opener.
+        spec = escape(f"polytool[{extra}]")
+        full = escape("polytool[full]")
         hint = (
-            f"Install with: [cyan]uv tool install 'polytool[{extra}]'[/cyan]\n"
-            f"Or for everything: [cyan]uv tool install 'polytool[full]'[/cyan]"
+            f"Install with: [cyan]uv tool install '{spec}'[/cyan]\n"
+            f"Or for everything: [cyan]uv tool install '{full}'[/cyan]"
         )
         super().__init__(message, hint)
         self.module = module
@@ -36,21 +53,14 @@ class MissingExtraError(PolytoolError):
 
 def fail(message: str, hint: str | None = None) -> NoReturn:
     """Print a red error panel and exit with code 1."""
-    body = f"[red bold]{message}[/red bold]"
-    if hint:
-        body += f"\n\n[dim]Hint:[/dim] {hint}"
-    err_console.print(Panel(body, border_style="red", title="Error"))
+    render_panel(message, hint)
     raise typer.Exit(code=1)
 
 
 def install_excepthook() -> None:
-    """Install a sys.excepthook that renders PolytoolError nicely."""
-    original = sys.excepthook
-
-    def hook(exc_type, exc_value, tb):
-        if isinstance(exc_value, PolytoolError):
-            fail(exc_value.message, exc_value.hint)
-            return
-        original(exc_type, exc_value, tb)
+    """No-op kept for backwards compatibility.
 
-    sys.excepthook = hook
+    Earlier versions installed a ``sys.excepthook``. The CLI entry-point now
+    handles ``PolytoolError`` directly via a try/except wrapper.
+    """
+    return

{polytool-0.2.0 → polytool-0.2.2}/src/polytool/core/ffmpeg.py

@@ -26,10 +26,12 @@ def ffmpeg_path() -> str:
     if iio is not None:
         return iio.get_ffmpeg_exe()
 
+    from rich.markup import escape
+
     from polytool.core.errors import PolytoolError
 
     raise PolytoolError(
         "ffmpeg not found.",
         hint="Install ffmpeg system-wide, or install the 'vid' extra: "
-        "[cyan]uv tool install 'polytool[vid]'[/cyan]",
+        f"[cyan]uv tool install '{escape('polytool[vid]')}'[/cyan]",
     )

polytool-0.2.0/src/polytool/cli/dl.py

@@ -1,102 +0,0 @@
-"""Download media from YouTube and 1000+ sites via yt-dlp."""
-
-from __future__ import annotations
-
-from pathlib import Path
-from typing import Annotated
-
-import typer
-
-from polytool.core.console import console
-from polytool.core.errors import PolytoolError
-
-app = typer.Typer(
-    name="dl",
-    help="Download media from YouTube and 1000+ sites (yt-dlp).",
-    no_args_is_help=True,
-)
-
-
-@app.command("get")
-def cmd_get(
-    url: Annotated[str, typer.Argument(help="Media URL")],
-    output_dir: Annotated[Path, typer.Option("--output", "-o", help="Output directory")] = Path(),
-    audio_only: Annotated[
-        bool,
-        typer.Option("--audio-only", "-a", help="Download audio (mp3) only"),
-    ] = False,
-    format_: Annotated[
-        str | None,
-        typer.Option("--format", "-f", help="yt-dlp format selector (e.g. 'best', '720p')"),
-    ] = None,
-    template: Annotated[
-        str,
-        typer.Option(
-            "--template",
-            "-t",
-            help="Output filename template (yt-dlp syntax)",
-        ),
-    ] = "%(title)s.%(ext)s",
-) -> None:
-    """Download a video or audio file.
-
-    Examples:
-
-        pt dl get 'https://www.youtube.com/watch?v=dQw4w9WgXcQ'
-        pt dl get URL --audio-only
-        pt dl get URL --format 720p -o ./downloads/
-    """
-    from polytool.core.lazy import require_extra
-
-    yt_dlp = require_extra("yt_dlp", extra="dl")
-
-    output_dir.mkdir(parents=True, exist_ok=True)
-    opts: dict = {
-        "outtmpl": str(output_dir / template),
-        "noplaylist": False,
-        "quiet": False,
-        "no_warnings": False,
-        "progress": True,
-    }
-    if audio_only:
-        opts["format"] = "bestaudio/best"
-        opts["postprocessors"] = [
-            {"key": "FFmpegExtractAudio", "preferredcodec": "mp3", "preferredquality": "192"}
-        ]
-    elif format_:
-        opts["format"] = format_
-
-    try:
-        with yt_dlp.YoutubeDL(opts) as ydl:
-            ydl.download([url])
-    except yt_dlp.utils.DownloadError as exc:
-        raise PolytoolError(f"Download failed: {exc}") from exc
-    except Exception as exc:
-        raise PolytoolError(f"Download failed: {exc}") from exc
-    console.print("[green]Done.[/green]")
-
-
-@app.command("info")
-def cmd_info(
-    url: Annotated[str, typer.Argument(help="Media URL")],
-) -> None:
-    """Show metadata about a URL without downloading.
-
-    Examples:
-
-        pt dl info 'https://www.youtube.com/watch?v=dQw4w9WgXcQ'
-    """
-    from polytool.core.lazy import require_extra
-
-    yt_dlp = require_extra("yt_dlp", extra="dl")
-
-    try:
-        with yt_dlp.YoutubeDL({"quiet": True, "no_warnings": True}) as ydl:
-            info = ydl.extract_info(url, download=False)
-    except Exception as exc:
-        raise PolytoolError(f"Could not fetch info: {exc}") from exc
-
-    interesting = ("title", "uploader", "duration", "view_count", "upload_date", "webpage_url")
-    for key in interesting:
-        if key in info and info[key] is not None:
-            console.print(f"[cyan]{key}[/cyan]: {info[key]}")