youpdated 0.2.0__tar.gz → 0.2.1__tar.gz

{youpdated-0.2.0 → youpdated-0.2.1}/CHANGELOG.md

@@ -4,6 +4,46 @@ All notable changes to this project are documented here. The format follows
 [Keep a Changelog](https://keepachangelog.com/en/1.1.0/), and this project adheres to
 [Semantic Versioning](https://semver.org/spec/v2.0.0.html).
 
+## [0.2.1] — 2026-08-25
+
+### Fixed
+
+- **The release workflow's `attach` job failed on v0.2.0 and has been removed.** It copied the
+  built artifacts onto the GitHub Release, but this repo has immutable releases enabled, which
+  freezes assets when the release is published — and the job runs after that, so it could only ever
+  fail (`HTTP 422: Cannot upload assets to an immutable release`). Publishing to PyPI was
+  unaffected; 0.2.0 shipped correctly. Releases from now on will not carry attached `.whl`/`.tar.gz`
+  files. Get them from PyPI, where they are covered by a signed PEP 740 attestation binding each
+  digest to this repository and workflow — a stronger guarantee than the copy the job was making.
+
+- **Targets sharing one upstream document lost their updates**
+  Every Brave channel is served by one GitHub releases document, and every Firefox channel by one
+  Mozilla JSON. Each channel fetched it separately, so the first stored an ETag and the rest were
+  answered `304 Not Modified` against that ETag moments later and reported *nothing*. With the
+  default `jitter`, per-host pacing serializes those requests, which is the case that loses: a
+  config watching five Firefox channels and three Brave channels reported 2 of 8. Under
+  concurrency it was non-deterministic: is a channel reported depended on thread timing, so a
+  loaded machine changed the result.
+
+  A run now reuses each document across the targets that share it (`Client.run_scope()`), so the
+  document is fetched once and every target sees it. The same config went from 8 requests
+  reporting 2 of 8 targets, to 2 requests reporting 8 of 8. (And 147 ms to 43 ms of wall time)
+  Outside a run the client is unchanged: one GET per call, and a 304 still means "nothing new".
+
+- **The YouTube official-feed path never set the channel label.** `_label_and_parse` did not do
+  the labelling it was supposed to, so a channel that answered on the primary path was reported by
+  its raw `@handle` while the Invidious and Data API fallbacks named it properly. The label now
+  comes from the feed on all three paths.
+
+- **`feed` sources parsed every feed twice**
+  A `feed:` entry given as a bare URL had no label, so `FeedSource.fetch` parsed the document once
+  to read the feed's own `<title>` and then handed the same bytes to `parse_feed`, which parsed
+  them again. Feed parsing is the most expensive part of a run, so this ~doubled the
+  CPU cost of every bare-URL feed. One parse now feeds both the label and the entries.
+
+  `parse_feed()` is unchanged for callers that only need entries; it is now a wrapper over the new
+  `parse_document()` / `parse_entries()` split in `youpdated.sources.feed`.
+
 ## [0.2.0] — 2026-08-19
 
 ### Added
@@ -106,6 +146,7 @@ First release.
 - Firefox publishes current versions, so it reports one item per channel.
 - Edge exposes release notes only for the stable and beta channels. (But like, it's Edge, why do you want to know when it updates?)
 
+[0.2.1]: https://github.com/Void1-1/youpdated/releases/tag/v0.2.1
 [0.2.0]: https://github.com/Void1-1/youpdated/releases/tag/v0.2.0
 [0.1.1]: https://github.com/Void1-1/youpdated/releases/tag/v0.1.1
 [0.1.0]: https://github.com/Void1-1/youpdated/releases/tag/v0.1.0

{youpdated-0.2.0 → youpdated-0.2.1}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: youpdated
-Version: 0.2.0
+Version: 0.2.1
 Summary: Simple update tracker for games, apps, and packages
 Author-email: Void1-1 <161782542+Void1-1@users.noreply.github.com>
 License-Expression: MIT

{youpdated-0.2.0 → youpdated-0.2.1}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "youpdated"
-version = "0.2.0"
+version = "0.2.1"
 description = "Simple update tracker for games, apps, and packages"
 readme = "README.md"
 requires-python = ">=3.11"

{youpdated-0.2.0 → youpdated-0.2.1}/youpdated/__init__.py

@@ -1,3 +1,3 @@
 """Youpdated, a simple update tracker."""
 
-__version__ = "0.2.0"
+__version__ = "0.2.1"

{youpdated-0.2.0 → youpdated-0.2.1}/youpdated/http.py

@@ -9,8 +9,9 @@ import random
 import socket
 import threading
 import time
+from contextlib import contextmanager
 from dataclasses import dataclass, field
-from typing import Any, Iterable, Sequence
+from typing import Any, Iterable, Iterator, Sequence
 from urllib.parse import urlsplit
 
 import httpx
@@ -127,6 +128,16 @@ class Client:
         self._host_last: dict[str, float] = {}
         self._registry_lock = threading.Lock()
 
+        # One upstream document can back several targets: every Brave channel lives
+        # in one releases feed, every Firefox channel in one JSON. Bodies fetched
+        # during this run are reused so those targets neither re-download the
+        # document nor lose it to a validator this same run stored.
+        self._run_bodies: dict[tuple[str, tuple[tuple[str, str], ...]], Fetched] = {}
+        self._bodies_lock = threading.Lock()
+        #: Only reuse bodies inside :meth:`run_scope`. A client used directly,
+        #: outside a run, keeps the plain one-GET-per-call contract.
+        self._run_active = False
+
         self._client = httpx.Client(
             proxy=self.privacy.proxy,
             timeout=self.privacy.timeout,
@@ -155,6 +166,22 @@ class Client:
             f"concurrency={self.privacy.concurrency} timeout={self.privacy.timeout}s"
         )
 
+    @contextmanager
+    def run_scope(self) -> "Iterator[Client]":
+        """Reuse each fetched document for the duration of one run.
+
+        Bodies are dropped again on exit so a client reused for a later run never serves stale data.
+        """
+        with self._bodies_lock:
+            self._run_bodies.clear()
+            self._run_active = True
+        try:
+            yield self
+        finally:
+            with self._bodies_lock:
+                self._run_bodies.clear()
+                self._run_active = False
+
     # internals
 
     def _user_agent(self) -> str:
@@ -176,6 +203,13 @@ class Client:
                     time.sleep(wait)
             self._host_last[host] = time.monotonic()
 
+    def _cached_body(
+        self, key: tuple[str, tuple[tuple[str, str], ...]]
+    ) -> "Fetched | None":
+        """The 200 body already fetched for this key during this run, if any."""
+        with self._bodies_lock:
+            return self._run_bodies.get(key) if self._run_active else None
+
     def note(self, message: str) -> None:
         if self.verbose and self._log:
             self._log(message)
@@ -204,6 +238,11 @@ class Client:
 
         soft = frozenset(soft_statuses)
         conditional = conditional and self.use_conditional
+        cache_key = (url, tuple(sorted((headers or {}).items())))
+        cached = self._cached_body(cache_key)
+        if cached is not None:
+            self.note(f"GET {url} -> reusing the copy already fetched this run")
+            return cached
         request_headers = {"User-Agent": self._user_agent()}
         if headers:
             request_headers.update(headers)
@@ -230,21 +269,34 @@ class Client:
             self.note(f"GET {url} -> {response.status_code}")
 
             if response.status_code == 304:
-                return None
+                # Normally "unchanged since your last run", so there is nothing to
+                # report. But if this run already holds the body, the validator we
+                # sent was our own from moments ago: hand back what we have. Only
+                # reachable when two threads race past the check above; the common
+                # case is served from the cache without a request at all.
+                return self._cached_body(cache_key)
 
             if response.status_code == 200:
+                result = Fetched(
+                    url=str(response.url),
+                    status=response.status_code,
+                    content=response.content,
+                    headers=dict(response.headers),
+                )
+                # Cache the body before publishing validator. A thread racing
+                # can only be answered 304 once the validator is stored, so this
+                # ordering guarantees the body is already there for it to fall back
+                # on.
+                with self._bodies_lock:
+                    if self._run_active:
+                        self._run_bodies[cache_key] = result
                 if conditional and self.state is not None:
                     self.state.remember_validators(
                         url,
                         response.headers.get("etag"),
                         response.headers.get("last-modified"),
                     )
-                return Fetched(
-                    url=str(response.url),
-                    status=response.status_code,
-                    content=response.content,
-                    headers=dict(response.headers),
-                )
+                return result
 
             if response.status_code in soft:
                 return Fetched(

{youpdated-0.2.0 → youpdated-0.2.1}/youpdated/runner.py

@@ -94,7 +94,8 @@ def run(
             return target, exc
 
     workers = max(1, min(config.privacy.concurrency, len(targets)))
-    with ThreadPoolExecutor(max_workers=workers) as pool:
+    # run_scope: targets that share an upstream document fetch it once between them
+    with client.run_scope(), ThreadPoolExecutor(max_workers=workers) as pool:
         for target, outcome in pool.map(work, targets):
             if isinstance(outcome, Exception):
                 result.errors.append(

{youpdated-0.2.0 → youpdated-0.2.1}/youpdated/sources/feed.py

@@ -75,8 +75,23 @@ def entry_body(entry: Any) -> str | None:
     return html_to_text(entry.get("summary"))
 
 
-def parse_feed(
-    content: bytes,
+def parse_document(content: bytes) -> Any:
+    """Parse feed bytes once.
+
+    Anything that needs both a feed's metadata and entries parses once and passes the result to
+    :func:`parse_entries`
+    """
+    return feedparser.parse(content)
+
+
+def feed_title(parsed: Any) -> str | None:
+    """The title the feed publishes for itself, or None if it has none."""
+    title = (parsed.feed or {}).get("title")
+    return title.strip() or None if title else None
+
+
+def parse_entries(
+    parsed: Any,
     *,
     source: str,
     target: str,
@@ -84,8 +99,7 @@ def parse_feed(
     version_of: Callable[[Any], str | None] | None = None,
     tags: tuple[str, ...] = (),
 ) -> list[Update]:
-    """Turn feed bytes into Updates, newest first."""
-    parsed = feedparser.parse(content)
+    """Turn an already-parsed feed into Updates, newest first."""
     updates: list[Update] = []
 
     for entry in parsed.entries[: limit or None]:
@@ -109,3 +123,23 @@ def parse_feed(
     # Undated entries sort last
     updates.sort(key=lambda u: u.published or _UNDATED, reverse=True)
     return updates
+
+
+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."""
+    return parse_entries(
+        parse_document(content),
+        source=source,
+        target=target,
+        limit=limit,
+        version_of=version_of,
+        tags=tags,
+    )

{youpdated-0.2.0 → youpdated-0.2.1}/youpdated/sources/generic.py

@@ -13,13 +13,11 @@ 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
+from .feed import feed_title, parse_document, parse_entries
 
 MAX_ITEMS = 20
 VERSION_RE = re.compile(r"\bv?(\d+\.\d+[\d.]*(?:-[A-Za-z0-9.]+)?)\b")
@@ -55,14 +53,16 @@ class FeedSource:
         if fetched is None:
             return []
 
+        # One parse feeds both the label and the entries; feedparser is the most
+        # expensive step in a run, and parsing the same bytes twice doubled it.
+        parsed = parse_document(fetched.content)
+
         # 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
+            target.label = feed_title(parsed) or urlsplit(target.key).netloc
 
-        return parse_feed(
-            fetched.content,
+        return parse_entries(
+            parsed,
             source=self.name,
             target=target.key,
             limit=target.params["limit"],

{youpdated-0.2.0 → youpdated-0.2.1}/youpdated/sources/youtube.py

@@ -22,7 +22,7 @@ from ..http import Client, FetchError
 from ..models import Target, Update
 from ..registry import register
 from .base import ConfigEntryError, entry_fields, require
-from .feed import parse_feed
+from .feed import feed_title, parse_document, parse_entries
 
 CHANNEL_ID_RE = re.compile(r"^UC[A-Za-z0-9_-]{22}$")
 PLAYLIST_ID_RE = re.compile(r"^(?:PL|UU|LL|FL|OL)[A-Za-z0-9_-]{10,}$")
@@ -116,7 +116,7 @@ class YouTubeSource:
             return []
         if fetched.status in (403, 404):
             raise FetchError(f"official feed returned {fetched.status} (likely blocked)")
-        return self._label_and_parse(target, fetched.content, via="feed")
+        return self._label_and_parse(target, fetched.content)
 
     # invidious
 
@@ -247,9 +247,14 @@ class YouTubeSource:
 
     # helpers
 
-    def _label_and_parse(self, target: Target, content: bytes, via: str) -> list[Update]:
-        updates = parse_feed(
-            content,
+    def _label_and_parse(self, target: Target, content: bytes) -> list[Update]:
+        parsed = parse_document(content)
+        # The Invidious and Data API paths both name the channel; take it from
+        # feed so the label does not depend on which path answered.
+        if not target.label:
+            target.label = feed_title(parsed)
+        updates = parse_entries(
+            parsed,
             source=self.name,
             target=target.key,
             limit=MAX_ITEMS,

{youpdated-0.2.0 → youpdated-0.2.1}/youpdated.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: youpdated
-Version: 0.2.0
+Version: 0.2.1
 Summary: Simple update tracker for games, apps, and packages
 Author-email: Void1-1 <161782542+Void1-1@users.noreply.github.com>
 License-Expression: MIT