boneIO 1.4.2__tar.gz → 1.4.3__tar.gz

{boneio-1.4.2/boneio.egg-info → boneio-1.4.3}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: boneio
-Version: 1.4.2
+Version: 1.4.3
 Summary: Python App for BoneIO
 Author-email: Paweł Szafer <pszafer@gmail.com>
 License: GNU General Public License v3.0

{boneio-1.4.2 → boneio-1.4.3}/boneio/migrations/assets/MANIFEST.sha256

@@ -10,10 +10,11 @@ f2ed05c6f5934a15f12571139bdc225804f67b8c83561cc39868f7b2296d2697  docker/daemon.
 3db75f83033d82ca229e2d3bcb7daf4a5584f65b298d834bd0ee12527ae06e22  mosquitto/boneio.conf
 3fc86895f5fd3e59d2ee2d229ff7ff7c0030752f0c4eca0bb04314ea57ac0ede  sudoers/boneio
 80e528c3a0e03a4d269bcb46db4224c8e5b6c75553b266cfc4f301b515ddcd95  systemd/boneio-oled-boot.service
-9d4f46cfe6df36ee786b4b08fccc0a4dbe8161b82bdcb74f61cde45869e20ff9  systemd/boneio.service
+df6cbd8ff2361a815917c3a24ca11ebb817fc98c9790833cb2475e0b9f4e9923  systemd/boneio-oled-shutdown.service
+455fe344a251e0162cdf26beff2a041c55340119de917675faafa06d573663c6  systemd/boneio.service
 5abbd8e37720f31d44ad59814c7ebbcfb5ae09ef32d83682dee6479f34270a31  systemd/set-hostname-once.service
 8eaea86c51a17c1bc7b68e9ea65a20b428577a0bc16793768f8dba575532e8ed  usr-local-bin/set-hostname-once.sh
 3340abd637e15bb789e20f2e7de5d95dc45d8e427689e0c62312d044cd3ad86e  usr-sbin/oled_boot_splash.py
 0537e194700c50d91295517e23bcccce9b23be740b93381dff35b510d562c6fe  usr-sbin/oled_boot_splash.sh
-700c812bcf192f8be079ae58fce45543c8f60d9a9c25ab149f8dd68786c717d7  usr-sbin/oled_msg.py
-e07152aae00b0d020ae69a69bfe2738a5f4b8768b62639516d85bbd2d808ba0a  usr-sbin/oled_msg.sh
+a95d897f49e1af2468b18a721731a6c679b3a0c54af4bb8338a5906f98898bdd  usr-sbin/oled_msg.py
+b30a474473c96ab973a442ea01bd197735a3d75f12d88129895488335bf5401c  usr-sbin/oled_msg.sh

boneio-1.4.3/boneio/migrations/assets/systemd/boneio-oled-shutdown.service

@@ -0,0 +1,12 @@
+[Unit]
+Description=OLED shutdown message (runs after network is down)
+DefaultDependencies=no
+Before=final.target
+After=network.target
+
+[Service]
+Type=oneshot
+ExecStart=/usr/sbin/oled_msg.sh "boneIO Black" "System stopped." "Safe to unplug."
+
+[Install]
+WantedBy=final.target

{boneio-1.4.2 → boneio-1.4.3}/boneio/migrations/assets/systemd/boneio.service

@@ -6,7 +6,7 @@ After=multi-user.target network.target boneio-oled-boot.service
 Type=simple
 ExecStartPre=-/usr/sbin/oled_msg.sh "boneIO Black" "is starting..." "Please wait..."
 ExecStart=${BONEIO_HOME}/boneio/venv/bin/boneio run -c ${BONEIO_HOME}/boneio/config.yaml
-ExecStopPost=/usr/sbin/oled_msg.sh "boneIO Black" "has stopped."
+ExecStopPost=-/bin/sh -c 'if ! systemctl is-system-running --quiet 2>/dev/null; then /usr/sbin/oled_msg.sh "boneIO Black" "Shutting down..."; fi'
 User=${BONEIO_USER}
 Restart=always
 RestartSec=3

boneio-1.4.3/boneio/migrations/assets/usr-sbin/oled_msg.py

@@ -0,0 +1,255 @@
+#!/usr/bin/env python3
+"""Display a centered message on optional SH1106 OLED.
+
+Supports two modes:
+  - Direct:  oled_msg.py "Line 1" "Line 2"   — one-shot render (slow, flickers)
+  - Daemon:  oled_msg.py --serve              — keeps luma in memory, reads
+             commands from /tmp/.oled_fifo (fast, no flicker)
+
+When the daemon is running, direct calls detect it and send messages
+through the FIFO instead of re-initializing luma.
+
+This script is safe to call when no OLED is connected or dependencies are
+missing: it exits quietly with code 0.
+"""
+
+from __future__ import annotations
+
+import os
+import sys
+
+_FIFO_PATH = "/tmp/.oled_fifo"
+_PID_PATH = "/tmp/.oled_serve.pid"
+
+
+def _fast_clear_oled() -> None:
+    """Clear OLED display via raw I2C before slow luma init.
+
+    On soft-reboot the SH1106 retains the previous image. Luma's sh1106()
+    constructor takes ~9 seconds (device enumeration, contrast setup, etc.).
+    This function clears the display in ~50ms using raw smbus2 writes,
+    so the stale image disappears almost instantly at boot.
+    """
+    try:
+        import smbus2
+
+        bus = smbus2.SMBus(2)
+        addr = 0x3C
+        # SH1106 init: display on, set page addressing
+        for cmd in [
+            0xAE,
+            0xD5,
+            0x80,
+            0xA8,
+            0x3F,
+            0xD3,
+            0x00,
+            0x40,
+            0xAD,
+            0x8B,
+            0xA1,
+            0xC8,
+            0xDA,
+            0x12,
+            0x81,
+            0xFF,
+            0xD9,
+            0x1F,
+            0xDB,
+            0x40,
+            0xA6,
+            0xAF,
+        ]:
+            bus.write_byte_data(addr, 0x00, cmd)
+        # Clear all 8 pages (128 columns each)
+        blank = [0x00] * 128
+        for page in range(8):
+            bus.write_byte_data(addr, 0x00, 0xB0 | page)  # set page
+            bus.write_byte_data(addr, 0x00, 0x02)  # low col (offset 2 for SH1106)
+            bus.write_byte_data(addr, 0x00, 0x10)  # high col
+            # Write in chunks of 32 (smbus limit)
+            for i in range(0, 128, 32):
+                bus.write_i2c_block_data(addr, 0x40, blank[i : i + 32])
+        bus.close()
+    except Exception:
+        pass  # No OLED or smbus2 not available — ignore
+
+
+def _is_daemon_running() -> bool:
+    """Check if the oled_msg daemon is running.
+
+    Returns:
+        True if daemon PID file exists and process is alive.
+    """
+    try:
+        with open(_PID_PATH) as f:
+            pid = int(f.read().strip())
+        os.kill(pid, 0)  # Check if process exists
+        return True
+    except (FileNotFoundError, ValueError, ProcessLookupError, PermissionError):
+        return False
+
+
+def _send_to_daemon(lines: list[str]) -> bool:
+    """Send a message to the running daemon via FIFO.
+
+    Args:
+        lines: List of text lines to display.
+
+    Returns:
+        True if message was sent successfully.
+    """
+    try:
+        # Open FIFO in non-blocking write to avoid hanging if daemon died
+        fd = os.open(_FIFO_PATH, os.O_WRONLY | os.O_NONBLOCK)
+        msg = "|".join(lines) + "\n"
+        os.write(fd, msg.encode())
+        os.close(fd)
+        return True
+    except (OSError, BrokenPipeError):
+        return False
+
+
+def _draw(device, font, lines: list[str]) -> None:
+    """Draw centered text lines on the OLED.
+
+    Args:
+        device: luma sh1106 device instance.
+        font: PIL ImageFont instance.
+        lines: List of 1-4 text strings to display.
+    """
+    from luma.core.render import canvas
+
+    with canvas(device) as draw:
+        if len(lines) == 1:
+            positions = [(20, 26)]
+        elif len(lines) == 2:
+            positions = [(12, 20), (12, 36)]
+        elif len(lines) == 3:
+            positions = [(8, 12), (8, 28), (8, 44)]
+        else:
+            positions = [(4, 4), (4, 18), (4, 32), (4, 46)]
+        for index, line in enumerate(lines):
+            draw.text(positions[index], line[:24], font=font, fill="white")
+
+
+def _serve() -> int:
+    """Run as a daemon: initialize luma once, then listen on FIFO for commands.
+
+    Message format on FIFO: "Line 1|Line 2|Line 3\\n"
+    Special messages: "clear\\n" to clear display, "quit\\n" to stop daemon.
+
+    Returns:
+        Exit code.
+    """
+    _fast_clear_oled()
+
+    try:
+        from luma.core.interface.serial import i2c
+        from luma.oled.device import sh1106
+        from PIL import ImageFont
+    except Exception:
+        return 0
+
+    try:
+        serial = i2c(port=2, address=0x3C)
+        device = sh1106(serial)
+        device.persist = True
+        font = ImageFont.load_default()
+    except Exception:
+        return 0
+
+    # Create FIFO
+    try:
+        os.unlink(_FIFO_PATH)
+    except FileNotFoundError:
+        pass
+    os.mkfifo(_FIFO_PATH)
+
+    # Write PID file
+    with open(_PID_PATH, "w") as f:
+        f.write(str(os.getpid()))
+
+    try:
+        while True:
+            # Open FIFO — blocks until a writer connects
+            with open(_FIFO_PATH) as fifo:
+                for raw_line in fifo:
+                    msg = raw_line.strip()
+                    if not msg:
+                        continue
+                    if msg == "quit":
+                        return 0
+                    if msg == "clear":
+                        _fast_clear_oled()
+                        continue
+                    lines = msg.split("|")
+                    _draw(device, font, lines)
+    except KeyboardInterrupt:
+        pass
+    finally:
+        try:
+            os.unlink(_FIFO_PATH)
+        except FileNotFoundError:
+            pass
+        try:
+            os.unlink(_PID_PATH)
+        except FileNotFoundError:
+            pass
+
+    return 0
+
+
+def main(argv: list[str]) -> int:
+    """Display a centered message on optional SH1106 OLED.
+
+    If --serve is passed, runs as a daemon listening on a FIFO.
+    Otherwise, sends message to daemon if running, or falls back
+    to direct luma rendering.
+
+    Args:
+        argv: Command-line arguments.
+
+    Returns:
+        Exit code (always 0).
+    """
+    if len(argv) > 1 and argv[1] == "--serve":
+        return _serve()
+
+    lines = [line[:24] for line in argv[1:5] if line]
+    if not lines:
+        return 0
+
+    # Try sending to daemon first (fast path — no Python init overhead)
+    if _is_daemon_running() and _send_to_daemon(lines):
+        return 0
+
+    # Fallback: direct rendering (slow but always works)
+    _fast_clear_oled()
+
+    try:
+        from luma.core.error import DeviceNotFoundError
+        from luma.core.interface.serial import i2c
+        from luma.oled.device import sh1106
+        from PIL import ImageFont
+    except Exception:
+        return 0
+
+    try:
+        serial = i2c(port=2, address=0x3C)
+        device = sh1106(serial)
+        device.persist = True
+    except (DeviceNotFoundError, OSError, Exception):
+        return 0
+
+    try:
+        _draw(device, ImageFont.load_default(), lines)
+    except Exception:
+        return 0
+
+    return 0
+
+
+if __name__ == "__main__":
+    raise SystemExit(main(sys.argv))
+

boneio-1.4.3/boneio/migrations/assets/usr-sbin/oled_msg.sh

@@ -0,0 +1,55 @@
+#!/bin/bash
+# oled_msg.sh — wrapper for optional Python SH1106 renderer
+# Usage: oled_msg.sh "Line 1" ["Line 2"] ["Line 3"] ["Line 4"]
+#        oled_msg.sh --serve    # start daemon (keeps luma in memory)
+#        oled_msg.sh --stop     # stop daemon
+#        oled_msg.sh clear      # clear display
+
+SCRIPT_DIR="$(cd "$(dirname "${BASH_SOURCE[0]}")" && pwd)"
+PYTHON_RENDERER="${SCRIPT_DIR}/oled_msg.py"
+VENV_PYTHON="/home/boneio/boneio/venv/bin/python3"
+OLED_FIFO="/tmp/.oled_fifo"
+OLED_PID="/tmp/.oled_serve.pid"
+
+if [ ! -f "${PYTHON_RENDERER}" ]; then
+    exit 0
+fi
+
+# Pick the right Python
+PYTHON=""
+if [ -x "${VENV_PYTHON}" ]; then
+    PYTHON="${VENV_PYTHON}"
+elif command -v python3 >/dev/null 2>&1; then
+    PYTHON="python3"
+else
+    exit 0
+fi
+
+# Handle --serve: start daemon in background
+if [ "$1" = "--serve" ]; then
+    "${PYTHON}" "${PYTHON_RENDERER}" --serve 2>/dev/null &
+    # Wait briefly for FIFO to be created
+    for i in $(seq 1 20); do
+        [ -p "$OLED_FIFO" ] && break
+        sleep 0.1
+    done
+    exit 0
+fi
+
+# Handle --stop: send quit command to daemon
+if [ "$1" = "--stop" ]; then
+    if [ -p "$OLED_FIFO" ]; then
+        echo "quit" > "$OLED_FIFO" 2>/dev/null || true
+    fi
+    exit 0
+fi
+
+# Normal message: try FIFO (fast), fallback to direct call
+if [ -p "$OLED_FIFO" ] && [ -f "$OLED_PID" ]; then
+    # Daemon is running — send via FIFO (instant, no Python startup)
+    MSG=$(IFS='|'; echo "$*")
+    echo "$MSG" > "$OLED_FIFO" 2>/dev/null && exit 0
+fi
+
+# Fallback: direct Python call
+"${PYTHON}" "${PYTHON_RENDERER}" "$@" 2>/dev/null || true

{boneio-1.4.2 → boneio-1.4.3}/boneio/migrations/bootstrap/boneio-migrate

@@ -237,7 +237,7 @@ def handle_systemctl_disable(action: dict[str, Any], assets_base: str) -> None:
 
 
 def handle_systemctl_restart(action: dict[str, Any], assets_base: str) -> None:
-    """Restart a systemd service.
+    """Restart a systemd service (tolerant of inactive services).
 
     Args:
         action: Action dict with unit.
@@ -245,11 +245,16 @@ def handle_systemctl_restart(action: dict[str, Any], assets_base: str) -> None:
     """
     unit = action["unit"]
     _LOGGER.info("systemctl restart %s", unit)
-    subprocess.run(["systemctl", "restart", unit], check=True, timeout=30)
+    result = subprocess.run(["systemctl", "restart", unit], capture_output=True, text=True, timeout=30)
+    if result.returncode != 0:
+        if "not active" in result.stderr or "not loaded" in result.stderr or "not found" in result.stderr:
+            _LOGGER.warning("systemctl restart %s skipped (not active)", unit)
+        else:
+            raise subprocess.CalledProcessError(result.returncode, ["systemctl", "restart", unit], result.stdout, result.stderr)
 
 
 def handle_systemctl_reload(action: dict[str, Any], assets_base: str) -> None:
-    """Reload a systemd service.
+    """Reload a systemd service (tolerant of inactive services).
 
     Args:
         action: Action dict with unit.
@@ -257,7 +262,12 @@ def handle_systemctl_reload(action: dict[str, Any], assets_base: str) -> None:
     """
     unit = action["unit"]
     _LOGGER.info("systemctl reload %s", unit)
-    subprocess.run(["systemctl", "reload", unit], check=True, timeout=30)
+    result = subprocess.run(["systemctl", "reload", unit], capture_output=True, text=True, timeout=30)
+    if result.returncode != 0:
+        if "not active" in result.stderr or "not loaded" in result.stderr or "not found" in result.stderr:
+            _LOGGER.warning("systemctl reload %s skipped (not active)", unit)
+        else:
+            raise subprocess.CalledProcessError(result.returncode, ["systemctl", "reload", unit], result.stdout, result.stderr)
 
 
 def handle_append_line_if_missing(action: dict[str, Any], assets_base: str) -> None:

boneio-1.4.3/boneio/migrations/versions/v1_4_3_oled_shutdown.py

@@ -0,0 +1,54 @@
+"""BoneIO 1.4.3 — OLED shutdown messages improvement.
+
+Adds a late-phase shutdown OLED service that shows "System stopped"
+after the network is already down. Updates boneio.service to only show
+"Shutting down..." during actual shutdown (not during restarts).
+"""
+
+from __future__ import annotations
+
+from boneio.migrations.actions import (
+    InstallFile,
+    MigrationAction,
+    SystemctlDaemonReload,
+    SystemctlEnable,
+)
+
+VERSION = "1.4.3"
+DESCRIPTION = "OLED shutdown messages: late-phase service + restart-aware ExecStopPost"
+REQUIRES_ROOT = True
+
+_BONEIO_USER = "boneio"
+_BONEIO_HOME = f"/home/{_BONEIO_USER}"
+
+
+def plan() -> list[MigrationAction]:
+    """Return the ordered list of migration actions for version 1.4.3.
+
+    Returns:
+        List of :class:`MigrationAction` to apply in order.
+    """
+    template_vars = {
+        "BONEIO_USER": _BONEIO_USER,
+        "BONEIO_HOME": _BONEIO_HOME,
+    }
+
+    return [
+        # 1. Install late-shutdown OLED service (runs after network is down)
+        InstallFile(
+            src="systemd/boneio-oled-shutdown.service",
+            dst="/etc/systemd/system/boneio-oled-shutdown.service",
+            mode=0o644,
+            on_change=SystemctlDaemonReload(),
+        ),
+        SystemctlEnable(unit="boneio-oled-shutdown.service"),
+
+        # 2. Update boneio.service with shutdown-aware ExecStopPost
+        InstallFile(
+            src="systemd/boneio.service",
+            dst="/etc/systemd/system/boneio.service",
+            mode=0o644,
+            template_vars=template_vars,
+            on_change=SystemctlDaemonReload(),
+        ),
+    ]

boneio-1.4.3/boneio/version.py

@@ -0,0 +1,2 @@
+# flake8: noqa
+__version__ = "1.4.3"

{boneio-1.4.2 → boneio-1.4.3/boneio.egg-info}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: boneio
-Version: 1.4.2
+Version: 1.4.3
 Summary: Python App for BoneIO
 Author-email: Paweł Szafer <pszafer@gmail.com>
 License: GNU General Public License v3.0

{boneio-1.4.2 → boneio-1.4.3}/boneio.egg-info/SOURCES.txt

@@ -254,6 +254,7 @@ boneio/migrations/assets/journald/journald.conf
 boneio/migrations/assets/mosquitto/boneio.conf
 boneio/migrations/assets/sudoers/boneio
 boneio/migrations/assets/systemd/boneio-oled-boot.service
+boneio/migrations/assets/systemd/boneio-oled-shutdown.service
 boneio/migrations/assets/systemd/boneio.service
 boneio/migrations/assets/systemd/set-hostname-once.service
 boneio/migrations/assets/usr-local-bin/set-hostname-once.sh
@@ -269,6 +270,7 @@ boneio/migrations/versions/v1_3_0_baseline.py
 boneio/migrations/versions/v1_3_1_fix_oled_boot.py
 boneio/migrations/versions/v1_3_2_cleanup_can_sudoers.py
 boneio/migrations/versions/v1_4_0_fix_mqtt_sudoers.py
+boneio/migrations/versions/v1_4_3_oled_shutdown.py
 boneio/modbus/__init__.py
 boneio/modbus/cli.py
 boneio/modbus/client.py

boneio-1.4.2/boneio/migrations/assets/usr-sbin/oled_msg.py

@@ -1,110 +0,0 @@
-#!/usr/bin/env python3
-"""Display a centered message on optional SH1106 OLED.
-
-This script is safe to call when no OLED is connected or dependencies are
-missing: it exits quietly with code 0.
-"""
-
-from __future__ import annotations
-
-import sys
-
-
-def _fast_clear_oled() -> None:
-    """Clear OLED display via raw I2C before slow luma init.
-
-    On soft-reboot the SH1106 retains the previous image. Luma's sh1106()
-    constructor takes ~9 seconds (device enumeration, contrast setup, etc.).
-    This function clears the display in ~50ms using raw smbus2 writes,
-    so the stale image disappears almost instantly at boot.
-    """
-    try:
-        import smbus2
-
-        bus = smbus2.SMBus(2)
-        addr = 0x3C
-        # SH1106 init: display on, set page addressing
-        for cmd in [
-            0xAE,
-            0xD5,
-            0x80,
-            0xA8,
-            0x3F,
-            0xD3,
-            0x00,
-            0x40,
-            0xAD,
-            0x8B,
-            0xA1,
-            0xC8,
-            0xDA,
-            0x12,
-            0x81,
-            0xFF,
-            0xD9,
-            0x1F,
-            0xDB,
-            0x40,
-            0xA6,
-            0xAF,
-        ]:
-            bus.write_byte_data(addr, 0x00, cmd)
-        # Clear all 8 pages (128 columns each)
-        blank = [0x00] * 128
-        for page in range(8):
-            bus.write_byte_data(addr, 0x00, 0xB0 | page)  # set page
-            bus.write_byte_data(addr, 0x00, 0x02)  # low col (offset 2 for SH1106)
-            bus.write_byte_data(addr, 0x00, 0x10)  # high col
-            # Write in chunks of 32 (smbus limit)
-            for i in range(0, 128, 32):
-                bus.write_i2c_block_data(addr, 0x40, blank[i : i + 32])
-        bus.close()
-    except Exception:
-        pass  # No OLED or smbus2 not available — ignore
-
-
-def main(argv: list[str]) -> int:
-    lines = [line[:24] for line in argv[1:5] if line]
-    if not lines:
-        return 0
-
-    # Immediately clear stale OLED content (e.g. "has stopped" from previous session)
-    _fast_clear_oled()
-
-    try:
-        from luma.core.error import DeviceNotFoundError
-        from luma.core.interface.serial import i2c
-        from luma.core.render import canvas
-        from luma.oled.device import sh1106
-        from PIL import ImageFont
-    except Exception:
-        return 0
-
-    try:
-        serial = i2c(port=2, address=0x3C)
-        device = sh1106(serial)
-        device.persist = True
-    except (DeviceNotFoundError, OSError, Exception):
-        return 0
-
-    try:
-        font = ImageFont.load_default()
-        with canvas(device) as draw:
-            if len(lines) == 1:
-                positions = [(20, 26)]
-            elif len(lines) == 2:
-                positions = [(12, 20), (12, 36)]
-            elif len(lines) == 3:
-                positions = [(8, 12), (8, 28), (8, 44)]
-            else:
-                positions = [(4, 4), (4, 18), (4, 32), (4, 46)]
-            for index, line in enumerate(lines):
-                draw.text(positions[index], line, font=font, fill="white")
-    except Exception:
-        return 0
-
-    return 0
-
-
-if __name__ == "__main__":
-    raise SystemExit(main(sys.argv))

boneio-1.4.2/boneio/migrations/assets/usr-sbin/oled_msg.sh

@@ -1,17 +0,0 @@
-#!/bin/bash
-# oled_msg.sh — wrapper for optional Python SH1106 renderer
-# Usage: oled_msg.sh "Line 1" ["Line 2"] ["Line 3"] ["Line 4"]
-
-SCRIPT_DIR="$(cd "$(dirname "${BASH_SOURCE[0]}")" && pwd)"
-PYTHON_RENDERER="${SCRIPT_DIR}/oled_msg.py"
-VENV_PYTHON="/home/boneio/boneio/venv/bin/python3"
-
-if [ ! -f "${PYTHON_RENDERER}" ]; then
-    exit 0
-fi
-
-if [ -x "${VENV_PYTHON}" ]; then
-    "${VENV_PYTHON}" "${PYTHON_RENDERER}" "$@" 2>/dev/null || true
-elif command -v python3 >/dev/null 2>&1; then
-    python3 "${PYTHON_RENDERER}" "$@" 2>/dev/null || true
-fi

boneio-1.4.2/boneio/version.py

@@ -1,2 +0,0 @@
-# flake8: noqa
-__version__ = "1.4.2"