download favicons for menus that support icons

wip vendor/rewrite favicon dep

update PKGBUILD

Author: pvsr

TODO

@@ -0,0 +1 @@
+favicon request content type: ["image/avif,image/webp,image/png,image/svg+xml,image/*;q=0.8,*/*;q=0.5"]

contrib/PKGBUILD

@@ -8,7 +8,7 @@ url="https://github.com/pvsr/qbpm"
 license=('GPL-3.0-or-later')
 sha512sums=('SKIP')
 arch=('any')
-depends=('python' 'python-click' 'python-xdg-base-dirs')
+depends=('python' 'python-click' 'python-xdg-base-dirs' 'python-httpx' 'python-pillow')
 makedepends=('git' 'python-build' 'python-installer' 'python-wheel' 'python-flit-core' 'scdoc')
 provides=('qbpm')
 source=("git+https://github.com/pvsr/qbpm")

flake.nix

@@ -60,12 +60,14 @@
           packages = [
             pkgs.ruff
             pkgs.nixfmt-rfc-style
+            pkgs.xdg-utils
             (pyprojectEnv (
               ps: with ps; [
                 flit
                 pytest
                 mypy
                 pylsp-mypy
+                # types-pillow
               ]
             ))
           ];

pyproject.toml

@@ -16,7 +16,7 @@ classifiers = [
     "Typing :: Typed",
 ]
 requires-python = ">= 3.11"
-dependencies = ["click", "xdg-base-dirs"]
+dependencies = ["click", "xdg-base-dirs", "httpx", "pillow"]
 
 [project.urls]
 homepage = "https://github.com/pvsr/qbpm"

qbpm.1.scd

@@ -80,6 +80,18 @@ appropriate \--basedir, or more conveniently using the qbpm launch and qbpm choo
 		qbpm launch -n qb-dev --debug --json-logging
 		```
 
+*icon* [options] <profile> <icon>
+	Install an icon to _profile_. _icon_ may be a url, a path to an image file,
+	or, if --by-name is passed, the name of an xdg icon installed on your
+	system. If _icon_ is a url, qbpm will fetch the page and attempt to find a
+	suitable favicon.
+
+	Options:
+
+	*-n, --by-name*
+		Interpret _icon_ as the name of an xdg icon file according to the
+		freedesktop.org icon specification. Likely to only work on Linux.
+
 *choose* [options]
 	Open a menu to choose a qutebrowser profile to launch. On linux this defaults
 	to dmenu or another compatible menu program such as rofi, and on macOS this
@@ -126,8 +138,24 @@ appropriate \--basedir, or more conveniently using the qbpm launch and qbpm choo
 
 Peter Rice
 
+<<<<<<< Conflict 1 of 1
+%%%%%%% Changes from base to side #1
+-Contribute at https://github.com/pvsr/qbpm
++# CONTRIBUTE
++
++_https://github.com/pvsr/qbpm_
++
++_https://codeberg.org/pvsr/qbpm_
++++++++ Contents of side #2
 # CONTRIBUTE
 
 _https://github.com/pvsr/qbpm_
 
 _https://codeberg.org/pvsr/qbpm_
+
+# LICENSE
+
+src/qbpm/favicon.py: MIT
+
+all other code and qbpm as a whole: GPLv3+
+>>>>>>> Conflict 1 of 1 ends

qbpm/config.py

@@ -0,0 +1,3 @@
+# TODO real config file
+default_icon = "qutebrowser"
+application_name_suffix = " (qutebrowser profile)"

qbpm/favicon.py

@@ -0,0 +1,118 @@
+"""
+SPDX-License-Identifier: MIT
+derived from favicon.py by Scott Werner
+https://github.com/scottwernervt/favicon/tree/123e431f53b2c4903b540246a85db0b1633d4786
+"""
+
+import re
+from collections import defaultdict, namedtuple
+from html.parser import HTMLParser
+from pathlib import Path
+from typing import Any
+
+import httpx
+
+LINK_RELS = [
+    "icon",
+    "shortcut icon",
+]
+
+SIZE_RE = re.compile(r"(?P<width>\d{2,4})x(?P<height>\d{2,4})", flags=re.IGNORECASE)
+
+Icon = namedtuple("Icon", ["url", "width", "height", "format", "src"])
+
+
+def get(client: httpx.Client) -> list[Icon]:
+    response = client.get("")
+    response.raise_for_status()
+    client.base_url = response.url
+
+    icons = {icon.url: icon for icon in tags(response.text)}
+
+    fallback_icon = fallback(client)
+    if fallback_icon and fallback_icon.src not in icons:
+        icons[fallback_icon.url] = fallback_icon
+
+    # print(f"{icons=}")
+    return list(icons.values())
+    # return sorted(icons, key=lambda i: i.width + i.height, reverse=True)
+
+
+def fallback(client: httpx.Client) -> Icon | None:
+    response = client.head("favicon.ico")
+    if response.status_code == 200 and response.headers["Content-Type"].startswith(
+        "image"
+    ):
+        return Icon(response.url, 0, 0, ".ico", "default")
+    return None
+
+
+class LinkRelParser(HTMLParser):
+    def __init__(self) -> None:
+        super().__init__()
+        self.icons: dict[str, set[str]] = defaultdict(set)
+
+    def handle_starttag(self, tag: str, attrs: list[tuple[str, str | None]]) -> None:
+        if tag == "link":
+            data = dict(attrs)
+            rel = data.get("rel")
+            if rel in LINK_RELS and (href := data.get("href") or data.get("content")):
+                # TODO replace with data
+                self.icons[rel].add(href)
+
+
+def tags(html: str) -> set[Icon]:
+    parser = LinkRelParser()
+    parser.feed(html[0 : html.find("</head>")])
+    hrefs = {link.strip() for links in parser.icons.values() for link in links}
+
+    icons = set()
+    for href in hrefs:
+        if not href or href.startswith("data:image/"):
+            continue
+
+        # url_parsed = urlparse(url)
+        # repair '//cdn.network.com/favicon.png' or `icon.png?v2`
+        href_parsed = httpx.URL(href)
+
+        width, height = (0, 0)  # dimensions(tag)
+        ext = Path(href_parsed.path).suffix
+
+        icon = Icon(
+            href_parsed,
+            width,
+            height,
+            ext.lower(),
+            "TODO",
+        )
+        icons.add(icon)
+
+    return icons
+
+
+def dimensions(tag: Any) -> tuple[int, int]:
+    """Get icon dimensions from size attribute or icon filename.
+
+    :param tag: Link or meta tag.
+    :type tag: :class:`bs4.element.Tag`
+
+    :return: If found, width and height, else (0,0).
+    :rtype: tuple(int, int)
+    """
+    sizes = tag.get("sizes", "")
+    if sizes and sizes != "any":
+        size = sizes.split(" ")  # '16x16 32x32 64x64'
+        size.sort(reverse=True)
+        width, height = re.split(r"[x\xd7]", size[0])
+    else:
+        filename = tag.get("href") or tag.get("content")
+        size = SIZE_RE.search(filename)
+        if size:
+            width, height = size.group("width"), size.group("height")
+        else:
+            width, height = "0", "0"
+
+    # repair bad html attribute values: sizes='192x192+'
+    width = "".join(c for c in width if c.isdigit())
+    height = "".join(c for c in height if c.isdigit())
+    return int(width), int(height)

qbpm/icons.py

@@ -0,0 +1,147 @@
+import re
+import shutil
+from collections.abc import Callable, Iterator
+from pathlib import Path
+from tempfile import TemporaryDirectory
+from typing import Optional
+
+import httpx
+from PIL import Image
+
+from . import Profile, __version__, favicon
+from .favicon import Icon
+from .utils import error, info
+
+# TODO more preferences: 16x16, 32, 0, other
+PREFERRED_ICONS = [
+    re.compile(p)
+    for p in [
+        r"favicon.*\.svg$",
+        r"favicon.*\.ico$",
+        r"favicon.*\.png$",
+        r"\.ico$",
+        r"icon\.png$",
+        r"\.svg$",
+    ]
+]
+
+
+def choose_icon(icons: list[Icon]) -> Iterator[Icon]:
+    preferred = PREFERRED_ICONS
+    for pattern in preferred:
+        for icon in icons:
+            if pattern.search(icon.url.path):
+                info(f"chose {icon.url}")
+                yield icon
+                icons.remove(icon)
+                yield from choose_icon(icons)
+
+
+headers = {"user-agent": f"qbpm/{__version__}"}
+
+
+def download_icon(profile: Profile, home_page: str, overwrite: bool) -> Optional[Path]:
+    base_url = httpx.URL(home_page)
+    if not base_url.scheme:
+        base_url = httpx.URL("https://" + home_page)
+    client = httpx.Client(base_url=base_url, headers=headers, follow_redirects=True)
+    tmp_dir = TemporaryDirectory()
+    work_dir = Path(tmp_dir.name)
+    try:
+        for icon in choose_icon(favicon.get(client)):
+            icon_body = client.get(icon.url)
+            if icon_body.status_code != 200:
+                info(f"got bad response code {icon_body.status_code} for {icon.url}")
+                return None
+            elif not icon_body.headers["Content-Type"].startswith("image"):
+                info(f"{icon.url} is not an image")
+                return None
+            icon_body.raise_for_status()
+            work_icon = work_dir / f"favicon{icon.format}"
+            with work_icon.open("wb") as icon_file:
+                for chunk in icon_body.iter_bytes(1024):
+                    icon_file.write(chunk)
+            icon_path = install_icon_file(profile, work_icon, overwrite, icon.url)
+            if icon_path:
+                # print(f"installed {client.base_url.join(icon.url)}")
+                return icon_path
+        if not icon_path:
+            # TODO pretty print
+            info(f"no favicons found matching one of {PREFERRED_ICONS}")
+            return None
+    except Exception as e:
+        # info(str(e))
+        raise e
+        error(f"failed to fetch favicon from {home_page}")
+        return None
+    finally:
+        tmp_dir.cleanup()
+        client.close()
+
+    return None
+
+
+def icon_for_profile(profile: Profile) -> Optional[str]:
+    icon_file = next(find_icon_files(profile), None)
+    if icon_file and icon_file.suffix == ".name":
+        return icon_file.read_text()
+    return str(icon_file) if icon_file else None
+
+
+def install_icon_file(
+    profile: Profile, src: Path, overwrite: bool, origin: Optional[str] = None
+) -> Optional[Path]:
+    clean_icons = check_for_icons(profile, overwrite)
+    if clean_icons is None:
+        return None
+    icon_format = src.suffix
+    dest = profile.root / f"icon{icon_format}"
+    if icon_format not in {".png", ".svg"}:
+        dest = dest.with_suffix(".png")
+        try:
+            image = Image.open(src)
+            clean_icons(set())
+            image.save(dest, format="png")
+        except Exception as e:
+            error(str(e))
+            error(f"failed to convert {origin or src} to png")
+            dest.unlink(missing_ok=True)
+            return None
+    else:
+        if src.resolve() != dest:
+            shutil.copy(src, dest)
+        clean_icons({dest})
+    print(dest)
+    return dest.absolute()
+
+
+def install_icon_by_name(profile: Profile, icon_name: str, overwrite: bool) -> bool:
+    clean_icons = check_for_icons(profile, overwrite)
+    if clean_icons is None:
+        return False
+    clean_icons(set())
+    file = profile.root / "icon.name"
+    file.write_text(icon_name)
+    return True
+
+
+def check_for_icons(
+    profile: Profile, overwrite: bool
+) -> Callable[[set[Path]], None] | None:
+    existing_icons = set(find_icon_files(profile))
+    if existing_icons and not overwrite:
+        error(f"icon already exists in {profile.root}, pass --overwrite to replace it")
+        return None
+
+    def clean_icons(keep: set[Path]) -> None:
+        for icon in existing_icons - keep:
+            icon.unlink()
+
+    return clean_icons
+
+
+def find_icon_files(profile: Profile) -> Iterator[Path]:
+    for ext in ["png", "svg", "name"]:
+        icon = profile.root / f"icon.{ext}"
+        if icon.is_file():
+            yield icon.absolute()