conson-xp 1.20.0__py3-none-any.whl → 1.22.0__py3-none-any.whl

xp/term/widgets/help_menu.py

@@ -0,0 +1,55 @@
+"""Help Menu Widget for displaying keyboard shortcuts and protocol keys."""
+
+from typing import Any
+
+from textual.app import ComposeResult
+from textual.containers import Vertical
+from textual.widgets import DataTable
+
+from xp.models.term import ProtocolKeysConfig
+
+
+class HelpMenuWidget(Vertical):
+    """Help menu widget displaying keyboard shortcuts and protocol keys.
+
+    Displays a table of available keyboard shortcuts mapped to their
+    corresponding protocol commands.
+
+    Attributes:
+        protocol_keys: Configuration of protocol keys and their telegrams.
+        help_table: DataTable widget for displaying key mappings.
+    """
+
+    def __init__(
+        self,
+        protocol_keys: ProtocolKeysConfig,
+        *args: Any,
+        **kwargs: Any,
+    ) -> None:
+        """Initialize the Help Menu widget.
+
+        Args:
+            protocol_keys: Configuration containing protocol key mappings.
+            args: Additional positional arguments for Vertical.
+            kwargs: Additional keyword arguments for Vertical.
+        """
+        super().__init__(*args, **kwargs)
+        self.protocol_keys = protocol_keys
+        self.help_table: DataTable = DataTable(id="help-table", show_header=False)
+        self.help_table.can_focus = False
+        self.border_title = "Help menu"
+        self.can_focus = False
+
+    def compose(self) -> ComposeResult:
+        """Compose the help menu layout.
+
+        Yields:
+            DataTable widget with key mappings.
+        """
+        yield self.help_table
+
+    def on_mount(self) -> None:
+        """Populate help table when widget mounts."""
+        self.help_table.add_columns("Key", "Command")
+        for key, config in self.protocol_keys.protocol.items():
+            self.help_table.add_row(key, config.name)

xp/{tui → term}/widgets/protocol_log.py

@@ -5,6 +5,7 @@ import logging
 from enum import Enum
 from typing import Any, Optional
 
+from textual.message import Message
 from textual.reactive import reactive
 from textual.widget import Widget
 from textual.widgets import RichLog
@@ -12,24 +13,62 @@ from textual.widgets import RichLog
 from xp.models.protocol.conbus_protocol import TelegramReceivedEvent
 from xp.services.conbus.conbus_receive_service import ConbusReceiveService
 from xp.services.protocol import ConbusEventProtocol
+from xp.utils.state_machine import StateMachine
 
 
 class ConnectionState(str, Enum):
     """Connection state enumeration.
 
     Attributes:
+        DISCONNECTING: Disconnecting to server.
         DISCONNECTED: Not connected to server.
         CONNECTING: Connection in progress.
         CONNECTED: Successfully connected.
         FAILED: Connection failed.
     """
 
+    DISCONNECTING = "DISCONNECTING"
     DISCONNECTED = "DISCONNECTED"
     CONNECTING = "CONNECTING"
     CONNECTED = "CONNECTED"
     FAILED = "FAILED"
 
 
+def create_connection_state_machine() -> StateMachine:
+    """Create and configure state machine for connection management.
+
+    Returns:
+        Configured StateMachine with connection state transitions.
+    """
+    sm = StateMachine(ConnectionState.DISCONNECTED)
+
+    # Define valid transitions
+    sm.define_transition(
+        "connect", {ConnectionState.DISCONNECTED, ConnectionState.FAILED}
+    )
+    sm.define_transition(
+        "disconnect", {ConnectionState.CONNECTED, ConnectionState.CONNECTING}
+    )
+    sm.define_transition(
+        "connecting", {ConnectionState.DISCONNECTED, ConnectionState.FAILED}
+    )
+    sm.define_transition("connected", {ConnectionState.CONNECTING})
+    sm.define_transition(
+        "disconnecting", {ConnectionState.CONNECTED, ConnectionState.CONNECTING}
+    )
+    sm.define_transition("disconnected", {ConnectionState.DISCONNECTING})
+    sm.define_transition(
+        "failed",
+        {
+            ConnectionState.CONNECTING,
+            ConnectionState.CONNECTED,
+            ConnectionState.DISCONNECTING,
+        },
+    )
+
+    return sm
+
+
 class ProtocolLogWidget(Widget):
     """Widget for displaying protocol telegram stream.
 
@@ -45,6 +84,18 @@ class ProtocolLogWidget(Widget):
         log_widget: RichLog widget for displaying messages.
     """
 
+    class StatusMessageChanged(Message):
+        """Message posted when status message changes."""
+
+        def __init__(self, message: str) -> None:
+            """Initialize the message.
+
+            Args:
+                message: The status message to display.
+            """
+            super().__init__()
+            self.message = message
+
     connection_state = reactive(ConnectionState.DISCONNECTED)
 
     def __init__(self, container: Any) -> None:
@@ -54,11 +105,13 @@ class ProtocolLogWidget(Widget):
             container: ServiceContainer for resolving services.
         """
         super().__init__()
+        self.border_title = "Protocol"
         self.container = container
         self.protocol: Optional[ConbusEventProtocol] = None
         self.service: Optional[ConbusReceiveService] = None
         self.logger = logging.getLogger(__name__)
         self.log_widget: Optional[RichLog] = None
+        self._state_machine = create_connection_state_machine()
 
     def compose(self) -> Any:
         """Compose the widget layout.
@@ -66,7 +119,7 @@ class ProtocolLogWidget(Widget):
         Yields:
             RichLog widget for message display.
         """
-        self.log_widget = RichLog(highlight=True, markup=True)
+        self.log_widget = RichLog(highlight=False, markup=True)
         yield self.log_widget
 
     async def on_mount(self) -> None:
@@ -88,7 +141,7 @@ class ProtocolLogWidget(Widget):
 
         # Delay connection to let UI render
         await asyncio.sleep(0.5)
-        await self._start_connection_async()
+        self._start_connection()
 
     async def _start_connection_async(self) -> None:
         """Start TCP connection to Conbus server (async).
@@ -105,11 +158,22 @@ class ProtocolLogWidget(Widget):
             self.logger.error("Protocol not initialized")
             return
 
+        # Guard: Don't connect if already connected or connecting
+        if not self._state_machine.can_transition("connecting"):
+            self.logger.warning(
+                f"Already {self._state_machine.get_state().value}, ignoring connect request"
+            )
+            return
+
         try:
-            # Set state to connecting
-            self.connection_state = ConnectionState.CONNECTING
-            if self.log_widget:
-                self.log_widget.write("[yellow]Connecting to Conbus server...[/yellow]")
+            # Transition to CONNECTING
+            if self._state_machine.transition("connecting", ConnectionState.CONNECTING):
+                self.connection_state = ConnectionState.CONNECTING
+                self.post_message(
+                    self.StatusMessageChanged(
+                        f"Connecting to {self.protocol.cli_config.ip}:{self.protocol.cli_config.port}..."
+                    )
+                )
 
             # Store protocol reference
             self.logger.info(f"Protocol object: {self.protocol}")
@@ -146,26 +210,11 @@ class ProtocolLogWidget(Widget):
             )
 
             reactor = self.service.conbus_protocol._reactor
-            # Schedule the connection on the running asyncio loop
-            # This ensures connectTCP is called in the context of the running loop
-
-            def do_connect() -> None:
-                """Execute TCP connection in event loop context."""
-                self.logger.info("Executing connectTCP in event loop callback")
-                if self.protocol is not None:
-                    reactor.connectTCP(
-                        self.protocol.cli_config.ip,
-                        self.protocol.cli_config.port,
-                        self.protocol,
-                    )
-
-            event_loop.call_soon(do_connect)
-            self.logger.info("Scheduled connectTCP on running loop")
-
-            if self.log_widget:
-                self.log_widget.write(
-                    f"[dim]→ {self.protocol.cli_config.ip}:{self.protocol.cli_config.port}[/dim]"
-                )
+            reactor.connectTCP(
+                self.protocol.cli_config.ip,
+                self.protocol.cli_config.port,
+                self.protocol,
+            )
 
             # Wait for connection to establish
             await asyncio.sleep(1.0)
@@ -173,15 +222,15 @@ class ProtocolLogWidget(Widget):
 
         except Exception as e:
             self.logger.error(f"Connection failed: {e}")
-            self.connection_state = ConnectionState.FAILED
-            if self.log_widget:
-                self.log_widget.write(f"[red]Connection error: {e}[/red]")
-            # Exit app after brief delay
-            self.set_timer(2.0, self.app.exit)
+            # Transition to FAILED
+            if self._state_machine.transition("failed", ConnectionState.FAILED):
+                self.connection_state = ConnectionState.FAILED
+                self.post_message(self.StatusMessageChanged(f"Connection error: {e}"))
 
     def _start_connection(self) -> None:
         """Start connection (sync wrapper for async method)."""
         # Use run_worker to run async method from sync context
+        self.logger.debug("Start connection")
         self.run_worker(self._start_connection_async(), exclusive=True)
 
     def _on_connection_made(self) -> None:
@@ -189,10 +238,16 @@ class ProtocolLogWidget(Widget):
 
         Sets state to CONNECTED and displays success message.
         """
-        self.connection_state = ConnectionState.CONNECTED
-        if self.log_widget:
-            self.log_widget.write("[green]Connected to Conbus server[/green]")
-            self.log_widget.write("[dim]---[/dim]")
+        self.logger.debug("Connection made")
+        # Transition to CONNECTED
+        if self._state_machine.transition("connected", ConnectionState.CONNECTED):
+            self.connection_state = ConnectionState.CONNECTED
+            if self.protocol:
+                self.post_message(
+                    self.StatusMessageChanged(
+                        f"Connected to {self.protocol.cli_config.ip}:{self.protocol.cli_config.port}"
+                    )
+                )
 
     def _on_telegram_received(self, event: TelegramReceivedEvent) -> None:
         """Handle telegram received signal.
@@ -200,9 +255,10 @@ class ProtocolLogWidget(Widget):
         Args:
             event: Telegram received event with frame data.
         """
+        self.logger.debug("Telegram received")
         if self.log_widget:
-            # Display [RX] in green, frame in gray
-            self.log_widget.write(f"[green]\\[RX][/green] [dim]{event.frame}[/dim]")
+            # Display [RX] and frame in bright green
+            self.log_widget.write(f"[#00ff00]\\[RX] {event.frame}[/#00ff00]")
 
     def _on_telegram_sent(self, telegram: str) -> None:
         """Handle telegram sent signal.
@@ -210,15 +266,17 @@ class ProtocolLogWidget(Widget):
         Args:
             telegram: Sent telegram string.
         """
+        self.logger.debug("Telegram sent")
         if self.log_widget:
-            # Display [TX] in green, frame in gray
-            self.log_widget.write(f"[green]\\[TX][/green] [dim]{telegram}[/dim]")
+            # Display [TX] and frame in bold bright green
+            self.log_widget.write(f"[bold #00ff00]\\[TX] {telegram}[/bold #00ff00]")
 
     def _on_timeout(self) -> None:
         """Handle timeout signal.
 
         Logs timeout but continues monitoring (no action needed).
         """
+        self.logger.debug("Timeout")
         self.logger.debug("Timeout occurred (continuous monitoring)")
 
     def _on_failed(self, error: str) -> None:
@@ -227,60 +285,83 @@ class ProtocolLogWidget(Widget):
         Args:
             error: Error message describing the failure.
         """
-        self.connection_state = ConnectionState.FAILED
-        self.logger.error(f"Connection failed: {error}")
+        # Transition to FAILED
+        if self._state_machine.transition("failed", ConnectionState.FAILED):
+            self.connection_state = ConnectionState.FAILED
+            self.logger.error(f"Connection failed: {error}")
+            self.post_message(self.StatusMessageChanged(f"Failed: {error}"))
 
-        if self.log_widget:
-            self.log_widget.write(f"[red]Connection failed: {error}[/red]")
+    def connect(self) -> None:
+        """Connect to Conbus server.
 
-        # Exit app after brief delay to show error
-        self.set_timer(2.0, self.app.exit)
+        Only initiates connection if currently DISCONNECTED or FAILED.
+        """
+        self.logger.debug("Connect")
+
+        # Guard: Check if connection is allowed
+        if not self._state_machine.can_transition("connect"):
+            self.logger.warning(
+                f"Cannot connect: current state is {self._state_machine.get_state().value}"
+            )
+            return
 
-    def connect(self) -> None:
-        """Connect to Conbus server."""
         self._start_connection()
 
     def disconnect(self) -> None:
-        """Disconnect from Conbus server."""
+        """Disconnect from Conbus server.
+
+        Only disconnects if currently CONNECTED or CONNECTING.
+        """
+        self.logger.debug("Disconnect")
+
+        # Guard: Check if disconnection is allowed
+        if not self._state_machine.can_transition("disconnect"):
+            self.logger.warning(
+                f"Cannot disconnect: current state is {self._state_machine.get_state().value}"
+            )
+            return
+
+        # Transition to DISCONNECTING
+        if self._state_machine.transition(
+            "disconnecting", ConnectionState.DISCONNECTING
+        ):
+            self.connection_state = ConnectionState.DISCONNECTING
+            self.post_message(self.StatusMessageChanged("Disconnecting..."))
+
         if self.protocol:
             self.protocol.disconnect()
 
-    def send_discover(self) -> None:
-        """Send discover telegram.
+        # Transition to DISCONNECTED
+        if self._state_machine.transition("disconnected", ConnectionState.DISCONNECTED):
+            self.connection_state = ConnectionState.DISCONNECTED
+            self.post_message(self.StatusMessageChanged("Disconnected"))
+
+    def send_telegram(self, name: str, telegram: str) -> None:
+        """Send a raw telegram string.
 
-        Sends predefined discover telegram <S0000000000F01D00FA> to the bus.
-        Called when user presses 'd' key.
+        Args:
+            name: Telegram name (e.g., "Discover")
+            telegram: Telegram string including angle brackets (e.g., "S0000000000F01D00")
         """
         if self.protocol is None:
-            self.logger.warning("Cannot send discover: not connected")
-            if self.log_widget:
-                self.log_widget.write(
-                    "[yellow]Not connected, cannot send discover[/yellow]"
-                )
+            self.logger.warning("Cannot send telegram: not connected")
             return
 
         try:
-            # Send discover telegram
-            # Note: The telegram includes framing <>, but protocol may add it
-            # Check if protocol expects with or without brackets
-            from xp.models.telegram.system_function import SystemFunction
-            from xp.models.telegram.telegram_type import TelegramType
-
-            # Send discover: S 0000000000 F01 D00
-            self.protocol.send_telegram(
-                telegram_type=TelegramType.SYSTEM,
-                serial_number="0000000000",
-                system_function=SystemFunction.DISCOVERY,
-                data_value="00",
-            )
-
-            if self.log_widget:
-                self.log_widget.write("[yellow]Discover telegram sent[/yellow]")
+            # Remove angle brackets if present
+            self.post_message(self.StatusMessageChanged(f"Sending {name}..."))
+            # Send raw telegram
+            self.protocol.send_raw_telegram(telegram)
 
         except Exception as e:
-            self.logger.error(f"Failed to send discover: {e}")
-            if self.log_widget:
-                self.log_widget.write(f"[red]Failed to send discover: {e}[/red]")
+            self.logger.error(f"Failed to send telegram: {e}")
+            self.post_message(self.StatusMessageChanged(f"Failed: {e}"))
+
+    def clear_log(self) -> None:
+        """Clear the protocol log widget."""
+        if self.log_widget:
+            self.log_widget.clear()
+            self.post_message(self.StatusMessageChanged("Log cleared"))
 
     def on_unmount(self) -> None:
         """Clean up when widget unmounts.

xp/term/widgets/status_footer.py

@@ -0,0 +1,53 @@
+"""Status Footer Widget for displaying app footer with connection status."""
+
+from typing import Any
+
+from textual.app import ComposeResult
+from textual.containers import Horizontal
+from textual.widgets import Footer, Static
+
+
+class StatusFooterWidget(Horizontal):
+    """Footer widget with connection status indicator.
+
+    Combines the Textual Footer with a status indicator dot that shows
+    the current connection state.
+
+    Attributes:
+        status_widget: Static widget displaying colored status dot.
+    """
+
+    def __init__(self, *args: Any, **kwargs: Any) -> None:
+        """Initialize the Status Footer widget.
+
+        Args:
+            args: Additional positional arguments for Horizontal.
+            kwargs: Additional keyword arguments for Horizontal.
+        """
+        super().__init__(*args, **kwargs)
+        self.status_widget: Static = Static("○", id="status-line")
+
+    def compose(self) -> ComposeResult:
+        """Compose the footer layout.
+
+        Yields:
+            Footer and status indicator widgets.
+        """
+        yield Footer()
+        yield self.status_widget
+
+    def update_status(self, state: Any) -> None:
+        """Update status indicator with connection state.
+
+        Args:
+            state: Current connection state (ConnectionState enum).
+        """
+        # Map states to colored dots
+        dot = {
+            "CONNECTED": "[green]●[/green]",
+            "CONNECTING": "[yellow]●[/yellow]",
+            "DISCONNECTING": "[yellow]●[/yellow]",
+            "FAILED": "[red]●[/red]",
+            "DISCONNECTED": "○",
+        }.get(state.value, "○")
+        self.status_widget.update(dot)

xp/utils/logging.py

@@ -20,11 +20,22 @@ class LoggerService:
         self.logger = logging.getLogger(__name__)
 
     def setup(self) -> None:
-        """Setup console and file logging with configured levels."""
-        # Setup file logging for term app
-        self.setup_console_logging(
-            self.logging_config.log_format, self.logging_config.date_format
-        )
+        """Setup file logging only with configured levels."""
+        # Setup file logging for term app (console logging disabled)
+        root_logger = logging.getLogger()
+
+        # Remove any existing console handlers
+        root_logger.handlers = [
+            h
+            for h in root_logger.handlers
+            if not isinstance(h, logging.StreamHandler)
+            or isinstance(h, RotatingFileHandler)
+        ]
+
+        # Set root logger level
+        numeric_level = getattr(logging, self.logging_config.default_level.upper())
+        root_logger.setLevel(numeric_level)
+
         self.setup_file_logging(
             self.logging_config.log_format, self.logging_config.date_format
         )

xp/utils/state_machine.py

@@ -0,0 +1,81 @@
+"""Lightweight state machine utilities.
+
+Provides simple, zero-dependency state machine implementation for
+managing state transitions with validation.
+"""
+
+from enum import Enum
+from typing import Set
+
+
+class StateMachine:
+    """Lightweight state machine for managing state transitions.
+
+    Enforces valid state transitions and prevents invalid operations.
+    Zero dependencies, suitable for any state-based logic.
+
+    Example:
+        >>> from enum import Enum
+        >>> class State(str, Enum):
+        ...     IDLE = "IDLE"
+        ...     RUNNING = "RUNNING"
+        ...
+        >>> sm = StateMachine(State.IDLE)
+        >>> sm.define_transition("start", {State.IDLE}, State.RUNNING)
+        >>> sm.can_transition("start")  # True
+        >>> sm.transition("start", State.RUNNING)  # True
+        >>> sm.get_state()  # State.RUNNING
+    """
+
+    def __init__(self, initial: Enum):
+        """Initialize state machine.
+
+        Args:
+            initial: Initial state (any Enum value).
+        """
+        self.state = initial
+        self._valid_transitions: dict[str, Set[Enum]] = {}
+
+    def define_transition(self, action: str, valid_sources: Set[Enum]) -> None:
+        """Define valid source states for an action.
+
+        Args:
+            action: Action name (e.g., "connect", "disconnect").
+            valid_sources: Set of states from which action is valid.
+        """
+        self._valid_transitions[action] = valid_sources
+
+    def can_transition(self, action: str) -> bool:
+        """Check if action is valid from current state.
+
+        Args:
+            action: Action to check (e.g., "connect", "disconnect").
+
+        Returns:
+            True if action is valid from current state.
+        """
+        valid_sources = self._valid_transitions.get(action, set())
+        return self.state in valid_sources
+
+    def transition(self, action: str, new_state: Enum) -> bool:
+        """Attempt state transition.
+
+        Args:
+            action: Action triggering the transition.
+            new_state: Target state.
+
+        Returns:
+            True if transition succeeded, False if invalid.
+        """
+        if self.can_transition(action):
+            self.state = new_state
+            return True
+        return False
+
+    def get_state(self) -> Enum:
+        """Get current state.
+
+        Returns:
+            Current state as Enum value.
+        """
+        return self.state

xp/tui/app.py

@@ -1,72 +0,0 @@
-"""Protocol Monitor TUI Application."""
-
-from pathlib import Path
-from typing import Any, Optional
-
-from textual.app import App, ComposeResult
-from textual.widgets import Footer, Header
-
-from xp.tui.widgets.protocol_log import ProtocolLogWidget
-
-
-class ProtocolMonitorApp(App[None]):
-    """Textual app for real-time protocol monitoring.
-
-    Displays live RX/TX telegram stream from Conbus server in an interactive
-    terminal interface with keyboard shortcuts for control.
-
-    Attributes:
-        container: ServiceContainer for dependency injection.
-        CSS_PATH: Path to CSS stylesheet file.
-        BINDINGS: Keyboard bindings for app actions.
-        TITLE: Application title displayed in header.
-    """
-
-    CSS_PATH = Path(__file__).parent / "protocol.tcss"
-    TITLE = "Protocol Monitor"
-
-    BINDINGS = [
-        ("q", "quit", "Quit"),
-        ("c", "connect", "Connect"),
-        ("d", "disconnect", "Disconnect"),
-        ("1", "discover", "Discover"),
-    ]
-
-    def __init__(self, container: Any) -> None:
-        """Initialize the Protocol Monitor app.
-
-        Args:
-            container: ServiceContainer for resolving services.
-        """
-        super().__init__()
-        self.container = container
-        self.protocol_widget: Optional[ProtocolLogWidget] = None
-
-    def compose(self) -> ComposeResult:
-        """Compose the app layout with widgets.
-
-        Yields:
-            Header, ProtocolLogWidget, and Footer widgets.
-        """
-        yield Header()
-        self.protocol_widget = ProtocolLogWidget(container=self.container)
-        yield self.protocol_widget
-        yield Footer()
-
-    def action_discover(self) -> None:
-        """Send discover telegram on 'D' key press.
-
-        Sends predefined discover telegram <S0000000000F01D00FA> to the bus.
-        """
-        if self.protocol_widget:
-            self.protocol_widget.send_discover()
-
-    def action_connect(self) -> None:
-        """Connect protocol on 'c' key press."""
-        if self.protocol_widget:
-            self.protocol_widget.connect()
-
-    def action_disconnect(self) -> None:
-        """Disconnect protocol on 'd' key press."""
-        if self.protocol_widget:
-            self.protocol_widget.disconnect()