led-ticker-weather 0.2.0__tar.gz

led_ticker_weather-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_weather-0.2.0/CLAUDE.md

@@ -0,0 +1,65 @@
+# CLAUDE.md
+
+Guidance for Claude Code when working in **led-ticker-weather**, 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:
+
+- `weather.current` — a current-conditions widget backed by `WeatherWidget`
+  (`src/led_ticker_weather/weather.py`). It fetches current conditions from
+  [WeatherAPI.com](https://www.weatherapi.com/) (key via the `WEATHERAPI_KEY` env var) and
+  draws the location label, temperature, and a condition icon.
+
+The entry-point name `weather` is the plugin namespace, so the config `type` is
+`weather.current`. `register()` in `__init__.py` calls `api.widget("current")(WeatherWidget)`.
+
+This package split out of `led-ticker-feeds` (was `feeds.weather`); history is preserved.
+
+## Load-bearing invariants
+
+- **Public surface only:** `weather.py` imports ONLY from `led_ticker.plugin` (plus stdlib +
+  `aiohttp` + `attrs`). Never reach into `led_ticker.<internal>`. Enforced by
+  `tests/test_import_purity.py` (AST scan of `src/led_ticker_weather`).
+- **Deps:** `aiohttp` only (no `feedparser` — that is an rss-only dep).
+- **Condition → icon mapping:** `_match_condition(condition) -> slug` is the icon resolver
+  (sun / cloud / rain / snow / thunder / fog; unknown defaults to sun). `test_weather_icons.py`
+  is the per-branch tripwire; `test_weather.py` asserts every slug it can return exists in both
+  the lowres and hires emoji registries.
+- **`WEATHERAPI_KEY`:** `test_weather.py` provides it via an autouse `monkeypatch.setenv`
+  fixture — never hardcode a real key. `test_weather_icons.py` calls the pure resolver and
+  needs no key.
+- **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/weather
+uv run ruff check plugins/weather
+uv run pyright plugins/weather/src
+```
+
+Python **3.14+** only.
+
+## Package layout
+
+```
+src/led_ticker_weather/
+  __init__.py   # register(api) → api.widget("current")(WeatherWidget)
+  weather.py    # WeatherWidget + _match_condition icon resolver
+tests/
+  test_weather.py        # widget behavior (autouse WEATHERAPI_KEY fixture)
+  test_weather_icons.py  # _match_condition per-branch tripwire
+  test_import_purity.py  # AST: only led_ticker.plugin imports
+  test_smoke.py          # entry-point registers weather.current
+  conftest.py            # shared canvas / make_widget fixtures
+```

led_ticker_weather-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_weather-0.2.0/PKG-INFO

@@ -0,0 +1,90 @@
+Metadata-Version: 2.4
+Name: led-ticker-weather
+Version: 0.2.0
+Summary: Current-conditions weather widget for led-ticker (weather.current).
+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: 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-weather
+
+A current-conditions weather **plugin** for [led-ticker](https://github.com/JamesAwesome/led-ticker), backed by [WeatherAPI.com](https://www.weatherapi.com/). It contributes a single `weather.current` widget that shows the location label, current temperature, and a condition icon.
+
+This package split out of `led-ticker-feeds` (its `feeds.weather` widget); the type is now `weather.current`.
+
+## Prerequisites
+
+- A working [led-ticker](https://github.com/JamesAwesome/led-ticker) install.
+- A free [WeatherAPI.com](https://www.weatherapi.com/) API key, exported as `WEATHERAPI_KEY`.
+- Internet access on the Pi (the widget calls the WeatherAPI.com API).
+
+## 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@weather-v0.2.0#subdirectory=plugins/weather
+```
+
+```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@weather-v0.2.0#subdirectory=plugins/weather"
+```
+
+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
+
+Set the API key in your `.env`:
+
+```text
+WEATHERAPI_KEY=your-key-here
+```
+
+Then add the widget:
+
+```toml
+[[sections]]
+[[sections.widgets]]
+type = "weather.current"
+location = "London"
+```
+
+The widget polls WeatherAPI.com in the background and renders the label, temperature, and a condition icon. Conditions map to icon slugs via `_match_condition` (sun / cloud / rain / snow / thunder / fog).
+
+## 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/weather
+uv run ruff check plugins/weather
+```

led_ticker_weather-0.2.0/README.md

@@ -0,0 +1,63 @@
+# led-ticker-weather
+
+A current-conditions weather **plugin** for [led-ticker](https://github.com/JamesAwesome/led-ticker), backed by [WeatherAPI.com](https://www.weatherapi.com/). It contributes a single `weather.current` widget that shows the location label, current temperature, and a condition icon.
+
+This package split out of `led-ticker-feeds` (its `feeds.weather` widget); the type is now `weather.current`.
+
+## Prerequisites
+
+- A working [led-ticker](https://github.com/JamesAwesome/led-ticker) install.
+- A free [WeatherAPI.com](https://www.weatherapi.com/) API key, exported as `WEATHERAPI_KEY`.
+- Internet access on the Pi (the widget calls the WeatherAPI.com API).
+
+## 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@weather-v0.2.0#subdirectory=plugins/weather
+```
+
+```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@weather-v0.2.0#subdirectory=plugins/weather"
+```
+
+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
+
+Set the API key in your `.env`:
+
+```text
+WEATHERAPI_KEY=your-key-here
+```
+
+Then add the widget:
+
+```toml
+[[sections]]
+[[sections.widgets]]
+type = "weather.current"
+location = "London"
+```
+
+The widget polls WeatherAPI.com in the background and renders the label, temperature, and a condition icon. Conditions map to icon slugs via `_match_condition` (sun / cloud / rain / snow / thunder / fog).
+
+## 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/weather
+uv run ruff check plugins/weather
+```

led_ticker_weather-0.2.0/pyproject.toml

@@ -0,0 +1,56 @@
+[project]
+name = "led-ticker-weather"
+version = "0.2.0"
+description = "Current-conditions weather widget for led-ticker (weather.current)."
+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",
+]
+
+# Entry-point NAME ("weather") is the plugin namespace -> TOML `type = "weather.current"`.
+[project.entry-points."led_ticker.plugins"]
+weather = "led_ticker_weather: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_weather"]
+
+[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_weather-0.2.0/src/led_ticker_weather/__init__.py

@@ -0,0 +1,12 @@
+"""led-ticker-weather: current-conditions widget (weather.current) contributed
+via the ``led_ticker.plugins`` entry point.
+
+The entry-point name ``weather`` is the plugin namespace, so the widget is
+referenced in config.toml as ``type = "weather.current"``.
+"""
+
+from led_ticker_weather.weather import WeatherWidget
+
+
+def register(api):
+    api.widget("current")(WeatherWidget)

led_ticker_weather-0.2.0/src/led_ticker_weather/weather.py

@@ -0,0 +1,281 @@
+"""Weather widget using WeatherAPI.com (weather.current)."""
+
+import logging
+import os
+from typing import Any, Self
+
+import aiohttp
+import attrs
+from led_ticker.plugin import (
+    FONT_DEFAULT,
+    Canvas,
+    Color,
+    ColorProvider,
+    DrawResult,
+    Font,
+    FrameAwareBase,
+    as_color_provider,
+    compute_baseline,
+    compute_cursor,
+    draw_emoji_at,
+    draw_text,
+    draw_text_per_char,
+    get_text_width,
+    make_color,
+    measure_emoji_at,
+    run_monitor_loop,
+    spawn_tracked,
+)
+from led_ticker.plugin import (
+    colors as _colors,
+)
+
+WEATHERAPI_URL: str = "https://api.weatherapi.com/v1/current.json"
+
+
+def _coerce_provider(value: Any) -> ColorProvider:
+    """Coerce a color field to a ColorProvider.
+
+    None -> default; an existing provider (has ``color_for``) -> as-is; a raw
+    [r, g, b] list/tuple -> ``as_color_provider(make_color(...))``; an existing
+    ``graphics.Color`` -> ``as_color_provider``. Config strings/tables (e.g.
+    "rainbow", {style=...}) are coerced into providers by the loader BEFORE
+    construction, so they arrive here already as providers and pass through.
+    """
+    if value is None:
+        return as_color_provider(_colors.DEFAULT_COLOR)
+    if hasattr(value, "color_for"):
+        return value
+    if isinstance(value, (list, tuple)):
+        return as_color_provider(make_color(*value))
+    return as_color_provider(value)  # already a graphics.Color
+
+
+def _match_condition(condition: str) -> str:
+    """Map a WeatherAPI condition string to an emoji slug."""
+    c = condition.lower()
+    if "thunder" in c:
+        return "thunder"
+    if "snow" in c or "blizzard" in c or "ice" in c or "sleet" in c:
+        return "snow"
+    if "rain" in c or "drizzle" in c or "shower" in c:
+        return "rain"
+    if "fog" in c or "mist" in c:
+        return "fog"
+    if "partly" in c:
+        return "partly_cloudy"
+    if "cloud" in c or "overcast" in c:
+        return "cloud"
+    # Sunny, Clear, or anything else
+    return "sun"
+
+
+@attrs.define
+class WeatherWidget(FrameAwareBase):
+    """Current weather display widget."""
+
+    session: aiohttp.ClientSession
+    location: str  # query string: "New York", "10001", "40.71,-74.01"
+    text: str
+    units: str = "imperial"
+    font: Font = attrs.Factory(lambda: FONT_DEFAULT)
+    font_color: Color | ColorProvider = attrs.Factory(lambda: _colors.DEFAULT_COLOR)
+    # WeatherWidget keeps two color knobs: `font_color` for the label
+    # (e.g. "Brooklyn:") and `font_color_temp` for the temperature
+    # value (e.g. "64°F"). They're separate so a config can color the
+    # label with an effect (`font_color = "rainbow"`) while keeping
+    # the temp value in a steady high-contrast color (default white).
+    # If you want the temp to also use the effect, set them both:
+    #   font_color = "rainbow"
+    #   font_color_temp = "rainbow"
+    font_color_temp: Color | ColorProvider = attrs.Factory(lambda: _colors.RGB_WHITE)
+    bg_color: Color | None = attrs.field(default=None, kw_only=True)
+    center: bool = True
+    padding: int = 6
+    hold_time: float = 0.0
+    show_icon: bool = True
+    unit_symbol: str = attrs.field(init=False, default="")
+    current_temp: int = attrs.field(init=False, default=0)
+    weather: str = attrs.field(init=False, default="")
+
+    def __attrs_post_init__(self) -> None:
+        # Normalize both color fields to ColorProvider instances. The loader
+        # pre-coerces rich config forms ("rainbow", {style=...}) into providers
+        # before construction, so _coerce_provider is an idempotent pass-through
+        # for those; raw graphics.Color / [r, g, b] values (e.g. from defaults or
+        # direct construction) get wrapped here.
+        self.font_color = _coerce_provider(self.font_color)
+        self.font_color_temp = _coerce_provider(self.font_color_temp)
+
+        # Support dict location from TOML: {lat = 40.71, lon = -74.01}
+        if isinstance(self.location, dict):
+            lat = self.location.get("lat", 0)
+            lon = self.location.get("lon", 0)
+            self.location = f"{lat},{lon}"
+
+        if self.units == "imperial":
+            self.unit_symbol = "F"
+        elif self.units == "metric":
+            self.unit_symbol = "C"
+
+    @classmethod
+    async def start(
+        cls, *args: Any, update_interval: int = 10800, **kwargs: Any
+    ) -> Self:
+        widget = cls(*args, **kwargs)
+        try:
+            await widget.update()
+        except Exception:
+            logging.exception(
+                "Weather initial update failed for %s, will retry in background",
+                widget.location,
+            )
+        spawn_tracked(run_monitor_loop(widget, update_interval))
+        return widget
+
+    async def update(self) -> None:
+        logging.info("Updating weather for: %s", self.location)
+        api_key = os.getenv("WEATHERAPI_KEY", "")
+        if not api_key:
+            raise ValueError("WEATHERAPI_KEY not set. Add it to your .env file.")
+        params = {
+            "key": api_key,
+            "q": self.location,
+        }
+        async with self.session.get(
+            WEATHERAPI_URL,
+            params=params,
+        ) as response:
+            data = await response.json()
+
+            # WeatherAPI returns {"error": {...}} on failure
+            if "error" in data:
+                code = data["error"].get("code", "?")
+                msg = data["error"].get("message", "Unknown error")
+                raise ValueError(f"WeatherAPI error {code}: {msg}")
+
+            current = data["current"]
+            if self.units == "imperial":
+                self.current_temp = int(current["temp_f"])
+            else:
+                self.current_temp = int(current["temp_c"])
+            self.weather = current["condition"]["text"]
+
+    def draw(
+        self,
+        canvas: Canvas,
+        cursor_pos: int = 0,
+        *,
+        y_offset: int = 0,
+        font_color: Any = None,
+    ) -> DrawResult:
+        temp_text = f"{self.current_temp}{self.unit_symbol}"
+        label_text = f"{self.text}: "
+
+        # Resolve the icon slug once and read its actual rendered footprint
+        # via `measure_emoji_at` — keeps layout in sync with whichever
+        # variant `draw_emoji_at` will pick (lowres on plain canvas,
+        # hires-when-available on a ScaledCanvas, falling back to lowres
+        # for slugs without a HIRES_REGISTRY entry like `partly_cloudy`).
+        # Reading the footprint dynamically scales correctly across
+        # per-section `scale` overrides — at scale=2 a hires sprite is 16
+        # logical wide, and a hardcoded `8` here would let the temperature
+        # text overlap the icon.
+        if self.show_icon:
+            content_width = (
+                get_text_width(self.font, label_text, padding=0, canvas=canvas)
+                + measure_emoji_at(canvas, _match_condition(self.weather))
+                + get_text_width(self.font, temp_text, padding=0, canvas=canvas)
+            )
+        else:
+            condition_text = f"{self.weather} "
+            content_width = get_text_width(
+                self.font,
+                f"{label_text}{condition_text}{temp_text}",
+                padding=0,
+                canvas=canvas,
+            )
+
+        cursor_pos, end_padding = compute_cursor(
+            canvas.width,
+            content_width,
+            cursor_pos,
+            self.padding,
+            center=self.center,
+        )
+
+        baseline_y = compute_baseline(self.font, canvas, valign="center") + y_offset
+
+        cursor_pos += self._draw_segment(
+            canvas,
+            cursor_pos,
+            baseline_y,
+            self.font_color,
+            label_text,
+            frame_count=self.frame_for("font_color"),
+        )
+
+        if self.show_icon:
+            # Bottom-anchor the condition icon at the text baseline (exact at
+            # any scale via draw_emoji_at's real-pixel bottom-anchor).
+            cursor_pos += draw_emoji_at(
+                canvas,
+                _match_condition(self.weather),
+                int(cursor_pos),
+                bottom_baseline=baseline_y,
+            )
+        else:
+            cursor_pos += self._draw_segment(
+                canvas,
+                cursor_pos,
+                baseline_y,
+                self.font_color,
+                f"{self.weather} ",
+                frame_count=self.frame_for("font_color"),
+            )
+
+        cursor_pos += self._draw_segment(
+            canvas,
+            cursor_pos,
+            baseline_y,
+            self.font_color_temp,
+            temp_text,
+            frame_count=self.frame_for("font_color_temp"),
+        )
+        cursor_pos += end_padding
+
+        return canvas, cursor_pos
+
+    def _draw_segment(
+        self,
+        canvas: Canvas,
+        x: int,
+        baseline_y: int,
+        provider: ColorProvider,
+        text: str,
+        frame_count: int,
+    ) -> int:
+        """Render one weather text segment (label / condition / temp).
+
+        Per-char providers (rainbow / gradient) iterate chars via
+        `draw_text_per_char` so each char renders with its own hue.
+        Whole-string providers (constant / color_cycle / random)
+        materialize once and use `draw_text`. Mirrors the per-char
+        dispatch in `TickerCountdown.draw` and image widgets'
+        `_draw_text` — without it, `font_color = "rainbow"` on
+        weather collapsed the label / condition / temp to a single
+        sweeping hue.
+        """
+        if provider.per_char:
+            return draw_text_per_char(
+                canvas,
+                self.font,
+                x,
+                baseline_y,
+                text,
+                lambda idx, total: provider.color_for(frame_count, idx, total),
+            )
+        color = provider.color_for(frame_count, 0, len(text) if text else 1)
+        # plugin draw_text signature: (canvas, font, text, x, y, color) → absolute x.
+        # Subtract starting x to return relative advance width.
+        return draw_text(canvas, self.font, text, x, baseline_y, color) - x

led_ticker_weather-0.2.0/tests/conftest.py

@@ -0,0 +1,35 @@
+"""Shared test fixtures for the led-ticker-weather 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_weather-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_weather"
+
+
+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_weather-0.2.0/tests/test_smoke.py

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