conson-xp 1.27.0__tar.gz → 1.28.0__tar.gz

{conson_xp-1.27.0 → conson_xp-1.28.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: conson-xp
-Version: 1.27.0
+Version: 1.28.0
 Summary: XP Protocol Communication Tools
 Author-Email: ldvchosal <ldvchosal@github.com>
 License: MIT License
@@ -417,6 +417,7 @@ xp telegram version
 
 xp term
 xp term protocol
+xp term state
 
 <!-- END CLI HELP -->
 ```

{conson_xp-1.27.0 → conson_xp-1.28.0}/README.md

@@ -364,6 +364,7 @@ xp telegram version
 
 xp term
 xp term protocol
+xp term state
 
 <!-- END CLI HELP -->
 ```

{conson_xp-1.27.0 → conson_xp-1.28.0}/pyproject.toml

@@ -22,7 +22,7 @@ dependencies = [
 ]
 requires-python = ">=3.11"
 readme = "README.md"
-version = "1.27.0"
+version = "1.28.0"
 
 [project.license]
 file = "LICENSE"

{conson_xp-1.27.0 → conson_xp-1.28.0}/src/xp/__init__.py

@@ -3,7 +3,7 @@
 conson-xp package.
 """
 
-__version__ = "1.27.0"
+__version__ = "1.28.0"
 __manufacturer__ = "salchichon"
 __model__ = "xp.cli"
 __serial__ = "2025.09.23.000"

{conson_xp-1.27.0 → conson_xp-1.28.0}/src/xp/cli/commands/term/term_commands.py

@@ -25,3 +25,24 @@ def protocol_monitor(ctx: Context) -> None:
 
     # Resolve ProtocolMonitorApp from container and run
     ctx.obj.get("container").get_container().resolve(ProtocolMonitorApp).run()
+
+
+@term.command("state")
+@click.pass_context
+def state_monitor(ctx: Context) -> None:
+    r"""Start TUI for module state monitoring.
+
+    Displays module states from Conson configuration with real-time
+    updates in an interactive terminal interface.
+
+    Args:
+        ctx: Click context object.
+
+    Examples:
+        \b
+        xp term state
+    """
+    from xp.term.state import StateMonitorApp
+
+    # Resolve StateMonitorApp from container and run
+    ctx.obj.get("container").get_container().resolve(StateMonitorApp).run()

{conson_xp-1.27.0 → conson_xp-1.28.0}/src/xp/models/term/__init__.py

@@ -1,11 +1,13 @@
 """Terminal UI models."""
 
+from xp.models.term.module_state import ModuleState
 from xp.models.term.protocol_keys_config import (
     ProtocolKeyConfig,
     ProtocolKeysConfig,
 )
 
 __all__ = [
+    "ModuleState",
     "ProtocolKeyConfig",
     "ProtocolKeysConfig",
 ]

conson_xp-1.28.0/src/xp/models/term/module_state.py

@@ -0,0 +1,28 @@
+"""Module state data model."""
+
+from dataclasses import dataclass
+from datetime import datetime
+from typing import Optional
+
+
+@dataclass
+class ModuleState:
+    """State of a Conson module for TUI display.
+
+    Attributes:
+        name: Module name/identifier (e.g., A01, A02).
+        serial_number: Module serial number.
+        module_type: Module type designation (e.g., XP130, XP230, XP24).
+        outputs: Output states as space-separated binary values. Empty string for modules without outputs.
+        auto_report: Auto-report enabled status (Y/N).
+        error_status: Module status ("OK" or error code like "E10").
+        last_update: Last communication timestamp. None if never updated.
+    """
+
+    name: str
+    serial_number: str
+    module_type: str
+    outputs: str
+    auto_report: bool
+    error_status: str
+    last_update: Optional[datetime]

{conson_xp-1.27.0 → conson_xp-1.28.0}/src/xp/services/server/xp24_server_service.py

@@ -161,10 +161,7 @@ class XP24ServerService(BaseServerService):
 
         data_value = handler()
         data_part = (
-            f"R{self.serial_number}"
-            f"F02D{datapoint_type.value}"
-            f"{self.module_type_code.value:02}"
-            f"{data_value}"
+            f"R{self.serial_number}" f"F02D{datapoint_type.value}" f"{data_value}"
         )
         telegram = self._build_response_telegram(data_part)
 

{conson_xp-1.27.0 → conson_xp-1.28.0}/src/xp/services/server/xp33_server_service.py

@@ -226,10 +226,7 @@ class XP33ServerService(BaseServerService):
 
         data_value = handler()
         data_part = (
-            f"R{self.serial_number}"
-            f"F02D{datapoint_type.value}"
-            f"{self.module_type_code.value:02}"
-            f"{data_value}"
+            f"R{self.serial_number}" f"F02D{datapoint_type.value}" f"{data_value}"
         )
         telegram = self._build_response_telegram(data_part)
 

{conson_xp-1.27.0 → conson_xp-1.28.0}/src/xp/services/telegram/telegram_output_service.py

@@ -320,3 +320,36 @@ class TelegramOutputService:
             f"Timestamp: {telegram.timestamp}\n"
             f"Checksum: {telegram.checksum}{checksum_status}"
         )
+
+    @staticmethod
+    def format_output_state(data_value: str) -> str:
+        """Format module output state data value for display.
+
+        Algorithm:
+        1. Remove 'x' characters
+        2. Format to 4 chars with space padding on the right
+        3. Invert order
+        4. Add spaces between characters
+
+        Args:
+            data_value: Raw data value from module output state datapoint (e.g., "xxxx0101", "xx1110").
+
+        Returns:
+            Formatted output string with spaces (e.g., "1 0 1 0", "0 1 1 1").
+
+        Examples:
+            >>> TelegramOutputService.format_output_state("xxxx0101")
+            "1 0 1 0"
+            >>> TelegramOutputService.format_output_state("xx1110")
+            "0 1 1 1"
+            >>> TelegramOutputService.format_output_state("xxxx01")
+            "  1 0"
+        """
+        # Remove 'x' characters
+        cleaned = data_value.replace("x", "").replace("X", "")
+        # Format to 4 chars with space padding on the right
+        padded = cleaned.ljust(4)[:4]
+        # Invert order
+        inverted = padded[::-1]
+        # Add spaces between characters
+        return " ".join(inverted)

conson_xp-1.28.0/src/xp/services/term/__init__.py

@@ -0,0 +1,6 @@
+"""Terminal interface services."""
+
+from xp.services.term.protocol_monitor_service import ProtocolMonitorService
+from xp.services.term.state_monitor_service import StateMonitorService
+
+__all__ = ["ProtocolMonitorService", "StateMonitorService"]

conson_xp-1.28.0/src/xp/services/term/state_monitor_service.py

@@ -0,0 +1,313 @@
+"""State Monitor Service for terminal interface."""
+
+import logging
+from datetime import datetime
+from typing import Dict, List
+
+from psygnal import Signal
+
+from xp.models.homekit.homekit_conson_config import ConsonModuleListConfig
+from xp.models.protocol.conbus_protocol import TelegramReceivedEvent
+from xp.models.telegram.datapoint_type import DataPointType
+from xp.models.telegram.system_function import SystemFunction
+from xp.models.telegram.telegram_type import TelegramType
+from xp.models.term.connection_state import ConnectionState
+from xp.models.term.module_state import ModuleState
+from xp.services.protocol.conbus_event_protocol import ConbusEventProtocol
+from xp.services.telegram.telegram_output_service import TelegramOutputService
+from xp.services.telegram.telegram_service import TelegramService
+
+
+class StateMonitorService:
+    """Service for module state monitoring in terminal interface.
+
+    Wraps ConbusEventProtocol and ConsonModuleListConfig to provide
+    high-level module state tracking for the TUI.
+
+    Attributes:
+        on_connection_state_changed: Signal emitted when connection state changes.
+        on_module_list_updated: Signal emitted when module list refreshed from config.
+        on_module_state_changed: Signal emitted when individual module state updates.
+        on_module_error: Signal emitted when module error occurs.
+        on_status_message: Signal emitted for status messages.
+        connection_state: Property returning current connection state.
+        server_info: Property returning server connection info (IP:port).
+        module_states: Property returning list of all module states.
+    """
+
+    on_connection_state_changed: Signal = Signal(ConnectionState)
+    on_module_list_updated: Signal = Signal(list)
+    on_module_state_changed: Signal = Signal(ModuleState)
+    on_module_error: Signal = Signal(str, str)
+    on_status_message: Signal = Signal(str)
+
+    def __init__(
+        self,
+        conbus_protocol: ConbusEventProtocol,
+        conson_config: ConsonModuleListConfig,
+        telegram_service: TelegramService,
+    ) -> None:
+        """Initialize the State Monitor service.
+
+        Args:
+            conbus_protocol: ConbusEventProtocol instance.
+            conson_config: ConsonModuleListConfig for module configuration.
+            telegram_service: TelegramService for parsing telegrams.
+        """
+        self.logger = logging.getLogger(__name__)
+        self._conbus_protocol = conbus_protocol
+        self._conson_config = conson_config
+        self._telegram_service = telegram_service
+        self._connection_state = ConnectionState.DISCONNECTED
+        self._state_machine = ConnectionState.create_state_machine()
+        self._module_states: Dict[str, ModuleState] = {}
+
+        # Connect to protocol signals
+        self._connect_signals()
+
+        # Initialize module states from config
+        self._initialize_module_states()
+
+    def _initialize_module_states(self) -> None:
+        """Initialize module states from ConsonModuleListConfig."""
+        for module_config in self._conson_config.root:
+            # Map auto_report_status: PP → True, others → False
+            auto_report = module_config.auto_report_status == "PP"
+
+            module_state = ModuleState(
+                name=module_config.name,
+                serial_number=module_config.serial_number,
+                module_type=module_config.module_type,
+                outputs="",  # Empty initially
+                auto_report=auto_report,
+                error_status="OK",
+                last_update=None,  # Not updated yet
+            )
+            self._module_states[module_config.serial_number] = module_state
+
+    def _connect_signals(self) -> None:
+        """Connect to protocol signals."""
+        self._conbus_protocol.on_connection_made.connect(self._on_connection_made)
+        self._conbus_protocol.on_connection_failed.connect(self._on_connection_failed)
+        self._conbus_protocol.on_telegram_received.connect(self._on_telegram_received)
+        self._conbus_protocol.on_timeout.connect(self._on_timeout)
+        self._conbus_protocol.on_failed.connect(self._on_failed)
+
+    def _disconnect_signals(self) -> None:
+        """Disconnect from protocol signals."""
+        self._conbus_protocol.on_connection_made.disconnect(self._on_connection_made)
+        self._conbus_protocol.on_connection_failed.disconnect(
+            self._on_connection_failed
+        )
+        self._conbus_protocol.on_telegram_received.disconnect(
+            self._on_telegram_received
+        )
+        self._conbus_protocol.on_timeout.disconnect(self._on_timeout)
+        self._conbus_protocol.on_failed.disconnect(self._on_failed)
+
+    @property
+    def connection_state(self) -> ConnectionState:
+        """Get current connection state.
+
+        Returns:
+            Current connection state.
+        """
+        return self._connection_state
+
+    @property
+    def server_info(self) -> str:
+        """Get server connection info (IP:port).
+
+        Returns:
+            Server address in format "IP:port".
+        """
+        return f"{self._conbus_protocol.cli_config.ip}:{self._conbus_protocol.cli_config.port}"
+
+    @property
+    def module_states(self) -> List[ModuleState]:
+        """Get all module states.
+
+        Returns:
+            List of all module states.
+        """
+        return list(self._module_states.values())
+
+    def connect(self) -> None:
+        """Initiate connection to server."""
+        if not self._state_machine.can_transition("connect"):
+            self.logger.warning(
+                f"Cannot connect: current state is {self._connection_state.value}"
+            )
+            return
+
+        if self._state_machine.transition("connecting", ConnectionState.CONNECTING):
+            self._connection_state = ConnectionState.CONNECTING
+            self.on_connection_state_changed.emit(self._connection_state)
+            self.on_status_message.emit(f"Connecting to {self.server_info}...")
+
+        self._conbus_protocol.connect()
+
+    def disconnect(self) -> None:
+        """Disconnect from server."""
+        if not self._state_machine.can_transition("disconnect"):
+            self.logger.warning(
+                f"Cannot disconnect: current state is {self._connection_state.value}"
+            )
+            return
+
+        if self._state_machine.transition(
+            "disconnecting", ConnectionState.DISCONNECTING
+        ):
+            self._connection_state = ConnectionState.DISCONNECTING
+            self.on_connection_state_changed.emit(self._connection_state)
+            self.on_status_message.emit("Disconnecting...")
+
+        self._conbus_protocol.disconnect()
+
+        if self._state_machine.transition("disconnected", ConnectionState.DISCONNECTED):
+            self._connection_state = ConnectionState.DISCONNECTED
+            self.on_connection_state_changed.emit(self._connection_state)
+            self.on_status_message.emit("Disconnected")
+
+    def toggle_connection(self) -> None:
+        """Toggle connection state between connected and disconnected.
+
+        Disconnects if currently connected or connecting.
+        Connects if currently disconnected or failed.
+        """
+        if self._connection_state in (
+            ConnectionState.CONNECTED,
+            ConnectionState.CONNECTING,
+        ):
+            self.disconnect()
+        else:
+            self.connect()
+
+    def refresh_all(self) -> None:
+        """Refresh all module states.
+
+        Queries module_output_state datapoint for eligible modules (XP24, XP33LR, XP33LED).
+        Updates outputs column and last_update timestamp for each queried module.
+        """
+        self.on_status_message.emit("Refreshing module states...")
+
+        # Eligible module types that support output state queries
+        eligible_types = {"XP24", "XP33LR", "XP33LED"}
+
+        # Filter and query eligible modules
+        for module_state in self._module_states.values():
+            if module_state.module_type in eligible_types:
+                self._query_module_output_state(module_state.serial_number)
+                self.logger.debug(
+                    f"Querying output state for {module_state.name} ({module_state.module_type})"
+                )
+
+    def _query_module_output_state(self, serial_number: str) -> None:
+        """Query module output state datapoint.
+
+        Args:
+            serial_number: Module serial number to query.
+        """
+        self._conbus_protocol.send_telegram(
+            telegram_type=TelegramType.SYSTEM,
+            serial_number=serial_number,
+            system_function=SystemFunction.READ_DATAPOINT,
+            data_value=str(DataPointType.MODULE_OUTPUT_STATE.value),
+        )
+
+    def _on_connection_made(self) -> None:
+        """Handle connection made event."""
+        if self._state_machine.transition("connected", ConnectionState.CONNECTED):
+            self._connection_state = ConnectionState.CONNECTED
+            self.on_connection_state_changed.emit(self._connection_state)
+            self.on_status_message.emit(f"Connected to {self.server_info}")
+
+            # Emit initial module list
+            self.on_module_list_updated.emit(self.module_states)
+
+    def _on_connection_failed(self, failure: Exception) -> None:
+        """Handle connection failed event.
+
+        Args:
+            failure: Exception that caused the failure.
+        """
+        if self._state_machine.transition("failed", ConnectionState.FAILED):
+            self._connection_state = ConnectionState.FAILED
+            self.on_connection_state_changed.emit(self._connection_state)
+            self.on_status_message.emit(f"Connection failed: {failure}")
+
+    def _on_telegram_received(self, event: TelegramReceivedEvent) -> None:
+        """Handle telegram received event.
+
+        Parse output states from telegram and update module state.
+
+        Args:
+            event: Telegram received event.
+        """
+        # Only process reply telegrams
+        if event.telegram_type != TelegramType.REPLY:
+            return
+
+        serial_number = event.serial_number
+        if not serial_number or serial_number not in self._module_states:
+            return
+
+        # Parse the reply telegram
+        reply_telegram = self._telegram_service.parse_reply_telegram(event.frame)
+        if not reply_telegram:
+            return
+
+        # Check if this is a module output state response
+        if (
+            reply_telegram.system_function == SystemFunction.READ_DATAPOINT
+            and reply_telegram.datapoint_type == DataPointType.MODULE_OUTPUT_STATE
+        ):
+            module_state = self._module_states[serial_number]
+
+            # Parse output state from data_value using TelegramOutputService
+            outputs = TelegramOutputService.format_output_state(
+                reply_telegram.data_value
+            )
+            module_state.outputs = outputs
+            module_state.last_update = datetime.now()
+
+            self.on_module_state_changed.emit(module_state)
+            self.logger.debug(f"Updated outputs for {module_state.name}: {outputs}")
+
+    def _on_timeout(self) -> None:
+        """Handle timeout event."""
+        self.on_status_message.emit("Connection timeout")
+
+    def _on_failed(self, failure: Exception) -> None:
+        """Handle protocol failure event.
+
+        Args:
+            failure: Exception that caused the failure.
+        """
+        if self._state_machine.transition("failed", ConnectionState.FAILED):
+            self._connection_state = ConnectionState.FAILED
+            self.on_connection_state_changed.emit(self._connection_state)
+            self.on_status_message.emit(f"Protocol error: {failure}")
+
+    def cleanup(self) -> None:
+        """Clean up service resources."""
+        self._disconnect_signals()
+        self.logger.debug("StateMonitorService cleaned up")
+
+    def __enter__(self) -> "StateMonitorService":
+        """Context manager entry.
+
+        Returns:
+            Self for context manager.
+        """
+        return self
+
+    def __exit__(self, _exc_type: object, _exc_val: object, _exc_tb: object) -> None:
+        """Context manager exit.
+
+        Args:
+            _exc_type: Exception type.
+            _exc_val: Exception value.
+            _exc_tb: Exception traceback.
+        """
+        self.cleanup()

conson_xp-1.28.0/src/xp/term/state.py

@@ -0,0 +1,97 @@
+"""State Monitor TUI Application."""
+
+from pathlib import Path
+from typing import Optional
+
+from textual.app import App, ComposeResult
+
+from xp.services.term.state_monitor_service import StateMonitorService
+from xp.term.widgets.modules_list import ModulesListWidget
+from xp.term.widgets.status_footer import StatusFooterWidget
+
+
+class StateMonitorApp(App[None]):
+    """Textual app for module state monitoring.
+
+    Displays module states from Conson configuration in an interactive
+    terminal interface with real-time updates.
+
+    Attributes:
+        state_service: StateMonitorService for module state operations.
+        CSS_PATH: Path to CSS stylesheet file.
+        BINDINGS: Keyboard bindings for app actions.
+        TITLE: Application title displayed in header.
+        ENABLE_COMMAND_PALETTE: Disable Textual's command palette feature.
+    """
+
+    CSS_PATH = Path(__file__).parent / "state.tcss"
+    TITLE = "Modules"
+    ENABLE_COMMAND_PALETTE = False
+
+    BINDINGS = [
+        ("Q", "quit", "Quit"),
+        ("C", "toggle_connection", "Connect"),
+        ("r", "refresh_all", "Refresh"),
+    ]
+
+    def __init__(self, state_service: StateMonitorService) -> None:
+        """Initialize the State Monitor app.
+
+        Args:
+            state_service: StateMonitorService for module state operations.
+        """
+        super().__init__()
+        self.state_service: StateMonitorService = state_service
+        self.modules_widget: Optional[ModulesListWidget] = None
+        self.footer_widget: Optional[StatusFooterWidget] = None
+
+    def compose(self) -> ComposeResult:
+        """Compose the app layout with widgets.
+
+        Yields:
+            ModulesListWidget and StatusFooterWidget.
+        """
+        self.modules_widget = ModulesListWidget(
+            service=self.state_service, id="modules-list"
+        )
+        yield self.modules_widget
+
+        self.footer_widget = StatusFooterWidget(
+            service=self.state_service, id="footer-container"
+        )
+        yield self.footer_widget
+
+    async def on_mount(self) -> None:
+        """Initialize app after UI is mounted.
+
+        Delays connection by 0.5s to let UI render first.
+        Sets up automatic screen refresh every second to update elapsed times.
+        """
+        import asyncio
+
+        # Delay connection to let UI render
+        await asyncio.sleep(0.5)
+        self.state_service.connect()
+
+        # Set up periodic refresh to update elapsed times
+        self.set_interval(1.0, self._refresh_last_update_column)
+
+    def _refresh_last_update_column(self) -> None:
+        """Refresh only the last_update column to show elapsed time."""
+        if self.modules_widget:
+            self.modules_widget.refresh_last_update_times()
+
+    def action_toggle_connection(self) -> None:
+        """Toggle connection on 'c' key press.
+
+        Connects if disconnected/failed, disconnects if connected/connecting.
+        """
+        self.state_service.toggle_connection()
+
+    def action_refresh_all(self) -> None:
+        """Refresh all module data on 'r' key press."""
+        self.state_service.refresh_all()
+
+    def on_unmount(self) -> None:
+        """Clean up service when app unmounts."""
+        self.state_service.cleanup()

conson_xp-1.28.0/src/xp/term/state.tcss

@@ -0,0 +1,86 @@
+/* State Monitor TUI Styling */
+
+/* Color overrides */
+$success: #00ff00;
+
+/* App-level styling */
+Screen {
+    background: $background;
+}
+
+/* Modules List Widget */
+ModulesListWidget {
+    border: solid $success;
+    border-title-align: left;
+    width: 1fr;
+    height: 1fr;
+    background: $background;
+    padding: 1;
+}
+
+ModulesListWidget:focus {
+    background: $background;
+    background-tint: transparent;
+}
+
+#modules-table {
+    background: $background !important;
+    width: 100%;
+    height: 1fr;
+}
+
+#modules-table:focus {
+    background: $background !important;
+    background-tint: transparent;
+}
+
+DataTable {
+    background: $background;
+    color: $success;
+}
+
+DataTable > .datatable--header {
+    background: $background;
+    color: $success;
+}
+
+DataTable > .datatable--cursor {
+    background: $background;
+    color: $success;
+}
+
+DataTable:focus > .datatable--cursor {
+    background: $background;
+    color: $success;
+}
+
+/* Footer styling */
+#footer-container {
+    dock: bottom;
+    height: 1;
+    background: $background;
+}
+
+Footer {
+    width: auto;
+    background: $background;
+    color: $text;
+}
+
+#status-text {
+    dock: right;
+    width: auto;
+    padding: 0 3;
+    background: $background;
+    color: $text;
+    text-align: right;
+}
+
+#status-line {
+    dock: right;
+    width: auto;
+    padding: 0 1;
+    background: $background;
+    color: $text;
+    text-align: right;
+}