Ci and deps

.github/workflows/python-publish.yml

@@ -10,24 +10,28 @@ on:
   workflow_dispatch:
 
 jobs:
+  test:
+    uses: ./.github/workflows/tests.yml
+
   deploy:
+    needs: test
 
     runs-on: ubuntu-latest
 
     steps:
-    - uses: actions/checkout@v2
+    - uses: actions/checkout@v4
     - name: Set up Python
-      uses: actions/setup-python@v2
+      uses: actions/setup-python@v5
       with:
         python-version: '3.x'
     - name: Install dependencies
       run: |
         python -m pip install --upgrade pip
-        pip install setuptools wheel twine
+        pip install build twine
     - name: Build and publish
       env:
         TWINE_USERNAME: ${{ secrets.PYPI_USERNAME }}
         TWINE_PASSWORD: ${{ secrets.PYPI_PASSWORD }}
       run: |
-        python setup.py sdist bdist_wheel
+        python -m build
         twine upload dist/*

.github/workflows/tests.yml

@@ -0,0 +1,37 @@
+name: Tests
+
+on:
+  push:
+    branches: [master]
+  pull_request:
+  workflow_call:
+
+jobs:
+  test:
+    runs-on: ubuntu-latest
+    strategy:
+      matrix:
+        # oldest supported (setup.py python_requires) and newest
+        python-version: ["3.10", "3.14"]
+
+    steps:
+      - uses: actions/checkout@v4
+
+      - uses: actions/setup-python@v5
+        with:
+          python-version: ${{ matrix.python-version }}
+
+      - name: Install dependencies
+        run: python -m pip install -r requirements-dev.txt
+
+      - name: Run tests
+        run: python -m pytest -q
+
+      # catches data files missing from the package, which only fail once
+      # installed, e.g. `departure --help` crashing on import
+      - name: Check built package installs and runs
+        run: |
+          python -m build --wheel --outdir dist
+          python -m venv /tmp/wheel-venv
+          /tmp/wheel-venv/bin/pip install dist/*.whl
+          cd /tmp && /tmp/wheel-venv/bin/departure --help

.vscode/launch.json

@@ -0,0 +1,14 @@
+{
+    // Use IntelliSense to learn about possible attributes.
+    // Hover to view descriptions of existing attributes.
+    // For more information, visit: https://go.microsoft.com/fwlink/?linkid=830387
+    "version": "0.2.0",
+    "configurations": [
+        {
+            "name": "Python: Module",
+            "type": "python",
+            "request": "launch",
+            "module": "departure.cli.client",
+        }
+    ]
+}

MANIFEST.in

@@ -1,4 +1,5 @@
 include departure/provider/national_rail/data/station_codes.csv
+include departure/provider/nexus/data/stops.csv
 include departure/provider/ns/data/stations-2020-01-nl.csv
 include departure/provider/ratp/data/Wsiv.wsdl
 include departure/provider/sncf/data/referentiel-gares-voyageurs.json

departure/board/board.py

@@ -1,6 +1,7 @@
-from typing import Tuple, List
+from typing import Tuple, List, Optional
 
 import departure.board.movement as movement
+from departure.board.movement import NoMovement
 
 Pixel = Tuple[int, int, Tuple[int, int, int]]
 Pixels = List[Pixel]
@@ -102,7 +103,7 @@ def __init__(
         output_w: int,
         output_h: int,
         content: BoardSectionContent,
-        movement: movement.Movement = movement.NoMovement(),
+        movement: Optional[movement.Movement] = None,
     ):
         # area on the departure board where this section is displayed
         self.output_x = output_x
@@ -113,8 +114,8 @@ def __init__(
         # content to be displayed in this section
         self._content = content
 
-        # movement class
-        self._movement = movement
+        # movement class (fresh instance per section: movements hold state)
+        self._movement = movement if movement is not None else NoMovement()
 
         # pixels in absolute coordinates
         self.section_pixels = None
@@ -216,10 +217,15 @@ def pixels(self) -> Pixels:
 
 
 class Board:
-    def __init__(self, board_w: int, board_h: int, sections: List[BoardSection] = []):
+    def __init__(
+        self,
+        board_w: int,
+        board_h: int,
+        sections: Optional[List[BoardSection]] = None,
+    ):
         self.board_w = board_w
         self.board_h = board_h
-        self.sections = sections
+        self.sections = sections if sections is not None else []
         self.display_pixels = None
         self._has_changed = True
 

departure/board/board_client.py

@@ -11,53 +11,110 @@
 logger = logging.getLogger(__name__)
 
 
-class BoardClient:  # pylint: disable=too-few-public-methods
-    def __init__(self):
-        self.running = False
+class BoardGate:
+    """
+    Forwards calls to a view model until closed, then drops them.
 
-    def run(
-        self,
-        view_model_class: view_model.ViewModel,
-        data_updater_class: data_updater.DataUpdater,
-        data_updater_extra_arguments: dict,
-    ) -> None:
+    A stopped data updater may still be in the middle of a poll (HTTP or SOAP
+    call); closing the gate stops that poll from reaching the board once a
+    new client has taken over.
+    """
 
-        end_event = threading.Event()
+    def __init__(self, target_view_model: view_model.ViewModel):
+        self._view_model = target_view_model
+        self._lock = threading.Lock()
+        self._open = True
 
-        # set departure board server
-        if "DEPARTURE_BOARD_SERVER" in os.environ:
-            departure_board_server = os.environ["DEPARTURE_BOARD_SERVER"]
-            server_info_str = "DEPARTURE_BOARD_SERVER env var set - "
-        else:
-            server_info_str = "DEPARTURE_BOARD_SERVER env var not set - "
-            departure_board_server = "127.0.0.1"
-        logger.info("%s using %s as server", server_info_str, departure_board_server)
+    def __getattr__(self, name):
+        method = getattr(self._view_model, name)
 
-        # open channel to board server
-        channel = grpc.insecure_channel(f"{departure_board_server}:50051")
+        def forward(*args, **kwargs):
+            with self._lock:
+                if self._open:
+                    return method(*args, **kwargs)
+            return None
 
-        # set up client parameters
-        board_manager_stub = departure_pb2_grpc.BoardManagerStub(channel)
-        target_view_model = view_model_class(board_manager_stub)
+        return forward
 
-        # init and run updater thread
-        data_updater_thread = data_updater_class(
-            target_view_model=target_view_model,
-            data_refresh_delay_in_s=15,
-            end_event=end_event,
-            **data_updater_extra_arguments,
-        )
+    def close(self) -> None:
+        # waits for any call in progress, so nothing reaches the board after
+        with self._lock:
+            self._open = False
 
-        data_updater_thread.start()
 
-        self.running = True
+class BoardClient:
+    def __init__(self):
+        self._lock = threading.Lock()
+        self._channel = None
+        self._view_model = None
+        self._gate = None
+        self._end_event = None
+
+    @property
+    def running(self) -> bool:
+        return self._gate is not None
 
-        # run until self.running is set to false
-        while self.running:
-            end_event.wait(0.5)
+    def start(
+        self,
+        view_model_class: view_model.ViewModel,
+        data_updater_class: data_updater.DataUpdater,
+        data_updater_extra_arguments: dict,
+    ) -> None:
+        with self._lock:
+            # replace any client already running
+            self._stop()
+
+            # set departure board server
+            if "DEPARTURE_BOARD_SERVER" in os.environ:
+                departure_board_server = os.environ["DEPARTURE_BOARD_SERVER"]
+                server_info_str = "DEPARTURE_BOARD_SERVER env var set - "
+            else:
+                server_info_str = "DEPARTURE_BOARD_SERVER env var not set - "
+                departure_board_server = "127.0.0.1"
+            logger.info(
+                "%s using %s as server", server_info_str, departure_board_server
+            )
+
+            # open channel to board server
+            self._channel = grpc.insecure_channel(f"{departure_board_server}:50051")
+
+            # set up client parameters
+            board_manager_stub = departure_pb2_grpc.BoardManagerStub(self._channel)
+            self._view_model = view_model_class(board_manager_stub)
+            self._gate = BoardGate(self._view_model)
+            self._end_event = threading.Event()
+
+            # init and run updater thread
+            data_updater_thread = data_updater_class(
+                target_view_model=self._gate,
+                data_refresh_delay_in_s=15,
+                end_event=self._end_event,
+                **data_updater_extra_arguments,
+            )
+            # a poll in flight must not keep the process alive on exit
+            data_updater_thread.daemon = True
+            data_updater_thread.start()
+
+    def stop(self) -> None:
+        with self._lock:
+            self._stop()
+
+    def _stop(self) -> None:
+        if self._gate is None:
+            return
 
-        # clean and exit
         logger.info("stopping")
-        end_event.set()
-        data_updater_thread.join()
-        target_view_model.update(None)
+
+        # the updater thread ends after its current poll, if any; the closed
+        # gate stops that poll reaching the board, so there's no need to wait
+        self._end_event.set()
+        self._gate.close()
+
+        # clear board
+        self._view_model.update(None)
+        self._channel.close()
+
+        self._channel = None
+        self._view_model = None
+        self._gate = None
+        self._end_event = None

departure/board/contents.py

@@ -31,13 +31,28 @@ def _glyph_pixels(self, glyph, x_offset, y_offset, colour=(255, 255, 255)):
             if glyph.data[y] & (1 << (glyph.bbW - x - 1))
         ]
 
+    def _glyph(self, char):
+        # fonts only cover some characters (e.g. no accents or CJK): fall back
+        # to "?" so one odd station name doesn't break the whole board
+        for candidate in (char, "?"):
+            try:
+                return self.font[ord(candidate)]
+            except KeyError:
+                pass
+        return None
+
+    def _line_height(self):
+        return self.font[b"FONT_ASCENT"] + self.font[b"FONT_DESCENT"]
+
     def monochrome_text_pixels(
         self, text, colour=(255, 255, 255), max_width=0  # 0 == no max width
     ):
         pixels = []
         advance = 0
         for c in text:
-            glyph = self.font[ord(c)]
+            glyph = self._glyph(c)
+            if glyph is None:
+                continue
             pixels += self._glyph_pixels(
                 glyph, advance, self.font[b"FONT_ASCENT"] - 1, colour
             )
@@ -51,7 +66,7 @@ def colour_text_pixels(self, text_array):
         if self.colour_map is None:
             raise BoardTextException("missing colour map")
 
-        x_size, y_size = 0, 0
+        x_size, y_size = 0, self._line_height()
         output_pixels = []
 
         for text_part in text_array:
@@ -65,7 +80,7 @@ def colour_text_pixels(self, text_array):
             )
             output_pixels += [(x + x_size, y, c) for x, y, c in pixels]
             x_size += size[0]
-        y_size = size[1]
+            y_size = size[1]
         return output_pixels, (x_size, y_size)
 
     def colour_text_tabbed_row_pixels(self, text_row):
@@ -74,6 +89,7 @@ def colour_text_tabbed_row_pixels(self, text_row):
 
         output_pixels = []
         x_size = 0
+        y_size = self._line_height()
         for i, text_part in enumerate(text_row):
             tab_pos, tab_type = self.tabs[i]
             text, colour = text_part[:2]
@@ -97,7 +113,7 @@ def colour_text_tabbed_row_pixels(self, text_row):
                 # extend width as needed
                 x_size = max(x_size, tab_pos + 1)
 
-        y_size = size[1]
+            y_size = size[1]
 
         return output_pixels, (x_size, y_size)
 

departure/board/data_updater.py

@@ -24,7 +24,15 @@ def run(self):
             loop_start_time = time.monotonic()
             next_loop_start_time = loop_start_time + self.data_refresh_delay_in_s
 
-            self.update()
+            try:
+                self.update()
+            except Exception:  # pylint: disable=broad-except
+                # one bad poll must not end the thread and freeze the board
+                logger.exception("data update failed, will retry")
+                try:
+                    self.update_failed()
+                except Exception:  # pylint: disable=broad-except
+                    logger.exception("could not show data update failure")
 
             if next_loop_start_time > time.monotonic():
                 self.end_event.wait(next_loop_start_time - time.monotonic())
@@ -35,3 +43,8 @@ def run(self):
 
     def update(self):
         raise NotImplementedError()
+
+    def update_failed(self):
+        # called after update() raises; override to stop the board showing
+        # data from before the failure as if it were live
+        pass