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

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

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

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

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

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

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

{conson_xp-1.23.0 → conson_xp-1.24.0}/src/xp/cli/commands/conbus/conbus_discover_commands.py

@@ -36,6 +36,7 @@ def send_discover_telegram(ctx: click.Context) -> None:
             discovered_devices: Discover response with all found devices.
         """
         click.echo(json.dumps(discovered_devices.to_dict(), indent=2))
+        service.stop_reactor()
 
     def on_device_discovered(discovered_device: DiscoveredDevice) -> None:
         """Handle discovery of sa single module.
@@ -57,5 +58,9 @@ def send_discover_telegram(ctx: click.Context) -> None:
     service: ConbusDiscoverService = (
         ctx.obj.get("container").get_container().resolve(ConbusDiscoverService)
     )
-    service.run(progress, on_device_discovered, on_finish, 5)
-    service.start_reactor()
+    with service:
+        service.on_progress.connect(progress)
+        service.on_device_discovered.connect(on_device_discovered)
+        service.on_finish.connect(on_finish)
+        service.set_timeout(5)
+        service.start_reactor()

{conson_xp-1.23.0 → conson_xp-1.24.0}/src/xp/cli/commands/conbus/conbus_receive_commands.py

@@ -43,8 +43,9 @@ def receive_telegrams(ctx: Context, timeout: float) -> None:
             response_received: Receive response object with telegrams.
         """
         click.echo(json.dumps(response_received.to_dict(), indent=2))
+        service.stop_reactor()
 
-    def progress(telegram_received: str) -> None:
+    def on_progress(telegram_received: str) -> None:
         """Handle progress updates during telegram receive operation.
 
         Args:
@@ -56,5 +57,7 @@ def receive_telegrams(ctx: Context, timeout: float) -> None:
         ctx.obj.get("container").get_container().resolve(ConbusReceiveService)
     )
     with service:
-        service.init(progress, on_finish, timeout)
+        service.on_progress.connect(on_progress)
+        service.on_finish.connect(on_finish)
+        service.set_timeout(timeout)
         service.start_reactor()

{conson_xp-1.23.0 → conson_xp-1.24.0}/src/xp/services/conbus/conbus_discover_service.py

@@ -4,8 +4,11 @@ This service implements a TCP client that connects to Conbus servers and sends
 discover telegrams to find modules on the network.
 """
 
+import asyncio
 import logging
-from typing import Callable, Optional
+from typing import Any, Optional
+
+from psygnal import Signal
 
 from xp.models import ConbusDiscoverResponse
 from xp.models.conbus.conbus_discover import DiscoveredDevice
@@ -26,9 +29,15 @@ class ConbusDiscoverService:
 
     Attributes:
         conbus_protocol: Protocol instance for Conbus communication.
+        on_progress: Signal emitted when discovery progress is made (with serial number).
+        on_finish: Signal emitted when discovery finishes (with result).
+        on_device_discovered: Signal emitted when a device is discovered (with device info).
     """
 
     conbus_protocol: ConbusEventProtocol
+    on_progress: Signal = Signal(str)
+    on_finish: Signal = Signal(DiscoveredDevice)
+    on_device_discovered: Signal = Signal(ConbusDiscoverResponse)
 
     def __init__(self, conbus_protocol: ConbusEventProtocol) -> None:
         """Initialize the Conbus discover service.
@@ -36,12 +45,6 @@ class ConbusDiscoverService:
         Args:
             conbus_protocol: ConbusProtocol.
         """
-        self.progress_callback: Optional[Callable[[str], None]] = None
-        self.device_discover_callback: Optional[Callable[[DiscoveredDevice], None]] = (
-            None
-        )
-        self.finish_callback: Optional[Callable[[ConbusDiscoverResponse], None]] = None
-
         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)
@@ -135,9 +138,7 @@ class ConbusDiscoverService:
             "module_type_name": None,
         }
         self.discovered_device_result.discovered_devices.append(device)
-
-        if self.device_discover_callback:
-            self.device_discover_callback(device)
+        self.on_device_discovered.emit(device)
 
         # Send READ_DATAPOINT telegram to query module type
         self.logger.debug(f"Sending module type query for {serial_number}")
@@ -147,8 +148,7 @@ class ConbusDiscoverService:
             system_function=SystemFunction.READ_DATAPOINT,
             data_value=DataPointType.MODULE_TYPE.value,
         )
-        if self.progress_callback:
-            self.progress_callback(serial_number)
+        self.on_progress.emit(serial_number)
 
     def handle_module_type_code_response(
         self, serial_number: str, module_type_code: str
@@ -194,8 +194,7 @@ class ConbusDiscoverService:
                     device["module_type_code"] = code
                     device["module_type_name"] = module_type_name
 
-                    if self.device_discover_callback:
-                        self.device_discover_callback(device)
+                    self.on_device_discovered.emit(device)
 
                     self.logger.debug(
                         f"Updated device {serial_number} with module_type {module_type_name}"
@@ -231,9 +230,7 @@ class ConbusDiscoverService:
                     self.logger.debug(
                         f"Updated device {serial_number} with module_type {module_type}"
                     )
-                    if self.device_discover_callback:
-                        self.device_discover_callback(device)
-
+                    self.on_device_discovered.emit(device)
                     break
 
         self.conbus_protocol.send_telegram(
@@ -249,10 +246,7 @@ class ConbusDiscoverService:
         self.logger.info("Discovery stopped after: %ss", timeout)
         self.discovered_device_result.success = False
         self.discovered_device_result.error = "Discovered device timeout"
-        if self.finish_callback:
-            self.finish_callback(self.discovered_device_result)
-
-        self.stop_reactor()
+        self.on_finish.emit(self.discovered_device_result)
 
     def failed(self, message: str) -> None:
         """Handle failed connection event.
@@ -263,50 +257,64 @@ class ConbusDiscoverService:
         self.logger.debug(f"Failed: {message}")
         self.discovered_device_result.success = False
         self.discovered_device_result.error = message
-        if self.finish_callback:
-            self.finish_callback(self.discovered_device_result)
-
-        self.stop_reactor()
+        self.on_finish.emit(self.discovered_device_result)
 
     def succeed(self) -> None:
         """Handle discovered device success event."""
         self.logger.debug("Succeed")
         self.discovered_device_result.success = True
         self.discovered_device_result.error = None
-        if self.finish_callback:
-            self.finish_callback(self.discovered_device_result)
+        self.on_finish.emit(self.discovered_device_result)
 
-        self.stop_reactor()
+    def set_timeout(self, timeout_seconds: float) -> None:
+        """Setup callbacks and timeout for receiving telegrams.
 
-    def stop_reactor(self) -> None:
-        """Stop reactor."""
-        self.logger.info("Stopping reactor")
-        self.conbus_protocol.stop_reactor()
-
-    def start_reactor(self) -> None:
-        """Start reactor."""
-        self.logger.info("Starting reactor")
-        self.conbus_protocol.start_reactor()
+        Args:
+            timeout_seconds: Optional timeout in seconds.
+        """
+        self.logger.debug("Set timeout")
+        self.conbus_protocol.timeout_seconds = timeout_seconds
 
-    def run(
+    def set_event_loop(
         self,
-        progress_callback: Callable[[str], None],
-        device_discover_callback: Callable[[DiscoveredDevice], None],
-        finish_callback: Callable[[ConbusDiscoverResponse], None],
-        timeout_seconds: Optional[float] = None,
+        event_loop: asyncio.AbstractEventLoop,
     ) -> None:
-        """Run reactor in dedicated thread with its own event loop.
+        """Setup callbacks and timeout for receiving telegrams.
 
         Args:
-            progress_callback: Callback for each discovered device.
-            device_discover_callback: Callback for each discovered device.
-            finish_callback: Callback when discovery completes.
-            timeout_seconds: Optional timeout in seconds.
+            event_loop: Optional event loop to use for async operations.
         """
-        self.logger.info("Starting discovery")
+        self.logger.debug("Set eventloop")
+        self.conbus_protocol.set_event_loop(event_loop)
 
-        if timeout_seconds:
-            self.conbus_protocol.timeout_seconds = timeout_seconds
-        self.progress_callback = progress_callback
-        self.device_discover_callback = device_discover_callback
-        self.finish_callback = finish_callback
+    def start_reactor(self) -> None:
+        """Start the reactor."""
+        self.conbus_protocol.start_reactor()
+
+    def stop_reactor(self) -> None:
+        """Start the reactor."""
+        self.conbus_protocol.stop_reactor()
+
+    def __enter__(self) -> "ConbusDiscoverService":
+        """Enter context manager.
+
+        Returns:
+            Self for context manager protocol.
+        """
+        # Reset state for singleton reuse
+        self.receive_response = ConbusDiscoverResponse(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)
+        self.on_device_discovered.disconnect()
+        self.on_progress.disconnect()
+        self.on_finish.disconnect()
+        self.stop_reactor()

{conson_xp-1.23.0 → conson_xp-1.24.0}/src/xp/services/conbus/conbus_receive_service.py

@@ -6,7 +6,9 @@ allowing clients to receive waiting event telegrams using empty telegram sends.
 
 import asyncio
 import logging
-from typing import Any, Callable, Optional
+from typing import Any, Optional
+
+from psygnal import Signal
 
 from xp.models.conbus.conbus_receive import ConbusReceiveResponse
 from xp.models.protocol.conbus_protocol import TelegramReceivedEvent
@@ -22,9 +24,13 @@ class ConbusReceiveService:
 
     Attributes:
         conbus_protocol: Protocol instance for Conbus communication.
+        on_progress: Signal emitted when a telegram is received (with telegram frame).
+        on_finish: Signal emitted when receiving finishes (with result).
     """
 
     conbus_protocol: ConbusEventProtocol
+    on_progress: Signal = Signal(str)
+    on_finish: Signal = Signal(ConbusReceiveResponse)
 
     def __init__(self, conbus_protocol: ConbusEventProtocol) -> None:
         """Initialize the Conbus receive service.
@@ -32,8 +38,6 @@ class ConbusReceiveService:
         Args:
             conbus_protocol: ConbusEventProtocol instance.
         """
-        self.progress_callback: Optional[Callable[[str], None]] = None
-        self.finish_callback: Optional[Callable[[ConbusReceiveResponse], None]] = None
         self.receive_response: ConbusReceiveResponse = ConbusReceiveResponse(
             success=True
         )
@@ -67,8 +71,7 @@ class ConbusReceiveService:
             telegram_received: The telegram received event.
         """
         self.logger.debug(f"Telegram received: {telegram_received}")
-        if self.progress_callback:
-            self.progress_callback(telegram_received.frame)
+        self.on_progress.emit(telegram_received.frame)
 
         if not self.receive_response.received_telegrams:
             self.receive_response.received_telegrams = []
@@ -79,8 +82,7 @@ class ConbusReceiveService:
         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)
+        self.on_finish.emit(self.receive_response)
 
     def failed(self, message: str) -> None:
         """Handle failed connection event.
@@ -91,37 +93,37 @@ class ConbusReceiveService:
         self.logger.debug("Failed %s:", message)
         self.receive_response.success = False
         self.receive_response.error = message
-        if self.finish_callback:
-            self.finish_callback(self.receive_response)
+        self.on_finish.emit(self.receive_response)
+
+    def set_timeout(self, timeout_seconds: float) -> None:
+        """Setup callbacks and timeout for receiving telegrams.
 
-    def init(
+        Args:
+            timeout_seconds: Optional timeout in seconds.
+        """
+        self.logger.debug("Set timeout")
+        self.conbus_protocol.timeout_seconds = timeout_seconds
+
+    def set_event_loop(
         self,
-        progress_callback: Callable[[str], None],
-        finish_callback: Callable[[ConbusReceiveResponse], None],
-        timeout_seconds: Optional[float] = None,
-        event_loop: Optional[asyncio.AbstractEventLoop] = None,
+        event_loop: asyncio.AbstractEventLoop,
     ) -> None:
         """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.conbus_protocol.timeout_seconds = timeout_seconds
-        self.progress_callback = progress_callback
-        self.finish_callback = finish_callback
-
-        if event_loop:
-            self.conbus_protocol.set_event_loop(event_loop)
+        self.logger.debug("Set eventloop")
+        self.conbus_protocol.set_event_loop(event_loop)
 
     def start_reactor(self) -> None:
         """Start the reactor."""
         self.conbus_protocol.start_reactor()
 
+    def stop_reactor(self) -> None:
+        """Start the reactor."""
+        self.conbus_protocol.stop_reactor()
+
     def __enter__(self) -> "ConbusReceiveService":
         """Enter context manager.
 
@@ -141,3 +143,6 @@ class ConbusReceiveService:
         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)
+        self.on_progress.disconnect()
+        self.on_finish.disconnect()
+        self.stop_reactor()

{conson_xp-1.23.0 → conson_xp-1.24.0}/src/xp/term/protocol.yml

@@ -63,8 +63,8 @@ protocol:
   "e":
     name: "Link 1 Off"
     telegrams:
-      - E02L01I00M
-      - E02L01I00B
+      - E02L01I09M
+      - E02L01I09B
 
   "f":
     name: "Link 2 On"
@@ -75,8 +75,8 @@ protocol:
   "g":
     name: "Link 2 Off"
     telegrams:
-      - E02L02I00M
-      - E02L02I00B
+      - E02L02I09M
+      - E02L02I09B
 
   "h":
     name: "Link 3 On"
@@ -87,8 +87,8 @@ protocol:
   "i":
     name: "Link 3 Off"
     telegrams:
-      - E02L03I00M
-      - E02L03I00B
+      - E02L03I09M
+      - E02L03I09B
 
   "j":
     name: "Link 4 On"
@@ -99,8 +99,8 @@ protocol:
   "k":
     name: "Link 4 Off"
     telegrams:
-      - E02L04I00M
-      - E02L04I00B
+      - E02L04I09M
+      - E02L04I09B
 
   "l":
     name: "Link 5 On"
@@ -111,8 +111,8 @@ protocol:
   "m":
     name: "Link 5 Off"
     telegrams:
-      - E02L05I00M
-      - E02L05I00B
+      - E02L05I09M
+      - E02L05I09B
 
   "n":
     name: "Link 6 On"
@@ -123,8 +123,8 @@ protocol:
   "o":
     name: "Link 6 Off"
     telegrams:
-      - E02L06I00M
-      - E02L06I00B
+      - E02L06I09M
+      - E02L06I09B
 
   "p":
     name: "Link 7 On"
@@ -135,5 +135,5 @@ protocol:
   "q":
     name: "Link 7 Off"
     telegrams:
-      - E02L07I00M
-      - E02L07I00B
+      - E02L07I09M
+      - E02L07I09B

{conson_xp-1.23.0 → conson_xp-1.24.0}/src/xp/term/widgets/protocol_log.py

@@ -12,7 +12,6 @@ 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.status_message import StatusMessageChanged
-from xp.services.conbus.conbus_receive_service import ConbusReceiveService
 from xp.services.protocol import ConbusEventProtocol
 
 
@@ -26,7 +25,6 @@ class ProtocolLogWidget(Widget):
         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.
     """
@@ -43,7 +41,6 @@ class ProtocolLogWidget(Widget):
         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 = ConnectionState.create_state_machine()
@@ -64,8 +61,7 @@ class ProtocolLogWidget(Widget):
         Resolves ConbusReceiveService and connects signals.
         """
         # Resolve service from container (singleton)
-        self.service = self.container.resolve(ConbusReceiveService)
-        self.protocol = self.service.conbus_protocol
+        self.protocol = self.container.resolve(ConbusEventProtocol)
 
         # Connect psygnal signals
         self.protocol.on_connection_made.connect(self._on_connection_made)
@@ -86,10 +82,6 @@ class ProtocolLogWidget(Widget):
         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
@@ -114,41 +106,12 @@ class ProtocolLogWidget(Widget):
             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
-            reactor.connectTCP(
-                self.protocol.cli_config.ip,
-                self.protocol.cli_config.port,
-                self.protocol,
-            )
+            self.protocol.connect()
 
             # Wait for connection to establish
             await asyncio.sleep(1.0)

{conson_xp-1.23.0 → conson_xp-1.24.0}/tests/unit/test_services/test_conbus_receive_service.py

@@ -43,8 +43,6 @@ class TestConbusReceiveService:
 
     def test_service_initialization(self, service, mock_protocol):
         """Test service can be initialized with required dependencies."""
-        assert service.progress_callback is None
-        assert service.finish_callback is None
         assert service.receive_response.success is True
         assert service.receive_response.received_telegrams == []
 
@@ -117,9 +115,9 @@ class TestConbusReceiveService:
         ]
 
     def test_telegram_received_with_progress_callback(self, service, mock_protocol):
-        """Test telegram_received calls progress callback."""
+        """Test telegram_received emits progress signal."""
         progress_mock = Mock()
-        service.progress_callback = progress_mock
+        service.on_progress.connect(progress_mock)
 
         telegram_event = TelegramReceivedEvent(
             protocol=mock_protocol,
@@ -137,9 +135,7 @@ class TestConbusReceiveService:
         progress_mock.assert_called_once_with("<T123456789012D0AK>")
 
     def test_telegram_received_without_progress_callback(self, service, mock_protocol):
-        """Test telegram_received doesn't crash when progress_callback is None."""
-        service.progress_callback = None
-
+        """Test telegram_received doesn't crash when no signal handlers connected."""
         telegram_event = TelegramReceivedEvent(
             protocol=mock_protocol,
             frame="<T123456789012D0AK>",
@@ -157,7 +153,7 @@ class TestConbusReceiveService:
     def test_timeout(self, service, mock_protocol):
         """Test timeout callback marks operation as successful."""
         finish_mock = Mock()
-        service.finish_callback = finish_mock
+        service.on_finish.connect(finish_mock)
 
         service.timeout()
 
@@ -165,16 +161,14 @@ class TestConbusReceiveService:
         finish_mock.assert_called_once_with(service.receive_response)
 
     def test_timeout_without_finish_callback(self, service):
-        """Test timeout doesn't crash when finish_callback is None."""
-        service.finish_callback = None
-
+        """Test timeout doesn't crash when no signal handlers connected."""
         # Should not raise any errors
         service.timeout()
 
     def test_failed(self, service):
         """Test failed callback updates service response."""
         finish_mock = Mock()
-        service.finish_callback = finish_mock
+        service.on_finish.connect(finish_mock)
 
         service.failed("Connection timeout")
 
@@ -183,43 +177,32 @@ class TestConbusReceiveService:
         finish_mock.assert_called_once_with(service.receive_response)
 
     def test_failed_without_finish_callback(self, service):
-        """Test failed doesn't crash when finish_callback is None."""
-        service.finish_callback = None
-
+        """Test failed doesn't crash when no signal handlers connected."""
         # Should not raise any errors
         service.failed("Connection timeout")
 
-    def test_start(self, service, mock_protocol):
-        """Test start method sets up service parameters."""
-        finish_mock = Mock()
-        progress_mock = Mock()
-
-        service.init(
-            progress_callback=progress_mock,
-            finish_callback=finish_mock,
-            timeout_seconds=10,
-        )
+    def test_set_timeout(self, service, mock_protocol):
+        """Test set_timeout method sets timeout on protocol."""
+        service.set_timeout(timeout_seconds=10)
 
-        assert service.progress_callback == progress_mock
-        assert service.finish_callback == finish_mock
         assert mock_protocol.timeout_seconds == 10
 
-    def test_start_without_timeout(self, service, mock_protocol):
-        """Test start method with None timeout uses protocol default."""
+    def test_signal_connections(self, service):
+        """Test signals can be connected and emit correctly."""
         finish_mock = Mock()
         progress_mock = Mock()
-        original_timeout = mock_protocol.timeout_seconds
 
-        service.init(
-            progress_callback=progress_mock,
-            finish_callback=finish_mock,
-            timeout_seconds=None,
-        )
+        # Connect signals
+        service.on_progress.connect(progress_mock)
+        service.on_finish.connect(finish_mock)
+
+        # Emit signals
+        service.on_progress.emit("test_telegram")
+        service.on_finish.emit(service.receive_response)
 
-        assert service.progress_callback == progress_mock
-        assert service.finish_callback == finish_mock
-        # Timeout should remain unchanged
-        assert mock_protocol.timeout_seconds == original_timeout
+        # Verify callbacks were called
+        progress_mock.assert_called_once_with("test_telegram")
+        finish_mock.assert_called_once_with(service.receive_response)
 
     def test_start_reactor(self, service, mock_protocol):
         """Test start_reactor delegates to protocol."""
@@ -256,12 +239,8 @@ class TestConbusReceiveService:
 
     def test_context_manager_full_lifecycle(self, service, mock_protocol):
         """Test full context manager lifecycle with singleton reuse."""
-        finish_mock = Mock()
-        progress_mock = Mock()
-
         # First use
         with service:
-            service.init(progress_mock, finish_mock, 5.0)
             # Simulate receiving a telegram
             service.receive_response.received_telegrams = ["<T123456789012D0AK>"]