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

xp/services/conbus/conbus_receive_service.py

@@ -1,51 +1,55 @@
 """Conbus Receive Service for receiving telegrams from Conbus servers.
 
-This service uses ConbusProtocol to provide receive-only functionality,
+This service uses ConbusEventProtocol to provide receive-only functionality,
 allowing clients to receive waiting event telegrams using empty telegram sends.
 """
 
+import asyncio
 import logging
-from typing import Callable, Optional
+from typing import Any, Callable, Optional
 
-from twisted.internet.posixbase import PosixReactorBase
-
-from xp.models import ConbusClientConfig
 from xp.models.conbus.conbus_receive import ConbusReceiveResponse
 from xp.models.protocol.conbus_protocol import TelegramReceivedEvent
-from xp.services.protocol import ConbusProtocol
+from xp.services.protocol.conbus_event_protocol import ConbusEventProtocol
 
 
-class ConbusReceiveService(ConbusProtocol):
+class ConbusReceiveService:
     """
     Service for receiving telegrams from Conbus servers.
 
-    Uses ConbusProtocol to provide receive-only functionality
+    Uses ConbusEventProtocol to provide receive-only functionality
     for collecting waiting event telegrams from the server.
+
+    Attributes:
+        conbus_protocol: Protocol instance for Conbus communication.
     """
 
-    def __init__(
-        self,
-        cli_config: ConbusClientConfig,
-        reactor: PosixReactorBase,
-    ) -> None:
+    conbus_protocol: ConbusEventProtocol
+
+    def __init__(self, conbus_protocol: ConbusEventProtocol) -> None:
         """Initialize the Conbus receive service.
 
         Args:
-            cli_config: Conbus client configuration.
-            reactor: Twisted reactor instance.
+            conbus_protocol: ConbusEventProtocol instance.
         """
-        super().__init__(cli_config, reactor)
         self.progress_callback: Optional[Callable[[str], None]] = None
         self.finish_callback: Optional[Callable[[ConbusReceiveResponse], None]] = None
         self.receive_response: ConbusReceiveResponse = ConbusReceiveResponse(
             success=True
         )
 
+        self.conbus_protocol: ConbusEventProtocol = conbus_protocol
+        self.conbus_protocol.on_connection_made.connect(self.connection_made)
+        self.conbus_protocol.on_telegram_sent.connect(self.telegram_sent)
+        self.conbus_protocol.on_telegram_received.connect(self.telegram_received)
+        self.conbus_protocol.on_timeout.connect(self.timeout)
+        self.conbus_protocol.on_failed.connect(self.failed)
+
         # Set up logging
         self.logger = logging.getLogger(__name__)
 
-    def connection_established(self) -> None:
-        """Handle connection established event."""
+    def connection_made(self) -> None:
+        """Handle connection made event."""
         self.logger.debug("Connection established, waiting for telegrams.")
 
     def telegram_sent(self, telegram_sent: str) -> None:
@@ -70,17 +74,13 @@ class ConbusReceiveService(ConbusProtocol):
             self.receive_response.received_telegrams = []
         self.receive_response.received_telegrams.append(telegram_received.frame)
 
-    def timeout(self) -> bool:
-        """Handle timeout event to stop receiving.
-
-        Returns:
-            False to stop the reactor.
-        """
-        self.logger.info("Receive stopped after: %ss", self.timeout_seconds)
+    def timeout(self) -> None:
+        """Handle timeout event to stop receiving."""
+        timeout = self.conbus_protocol.timeout_seconds
+        self.logger.info("Receive stopped after: %ss", timeout)
         self.receive_response.success = True
         if self.finish_callback:
             self.finish_callback(self.receive_response)
-        return False
 
     def failed(self, message: str) -> None:
         """Handle failed connection event.
@@ -94,22 +94,50 @@ class ConbusReceiveService(ConbusProtocol):
         if self.finish_callback:
             self.finish_callback(self.receive_response)
 
-    def start(
+    def init(
         self,
         progress_callback: Callable[[str], None],
         finish_callback: Callable[[ConbusReceiveResponse], None],
         timeout_seconds: Optional[float] = None,
+        event_loop: Optional[asyncio.AbstractEventLoop] = None,
     ) -> None:
-        """Run reactor in dedicated thread with its own event loop.
+        """Setup callbacks and timeout for receiving telegrams.
 
         Args:
             progress_callback: Callback for each received telegram.
             finish_callback: Callback when receiving completes.
             timeout_seconds: Optional timeout in seconds.
+            event_loop: Optional event loop to use for async operations.
         """
         self.logger.info("Starting receive")
         if timeout_seconds:
-            self.timeout_seconds = timeout_seconds
+            self.conbus_protocol.timeout_seconds = timeout_seconds
         self.progress_callback = progress_callback
         self.finish_callback = finish_callback
-        self.start_reactor()
+
+        if event_loop:
+            self.conbus_protocol.set_event_loop(event_loop)
+
+    def start_reactor(self) -> None:
+        """Start the reactor."""
+        self.conbus_protocol.start_reactor()
+
+    def __enter__(self) -> "ConbusReceiveService":
+        """Enter context manager.
+
+        Returns:
+            Self for context manager protocol.
+        """
+        # Reset state for singleton reuse
+        self.receive_response = ConbusReceiveResponse(success=True)
+        return self
+
+    def __exit__(
+        self, _exc_type: Optional[type], _exc_val: Optional[Exception], _exc_tb: Any
+    ) -> None:
+        """Exit context manager and disconnect signals."""
+        self.conbus_protocol.on_connection_made.disconnect(self.connection_made)
+        self.conbus_protocol.on_telegram_sent.disconnect(self.telegram_sent)
+        self.conbus_protocol.on_telegram_received.disconnect(self.telegram_received)
+        self.conbus_protocol.on_timeout.disconnect(self.timeout)
+        self.conbus_protocol.on_failed.disconnect(self.failed)

xp/services/protocol/conbus_event_protocol.py

@@ -3,6 +3,7 @@
 This module implements the Twisted protocol for Conbus communication.
 """
 
+import asyncio
 import logging
 from queue import SimpleQueue
 from random import randint
@@ -302,14 +303,21 @@ class ConbusEventProtocol(protocol.Protocol, protocol.ClientFactory):
             self.logger.info("Stopping reactor")
             self._reactor.stop()
 
-    def start_reactor(self) -> None:
-        """Start the reactor if it's running."""
-        # Connect to TCP server
+    def connect(self) -> None:
+        """Connect to TCP server."""
         self.logger.info(
             f"Connecting to TCP server {self.cli_config.ip}:{self.cli_config.port}"
         )
         self._reactor.connectTCP(self.cli_config.ip, self.cli_config.port, self)
 
+    def disconnect(self) -> None:
+        """Disconnect from TCP server."""
+        self.logger.info("Disconnecting TCP server")
+        self._reactor.disconnectAll()
+
+    def start_reactor(self) -> None:
+        """Start the reactor if it's running."""
+        self.connect()
         # Run the reactor (which now uses asyncio underneath)
         self.logger.info("Starting reactor event loop.")
         self._reactor.run()
@@ -340,6 +348,23 @@ class ConbusEventProtocol(protocol.Protocol, protocol.ClientFactory):
         later = randint(10, 80) / 100
         self.call_later(later, self.process_telegram_queue)
 
+    def set_event_loop(self, event_loop: asyncio.AbstractEventLoop) -> None:
+        """Change the event loop.
+
+        Args:
+            event_loop: the event loop instance.
+        """
+        reactor = self._reactor
+        if hasattr(reactor, "_asyncioEventloop"):
+            reactor._asyncioEventloop = event_loop
+
+        # Set reactor to running state
+        if not reactor.running:
+            reactor.running = True
+            if hasattr(reactor, "startRunning"):
+                reactor.startRunning()
+            self.logger.info("Set reactor to running state")
+
     def __enter__(self) -> "ConbusEventProtocol":
         """Enter context manager.
 

xp/tui/__init__.py

@@ -0,0 +1 @@
+"""TUI (Terminal User Interface) module for XP."""

xp/tui/app.py

@@ -0,0 +1,72 @@
+"""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()

xp/tui/protocol.tcss

@@ -0,0 +1,50 @@
+/* Protocol Monitor TUI Styling */
+
+/* App-level styling */
+Screen {
+    background: $background;
+}
+
+/* Protocol Log Widget */
+ProtocolLogWidget {
+    border: solid $primary;
+    height: 1fr;
+    background: $surface;
+}
+
+ProtocolLogWidget > .connection-status {
+    color: $text;
+    text-align: center;
+    padding: 1;
+}
+
+ProtocolLogWidget > .connection-status.connecting {
+    color: $warning;
+}
+
+ProtocolLogWidget > .connection-status.connected {
+    color: $success;
+}
+
+ProtocolLogWidget > .connection-status.failed {
+    color: $error;
+}
+
+/* Message display styling */
+.message-tx {
+    color: $success;
+}
+
+.message-rx {
+    color: $success;
+}
+
+.message-frame {
+    color: $text-muted;
+}
+
+/* Footer styling */
+Footer {
+    background: $panel;
+    color: $text;
+}

xp/tui/widgets/__init__.py

@@ -0,0 +1 @@
+"""TUI widgets package."""

xp/tui/widgets/protocol_log.py

@@ -0,0 +1,312 @@
+"""Protocol Log Widget for displaying telegram stream."""
+
+import asyncio
+import logging
+from enum import Enum
+from typing import Any, Optional
+
+from textual.reactive import reactive
+from textual.widget import Widget
+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
+
+
+class ConnectionState(str, Enum):
+    """Connection state enumeration.
+
+    Attributes:
+        DISCONNECTED: Not connected to server.
+        CONNECTING: Connection in progress.
+        CONNECTED: Successfully connected.
+        FAILED: Connection failed.
+    """
+
+    DISCONNECTED = "DISCONNECTED"
+    CONNECTING = "CONNECTING"
+    CONNECTED = "CONNECTED"
+    FAILED = "FAILED"
+
+
+class ProtocolLogWidget(Widget):
+    """Widget for displaying protocol telegram stream.
+
+    Connects to Conbus server via ConbusReceiveService and displays
+    live RX/TX telegram stream with color-coded direction markers.
+
+    Attributes:
+        container: ServiceContainer for dependency injection.
+        connection_state: Current connection state (reactive).
+        protocol: Reference to ConbusEventProtocol (prevents duplicate connections).
+        service: ConbusReceiveService instance.
+        logger: Logger instance for this widget.
+        log_widget: RichLog widget for displaying messages.
+    """
+
+    connection_state = reactive(ConnectionState.DISCONNECTED)
+
+    def __init__(self, container: Any) -> None:
+        """Initialize the Protocol Log widget.
+
+        Args:
+            container: ServiceContainer for resolving services.
+        """
+        super().__init__()
+        self.container = container
+        self.protocol: Optional[ConbusEventProtocol] = None
+        self.service: Optional[ConbusReceiveService] = None
+        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=True, markup=True)
+        yield self.log_widget
+
+    async def on_mount(self) -> None:
+        """Initialize connection when widget mounts.
+
+        Delays connection by 0.5s to let UI render first.
+        Resolves ConbusReceiveService and connects signals.
+        """
+        # Resolve service from container (singleton)
+        self.service = self.container.resolve(ConbusReceiveService)
+        self.protocol = self.service.conbus_protocol
+
+        # Connect psygnal signals
+        self.protocol.on_connection_made.connect(self._on_connection_made)
+        self.protocol.on_telegram_received.connect(self._on_telegram_received)
+        self.protocol.on_telegram_sent.connect(self._on_telegram_sent)
+        self.protocol.on_timeout.connect(self._on_timeout)
+        self.protocol.on_failed.connect(self._on_failed)
+
+        # Delay connection to let UI render
+        await asyncio.sleep(0.5)
+        await self._start_connection_async()
+
+    async def _start_connection_async(self) -> None:
+        """Start TCP connection to Conbus server (async).
+
+        Guards against duplicate connections and sets up protocol signals.
+        Integrates Twisted reactor with Textual's asyncio loop cleanly.
+        """
+        # Guard against duplicate connections (race condition)
+        if self.service is None:
+            self.logger.error("Service not initialized")
+            return
+
+        if self.protocol is None:
+            self.logger.error("Protocol not initialized")
+            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]")
+
+            # Store protocol reference
+            self.logger.info(f"Protocol object: {self.protocol}")
+            self.logger.info(f"Reactor object: {self.protocol._reactor}")
+            self.logger.info(f"Reactor running: {self.protocol._reactor.running}")
+
+            # Setup service callbacks
+            def progress_callback(telegram: str) -> None:
+                """Handle progress updates for telegram reception.
+
+                Args:
+                    telegram: Received telegram string.
+                """
+                pass
+
+            def finish_callback(response: Any) -> None:
+                """Handle completion of telegram reception.
+
+                Args:
+                    response: Response object from telegram reception.
+                """
+                pass
+
+            # Get the currently running asyncio event loop (Textual's loop)
+            event_loop = asyncio.get_running_loop()
+            self.logger.info(f"Current running loop: {event_loop}")
+            self.logger.info(f"Loop is running: {event_loop.is_running()}")
+
+            self.service.init(
+                progress_callback=progress_callback,
+                finish_callback=finish_callback,
+                timeout_seconds=None,  # Continuous monitoring
+                event_loop=event_loop,
+            )
+
+            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]"
+                )
+
+            # Wait for connection to establish
+            await asyncio.sleep(1.0)
+            self.logger.info(f"After 1s - transport: {self.protocol.transport}")
+
+        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)
+
+    def _start_connection(self) -> None:
+        """Start connection (sync wrapper for async method)."""
+        # Use run_worker to run async method from sync context
+        self.run_worker(self._start_connection_async(), exclusive=True)
+
+    def _on_connection_made(self) -> None:
+        """Handle connection established signal.
+
+        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]")
+
+    def _on_telegram_received(self, event: TelegramReceivedEvent) -> None:
+        """Handle telegram received signal.
+
+        Args:
+            event: Telegram received event with frame data.
+        """
+        if self.log_widget:
+            # Display [RX] in green, frame in gray
+            self.log_widget.write(f"[green]\\[RX][/green] [dim]{event.frame}[/dim]")
+
+    def _on_telegram_sent(self, telegram: str) -> None:
+        """Handle telegram sent signal.
+
+        Args:
+            telegram: Sent telegram string.
+        """
+        if self.log_widget:
+            # Display [TX] in green, frame in gray
+            self.log_widget.write(f"[green]\\[TX][/green] [dim]{telegram}[/dim]")
+
+    def _on_timeout(self) -> None:
+        """Handle timeout signal.
+
+        Logs timeout but continues monitoring (no action needed).
+        """
+        self.logger.debug("Timeout occurred (continuous monitoring)")
+
+    def _on_failed(self, error: str) -> None:
+        """Handle connection failed signal.
+
+        Args:
+            error: Error message describing the failure.
+        """
+        self.connection_state = ConnectionState.FAILED
+        self.logger.error(f"Connection failed: {error}")
+
+        if self.log_widget:
+            self.log_widget.write(f"[red]Connection failed: {error}[/red]")
+
+        # Exit app after brief delay to show error
+        self.set_timer(2.0, self.app.exit)
+
+    def connect(self) -> None:
+        """Connect to Conbus server."""
+        self._start_connection()
+
+    def disconnect(self) -> None:
+        """Disconnect from Conbus server."""
+        if self.protocol:
+            self.protocol.disconnect()
+
+    def send_discover(self) -> None:
+        """Send discover telegram.
+
+        Sends predefined discover telegram <S0000000000F01D00FA> to the bus.
+        Called when user presses 'd' key.
+        """
+        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]"
+                )
+            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]")
+
+        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]")
+
+    def on_unmount(self) -> None:
+        """Clean up when widget unmounts.
+
+        Disconnects signals and closes transport connection.
+        """
+        if self.protocol is not None:
+            try:
+                # Disconnect all signals
+                self.protocol.on_connection_made.disconnect(self._on_connection_made)
+                self.protocol.on_telegram_received.disconnect(
+                    self._on_telegram_received
+                )
+                self.protocol.on_telegram_sent.disconnect(self._on_telegram_sent)
+                self.protocol.on_timeout.disconnect(self._on_timeout)
+                self.protocol.on_failed.disconnect(self._on_failed)
+
+                # Close transport if connected
+                if self.protocol.transport:
+                    self.protocol.disconnect()
+
+                # Reset protocol reference
+                self.protocol = None
+
+                # Set state to disconnected
+                self.connection_state = ConnectionState.DISCONNECTED
+
+            except Exception as e:
+                self.logger.error(f"Error during cleanup: {e}")