statsbadge-railclock 0.1.0__tar.gz

statsbadge_railclock-0.1.0/.github/workflows/ci.yml

@@ -0,0 +1,16 @@
+name: CI
+
+# Lint, build and test against statsbadge from source, by statsbadge's own rules. The steps
+# are statsbadge's, so every extension is checked the same way.
+on:
+  push:
+    branches: [main]
+  pull_request:
+  workflow_dispatch:
+
+permissions:
+  contents: read
+
+jobs:
+  check:
+    uses: pimoroni/statsbadge/.github/workflows/extension.yml@main

statsbadge_railclock-0.1.0/.github/workflows/publish.yml

@@ -0,0 +1,38 @@
+name: Publish
+
+# Trusted publishing, so PyPI trusts this workflow over OIDC and no API token is stored
+# here. Configure it once at pypi.org/manage/project/statsbadge-railclock/settings/publishing/
+# with this repository, this filename and the `pypi` environment. The build is
+# statsbadge's; the publish has to stay here, since PyPI trusts a file by name.
+on:
+  release:
+    types: [published]
+  workflow_dispatch:
+
+permissions:
+  contents: read
+
+jobs:
+  build:
+    uses: pimoroni/statsbadge/.github/workflows/extension-build.yml@main
+
+  publish:
+    name: Publish to PyPI
+    needs: build
+    runs-on: ubuntu-latest
+    environment: pypi
+    permissions:
+      id-token: write # for trusted publishing
+
+    steps:
+      - uses: actions/download-artifact@v8
+        with:
+          name: dist
+          path: dist
+
+      # setup-uv publishes exact versions only, no major tag
+      - uses: astral-sh/setup-uv@v10.2.0
+        with:
+          version: "0.12.18"
+
+      - run: uv publish --trusted-publishing always dist/*

statsbadge_railclock-0.1.0/.gitignore

@@ -0,0 +1,8 @@
+__pycache__/
+*.pyc
+*.egg-info/
+.ruff_cache/
+build/
+dist/
+.venv/
+.DS_Store

statsbadge_railclock-0.1.0/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 Vincent Willcox
+
+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.

statsbadge_railclock-0.1.0/PKG-INFO

@@ -0,0 +1,73 @@
+Metadata-Version: 2.5
+Name: statsbadge-railclock
+Version: 0.1.0
+Summary: A Rail Clock page for statsbadge: the time inside two rings of sweeping chevrons
+Project-URL: Homepage, https://github.com/vwillcox/statsbadge-railclock
+Project-URL: Repository, https://github.com/vwillcox/statsbadge-railclock
+Project-URL: Issues, https://github.com/vwillcox/statsbadge-railclock/issues
+Author: Vincent Willcox
+License-Expression: MIT AND OFL-1.1
+License-File: LICENSE
+License-File: src/statsbadge_railclock/OFL-Inter.txt
+Requires-Python: >=3.11
+Requires-Dist: statsbadge>=3.0.0
+Description-Content-Type: text/markdown
+
+# statsbadge-railclock
+
+A Rail Clock page for [statsbadge](https://github.com/pimoroni/statsbadge) on the Tufty
+2350.
+
+![The Rail Clock on a Tufty 2350, one minute sped up four times](https://raw.githubusercontent.com/vwillcox/statsbadge-railclock/main/shots/railclock.gif)
+
+The time sits inside two red rings, and each ring carries one chevron of the double arrow.
+The outer chevron goes round clockwise and the inner one anticlockwise, each taking a
+minute per turn. They meet as the double arrow at the top on the minute, and again at the
+bottom on the half minute.
+
+The design follows Network Rail's Rail Clock (Design Bridge and Partners, 2025), as drawn
+by the clock tile of my FireTVDeparture departure board:
+
+- **Geometry:** rings of radius 82 and 74.5 in a 200-unit square, with a stroke of 3. The
+  chevron arms leave the ring at 27°. The face takes 88% of the page.
+- **Colours:** red `#d0202f` and time `#ececec`, on a `#0b0f14` tile with a `#182230`
+  border.
+- **Time:** `HH:MM` in Inter Bold, with Inter's tabular digits and the raised colon it uses
+  between digits.
+
+The badge keeps time off its own clock, set from the computer's, so the chevrons sweep
+smoothly and keep going if the computer goes away. Until the first time arrives, the page
+reads `--:--`.
+
+## Install
+
+```bash
+statsbadge ext add railclock
+statsbadge install            # badge on USB: puts the page on it
+```
+
+Or type `railclock` into the install box on the config page's **Extensions** tab, then
+run `statsbadge install` with the badge on USB. Then add a **Rail Clock** page. It has no
+settings.
+
+## The font
+
+`railclock_digits.af` is made from Inter, which is under the SIL Open Font License 1.1
+(see `src/statsbadge_railclock/OFL-Inter.txt`). To rebuild it from `InterVariable.ttf`:
+
+1. Fix it at weight 700 and optical size 32 with `fontTools.varLib.instancer`.
+2. Point the digits at their tabular forms (`zero.tf` to `nine.tf`) and `:` at
+   `colon.case.tf`.
+3. Pack it with statsbadge's `tools/make_text_font.py`:
+
+```bash
+uv run --group fonts python tools/make_text_font.py InterRailClock.ttf --wide \
+    --chars "0123456789:-H" --out railclock_digits.af
+```
+
+## Notes
+
+This project is not affiliated with or endorsed by Network Rail or National Rail. The
+double arrow symbol is a registered trademark.
+
+The code is MIT licensed; the font is OFL-1.1.

statsbadge_railclock-0.1.0/README.md

@@ -0,0 +1,58 @@
+# statsbadge-railclock
+
+A Rail Clock page for [statsbadge](https://github.com/pimoroni/statsbadge) on the Tufty
+2350.
+
+![The Rail Clock on a Tufty 2350, one minute sped up four times](https://raw.githubusercontent.com/vwillcox/statsbadge-railclock/main/shots/railclock.gif)
+
+The time sits inside two red rings, and each ring carries one chevron of the double arrow.
+The outer chevron goes round clockwise and the inner one anticlockwise, each taking a
+minute per turn. They meet as the double arrow at the top on the minute, and again at the
+bottom on the half minute.
+
+The design follows Network Rail's Rail Clock (Design Bridge and Partners, 2025), as drawn
+by the clock tile of my FireTVDeparture departure board:
+
+- **Geometry:** rings of radius 82 and 74.5 in a 200-unit square, with a stroke of 3. The
+  chevron arms leave the ring at 27°. The face takes 88% of the page.
+- **Colours:** red `#d0202f` and time `#ececec`, on a `#0b0f14` tile with a `#182230`
+  border.
+- **Time:** `HH:MM` in Inter Bold, with Inter's tabular digits and the raised colon it uses
+  between digits.
+
+The badge keeps time off its own clock, set from the computer's, so the chevrons sweep
+smoothly and keep going if the computer goes away. Until the first time arrives, the page
+reads `--:--`.
+
+## Install
+
+```bash
+statsbadge ext add railclock
+statsbadge install            # badge on USB: puts the page on it
+```
+
+Or type `railclock` into the install box on the config page's **Extensions** tab, then
+run `statsbadge install` with the badge on USB. Then add a **Rail Clock** page. It has no
+settings.
+
+## The font
+
+`railclock_digits.af` is made from Inter, which is under the SIL Open Font License 1.1
+(see `src/statsbadge_railclock/OFL-Inter.txt`). To rebuild it from `InterVariable.ttf`:
+
+1. Fix it at weight 700 and optical size 32 with `fontTools.varLib.instancer`.
+2. Point the digits at their tabular forms (`zero.tf` to `nine.tf`) and `:` at
+   `colon.case.tf`.
+3. Pack it with statsbadge's `tools/make_text_font.py`:
+
+```bash
+uv run --group fonts python tools/make_text_font.py InterRailClock.ttf --wide \
+    --chars "0123456789:-H" --out railclock_digits.af
+```
+
+## Notes
+
+This project is not affiliated with or endorsed by Network Rail or National Rail. The
+double arrow symbol is a registered trademark.
+
+The code is MIT licensed; the font is OFL-1.1.

statsbadge_railclock-0.1.0/pyproject.toml

@@ -0,0 +1,32 @@
+[project]
+name = "statsbadge-railclock"
+dynamic = ["version"]
+description = "A Rail Clock page for statsbadge: the time inside two rings of sweeping chevrons"
+readme = "README.md"
+authors = [
+    { name = "Vincent Willcox" },
+]
+license = "MIT AND OFL-1.1"
+license-files = ["LICENSE", "src/statsbadge_railclock/OFL-Inter.txt"]
+requires-python = ">=3.11"
+dependencies = ["statsbadge>=3.0.0"]
+
+[project.urls]
+Homepage = "https://github.com/vwillcox/statsbadge-railclock"
+Repository = "https://github.com/vwillcox/statsbadge-railclock"
+Issues = "https://github.com/vwillcox/statsbadge-railclock/issues"
+
+# The whole extension mechanism is this one entry point:
+[project.entry-points."statsbadge.sources"]
+railclock = "statsbadge_railclock:RailClock"
+
+# The tag is the version.
+[tool.hatch.version]
+source = "uv-dynamic-versioning"
+
+[tool.hatch.build.targets.wheel]
+packages = ["src/statsbadge_railclock"]
+
+[build-system]
+requires = ["hatchling", "uv-dynamic-versioning"]
+build-backend = "hatchling.build"

statsbadge_railclock-0.1.0/src/statsbadge_railclock/OFL-Inter.txt

@@ -0,0 +1,92 @@
+Copyright (c) 2016 The Inter Project Authors (https://github.com/rsms/inter)
+
+This Font Software is licensed under the SIL Open Font License, Version 1.1.
+This license is copied below, and is also available with a FAQ at:
+http://scripts.sil.org/OFL
+
+-----------------------------------------------------------
+SIL OPEN FONT LICENSE Version 1.1 - 26 February 2007
+-----------------------------------------------------------
+
+PREAMBLE
+The goals of the Open Font License (OFL) are to stimulate worldwide
+development of collaborative font projects, to support the font creation
+efforts of academic and linguistic communities, and to provide a free and
+open framework in which fonts may be shared and improved in partnership
+with others.
+
+The OFL allows the licensed fonts to be used, studied, modified and
+redistributed freely as long as they are not sold by themselves. The
+fonts, including any derivative works, can be bundled, embedded,
+redistributed and/or sold with any software provided that any reserved
+names are not used by derivative works. The fonts and derivatives,
+however, cannot be released under any other type of license. The
+requirement for fonts to remain under this license does not apply
+to any document created using the fonts or their derivatives.
+
+DEFINITIONS
+"Font Software" refers to the set of files released by the Copyright
+Holder(s) under this license and clearly marked as such. This may
+include source files, build scripts and documentation.
+
+"Reserved Font Name" refers to any names specified as such after the
+copyright statement(s).
+
+"Original Version" refers to the collection of Font Software components as
+distributed by the Copyright Holder(s).
+
+"Modified Version" refers to any derivative made by adding to, deleting,
+or substituting -- in part or in whole -- any of the components of the
+Original Version, by changing formats or by porting the Font Software to a
+new environment.
+
+"Author" refers to any designer, engineer, programmer, technical
+writer or other person who contributed to the Font Software.
+
+PERMISSION AND CONDITIONS
+Permission is hereby granted, free of charge, to any person obtaining
+a copy of the Font Software, to use, study, copy, merge, embed, modify,
+redistribute, and sell modified and unmodified copies of the Font
+Software, subject to the following conditions:
+
+1) Neither the Font Software nor any of its individual components,
+in Original or Modified Versions, may be sold by itself.
+
+2) Original or Modified Versions of the Font Software may be bundled,
+redistributed and/or sold with any software, provided that each copy
+contains the above copyright notice and this license. These can be
+included either as stand-alone text files, human-readable headers or
+in the appropriate machine-readable metadata fields within text or
+binary files as long as those fields can be easily viewed by the user.
+
+3) No Modified Version of the Font Software may use the Reserved Font
+Name(s) unless explicit written permission is granted by the corresponding
+Copyright Holder. This restriction only applies to the primary font name as
+presented to the users.
+
+4) The name(s) of the Copyright Holder(s) or the Author(s) of the Font
+Software shall not be used to promote, endorse or advertise any
+Modified Version, except to acknowledge the contribution(s) of the
+Copyright Holder(s) and the Author(s) or with their explicit written
+permission.
+
+5) The Font Software, modified or unmodified, in part or in whole,
+must be distributed entirely under this license, and must not be
+distributed under any other license. The requirement for fonts to
+remain under this license does not apply to any document created
+using the Font Software.
+
+TERMINATION
+This license becomes null and void if any of the above conditions are
+not met.
+
+DISCLAIMER
+THE FONT SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO ANY WARRANTIES OF
+MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT
+OF COPYRIGHT, PATENT, TRADEMARK, OR OTHER RIGHT. IN NO EVENT SHALL THE
+COPYRIGHT HOLDER BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY,
+INCLUDING ANY GENERAL, SPECIAL, INDIRECT, INCIDENTAL, OR CONSEQUENTIAL
+DAMAGES, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
+FROM, OUT OF THE USE OR INABILITY TO USE THE FONT SOFTWARE OR FROM
+OTHER DEALINGS IN THE FONT SOFTWARE.

statsbadge_railclock-0.1.0/src/statsbadge_railclock/__init__.py

@@ -0,0 +1,43 @@
+"""The Rail Clock as a statsbadge page.
+
+The time inside two red rings, whose chevrons go round a turn a minute in opposite
+directions and meet as the double arrow on the minute and the half minute. The page is
+drawn on the badge, which keeps time off the host's clock; all this side sends is that.
+"""
+
+import os
+import time
+
+from statsbadge.sources.base import Source
+
+HERE = os.path.dirname(os.path.abspath(__file__))
+
+
+class RailClock(Source):
+    name = "railclock"
+    label = "Rail Clock"
+    provides = ("railclock",)
+
+    # The badge-side code, pushed by `statsbadge install` and imported by the app.
+    badge_module = os.path.join(HERE, "badge", "railclock.py")
+
+    # Inter at weight 700 and optical size 32: its tabular digits, the colon it raises
+    # between digits, and a dash for the placeholder, packed --wide.
+    badge_assets = (os.path.join(HERE, "badge", "railclock_digits.af"),)
+
+    badge_page = {
+        "kind": "railclock",
+        "title": "Rail Clock",
+        "fields": [],
+        "slots": {},
+    }
+
+    @classmethod
+    def available(cls, _config=None):
+        return True
+
+    def sample(self, frame, dt):
+        """Send the host's local time, which the badge sets its own clock from."""
+        now = time.localtime()
+        frame["railclock"] = {"hour": now.tm_hour, "minute": now.tm_min,
+                              "seconds": now.tm_sec}

statsbadge_railclock-0.1.0/src/statsbadge_railclock/badge/railclock.py

@@ -0,0 +1,216 @@
+"""The badge side of statsbadge-railclock: the Rail Clock, as a page.
+
+After Network Rail's Rail Clock (Design Bridge and Partners, 2025), as the FireTVDeparture
+departure board draws it in a tile: two red rings, each carrying one chevron of the double
+arrow, with the time inside them. The outer chevron goes round clockwise and the inner one
+anticlockwise, a turn a minute each. They meet as the double arrow at the top on the
+minute, and again at the bottom on the half minute.
+
+The geometry is the board's, in its 200 unit square, scaled to the tile.
+"""
+
+import machine
+import math
+import time
+
+import draw
+import look
+import pages
+
+DIGITS_FONT, DIGITS_FILE = "railclock", "railclock_digits.af"
+# Where `statsbadge install` puts this extension, should __file__ not say.
+EXT_HOME = "/system/apps/stats/ext/railclock/"
+
+# The board's stylesheet: the tile in a card's border, the red, the time.
+TILE = (11, 15, 20)
+EDGE = (24, 34, 48)
+RED = (208, 32, 47)
+TIME = (236, 236, 236)
+
+# renderRailClock(), in a 200 unit square.
+OUTER = 82.0
+INNER = 74.5
+STROKE = 3.0
+GAP = OUTER - INNER
+MID = (OUTER + INNER) / 2.0
+# The arms leave the ring at 27 degrees, as in Gerry Barney's logo.
+ARM = math.radians(27.0)
+BACK = GAP / math.tan(ARM)
+HALF = STROKE / 2.0 / math.sin(ARM)
+SPAN = math.degrees(BACK / MID)
+# The time: 34 units, Inter Bold, whose capitals stand 1490 of 2048. The packed font's
+# stand 81/128 of the size it is drawn at.
+TIME_UNITS = 34.0
+CAP_RATIO = (1490.0 / 2048.0) / (81.0 / 128.0)
+
+# The tile is the page band, with a little of the page showing round it as between the
+# board's cards, and the face is 88% of it.
+INSET = 4
+RADIUS = 8
+FACE = 0.88
+
+# A PCF85063A drifts a second or two a day.
+RESYNC_S = 30
+# A gap between draws longer than this is the page coming back on screen, so the frame
+# it is handed may be a host's last, from whenever it went quiet.
+AWAY_MS = 2000
+
+_pens = None
+_built = None
+_tried_font = False
+
+_synced = False
+_seen_seq = None
+_drawn_at = None
+_phase_second = None
+_phase_at = 0
+
+
+def _beside(name):
+    """Return a file shipped alongside this module, where the installer put both."""
+    here = globals().get("__file__") or ""
+    return here.rsplit("/", 1)[0] + "/" + name if "/" in here else EXT_HOME + name
+
+
+def _font():
+    global _tried_font
+    if not _tried_font:
+        _tried_font = True
+        draw.add_font(DIGITS_FONT, _beside(DIGITS_FILE), EXT_HOME + DIGITS_FILE)
+    return DIGITS_FONT if draw.has_font(DIGITS_FONT) else draw.TEXT
+
+
+def _colours():
+    """Return the pens, made once: a label is cached against its pen."""
+    global _pens
+    if _pens is None:
+        _pens = {"tile": color.rgb(*TILE), "edge": color.rgb(*EDGE),
+                 "red": color.rgb(*RED), "time": color.rgb(*TIME)}
+    return _pens
+
+
+def _point(radius, degrees):
+    """Return a point `radius` from the centre, `degrees` clockwise from twelve."""
+    angle = math.radians(degrees)
+    return vec2(radius * math.sin(angle), -radius * math.cos(angle))
+
+
+def _chevron(scale, ring, tip, direction):
+    """Return one chevron about the origin: railClockChevron(), bent onto the rings.
+
+    Built along the direction of travel and across the rings, so the arm crossing the gap
+    ends on the other ring's centreline and the opposite arm mirrors it outward.
+    """
+    local = ((HALF, 0.0), (HALF - BACK, GAP), (-HALF - BACK, GAP), (-HALF, 0.0),
+             (-HALF - BACK, -GAP), (HALF - BACK, -GAP))
+    return shape.custom([_point((ring + across) * scale,
+                                tip + direction * math.degrees(along / MID))
+                         for along, across in local])
+
+
+def _geometry():
+    """Return the tile, the face's centre and scale, and the two chevrons, built once."""
+    global _built
+    if _built is None:
+        top = look.BODY_TOP + INSET // 2
+        tile = (INSET, top, look.W - INSET * 2, look.BODY_H - INSET)
+        centre = (tile[0] + tile[2] / 2.0, tile[1] + tile[3] / 2.0)
+        scale = min(tile[2], tile[3]) * FACE / 200.0
+        # Offset by half the chevron's span, so the two crossing arms coincide as the
+        # logo whenever the chevrons meet.
+        outer = _chevron(scale, OUTER, SPAN / 2.0, 1)
+        inner = _chevron(scale, INNER, -SPAN / 2.0, -1)
+        _built = (tile, centre, scale, outer, inner)
+    return _built
+
+
+def _seconds():
+    """Return the second of the minute off the badge's clock, with its fraction."""
+    global _phase_second, _phase_at
+    whole = time.localtime()[5]
+    now = time.ticks_ms()
+    if whole != _phase_second:
+        _phase_second = whole
+        _phase_at = now
+    return whole + min(1.0, time.ticks_diff(now, _phase_at) / 1000.0)
+
+
+def _take(frame):
+    """Set the badge's clock from the host's, when this frame is a fresh reading.
+
+    Fresh is a frame seen to arrive while the page is up: the last frame of a host that
+    has gone away carries the time it went. A page coming on screen with nothing set yet
+    takes what it is handed, as the time it has is no better.
+    """
+    global _seen_seq, _drawn_at
+    now = time.ticks_ms()
+    back = _drawn_at is None or time.ticks_diff(now, _drawn_at) > AWAY_MS
+    _drawn_at = now
+    seq = frame.get("seq")
+    if back:
+        _seen_seq = seq
+        if not _synced:
+            _resync(frame.get("railclock") or {})
+        return
+    if seq != _seen_seq:
+        _seen_seq = seq
+        _resync(frame.get("railclock") or {})
+
+
+def _resync(clock):
+    """Set the badge's clock from a reading: the first, then only past RESYNC_S."""
+    global _synced
+    hour, minute, second = clock.get("hour"), clock.get("minute"), clock.get("seconds")
+    if hour is None or minute is None or second is None:
+        return
+    parts = time.localtime()
+    drift = (hour * 3600 + minute * 60 + second
+             - (parts[3] * 3600 + parts[4] * 60 + parts[5]) + 43200) % 86400 - 43200
+    if _synced and -RESYNC_S <= drift <= RESYNC_S:
+        return
+    machine.RTC().datetime((parts[0], parts[1], parts[2], parts[6],
+                            hour, minute, second, 0))
+    _synced = True
+
+
+def render(_page, frame, _history, _theme):
+    pens = _colours()
+    font = _font()
+    tile, centre, scale, outer, inner = _geometry()
+    _take(frame)
+
+    # The tile: the board's card, on the page.
+    screen.pen = pens["edge"]
+    screen.shape(shape.rounded_rectangle(rect(*tile), RADIUS))
+    screen.pen = pens["tile"]
+    screen.shape(shape.rounded_rectangle(
+        rect(tile[0] + 1, tile[1] + 1, tile[2] - 2, tile[3] - 2), RADIUS - 1))
+
+    # The rings, always there.
+    screen.pen = pens["red"]
+    half = STROKE * scale / 2.0
+    for ring in (OUTER, INNER):
+        screen.shape(shape.arc(vec2(*centre), ring * scale - half, ring * scale + half,
+                               0, 360))
+
+    # The chevrons, a turn a minute each way, off the badge's own clock.
+    turned = _seconds() * 6.0
+    outer.transform = mat3().translate(*centre).rotate(turned)
+    inner.transform = mat3().translate(*centre).rotate(-turned)
+    screen.shape(outer)
+    screen.shape(inner)
+
+    # The time, its capitals centred on the face, as the board's central baseline puts
+    # them. The board shows --:-- until its clock has the time.
+    if _synced:
+        hour, minute = time.localtime()[3:5]
+        shown = f"{hour:02d}:{minute:02d}"
+    else:
+        shown = "--:--"
+    size = int(TIME_UNITS * scale * CAP_RATIO + 0.5)
+    ink = size * draw.CAP
+    y = int(centre[1] - ink / 2.0 - (size - ink) + 0.5)
+    draw.blit_label(shown, size, pens["time"], int(centre[0]), y, align=1, name=font)
+
+
+pages.register("railclock", render, api=1, animated=True)

statsbadge_railclock-0.1.0/tests/test_railclock.py

@@ -0,0 +1,47 @@
+"""Checks run by statsbadge's extension workflow: `python tests/test_railclock.py`."""
+
+import ast
+import os
+
+from statsbadge import badge_api
+
+from statsbadge_railclock import RailClock
+
+
+def test_sends_the_host_time():
+    frame = {}
+    RailClock({}).sample(frame, 1.0)
+    clock = frame["railclock"]
+    assert 0 <= clock["hour"] < 24
+    assert 0 <= clock["minute"] < 60
+    assert 0 <= clock["seconds"] < 62
+
+
+def test_ships_what_the_badge_needs():
+    assert RailClock.available()
+    for path in (RailClock.badge_module, *RailClock.badge_assets):
+        assert os.path.isfile(path), path
+        assert os.path.getsize(path) > 0, path
+
+
+def test_badge_module_keeps_to_the_badge_api():
+    """Only what statsbadge publishes for badge modules, at its current version."""
+    source = open(RailClock.badge_module, encoding="utf-8").read()
+    assert f"api={badge_api.VERSION}" in source
+    for node in ast.walk(ast.parse(source)):
+        if not (isinstance(node, ast.Attribute) and isinstance(node.value, ast.Name)):
+            continue
+        if node.value.id in badge_api.NAMES:
+            assert node.attr in badge_api.NAMES[node.value.id], (
+                f"{node.value.id}.{node.attr} is not in badge_api")
+    imported = {alias.name for node in ast.walk(ast.parse(source))
+                if isinstance(node, ast.Import) for alias in node.names}
+    app_modules = {"deck", "app", "net", "splash", "setup"}
+    assert not imported & app_modules, imported & app_modules
+
+
+if __name__ == "__main__":
+    for name, test in list(globals().items()):
+        if name.startswith("test_") and callable(test):
+            test()
+            print("ok", name)