led-ticker-rss 0.2.0__tar.gz

led_ticker_rss-0.2.0/.gitignore

@@ -0,0 +1,12 @@
+.venv/
+__pycache__/
+*.py[cod]
+*.egg-info/
+dist/
+build/
+.pytest_cache/
+.ruff_cache/
+.coverage
+.coverage.*
+htmlcov/
+.env

led_ticker_rss-0.2.0/CLAUDE.md

@@ -0,0 +1,58 @@
+# CLAUDE.md
+
+Guidance for Claude Code when working in **led-ticker-rss**, an external plugin for
+[led-ticker](https://github.com/JamesAwesome/led-ticker).
+
+`README.md` is the source of truth for the user-facing surface (config options, install).
+This file keeps the **load-bearing invariants** a contributor must respect.
+
+## Overview
+
+This plugin contributes, via the `led_ticker.plugins` entry point, a single widget:
+
+- `rss.feed` — an RSS/Atom headline Container backed by `RSSFeedMonitor`
+  (`src/led_ticker_rss/rss.py`). It polls a feed URL in the background and expands each
+  story into its own scrolling `TickerMessage`; the engine re-reads `feed_stories` on every
+  pass so live updates surface within one cycle.
+
+The entry-point name `rss` is the plugin namespace, so the config `type` is `rss.feed`.
+`register()` in `__init__.py` calls `api.widget("feed")(RSSFeedMonitor)`.
+
+This package split out of `led-ticker-feeds` (was `feeds.rss`); history is preserved.
+
+## Load-bearing invariants
+
+- **Public surface only:** `rss.py` imports ONLY from `led_ticker.plugin` (plus stdlib +
+  `aiohttp` + `attrs` + `feedparser`). Never reach into `led_ticker.<internal>`. Enforced by
+  `tests/test_import_purity.py` (AST scan of `src/led_ticker_rss`).
+- **Deps:** `aiohttp` (fetch) and `feedparser>=6.0` (parse). `feedparser` is rss-only — it is
+  NOT a weather dep.
+- **No `from __future__ import annotations`** (Python 3.14 / PEP 649 rule, same as core).
+
+## Commands
+
+led-ticker is **not on PyPI**; it resolves from a sibling checkout via the monorepo root
+`[tool.uv.sources]`. The rgbmatrix stub is vendored at the monorepo root and put on the
+import path by the **root** `pyproject.toml`. Run tooling from the repo root:
+
+```bash
+uv sync --extra dev
+uv run pytest plugins/rss
+uv run ruff check plugins/rss
+uv run pyright plugins/rss/src
+```
+
+Python **3.14+** only.
+
+## Package layout
+
+```
+src/led_ticker_rss/
+  __init__.py   # register(api) → api.widget("feed")(RSSFeedMonitor)
+  rss.py        # RSSFeedMonitor (Container): update() pulls + parses the feed
+tests/
+  test_rss.py            # widget behavior
+  test_import_purity.py  # AST: only led_ticker.plugin imports
+  test_smoke.py          # entry-point registers rss.feed
+  conftest.py            # shared canvas / make_widget fixtures
+```

led_ticker_rss-0.2.0/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 James Awesome
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

led_ticker_rss-0.2.0/PKG-INFO

@@ -0,0 +1,82 @@
+Metadata-Version: 2.4
+Name: led-ticker-rss
+Version: 0.2.0
+Summary: RSS/Atom headline widget for led-ticker (rss.feed).
+Project-URL: Homepage, https://docs.ledticker.dev
+Project-URL: Repository, https://github.com/JamesAwesome/led-ticker-plugins
+Project-URL: Issues, https://github.com/JamesAwesome/led-ticker-plugins/issues
+Author-email: James Awesome <james@morelli.nyc>
+License-Expression: MIT
+License-File: LICENSE
+Classifier: Development Status :: 4 - Beta
+Classifier: Operating System :: POSIX :: Linux
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.14
+Classifier: Topic :: Multimedia :: Graphics
+Requires-Python: >=3.14
+Requires-Dist: aiohttp
+Requires-Dist: feedparser>=6.0
+Requires-Dist: led-ticker-core>=2.0
+Provides-Extra: dev
+Requires-Dist: pre-commit>=4.0; extra == 'dev'
+Requires-Dist: pyright>=1.1; extra == 'dev'
+Requires-Dist: pytest-asyncio>=0.23; extra == 'dev'
+Requires-Dist: pytest-cov>=5.0; extra == 'dev'
+Requires-Dist: pytest>=8.0; extra == 'dev'
+Requires-Dist: ruff>=0.4; extra == 'dev'
+Description-Content-Type: text/markdown
+
+# led-ticker-rss
+
+An RSS/Atom headline **plugin** for [led-ticker](https://github.com/JamesAwesome/led-ticker). It contributes a single `rss.feed` widget that polls a feed URL and scrolls each story headline across the panel as its own ticker message.
+
+This package split out of `led-ticker-feeds` (its `feeds.rss` widget); the type is now `rss.feed`.
+
+## Prerequisites
+
+- A working [led-ticker](https://github.com/JamesAwesome/led-ticker) install.
+- Internet access on the Pi (the widget fetches the feed URL).
+
+## Install
+
+The widget auto-registers via the `led_ticker.plugins` entry point — once the package is installed, no `[plugins]` config change is needed.
+
+**Into a containerized led-ticker (recommended):** add this package to `config/requirements-plugins.txt` (copy it from `config/requirements-plugins.example.txt`), then rebuild:
+
+```text
+git+https://github.com/JamesAwesome/led-ticker-plugins.git@rss-v0.2.0#subdirectory=plugins/rss
+```
+
+```bash
+# in your led-ticker checkout
+docker compose up -d --build
+```
+
+**Standalone (a venv that already has led-ticker):**
+
+```bash
+pip install "git+https://github.com/JamesAwesome/led-ticker-plugins.git@rss-v0.2.0#subdirectory=plugins/rss"
+```
+
+led-ticker isn't on PyPI, so this path only works where led-ticker is already installed. See the led-ticker [Plugins docs](https://docs.ledticker.dev/plugins/) for the constraint-based install the Docker image uses.
+
+## Configuration
+
+```toml
+[[sections]]
+[[sections.widgets]]
+type = "rss.feed"
+url = "https://feeds.bbci.co.uk/news/rss.xml"
+```
+
+The widget is a Container: it pulls the feed in the background and expands each story into its own scrolling `TickerMessage`, so live updates surface within one display cycle.
+
+## Development
+
+This package lives in the [led-ticker-plugins](https://github.com/JamesAwesome/led-ticker-plugins) monorepo. Run tooling from the repo root:
+
+```bash
+uv sync --extra dev
+uv run pytest plugins/rss
+uv run ruff check plugins/rss
+```

led_ticker_rss-0.2.0/README.md

@@ -0,0 +1,54 @@
+# led-ticker-rss
+
+An RSS/Atom headline **plugin** for [led-ticker](https://github.com/JamesAwesome/led-ticker). It contributes a single `rss.feed` widget that polls a feed URL and scrolls each story headline across the panel as its own ticker message.
+
+This package split out of `led-ticker-feeds` (its `feeds.rss` widget); the type is now `rss.feed`.
+
+## Prerequisites
+
+- A working [led-ticker](https://github.com/JamesAwesome/led-ticker) install.
+- Internet access on the Pi (the widget fetches the feed URL).
+
+## Install
+
+The widget auto-registers via the `led_ticker.plugins` entry point — once the package is installed, no `[plugins]` config change is needed.
+
+**Into a containerized led-ticker (recommended):** add this package to `config/requirements-plugins.txt` (copy it from `config/requirements-plugins.example.txt`), then rebuild:
+
+```text
+git+https://github.com/JamesAwesome/led-ticker-plugins.git@rss-v0.2.0#subdirectory=plugins/rss
+```
+
+```bash
+# in your led-ticker checkout
+docker compose up -d --build
+```
+
+**Standalone (a venv that already has led-ticker):**
+
+```bash
+pip install "git+https://github.com/JamesAwesome/led-ticker-plugins.git@rss-v0.2.0#subdirectory=plugins/rss"
+```
+
+led-ticker isn't on PyPI, so this path only works where led-ticker is already installed. See the led-ticker [Plugins docs](https://docs.ledticker.dev/plugins/) for the constraint-based install the Docker image uses.
+
+## Configuration
+
+```toml
+[[sections]]
+[[sections.widgets]]
+type = "rss.feed"
+url = "https://feeds.bbci.co.uk/news/rss.xml"
+```
+
+The widget is a Container: it pulls the feed in the background and expands each story into its own scrolling `TickerMessage`, so live updates surface within one display cycle.
+
+## Development
+
+This package lives in the [led-ticker-plugins](https://github.com/JamesAwesome/led-ticker-plugins) monorepo. Run tooling from the repo root:
+
+```bash
+uv sync --extra dev
+uv run pytest plugins/rss
+uv run ruff check plugins/rss
+```

led_ticker_rss-0.2.0/pyproject.toml

@@ -0,0 +1,57 @@
+[project]
+name = "led-ticker-rss"
+version = "0.2.0"
+description = "RSS/Atom headline widget for led-ticker (rss.feed)."
+readme = "README.md"
+license = "MIT"
+license-files = ["LICENSE"]
+requires-python = ">=3.14"
+authors = [{ name = "James Awesome", email = "james@morelli.nyc" }]
+classifiers = [
+    "Development Status :: 4 - Beta",
+    "Programming Language :: Python :: 3",
+    "Programming Language :: Python :: 3.14",
+    "Operating System :: POSIX :: Linux",
+    "Topic :: Multimedia :: Graphics",
+]
+dependencies = [
+    "led-ticker-core>=2.0",
+    "aiohttp",
+    "feedparser>=6.0",
+]
+
+# Entry-point NAME ("rss") is the plugin namespace -> TOML `type = "rss.feed"`.
+[project.entry-points."led_ticker.plugins"]
+rss = "led_ticker_rss:register"
+
+[project.optional-dependencies]
+dev = [
+    "pytest>=8.0",
+    "pytest-asyncio>=0.23",
+    "pytest-cov>=5.0",
+    "pre-commit>=4.0",
+    "ruff>=0.4",
+    "pyright>=1.1",
+]
+
+[project.urls]
+Homepage = "https://docs.ledticker.dev"
+Repository = "https://github.com/JamesAwesome/led-ticker-plugins"
+Issues = "https://github.com/JamesAwesome/led-ticker-plugins/issues"
+
+[build-system]
+requires = ["hatchling"]
+build-backend = "hatchling.build"
+
+[tool.hatch.build.targets.wheel]
+packages = ["src/led_ticker_rss"]
+
+[tool.ruff]
+target-version = "py314"
+src = ["src"]
+
+[tool.ruff.lint]
+select = ["E", "F", "I", "UP", "B", "SIM"]
+
+[tool.coverage.report]
+fail_under = 90

led_ticker_rss-0.2.0/src/led_ticker_rss/__init__.py

@@ -0,0 +1,12 @@
+"""led-ticker-rss: RSS/Atom headline widget (rss.feed) contributed via the
+``led_ticker.plugins`` entry point.
+
+The entry-point name ``rss`` is the plugin namespace, so the widget is
+referenced in config.toml as ``type = "rss.feed"``.
+"""
+
+from led_ticker_rss.rss import RSSFeedMonitor
+
+
+def register(api):
+    api.widget("feed")(RSSFeedMonitor)

led_ticker_rss-0.2.0/src/led_ticker_rss/rss.py

@@ -0,0 +1,91 @@
+"""RSS feed monitor widget."""
+
+import asyncio
+import itertools
+import logging
+from typing import Any, Self
+
+import aiohttp
+import attrs
+import feedparser
+from led_ticker.plugin import (
+    FONT_DEFAULT,
+    Color,
+    Font,
+    TickerMessage,
+    run_monitor_loop,
+    spawn_tracked,
+)
+from led_ticker.plugin import (
+    colors as _colors,
+)
+
+logger: logging.Logger = logging.getLogger(__name__)
+
+
+@attrs.define
+class RSSFeedMonitor:
+    """Fetches and displays headlines from an RSS feed."""
+
+    session: aiohttp.ClientSession
+    feed_url: str
+    padding: int = 6
+    colors: itertools.cycle[Color] = attrs.Factory(
+        lambda: itertools.cycle([_colors.DEFAULT_COLOR, _colors.RED, _colors.GREEN])
+    )
+    max_stories: int = 5
+    # When set, every story TickerMessage gets this color/provider
+    # (e.g. `font_color = "rainbow"` paints all stories rainbow).
+    # When unset (None), fall back to the legacy 3-color rotation
+    # (DEFAULT_COLOR / RED / GREEN) so existing configs keep working.
+    font_color: Any = attrs.field(default=None, kw_only=True)
+    bg_color: Color | None = attrs.field(default=None, kw_only=True)
+    font: Font = attrs.field(default=attrs.Factory(lambda: FONT_DEFAULT), kw_only=True)
+    feed_title: TickerMessage | None = attrs.field(init=False, default=None)
+    feed_stories: list[TickerMessage] = attrs.field(init=False, factory=list)
+
+    def _story_color(self) -> Any:
+        """Per-story color: `font_color` if set, else next from the
+        legacy cycle. Called once per story in `update()`."""
+        if self.font_color is not None:
+            return self.font_color
+        return next(self.colors)
+
+    @classmethod
+    async def start(
+        cls,
+        session: aiohttp.ClientSession,
+        feed_url: str,
+        update_interval: int = 1800,
+        **kwargs: Any,
+    ) -> Self:
+        widget = cls(session=session, feed_url=feed_url, **kwargs)
+        await widget.update()
+        spawn_tracked(run_monitor_loop(widget, update_interval))
+        return widget
+
+    async def update(self) -> None:
+        logger.info("Updating RSS Feed from: %s", self.feed_url)
+        async with self.session.get(self.feed_url) as response:
+            feed_data = await response.text()
+            feed = await asyncio.to_thread(feedparser.parse, feed_data)
+            self.feed_title = TickerMessage(
+                feed["channel"]["title"],  # type: ignore[index]
+                font=self.font,
+                font_color=self._story_color(),
+                bg_color=self.bg_color,
+            )
+            self.feed_stories = [
+                TickerMessage(
+                    item["title"],  # type: ignore[index]
+                    font=self.font,
+                    font_color=self._story_color(),
+                    bg_color=self.bg_color,
+                )
+                for item in itertools.islice(feed["items"], self.max_stories)  # type: ignore[index]
+            ]
+        logger.info(
+            "RSS %s updated: %d stories",
+            self.feed_url,
+            len(self.feed_stories),
+        )

led_ticker_rss-0.2.0/tests/conftest.py

@@ -0,0 +1,35 @@
+"""Shared test fixtures for the led-ticker-rss plugin test suite.
+
+The rgbmatrix stub is on the pytest path via ``pythonpath`` in
+``pyproject.toml`` (``../led-ticker/tests/stubs``). The plugin doesn't ship
+core's conftest, so re-provide the small fixtures the ported tests use.
+"""
+
+import unittest.mock as mock
+
+import pytest
+
+
+@pytest.fixture
+def canvas():
+    """Mock LED canvas with standard width and height."""
+    c = mock.Mock()
+    c.width = 160
+    c.height = 16
+    return c
+
+
+@pytest.fixture
+def make_widget():
+    """Factory for mock widgets with configurable draw width."""
+
+    def _factory(content_width=40):
+        widget = mock.Mock()
+        widget.hold_time = 0.0
+        widget.draw.side_effect = lambda c, cursor_pos=0, **kw: (
+            c,
+            cursor_pos + content_width,
+        )
+        return widget
+
+    return _factory

led_ticker_rss-0.2.0/tests/test_import_purity.py

@@ -0,0 +1,29 @@
+import ast
+import pathlib
+
+SRC = pathlib.Path(__file__).resolve().parents[1] / "src" / "led_ticker_rss"
+
+
+def _led_ticker_imports(path):
+    tree = ast.parse(path.read_text(), filename=str(path))
+    names = []
+    for node in ast.walk(tree):
+        if isinstance(node, ast.ImportFrom) and node.module:
+            if node.module.split(".")[0] == "led_ticker":
+                names.append(node.module)
+        elif isinstance(node, ast.Import):
+            for alias in node.names:
+                if alias.name.split(".")[0] == "led_ticker":
+                    names.append(alias.name)
+    return names
+
+
+def test_plugin_imports_only_public_surface():
+    offenders = {}
+    for py in SRC.rglob("*.py"):
+        bad = [m for m in _led_ticker_imports(py) if m != "led_ticker.plugin"]
+        if bad:
+            offenders[py.name] = bad
+    assert not offenders, (
+        f"modules import led_ticker internals instead of led_ticker.plugin: {offenders}"
+    )

led_ticker_rss-0.2.0/tests/test_rss.py

@@ -0,0 +1,215 @@
+"""Tests for led_ticker_rss.rss."""
+
+import unittest.mock as mock
+
+import feedparser as _feedparser
+import pytest
+from led_ticker.widgets.message import TickerMessage
+
+from led_ticker_rss.rss import RSSFeedMonitor
+
+SAMPLE_RSS = """<?xml version="1.0" encoding="UTF-8"?>
+<rss version="2.0">
+  <channel>
+    <title>Test Feed</title>
+    <item><title>Story One</title></item>
+    <item><title>Story Two</title></item>
+    <item><title>Story Three</title></item>
+  </channel>
+</rss>
+"""
+
+
+@pytest.fixture
+def mock_session():
+    session = mock.MagicMock()
+    response = mock.AsyncMock()
+    response.text.return_value = SAMPLE_RSS
+
+    # Create a proper async context manager
+    ctx = mock.AsyncMock()
+    ctx.__aenter__.return_value = response
+    session.get.return_value = ctx
+    return session
+
+
+class TestRSSFeedMonitor:
+    async def test_update_parses_feed(self, mock_session):
+        monitor = RSSFeedMonitor(
+            session=mock_session, feed_url="http://example.com/rss"
+        )
+        await monitor.update()
+
+        assert isinstance(monitor.feed_title, TickerMessage)
+        assert monitor.feed_title.text == "Test Feed"
+        assert len(monitor.feed_stories) == 3
+        assert monitor.feed_stories[0].text == "Story One"
+
+    async def test_update_respects_max_stories(self, mock_session):
+        monitor = RSSFeedMonitor(
+            session=mock_session, feed_url="http://example.com/rss", max_stories=2
+        )
+        await monitor.update()
+        assert len(monitor.feed_stories) == 2
+
+    async def test_stories_are_ticker_messages(self, mock_session):
+        monitor = RSSFeedMonitor(
+            session=mock_session, feed_url="http://example.com/rss"
+        )
+        await monitor.update()
+        for story in monitor.feed_stories:
+            assert isinstance(story, TickerMessage)
+
+    async def test_font_propagates_to_stories(self, mock_session):
+        """font= on RSSFeedMonitor must flow to every generated TickerMessage."""
+        from led_ticker.fonts import resolve_font
+
+        custom_font = resolve_font("Inter-Regular", 16, threshold=80)
+        monitor = RSSFeedMonitor(
+            session=mock_session,
+            feed_url="http://example.com/rss",
+            font=custom_font,
+        )
+        await monitor.update()
+
+        assert monitor.feed_title.font is custom_font
+        assert all(s.font is custom_font for s in monitor.feed_stories)
+
+    async def test_font_defaults_to_font_default(self, mock_session):
+        """No font= specified → stories use FONT_DEFAULT (back-compat)."""
+        from led_ticker.fonts import FONT_DEFAULT
+
+        monitor = RSSFeedMonitor(
+            session=mock_session, feed_url="http://example.com/rss"
+        )
+        await monitor.update()
+
+        assert monitor.feed_title.font is FONT_DEFAULT
+        assert all(s.font is FONT_DEFAULT for s in monitor.feed_stories)
+
+
+class TestRssBgColor:
+    def test_field_exists(self):
+        names = {a.name for a in RSSFeedMonitor.__attrs_attrs__}
+        assert "bg_color" in names
+
+    def test_bg_color_propagates_to_stories(self, mock_session):
+        """bg_color set on the container propagates to every story
+        TickerMessage in feed_stories."""
+        from rgbmatrix.graphics import Color
+
+        bg = Color(40, 50, 60)
+        feed = RSSFeedMonitor(
+            session=mock_session, feed_url="https://example.com/feed", bg_color=bg
+        )
+        # Manually populate stories the way update() would. Bypass network.
+        feed.feed_title = TickerMessage(text="Title", bg_color=bg)
+        feed.feed_stories = [
+            TickerMessage(text=item, bg_color=bg) for item in ("a", "b", "c")
+        ]
+
+        assert feed.bg_color is bg
+        assert feed.feed_title.bg_color is bg
+        assert all(s.bg_color is bg for s in feed.feed_stories)
+
+    async def test_update_threads_bg_color(self, mock_session):
+        """After update(), every story and the title carry bg_color."""
+        from rgbmatrix.graphics import Color
+
+        bg = Color(40, 50, 60)
+        feed = RSSFeedMonitor(
+            session=mock_session, feed_url="https://example.com/feed", bg_color=bg
+        )
+        await feed.update()
+
+        assert feed.feed_title is not None
+        assert feed.feed_title.bg_color is bg
+        assert all(s.bg_color is bg for s in feed.feed_stories)
+
+
+class TestRssFontColor:
+    """`font_color` overrides the legacy 3-color cycle. When set, every
+    story TickerMessage gets the same color/provider; when unset
+    (None), fall back to the legacy rotation."""
+
+    async def test_font_color_unset_uses_legacy_cycle(self, mock_session):
+        """Default behavior: stories cycle through the 3 legacy colors."""
+        feed = RSSFeedMonitor(session=mock_session, feed_url="https://example.com/feed")
+        await feed.update()
+
+        # Three distinct stories → three distinct cycle colors. The
+        # exact values come from DEFAULT_COLOR / DOWN / UP cycling.
+        colors = [s.font_color for s in feed.feed_stories]
+        # All three should be distinct (cycle has 3 entries, 3 stories).
+        assert len({(c._color.red, c._color.green, c._color.blue) for c in colors}) == 3
+
+    async def test_font_color_set_applies_to_all_stories(self, mock_session):
+        """`font_color = Rainbow()` → every story gets the same provider."""
+        from led_ticker.color_providers import Rainbow
+
+        rainbow = Rainbow()
+        feed = RSSFeedMonitor(
+            session=mock_session,
+            feed_url="https://example.com/feed",
+            font_color=rainbow,
+        )
+        await feed.update()
+
+        assert feed.feed_title is not None
+        # Title + every story shares the same provider instance.
+        assert feed.feed_title.font_color is rainbow
+        assert all(s.font_color is rainbow for s in feed.feed_stories)
+
+
+class TestFeedparserOffEventLoop:
+    """feedparser.parse is CPU-bound XML parsing. Calling it directly on
+    the event loop blocks all other coroutines for the full parse duration.
+    It must be offloaded via asyncio.to_thread (C2)."""
+
+    async def test_feedparser_called_via_to_thread(self, mock_session, monkeypatch):
+        """asyncio.to_thread must be called with feedparser.parse and the
+        raw feed text — not feedparser.parse called directly."""
+        calls: list[tuple] = []
+
+        async def _fake_to_thread(func, *args, **kwargs):
+            calls.append((func, args, kwargs))
+            return func(*args, **kwargs)
+
+        monkeypatch.setattr("led_ticker_rss.rss.asyncio.to_thread", _fake_to_thread)
+
+        monitor = RSSFeedMonitor(
+            session=mock_session, feed_url="http://example.com/rss"
+        )
+        await monitor.update()
+
+        assert len(calls) == 1, f"expected 1 to_thread call, got {len(calls)}: {calls}"
+        func, args, kwargs = calls[0]
+        assert func is _feedparser.parse, f"expected feedparser.parse, got {func}"
+        assert args == (SAMPLE_RSS,), f"expected (SAMPLE_RSS,), got {args}"
+
+
+class TestRSSFeedUpdateLogging:
+    """Periodic update() must log INFO so users can tell the background
+    task is firing.
+    """
+
+    async def test_rss_update_logs_info(self, mock_session, caplog) -> None:
+        import logging
+
+        from led_ticker_rss.rss import RSSFeedMonitor
+
+        widget = RSSFeedMonitor(
+            session=mock_session, feed_url="http://example.com/feed"
+        )
+
+        with caplog.at_level(logging.INFO, logger="led_ticker_rss.rss"):
+            await widget.update()
+
+        matching = [
+            r
+            for r in caplog.records
+            if r.levelno == logging.INFO
+            and "updated" in r.message
+            and str(len(widget.feed_stories)) in r.message
+        ]
+        assert matching, f"expected INFO log; got {[r.message for r in caplog.records]}"

led_ticker_rss-0.2.0/tests/test_smoke.py

@@ -0,0 +1,15 @@
+from led_ticker import _plugin_loader as L
+
+
+def test_entry_point_registers_rss_namespace():
+    L.reset_plugins()
+    try:
+        result = L.load_plugins(None, entry_points_enabled=True)
+        loaded = {info.namespace for info in result.loaded}
+        assert "rss" in loaded, f"rss plugin not discovered: {result}"
+
+        from led_ticker.widgets import get_widget_class
+
+        assert get_widget_class("rss.feed") is not None
+    finally:
+        L.reset_plugins()