youpdated 0.1.0__py3-none-any.whl

youpdated/sources/__init__.py

@@ -0,0 +1,5 @@
+"""Built-in sources. Importing this package registers all"""
+
+from . import browser, generic, github, itch, npm, steam, youtube  # noqa: F401
+
+__all__ = ["browser", "generic", "github", "itch", "npm", "steam", "youtube"]

youpdated/sources/base.py

@@ -0,0 +1,44 @@
+"""Source plugin contract"""
+
+from __future__ import annotations
+
+from typing import Any, ClassVar, Iterable, Protocol, runtime_checkable
+
+from ..http import Client
+from ..models import Target, Update
+
+
+class ConfigEntryError(Exception):
+    """Unknown entry or formats"""
+
+
+@runtime_checkable
+class Source(Protocol):
+    name: ClassVar[str]
+    # shown by `youpdated sources`
+    summary: ClassVar[str]
+
+    def targets(self, entries: list[Any]) -> list[Target]:
+        """Normalize raw config into targets"""
+
+    def fetch(self, target: Target, client: Client) -> Iterable[Update]:
+        """Fetch current items for one target. May raise errs; collected."""
+
+
+def entry_fields(entry: Any, scalar_key: str, source: str) -> dict[str, Any]:
+    """Accept both config shapes: a scalar or mapping.
+
+    ``- python/cpython`` and ``- {repo: python/cpython, watch: [...]}`` both arrive and leave as dict
+    """
+    if isinstance(entry, dict):
+        return dict(entry)
+    if isinstance(entry, (str, int, float)):
+        return {scalar_key: entry}
+    raise ConfigEntryError(f"sources.{source}: entry must be a value or a mapping, got {entry!r}")
+
+
+def require(fields: dict[str, Any], key: str, source: str) -> Any:
+    value = fields.get(key)
+    if value is None or (isinstance(value, str) and not value.strip()):
+        raise ConfigEntryError(f"sources.{source}: entry is missing required `{key}`")
+    return value

youpdated/sources/browser.py

@@ -0,0 +1,397 @@
+"""Browser releases: Chrome, Brave, Firefox, and Edge.
+
+Each publishes version history public and unauthenticated;
+This normalizes the four into one Update, and the platform names for the user
+(``mac`` each translates custom)
+
+    sources:
+      browser:
+        - chrome
+        - brave
+        - browser: chrome
+          platform: windows
+          channel: beta
+"""
+
+from __future__ import annotations
+
+import re
+import sys
+from datetime import datetime, timezone
+from typing import Any, ClassVar, Iterable
+
+from ..http import Client
+from ..models import Target, Update
+from ..registry import register
+from .base import ConfigEntryError, entry_fields, require
+from .feed import html_to_text, parse_feed
+
+MAX_VERSIONS = 10
+VERSION_RE = re.compile(r"v?(\d+(?:\.\d+)+)")
+
+# user input -> vendor name
+PLATFORM_ALIASES = {
+    "mac": "mac", "macos": "mac", "osx": "mac", "darwin": "mac",
+    "win": "windows", "windows": "windows", "win64": "windows", "win32": "windows",
+    "linux": "linux",
+    "android": "android",
+    "ios": "ios",
+}
+
+CHROME_PLATFORMS = {
+    "mac": "mac", "windows": "win64", "linux": "linux",
+    "android": "android", "ios": "ios",
+}
+CHROME_CHANNELS = ("stable", "beta", "dev", "canary", "extended")
+
+EDGE_PLATFORMS = {
+    "mac": "MacOS", "windows": "Windows", "linux": "Linux",
+    "android": "Android", "ios": "iOS",
+}
+EDGE_CHANNELS = {"stable": "Stable", "beta": "Beta", "dev": "Dev", "canary": "Canary"}
+# Microsoft only publishes release notes for stable and beta. (Again, who uses EDGE?)
+EDGE_RELNOTES = {
+    "stable": "https://learn.microsoft.com/deployedge/microsoft-edge-relnote-stable-channel",
+    "beta": "https://learn.microsoft.com/deployedge/microsoft-edge-relnote-beta-channel",
+}
+EDGE_RELNOTE_FALLBACK = "https://www.microsoft.com/edge/download/insider"
+
+# Brave publishes every channel into one repo feed, distinguished by title prefix ("Release v1.95.79", "Beta v1.94.112", "Nightly v1.96.0")
+BRAVE_CHANNELS = {
+    "stable": "Release",
+    "release": "Release",
+    "beta": "Beta",
+    "nightly": "Nightly",
+    "dev": "Dev",
+}
+
+# Mozilla publishes one document
+FIREFOX_CHANNELS = {
+    "stable": ("LATEST_FIREFOX_VERSION", "LAST_RELEASE_DATE"),
+    "release": ("LATEST_FIREFOX_VERSION", "LAST_RELEASE_DATE"),
+    "beta": ("LATEST_FIREFOX_DEVEL_VERSION", None),
+    "dev": ("FIREFOX_DEVEDITION", None),
+    "nightly": ("FIREFOX_NIGHTLY", None),
+    "esr": ("FIREFOX_ESR", None),
+}
+
+BROWSERS = ("chrome", "brave", "firefox", "edge")
+
+def _host_platform() -> str:
+    if sys.platform.startswith("darwin"):
+        return "mac"
+    if sys.platform.startswith("win"):
+        return "windows"
+    return "linux"
+
+
+@register
+class BrowserSource:
+    name: ClassVar[str] = "browser"
+    summary: ClassVar[str] = "New releases of Chrome, Brave, Firefox, or Edge"
+
+    def targets(self, entries: list[Any]) -> list[Target]:
+        targets = []
+        for entry in entries:
+            fields = entry_fields(entry, "browser", self.name)
+            browser = str(require(fields, "browser", self.name)).strip().lower()
+            if browser not in BROWSERS:
+                raise ConfigEntryError(
+                    f"sources.{self.name}: unknown browser `{browser}`; "
+                    f"valid options are {list(BROWSERS)}"
+                )
+
+            raw_platform = str(fields.get("platform") or _host_platform()).lower()
+            platform = PLATFORM_ALIASES.get(raw_platform)
+            if platform is None:
+                raise ConfigEntryError(
+                    f"sources.{self.name}: unknown platform `{raw_platform}`; "
+                    f"valid options are {sorted(set(PLATFORM_ALIASES.values()))}"
+                )
+
+            channel = str(fields.get("channel") or "stable").lower()
+            self._validate_channel(browser, channel)
+
+            # Brave publishes one feed for every platform, so the platform is not part of identity but channel is.
+            key = (
+                f"brave/{channel}"
+                if browser == "brave"
+                else f"{browser}/{platform}/{channel}"
+            )
+            targets.append(
+                Target(
+                    source=self.name,
+                    key=key,
+                    label=fields.get("name") or _pretty(browser, platform, channel),
+                    params={"browser": browser, "platform": platform, "channel": channel},
+                )
+            )
+        return targets
+
+    def _validate_channel(self, browser: str, channel: str) -> None:
+        valid = {
+            "chrome": CHROME_CHANNELS,
+            "edge": tuple(EDGE_CHANNELS),
+            "firefox": tuple(FIREFOX_CHANNELS),
+            "brave": tuple(BRAVE_CHANNELS),
+        }[browser]
+        if channel not in valid:
+            raise ConfigEntryError(
+                f"sources.{self.name}: `{channel}` is not a {browser} channel; "
+                f"valid options are {list(valid)}"
+            )
+
+    def fetch(self, target: Target, client: Client) -> Iterable[Update]:
+        browser = target.params["browser"]
+        return {
+            "chrome": self._chrome,
+            "brave": self._brave,
+            "firefox": self._firefox,
+            "edge": self._edge,
+        }[browser](target, client)
+
+    # Chrome
+
+    def _chrome(self, target: Target, client: Client) -> list[Update]:
+        platform = CHROME_PLATFORMS[target.params["platform"]]
+        channel = target.params["channel"]
+        url = (
+            "https://versionhistory.googleapis.com/v1/chrome/platforms/"
+            f"{platform}/channels/{channel}/versions/all/releases"
+        )
+        fetched = client.get(url, conditional=True)
+        if fetched is None:
+            return []
+
+        # One version can appear several times as its rollout fraction grows: keeps the earliest start time per version.
+        starts: dict[str, datetime] = {}
+        for release in fetched.json().get("releases", []):
+            version = release.get("version")
+            started = _parse_iso((release.get("serving") or {}).get("startTime"))
+            if not version:
+                continue
+            if version not in starts or (started and started < starts[version]):
+                starts[version] = started
+
+        ordered = sorted(
+            starts.items(), key=lambda kv: kv[1] or datetime.min.replace(tzinfo=timezone.utc),
+            reverse=True,
+        )
+        return [
+            Update(
+                source=self.name,
+                target=target.key,
+                uid=f"chrome:{platform}:{channel}:{version}",
+                title=f"Chrome {version}",
+                url="https://chromereleases.googleblog.com/",
+                published=started,
+                version=version,
+                body=f"{channel} channel on {target.params['platform']}",
+                tags=("release", channel),
+            )
+            for version, started in ordered[:MAX_VERSIONS]
+        ]
+
+    # Brave
+
+    def _brave(self, target: Target, client: Client) -> list[Update]:
+        """Brave ships all channels as GitHub releases in one repo.
+
+        The ``.atom`` feed only carries the latest 10, and Brave has nightlies
+        The REST API is primary; the atom as fallback for rate-limits.
+        """
+        channel = target.params["channel"]
+        prefix = BRAVE_CHANNELS[channel].lower()
+
+        fetched = client.get(
+            "https://api.github.com/repos/brave/brave-browser/releases?per_page=100",
+            conditional=True,
+            headers={"Accept": "application/vnd.github+json"},
+            soft_statuses=(403, 429),
+        )
+        if fetched is not None and fetched.status == 200:
+            return self._brave_from_api(target, fetched.json(), channel, prefix)
+        if fetched is None:
+            return []  # 304: nothing changed
+
+        client.note("brave: GitHub API unavailable, falling back to the atom feed")
+        return self._brave_from_atom(target, client, channel, prefix)
+
+    def _brave_from_api(
+        self, target: Target, releases: list[dict], channel: str, prefix: str
+    ) -> list[Update]:
+        updates = []
+        for release in releases:
+            if release.get("draft"):
+                continue
+            # Release names can carry trailing whitespace and newlines
+            name = (release.get("name") or release.get("tag_name") or "").strip()
+            if not name.lower().startswith(prefix):
+                continue
+            tag = release.get("tag_name") or name
+            updates.append(
+                Update(
+                    source=self.name,
+                    target=target.key,
+                    uid=f"brave:{tag}",
+                    title=name,
+                    url=release.get("html_url", ""),
+                    published=_parse_iso(release.get("published_at")),
+                    version=_version_from_title(tag) or _version_from_title(name),
+                    body=html_to_text(release.get("body")),
+                    tags=("release", channel),
+                )
+            )
+            if len(updates) >= MAX_VERSIONS:
+                break
+        return updates
+
+    def _brave_from_atom(
+        self, target: Target, client: Client, channel: str, prefix: str
+    ) -> list[Update]:
+        fetched = client.get("https://github.com/brave/brave-browser/releases.atom")
+        if fetched is None:
+            return []
+        updates = parse_feed(
+            fetched.content,
+            source=self.name,
+            target=target.key,
+            limit=None,  # filtered below, don't truncate before
+            tags=("release", channel),
+        )
+        return [
+            Update(
+                source=u.source,
+                target=u.target,
+                # Keyed on the tag so the two paths dedupe
+                uid=f"brave:{_tag_from_url(u.url) or u.uid}",
+                title=u.title,
+                url=u.url,
+                published=u.published,
+                version=_version_from_title(u.title),
+                body=u.body,
+                tags=u.tags,
+            )
+            for u in updates
+            if u.title.strip().lower().startswith(prefix)
+        ][:MAX_VERSIONS]
+
+    # Firefox
+
+    def _firefox(self, target: Target, client: Client) -> list[Update]:
+        fetched = client.get(
+            "https://product-details.mozilla.org/1.0/firefox_versions.json", conditional=True
+        )
+        if fetched is None:
+            return []
+
+        doc = fetched.json()
+        channel = target.params["channel"]
+        version_key, date_key = FIREFOX_CHANNELS[channel]
+        version = doc.get(version_key)
+        if not version:
+            return []
+
+        # Mozilla publishes only current versions
+        # one item per channel; the uid carries the version so it reports once.
+        return [
+            Update(
+                source=self.name,
+                target=target.key,
+                uid=f"firefox:{channel}:{version}",
+                title=f"Firefox {version}",
+                url="https://www.mozilla.org/firefox/releases/",
+                published=_parse_date(doc.get(date_key)) if date_key else None,
+                version=version,
+                body=f"{channel} channel",
+                tags=("release", channel),
+            )
+        ]
+
+    # Edge
+
+    def _edge(self, target: Target, client: Client) -> list[Update]:
+        fetched = client.get("https://edgeupdates.microsoft.com/api/products", conditional=True)
+        if fetched is None:
+            return []
+
+        product_name = EDGE_CHANNELS[target.params["channel"]]
+        platform = EDGE_PLATFORMS[target.params["platform"]]
+
+        product = next(
+            (p for p in fetched.json() if p.get("Product") == product_name), None
+        )
+        if product is None:
+            return []
+
+        seen: dict[str, datetime | None] = {}
+        for release in product.get("Releases", []):
+            if release.get("Platform") != platform:
+                continue
+            version = release.get("ProductVersion")
+            published = _parse_iso(release.get("PublishedTime"))
+            if version and version not in seen:
+                seen[version] = published
+
+        ordered = sorted(
+            seen.items(), key=lambda kv: kv[1] or datetime.min.replace(tzinfo=timezone.utc),
+            reverse=True,
+        )
+        return [
+            Update(
+                source=self.name,
+                target=target.key,
+                uid=f"edge:{product_name}:{platform}:{version}",
+                title=f"Edge {version}",
+                url=EDGE_RELNOTES.get(target.params["channel"], EDGE_RELNOTE_FALLBACK),
+                published=published,
+                version=version,
+                body=f"{product_name} channel on {platform}",
+                tags=("release", target.params["channel"]),
+            )
+            for version, published in ordered[:MAX_VERSIONS]
+        ]
+
+
+def _pretty(browser: str, platform: str, channel: str) -> str:
+    names = {"chrome": "Chrome", "brave": "Brave", "firefox": "Firefox", "edge": "Edge"}
+    suffix = "" if channel in ("stable", "release") else f" {channel}"
+    if browser == "brave":
+        return f"Brave{suffix}"
+    return f"{names[browser]}{suffix} ({platform})"
+
+
+def _tag_from_url(url: str) -> str | None:
+    match = re.search(r"/releases/tag/([^/?#]+)", url or "")
+    return match.group(1) if match else None
+
+
+def _version_from_title(title: str) -> str | None:
+    match = VERSION_RE.search(title or "")
+    return match.group(1) if match else None
+
+
+def _parse_iso(value: str | None) -> datetime | None:
+    if not value:
+        return None
+    text = str(value).replace("Z", "+00:00")
+    # Some have more digits than fromisoformat accepts
+    if "." in text:
+        head, _, tail = text.partition(".")
+        digits = "".join(c for c in tail if c.isdigit())[:6]
+        rest = tail[len(digits):] if tail[len(digits):].startswith(("+", "-")) else ""
+        text = f"{head}.{digits or '0'}{rest}"
+    try:
+        parsed = datetime.fromisoformat(text)
+    except ValueError:
+        return None
+    return parsed if parsed.tzinfo else parsed.replace(tzinfo=timezone.utc)
+
+
+def _parse_date(value: str | None) -> datetime | None:
+    if not value:
+        return None
+    try:
+        return datetime.strptime(str(value), "%Y-%m-%d").replace(tzinfo=timezone.utc)
+    except ValueError:
+        return _parse_iso(value)

youpdated/sources/feed.py

@@ -0,0 +1,111 @@
+"""Shared RSS/Atom handling
+
+Steam, itch, GitHub, and YouTube all publish feeds, so entry to update mapping is here
+"""
+
+from __future__ import annotations
+
+import re
+from datetime import datetime, timezone
+from html.parser import HTMLParser
+from typing import Any, Callable
+
+import feedparser
+
+from ..models import Update
+
+BODY_LIMIT = 400
+_UNDATED = datetime(1970, 1, 1, tzinfo=timezone.utc)
+
+
+class _TextExtractor(HTMLParser):
+    def __init__(self) -> None:
+        super().__init__(convert_charrefs=True)
+        self.parts: list[str] = []
+        self._skip = 0
+
+    def handle_starttag(self, tag: str, attrs: Any) -> None:
+        if tag in {"script", "style"}:
+            self._skip += 1
+        elif tag in {"br", "p", "div", "li", "tr", "h1", "h2", "h3"}:
+            self.parts.append("\n")
+
+    def handle_endtag(self, tag: str) -> None:
+        if tag in {"script", "style"} and self._skip:
+            self._skip -= 1
+
+    def handle_data(self, data: str) -> None:
+        if not self._skip:
+            self.parts.append(data)
+
+
+def html_to_text(html: str | None, limit: int | None = BODY_LIMIT) -> str | None:
+    """Flatten feed HTML into plain-text summary"""
+    if not html:
+        return None
+    parser = _TextExtractor()
+    try:
+        parser.feed(html)
+        parser.close()
+    except Exception:
+        parser.parts = [re.sub(r"<[^>]+>", " ", html)]
+    text = "".join(parser.parts)
+    text = re.sub(r"[ \t\r\f\v]+", " ", text)
+    text = re.sub(r"\n\s*\n+", "\n", text).strip()
+    if not text:
+        return None
+    if limit and len(text) > limit:
+        text = text[: limit - 1].rstrip() + "…"
+    return text
+
+
+def entry_datetime(entry: Any) -> datetime | None:
+    for key in ("published_parsed", "updated_parsed", "created_parsed"):
+        parsed = entry.get(key)
+        if parsed:
+            # feedparser normalizes struct_time to UTC
+            return datetime(*parsed[:6], tzinfo=timezone.utc)
+    return None
+
+
+def entry_body(entry: Any) -> str | None:
+    content = entry.get("content")
+    if content and isinstance(content, list) and content[0].get("value"):
+        return html_to_text(content[0]["value"])
+    return html_to_text(entry.get("summary"))
+
+
+def parse_feed(
+    content: bytes,
+    *,
+    source: str,
+    target: str,
+    limit: int | None = 20,
+    version_of: Callable[[Any], str | None] | None = None,
+    tags: tuple[str, ...] = (),
+) -> list[Update]:
+    """Turn feed bytes into Updates, newest first."""
+    parsed = feedparser.parse(content)
+    updates: list[Update] = []
+
+    for entry in parsed.entries[: limit or None]:
+        link = entry.get("link") or ""
+        title = (entry.get("title") or "").strip() or "(untitled)"
+        uid = entry.get("id") or link or f"{title}|{entry.get('published', '')}"
+        updates.append(
+            Update(
+                source=source,
+                target=target,
+                uid=str(uid),
+                title=title,
+                url=link,
+                published=entry_datetime(entry),
+                version=version_of(entry) if version_of else None,
+                body=entry_body(entry),
+                tags=tags,
+            )
+        )
+
+    # Undated entries sort last
+    updates.sort(key=lambda u: u.published or _UNDATED, reverse=True)
+    return updates

youpdated/sources/generic.py

@@ -0,0 +1,76 @@
+"""Any RSS or Atom feed
+
+    sources:
+      feed:
+        - https://blog.rust-lang.org/feed.xml
+        - url: https://github.com/obsidianmd/obsidian-releases/releases.atom
+          name: Obsidian
+"""
+
+from __future__ import annotations
+
+import re
+from typing import Any, ClassVar, Iterable
+from urllib.parse import urlsplit
+
+import feedparser
+
+from ..http import Client
+from ..models import Target, Update
+from ..registry import register
+from .base import ConfigEntryError, entry_fields, require
+from .feed import parse_feed
+
+MAX_ITEMS = 20
+VERSION_RE = re.compile(r"\bv?(\d+\.\d+[\d.]*(?:-[A-Za-z0-9.]+)?)\b")
+
+
+@register
+class FeedSource:
+    name: ClassVar[str] = "feed"
+    summary: ClassVar[str] = "Any RSS or Atom feed, for apps without a dedicated source"
+
+    def targets(self, entries: list[Any]) -> list[Target]:
+        targets = []
+        for entry in entries:
+            fields = entry_fields(entry, "url", self.name)
+            url = str(require(fields, "url", self.name)).strip()
+            parts = urlsplit(url)
+            if parts.scheme not in ("http", "https") or not parts.netloc:
+                raise ConfigEntryError(
+                    f"sources.{self.name}: `{url}` is not an http(s) feed URL"
+                )
+            targets.append(
+                Target(
+                    source=self.name,
+                    key=url,
+                    label=fields.get("name"),
+                    params={"limit": int(fields.get("limit") or MAX_ITEMS)},
+                )
+            )
+        return targets
+
+    def fetch(self, target: Target, client: Client) -> Iterable[Update]:
+        fetched = client.get(target.key, conditional=True)
+        if fetched is None:
+            return []
+
+        # Prefer the feed's title over raw URL
+        if not target.label:
+            parsed = feedparser.parse(fetched.content)
+            title = (parsed.feed or {}).get("title")
+            target.label = title.strip() if title else urlsplit(target.key).netloc
+
+        return parse_feed(
+            fetched.content,
+            source=self.name,
+            target=target.key,
+            limit=target.params["limit"],
+            version_of=_version_from_title,
+            tags=("item",),
+        )
+
+
+def _version_from_title(entry: Any) -> str | None:
+    match = VERSION_RE.search(entry.get("title") or "")
+    return match.group(1) if match else None