enode-host 0.1.0__py3-none-any.whl → 0.1.2__py3-none-any.whl

enode_host/async_socket.py

@@ -1,4 +1,5 @@
 import asyncio
+import logging
 import struct
 from dataclasses import dataclass
 from typing import Dict, Optional
@@ -14,6 +15,8 @@ from .protocol import (
     parse_status,
 )
 
+logger = logging.getLogger(__name__)
+
 
 @dataclass
 class SocketResponse:
@@ -62,51 +65,70 @@ async def handle_client(reader: asyncio.StreamReader, writer: asyncio.StreamWrit
     peer = writer.get_extra_info("peername")
     peer_id = f"{peer[0]}:{peer[1]}" if peer else "unknown"
     clients[peer_id] = writer
-    print(f"[server] connected {peer_id} (clients={len(clients)})")
+    logger.info("[server] connected %s (clients=%d)", peer_id, len(clients))
 
     try:
         while True:
             msg_type, payload = await read_frame(reader)
             if msg_type == MsgType.STATUS:
                 status = parse_status(payload)
-                print(
-                    "[status] "
-                    f"node={status.node_type}:{status.node_number} "
-                    f"level={status.level} "
-                    f"parent={format_mac(status.parent_mac)} "
-                    f"self={format_mac(status.self_mac)} "
-                    f"rssi={status.rssi}"
+                logger.info(
+                    "[status] node=%s:%s level=%s parent=%s self=%s rssi=%s",
+                    status.node_type,
+                    status.node_number,
+                    status.level,
+                    format_mac(status.parent_mac),
+                    format_mac(status.self_mac),
+                    status.rssi,
                 )
                 writer.write(build_ack(MsgType.STATUS, 0, "ok"))
                 await writer.drain()
             elif msg_type == MsgType.DATA:
                 batch = parse_acc_batch(payload)
-                print(f"[data] node={batch.node_type}:{batch.node_number} samples={len(batch.samples)}")
+                logger.info(
+                    "[data] node=%s:%s samples=%d",
+                    batch.node_type,
+                    batch.node_number,
+                    len(batch.samples),
+                )
                 writer.write(build_ack(MsgType.DATA, 0, "ok"))
                 await writer.drain()
             elif msg_type == MsgType.PPS:
                 pps = parse_pps(payload)
-                print(f"[pps] node={pps.node_type}:{pps.node_number} cc={pps.cc} epoch={pps.epoch}")
+                logger.info(
+                    "[pps] node=%s:%s cc=%s epoch=%s",
+                    pps.node_type,
+                    pps.node_number,
+                    pps.cc,
+                    pps.epoch,
+                )
                 writer.write(build_ack(MsgType.PPS, 0, "ok"))
                 await writer.drain()
             elif msg_type == MsgType.SD_STREAM:
                 chunk = parse_sd_chunk(payload)
-                print(
-                    f"[sd] node={chunk.node_type}:{chunk.node_number} "
-                    f"file_time={chunk.file_time} offset={chunk.offset} size={len(chunk.data)}"
+                logger.info(
+                    "[sd] node=%s:%s file_time=%s offset=%s size=%d",
+                    chunk.node_type,
+                    chunk.node_number,
+                    chunk.file_time,
+                    chunk.offset,
+                    len(chunk.data),
                 )
                 writer.write(build_ack(MsgType.SD_STREAM, 0, "ok"))
                 await writer.drain()
             elif msg_type == MsgType.SD_DONE:
                 done = parse_sd_done(payload)
-                print(
-                    f"[sd] node={done.node_type}:{done.node_number} "
-                    f"file_time={done.file_time} status={done.status}"
+                logger.info(
+                    "[sd] node=%s:%s file_time=%s status=%s",
+                    done.node_type,
+                    done.node_number,
+                    done.file_time,
+                    done.status,
                 )
                 writer.write(build_ack(MsgType.SD_DONE, 0, "ok"))
                 await writer.drain()
             else:
-                print(f"[server] msg_type=0x{msg_type:02X} len={len(payload)}")
+                logger.info("[server] msg_type=0x%02X len=%d", msg_type, len(payload))
                 writer.write(build_ack(msg_type, 0, "ok"))
                 await writer.drain()
     except asyncio.IncompleteReadError:
@@ -115,7 +137,7 @@ async def handle_client(reader: asyncio.StreamReader, writer: asyncio.StreamWrit
         clients.pop(peer_id, None)
         writer.close()
         await writer.wait_closed()
-        print(f"[server] disconnected {peer_id} (clients={len(clients)})")
+        logger.info("[server] disconnected %s (clients=%d)", peer_id, len(clients))
 
 
 async def broadcast_messages(
@@ -125,7 +147,7 @@ async def broadcast_messages(
     while True:
         payload = await queue.get()
         if not clients:
-            print("[server] no clients to broadcast to")
+            logger.info("[server] no clients to broadcast to")
             continue
         for peer_id, writer in list(clients.items()):
             try:
@@ -133,7 +155,7 @@ async def broadcast_messages(
                 await writer.drain()
             except ConnectionError:
                 clients.pop(peer_id, None)
-        print(f"[server] broadcast to {len(clients)} clients")
+        logger.info("[server] broadcast to %d clients", len(clients))
 
 
 async def run_server(

enode_host/cli.py

@@ -1,6 +1,12 @@
 import argparse
 import asyncio
 import contextlib
+import datetime as dt
+import configparser
+import logging
+import os
+import sys
+from pathlib import Path
 from typing import List, Optional
 
 from .async_socket import run_client, run_server
@@ -13,6 +19,7 @@ from .protocol import (
     build_sd_stream_stop,
     build_sd_clear,
     build_set_mode,
+    build_shutdown,
     build_start_daq,
     build_stop_daq,
 )
@@ -61,9 +68,129 @@ def build_command_from_tokens(tokens: List[str]) -> Optional[bytes]:
         return build_sd_stream_stop()
     if cmd == "sd_clear":
         return build_sd_clear()
+    if cmd == "shutdown":
+        return build_shutdown()
     raise ValueError(f"unknown command: {cmd}")
 
 
+def _is_truthy(value: Optional[str]) -> bool:
+    if not value:
+        return False
+    return value.strip().lower() in {"1", "true", "yes", "y", "on"}
+
+
+def _setup_logging() -> None:
+    config = configparser.ConfigParser()
+    log_date = dt.datetime.now().strftime("%Y-%m%d")
+    log_name = f"enode-host-{log_date}.log"
+    repo_root = Path(__file__).resolve().parents[3]
+    logs_dir = repo_root / "logs"
+    try:
+        logs_dir.mkdir(parents=True, exist_ok=True)
+    except OSError as exc:
+        print(f"[log] failed to create logs dir: {logs_dir} ({exc})", file=sys.stderr)
+        return
+
+    log_path = logs_dir / log_name
+    log_format = "%(asctime)s %(levelname)s %(name)s: %(message)s"
+    formatter = logging.Formatter(log_format, datefmt="%Y-%m-%d %H:%M:%S")
+
+    root = logging.getLogger()
+    root.setLevel(logging.INFO)
+
+    config_candidates = [Path.cwd() / "config.ini", repo_root / "python" / "config.ini"]
+    config.read([str(path) for path in config_candidates if path.exists()])
+    file_pps = config.getboolean("Logging", "file_pps", fallback=True)
+    file_conn_rpt = config.getboolean("Logging", "file_conn_rpt", fallback=True)
+    console_pps = config.getboolean("Logging", "terminal_pps", fallback=True)
+    console_conn_rpt = config.getboolean("Logging", "terminal_conn_rpt", fallback=False)
+
+    class _ConsoleFilter(logging.Filter):
+        def filter(self, record: logging.LogRecord) -> bool:
+            msg = record.getMessage()
+            if not console_pps and msg.startswith("[pps]"):
+                return False
+            if not console_conn_rpt and msg.startswith("Conn Rpt:"):
+                return False
+            return True
+
+    class _FileFilter(logging.Filter):
+        def filter(self, record: logging.LogRecord) -> bool:
+            msg = record.getMessage()
+            if not file_pps and msg.startswith("[pps]"):
+                return False
+            if not file_conn_rpt and msg.startswith("Conn Rpt:"):
+                return False
+            return True
+
+    want_file = True
+    want_console = True
+    for handler in root.handlers:
+        if isinstance(handler, logging.FileHandler):
+            try:
+                if Path(handler.baseFilename).resolve() == log_path.resolve():
+                    want_file = False
+            except OSError:
+                pass
+            handler.addFilter(_FileFilter())
+        elif isinstance(handler, logging.StreamHandler):
+            if not isinstance(handler, logging.FileHandler):
+                want_console = False
+                handler.addFilter(_ConsoleFilter())
+        handler.setFormatter(formatter)
+
+    if want_file:
+        file_handler = logging.FileHandler(log_path, encoding="utf-8")
+        file_handler.setFormatter(formatter)
+        file_handler.addFilter(_FileFilter())
+        root.addHandler(file_handler)
+    if want_console:
+        console_handler = logging.StreamHandler()
+        console_handler.setFormatter(formatter)
+        console_handler.addFilter(_ConsoleFilter())
+        root.addHandler(console_handler)
+
+
+def _display_available() -> bool:
+    wayland_display = os.environ.get("WAYLAND_DISPLAY")
+    xdg_runtime_dir = os.environ.get("XDG_RUNTIME_DIR")
+    if wayland_display and xdg_runtime_dir:
+        if Path(xdg_runtime_dir, wayland_display).exists():
+            return True
+
+    display = os.environ.get("DISPLAY")
+    if not display:
+        return False
+
+    host, _, rest = display.rpartition(":")
+    if not rest:
+        return False
+
+    display_num = rest.split(".", 1)[0]
+    if not display_num.isdigit():
+        return True
+
+    host = host.lower()
+    if host in ("", "unix"):
+        return Path(f"/tmp/.X11-unix/X{display_num}").exists()
+
+    return True
+
+
+def _ensure_gui_display() -> bool:
+    if _is_truthy(os.environ.get("ENODE_GUI_FORCE")):
+        return True
+    if _display_available():
+        return True
+    print("[gui] no display detected (X11/Wayland).", file=sys.stderr)
+    print(
+        "[gui] Run `enode-host server ...`, or start an X11/Wayland session, or use `xvfb-run enode-host gui`.",
+        file=sys.stderr,
+    )
+    print("[gui] Set ENODE_GUI_FORCE=1 to try anyway.", file=sys.stderr)
+    return False
+
+
 def build_parser() -> argparse.ArgumentParser:
     parser = argparse.ArgumentParser(
         prog="enode-host",
@@ -112,6 +239,7 @@ def build_parser() -> argparse.ArgumentParser:
 
 
 def main() -> int:
+    _setup_logging()
     parser = build_parser()
     args = parser.parse_args()
 
@@ -120,6 +248,8 @@ def main() -> int:
         return 0
 
     if args.command is None:
+        if not _ensure_gui_display():
+            return 2
         try:
             from .gui_framed import run_gui
         except Exception as exc:
@@ -142,6 +272,8 @@ def main() -> int:
         return 0
 
     if args.command == "gui":
+        if not _ensure_gui_display():
+            return 2
         try:
             from .gui_framed import run_gui
         except Exception as exc:

enode_host/constants.py

@@ -17,6 +17,7 @@ PACKET_SIZE = 23
 SPEED_COL = "Speed\n(kB/s)"
 RSSI_COL = "RSSI\n(dB)"
 PPS_COL = "PPS\nage"
+BAT_COL = "BAT\n(V)"
 LEVEL_COL = "Lv"
 
 PPS_AGE_LIMIT_SEC = 10

enode_host/framed_mesh.py

@@ -1,4 +1,5 @@
 import asyncio
+import logging
 import threading
 from typing import Dict, Optional
 
@@ -16,6 +17,8 @@ from .protocol import (
     parse_gnss,
 )
 
+logger = logging.getLogger(__name__)
+
 
 class FramedMesh:
     def __init__(self, model, host: str = "0.0.0.0", port: int = 3333):
@@ -71,6 +74,7 @@ class FramedMesh:
                         daq_mode=status.daq_mode,
                         daq_on=status.daq_on,
                         stream_status=status.stream_status,
+                        bat_vol=status.bat_vol,
                         notify=False,
                     )
                 elif msg_type == MsgType.DATA:
@@ -87,12 +91,15 @@ class FramedMesh:
                         pps = parse_pps(payload)
                     except Exception as exc:
                         preview = payload[:12].hex()
-                        print(f"[pps] parse failed len={len(payload)} head={preview} err={exc}")
+                        logger.warning(
+                            "[pps] parse failed len=%d head=%s err=%s", len(payload), preview, exc
+                        )
                         continue
                     node_id = self.model.make_node_key(pps.node_type, pps.node_number)
                     self.clients[node_id] = writer
                     with self._stat_lock:
                         self._pps_frames += 1
+                    self._ui_log(f"[pps] node={node_id} cc={pps.cc} epoch={pps.epoch}")
                     self.model.enqueue_pps(node_id, pps.cc, pps.epoch)
                 elif msg_type == MsgType.SD_STREAM:
                     chunk = parse_sd_chunk(payload)
@@ -158,7 +165,7 @@ class FramedMesh:
         if callable(ui_log):
             ui_log(msg)
         else:
-            print(msg)
+            logger.info("%s", msg)
 
     async def _send(self, writer: asyncio.StreamWriter, payload: bytes) -> None:
         writer.write(payload)

enode_host/gui_framed.py

@@ -4,7 +4,7 @@ import threading
 import wx
 
 from .framed_mesh import FramedMesh
-from .cli import build_command_from_tokens
+from .cli import _setup_logging, build_command_from_tokens
 from .protocol import (
     Toggle,
     build_realtime_stream,
@@ -12,6 +12,7 @@ from .protocol import (
     build_sd_stream_start,
     build_sd_stream_stop,
     build_set_daq_mode,
+    build_shutdown,
     build_start_daq,
     build_stop_daq,
 )
@@ -30,6 +31,10 @@ class Controller:
         self.mesh = FramedMesh(self.model, host=host, port=port)
 
         self.view.m_button_nodes_update.Bind(wx.EVT_BUTTON, self.on_change_node_nums)
+        self.view.m_textCtrl_acc.Bind(wx.EVT_TEXT_ENTER, self.on_change_node_nums)
+        self.view.m_textCtrl_tmp.Bind(wx.EVT_TEXT_ENTER, self.on_change_node_nums)
+        self.view.m_textCtrl_str.Bind(wx.EVT_TEXT_ENTER, self.on_change_node_nums)
+        self.view.m_textCtrl_veh.Bind(wx.EVT_TEXT_ENTER, self.on_change_node_nums)
         self.view.Bind(wx.EVT_MENU, self.on_exit, self.view.m_menu_file_quit)
         self.view.Bind(wx.EVT_MENU, self.on_merge_rt_files, self.view.m_menu_data_export)
         self.view.Bind(wx.EVT_MENU, self.on_merge_sd_files, self.view.m_menu_data_merge_sd)
@@ -37,7 +42,7 @@ class Controller:
         self.view.Bind(wx.EVT_MENU, self.on_plot_sd_merged, self.view.m_menu_data_plot_sd)
         self.view.Bind(wx.EVT_MENU, self.on_clear_rt_files, self.view.m_menu_data_clear_rt)
         self.view.Bind(wx.EVT_MENU, self.on_clear_sd_files, self.view.m_menu_data_clear_sd)
-        self.view.Bind(wx.EVT_MENU, self.on_view_clf, self.view.m_menu_view_clf)
+        self.view.m_button_clf.Bind(wx.EVT_BUTTON, self.on_view_clf)
         self.view.m_button1.Bind(wx.EVT_BUTTON, self.on_command_choice_send)
         self.view.m_textCtrl_cmd.Bind(wx.EVT_TEXT_ENTER, self.on_command_send)
 
@@ -79,6 +84,7 @@ class Controller:
         self.model.init_other_data()
         self.view.init_plot()
         self.view.figure_update()
+        self.view.show_rt_plots()
 
     def _broadcast(self, payload: bytes, label: str) -> None:
         sent = self.mesh.broadcast_command(payload, label=label)
@@ -105,6 +111,8 @@ class Controller:
             self._broadcast(build_sd_stream_stop(), "sd_stream_stop")
         elif selection == "SD Clear All":
             self._broadcast(build_sd_clear(), "sd_clear")
+        elif selection == "Shutdown":
+            self._broadcast(build_shutdown(), "shutdown")
 
     def set_daq_mode(self, node_id: str, mode: int) -> None:
         payload = build_set_daq_mode(mode)
@@ -202,6 +210,7 @@ class Controller:
 
 
 def run_gui(host: str = "0.0.0.0", port: int = 3333) -> None:
+    _setup_logging()
     app = wx.App()
     Controller(host=host, port=port)
     app.MainLoop()