conson-xp 1.24.0__tar.gz → 1.26.0__tar.gz

{conson_xp-1.24.0 → conson_xp-1.26.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: conson-xp
-Version: 1.24.0
+Version: 1.26.0
 Summary: XP Protocol Communication Tools
 Author-Email: ldvchosal <ldvchosal@github.com>
 License: MIT License

{conson_xp-1.24.0 → conson_xp-1.26.0}/pyproject.toml

@@ -22,7 +22,7 @@ dependencies = [
 ]
 requires-python = ">=3.11"
 readme = "README.md"
-version = "1.24.0"
+version = "1.26.0"
 
 [project.license]
 file = "LICENSE"
@@ -209,7 +209,7 @@ composite = [
 ]
 
 [tool.pdm.scripts.clean]
-shell = "rm -rf .coverage coverage.xml htmlcov/ .pytest_cache/ conbus.log.* && find . -type d -name '__pycache__' -exec rm -rf {} +"
+shell = "rm -rf .coverage coverage.xml htmlcov/ .pytest_cache/ log/conbus.log.* && find . -type d -name '__pycache__' -exec rm -rf {} +"
 
 [tool.vulture]
 exclude = [

{conson_xp-1.24.0 → conson_xp-1.26.0}/src/xp/__init__.py

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

{conson_xp-1.24.0 → conson_xp-1.26.0}/src/xp/cli/commands/term/term_commands.py

@@ -23,9 +23,5 @@ def protocol_monitor(ctx: Context) -> None:
     """
     from xp.term.protocol import ProtocolMonitorApp
 
-    # Resolve ServiceContainer from context
-    container = ctx.obj.get("container").get_container()
-
-    # Initialize and run Textual app
-    app = ProtocolMonitorApp(container=container)
-    app.run()
+    # Resolve ProtocolMonitorApp from container and run
+    ctx.obj.get("container").get_container().resolve(ProtocolMonitorApp).run()

conson_xp-1.26.0/src/xp/models/term/telegram_display.py

@@ -0,0 +1,19 @@
+"""Domain models for telegram display in terminal interface."""
+
+from dataclasses import dataclass
+from typing import Literal, Optional
+
+
+@dataclass
+class TelegramDisplayEvent:
+    """Event containing telegram data for display in TUI.
+
+    Attributes:
+        direction: Direction of telegram ("RX" for received, "TX" for transmitted).
+        telegram: Formatted telegram string.
+        timestamp: Optional timestamp of the event.
+    """
+
+    direction: Literal["RX", "TX"]
+    telegram: str
+    timestamp: Optional[float] = None

{conson_xp-1.24.0 → conson_xp-1.26.0}/src/xp/services/protocol/conbus_event_protocol.py

@@ -325,10 +325,23 @@ class ConbusEventProtocol(protocol.Protocol, protocol.ClientFactory):
             self._reactor.stop()
 
     def connect(self) -> None:
-        """Connect to TCP server."""
+        """Connect to TCP server.
+
+        Automatically detects and integrates with running asyncio event loop if present.
+        """
         self.logger.info(
             f"Connecting to TCP server {self.cli_config.ip}:{self.cli_config.port}"
         )
+
+        # Auto-detect and integrate with asyncio event loop if available
+        try:
+            event_loop = asyncio.get_running_loop()
+            self.logger.debug(f"Detected running event loop: {event_loop}")
+            self.set_event_loop(event_loop)
+        except RuntimeError:
+            # No running event loop - that's fine for non-async contexts
+            self.logger.debug("No running event loop detected - using reactor only")
+
         self._reactor.connectTCP(self.cli_config.ip, self.cli_config.port, self)
 
     def disconnect(self) -> None:

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

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

conson_xp-1.26.0/src/xp/services/term/protocol_monitor_service.py

@@ -0,0 +1,265 @@
+"""Protocol Monitor Service for terminal interface."""
+
+import logging
+from typing import Any, ItemsView, Optional
+
+from psygnal import Signal
+from twisted.python.failure import Failure
+
+from xp.models.protocol.conbus_protocol import TelegramReceivedEvent
+from xp.models.term.connection_state import ConnectionState
+from xp.models.term.protocol_keys_config import ProtocolKeyConfig, ProtocolKeysConfig
+from xp.models.term.telegram_display import TelegramDisplayEvent
+from xp.services.protocol.conbus_event_protocol import ConbusEventProtocol
+
+
+class ProtocolMonitorService:
+    """Service for protocol monitoring in terminal interface.
+
+    Wraps ConbusEventProtocol and provides high-level operations
+    for the TUI without exposing protocol implementation details.
+
+    Attributes:
+        _conbus_protocol: Protocol instance for Conbus communication.
+        _protocol_keys: Configuration for protocol keyboard shortcuts.
+        connection_state: Current connection state (read-only property).
+        server_info: Server connection info as "IP:port" (read-only property).
+        on_connection_state_changed: Signal emitted when connection state changes.
+        on_telegram_display: Signal emitted when telegram should be displayed.
+        on_status_message: Signal emitted for status updates.
+    """
+
+    on_connection_state_changed: Signal = Signal(ConnectionState)
+    on_telegram_display: Signal = Signal(TelegramDisplayEvent)
+    on_status_message: Signal = Signal(str)
+
+    def __init__(
+        self,
+        conbus_protocol: ConbusEventProtocol,
+        protocol_keys: ProtocolKeysConfig,
+    ) -> None:
+        """Initialize the Protocol Monitor service.
+
+        Args:
+            conbus_protocol: ConbusEventProtocol instance.
+            protocol_keys: Protocol keys configuration.
+        """
+        self.logger = logging.getLogger(__name__)
+        self._conbus_protocol = conbus_protocol
+        self._connection_state = ConnectionState.DISCONNECTED
+        self._state_machine = ConnectionState.create_state_machine()
+        self._protocol_keys = protocol_keys
+
+        # Connect to protocol signals
+        self._connect_signals()
+
+    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_telegram_sent.connect(self._on_telegram_sent)
+        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_telegram_sent.disconnect(self._on_telegram_sent)
+        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}"
+
+    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 _send_telegram(self, name: str, telegram: str) -> None:
+        """Send a raw telegram.
+
+        Args:
+            name: Display name for the telegram.
+            telegram: Raw telegram string.
+        """
+        try:
+            self._conbus_protocol.send_raw_telegram(telegram)
+            self.on_status_message.emit(f"{name} sent.")
+        except Exception as e:
+            self.logger.error(f"Failed to send telegram: {e}")
+            self.on_status_message.emit(f"Failed: {e}")
+
+    def handle_key_press(self, key: str) -> bool:
+        """Handle protocol key press.
+
+        Args:
+            key: Key that was pressed.
+
+        Returns:
+            True if key was handled, False otherwise.
+        """
+        if key in self._protocol_keys.protocol:
+            key_config = self._protocol_keys.protocol[key]
+            for telegram in key_config.telegrams:
+                self._send_telegram(key_config.name, telegram)
+            return True
+        return False
+
+    # Protocol signal handlers
+
+    def _on_connection_made(self) -> None:
+        """Handle connection established."""
+        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}")
+
+    def _on_connection_failed(self, failure: Failure) -> None:
+        """Handle connection failed.
+
+        Args:
+            failure: Twisted failure object with error details.
+        """
+        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(failure.getErrorMessage())
+
+    def _on_telegram_received(self, event: TelegramReceivedEvent) -> None:
+        """Handle telegram received.
+
+        Args:
+            event: Telegram received event with frame data.
+        """
+        display_event = TelegramDisplayEvent(direction="RX", telegram=event.frame)
+        self.on_telegram_display.emit(display_event)
+
+    def _on_telegram_sent(self, telegram: str) -> None:
+        """Handle telegram sent.
+
+        Args:
+            telegram: Sent telegram string.
+        """
+        display_event = TelegramDisplayEvent(direction="TX", telegram=telegram)
+        self.on_telegram_display.emit(display_event)
+
+    def _on_timeout(self) -> None:
+        """Handle timeout."""
+        self.logger.debug("Timeout occurred (continuous monitoring)")
+
+    def _on_failed(self, error: str) -> None:
+        """Handle connection failed.
+
+        Args:
+            error: Error message describing 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"Failed: {error}")
+
+    def cleanup(self) -> None:
+        """Clean up service resources."""
+        self._disconnect_signals()
+        if self._conbus_protocol.transport:
+            self._disconnect()
+
+    def get_keys(self) -> ItemsView[str, ProtocolKeyConfig]:
+        """Get protocol key mappings.
+
+        Returns:
+            Dictionary items view of key to ProtocolKeyConfig mappings.
+        """
+        return self._protocol_keys.protocol.items()
+
+    def __enter__(self) -> "ProtocolMonitorService":
+        """Enter context manager.
+
+        Returns:
+            Self for context management.
+        """
+        return self
+
+    def __exit__(
+        self,
+        _exc_type: Optional[type],
+        _exc_val: Optional[BaseException],
+        _exc_tb: Optional[Any],
+    ) -> None:
+        """Exit context manager and clean up resources.
+
+        Args:
+            _exc_type: Exception type if any.
+            _exc_val: Exception value if any.
+            _exc_tb: Exception traceback if any.
+        """
+        self.cleanup()

{conson_xp-1.24.0 → conson_xp-1.26.0}/src/xp/term/protocol.py

@@ -6,8 +6,6 @@ from typing import Any, Optional
 from textual.app import App, ComposeResult
 from textual.containers import Horizontal
 
-from xp.models.term import ProtocolKeysConfig
-from xp.models.term.status_message import StatusMessageChanged
 from xp.term.widgets.help_menu import HelpMenuWidget
 from xp.term.widgets.protocol_log import ProtocolLogWidget
 from xp.term.widgets.status_footer import StatusFooterWidget
@@ -20,7 +18,7 @@ class ProtocolMonitorApp(App[None]):
     terminal interface with keyboard shortcuts for control.
 
     Attributes:
-        container: ServiceContainer for dependency injection.
+        protocol_service: ProtocolMonitorService for protocol operations.
         CSS_PATH: Path to CSS stylesheet file.
         BINDINGS: Keyboard bindings for app actions.
         TITLE: Application title displayed in header.
@@ -38,27 +36,17 @@ class ProtocolMonitorApp(App[None]):
         ("0-9,a-q", "protocol_keys", "Keys"),
     ]
 
-    def __init__(self, container: Any) -> None:
+    def __init__(self, protocol_service: Any) -> None:
         """Initialize the Protocol Monitor app.
 
         Args:
-            container: ServiceContainer for resolving services.
+            protocol_service: ProtocolMonitorService for protocol operations.
         """
         super().__init__()
-        self.container = container
+        self.protocol_service = protocol_service
         self.protocol_widget: Optional[ProtocolLogWidget] = None
         self.help_menu: Optional[HelpMenuWidget] = None
         self.footer_widget: Optional[StatusFooterWidget] = None
-        self.protocol_keys = self._load_protocol_keys()
-
-    def _load_protocol_keys(self) -> ProtocolKeysConfig:
-        """Load protocol keys from YAML config file.
-
-        Returns:
-            ProtocolKeysConfig instance.
-        """
-        config_path = Path(__file__).parent / "protocol.yml"
-        return ProtocolKeysConfig.from_yaml(config_path)
 
     def compose(self) -> ComposeResult:
         """Compose the app layout with widgets.
@@ -67,31 +55,37 @@ class ProtocolMonitorApp(App[None]):
             ProtocolLogWidget and Footer widgets.
         """
         with Horizontal(id="main-container"):
-            self.protocol_widget = ProtocolLogWidget(container=self.container)
+            self.protocol_widget = ProtocolLogWidget(service=self.protocol_service)
             yield self.protocol_widget
 
             # Help menu (hidden by default)
             self.help_menu = HelpMenuWidget(
-                protocol_keys=self.protocol_keys, id="help-menu"
+                service=self.protocol_service, id="help-menu"
             )
             yield self.help_menu
 
-        self.footer_widget = StatusFooterWidget(id="footer-container")
+        self.footer_widget = StatusFooterWidget(
+            service=self.protocol_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.
+        """
+        import asyncio
+
+        # Delay connection to let UI render
+        await asyncio.sleep(0.5)
+        self.protocol_service.connect()
+
     def action_toggle_connection(self) -> None:
         """Toggle connection on 'c' key press.
 
         Connects if disconnected/failed, disconnects if connected/connecting.
         """
-        if self.protocol_widget:
-            from xp.term.widgets.protocol_log import ConnectionState
-
-            state = self.protocol_widget.connection_state
-            if state in (ConnectionState.CONNECTED, ConnectionState.CONNECTING):
-                self.protocol_widget.disconnect()
-            else:
-                self.protocol_widget.connect()
+        self.protocol_service.toggle_connection()
 
     def action_reset(self) -> None:
         """Reset and clear protocol widget on 'r' key press."""
@@ -104,34 +98,4 @@ class ProtocolMonitorApp(App[None]):
         Args:
             event: Key press event from Textual.
         """
-        if event.key in self.protocol_keys.protocol and self.protocol_widget:
-            key_config = self.protocol_keys.protocol[event.key]
-            for telegram in key_config.telegrams:
-                self.protocol_widget.send_telegram(key_config.name, telegram)
-
-    def on_mount(self) -> None:
-        """Set up status line updates when app mounts."""
-        if self.protocol_widget:
-            self.protocol_widget.watch(
-                self.protocol_widget,
-                "connection_state",
-                self._update_status,
-            )
-
-    def _update_status(self, state: Any) -> None:
-        """Update status line with connection state.
-
-        Args:
-            state: Current connection state.
-        """
-        if self.footer_widget:
-            self.footer_widget.update_status(state)
-
-    def on_status_message_changed(self, message: StatusMessageChanged) -> None:
-        """Handle status message changes from protocol widget.
-
-        Args:
-            message: Message containing the status text.
-        """
-        if self.footer_widget:
-            self.footer_widget.update_message(message.message)
+        self.protocol_service.handle_key_press(event.key)

{conson_xp-1.24.0 → conson_xp-1.26.0}/src/xp/term/widgets/help_menu.py

@@ -1,12 +1,13 @@
 """Help Menu Widget for displaying keyboard shortcuts and protocol keys."""
 
-from typing import Any
+from typing import TYPE_CHECKING, Any
 
 from textual.app import ComposeResult
 from textual.containers import Vertical
 from textual.widgets import DataTable
 
-from xp.models.term import ProtocolKeysConfig
+if TYPE_CHECKING:
+    from xp.services.term.protocol_monitor_service import ProtocolMonitorService
 
 
 class HelpMenuWidget(Vertical):
@@ -16,25 +17,25 @@ class HelpMenuWidget(Vertical):
     corresponding protocol commands.
 
     Attributes:
-        protocol_keys: Configuration of protocol keys and their telegrams.
+        service: ProtocolMonitorService for accessing protocol keys.
         help_table: DataTable widget for displaying key mappings.
     """
 
     def __init__(
         self,
-        protocol_keys: ProtocolKeysConfig,
+        service: "ProtocolMonitorService",
         *args: Any,
         **kwargs: Any,
     ) -> None:
         """Initialize the Help Menu widget.
 
         Args:
-            protocol_keys: Configuration containing protocol key mappings.
+            service: ProtocolMonitorService instance.
             args: Additional positional arguments for Vertical.
             kwargs: Additional keyword arguments for Vertical.
         """
         super().__init__(*args, **kwargs)
-        self.protocol_keys = protocol_keys
+        self.service: ProtocolMonitorService = service
         self.help_table: DataTable = DataTable(id="help-table", show_header=False)
         self.help_table.can_focus = False
         self.border_title = "Help menu"
@@ -51,5 +52,5 @@ class HelpMenuWidget(Vertical):
     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():
+        for key, config in self.service.get_keys():
             self.help_table.add_row(key, config.name)

conson_xp-1.26.0/src/xp/term/widgets/protocol_log.py

@@ -0,0 +1,81 @@
+"""Protocol Log Widget for displaying telegram stream."""
+
+import logging
+from typing import Any, Optional
+
+from textual.widget import Widget
+from textual.widgets import RichLog
+
+from xp.models.term.telegram_display import TelegramDisplayEvent
+from xp.services.term.protocol_monitor_service import ProtocolMonitorService
+
+
+class ProtocolLogWidget(Widget):
+    """Widget for displaying protocol telegram stream.
+
+    Displays live RX/TX telegram stream with color-coded direction markers
+    via ProtocolMonitorService.
+
+    Attributes:
+        service: ProtocolMonitorService for protocol operations.
+        logger: Logger instance for this widget.
+        log_widget: RichLog widget for displaying messages.
+    """
+
+    def __init__(self, service: ProtocolMonitorService) -> None:
+        """Initialize the Protocol Log widget.
+
+        Args:
+            service: ProtocolMonitorService instance for protocol operations.
+        """
+        super().__init__()
+        self.border_title = "Protocol"
+        self.service = service
+        self.logger = logging.getLogger(__name__)
+        self.log_widget: Optional[RichLog] = None
+
+    def compose(self) -> Any:
+        """Compose the widget layout.
+
+        Yields:
+            RichLog widget for message display.
+        """
+        self.log_widget = RichLog(highlight=False, markup=True)
+        yield self.log_widget
+
+    def on_mount(self) -> None:
+        """Initialize widget when mounted.
+
+        Connects to service signals for telegram display.
+        """
+        # Connect to service signals
+        self.service.on_telegram_display.connect(self._on_telegram_display)
+
+    def _on_telegram_display(self, event: TelegramDisplayEvent) -> None:
+        """Handle telegram display event from service.
+
+        Args:
+            event: Telegram display event with direction and telegram data.
+        """
+        if self.log_widget:
+            color = "bold #00ff00" if event.direction == "TX" else "#00ff00"
+            self.log_widget.write(
+                f"[{color}]\\[{event.direction}] {event.telegram}[/{color}]"
+            )
+
+    def clear_log(self) -> None:
+        """Clear the protocol log widget."""
+        if self.log_widget:
+            self.log_widget.clear()
+
+    def on_unmount(self) -> None:
+        """Clean up when widget unmounts.
+
+        Disconnects signals from service.
+        """
+        try:
+            # Disconnect service signals
+            self.service.on_telegram_display.disconnect(self._on_telegram_display)
+
+        except Exception as e:
+            self.logger.error(f"Error during cleanup: {e}")