conson-xp 1.43.0__tar.gz → 1.45.0__tar.gz

{conson_xp-1.43.0 → conson_xp-1.45.0}/PKG-INFO

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

{conson_xp-1.43.0 → conson_xp-1.45.0}/pyproject.toml

@@ -23,7 +23,7 @@ dependencies = [
 ]
 requires-python = ">=3.11"
 readme = "README.md"
-version = "1.43.0"
+version = "1.45.0"
 
 [project.license]
 file = "LICENSE"

{conson_xp-1.43.0 → conson_xp-1.45.0}/src/xp/__init__.py

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

{conson_xp-1.43.0 → conson_xp-1.45.0}/src/xp/cli/commands/conbus/conbus_actiontable_commands.py

@@ -98,7 +98,7 @@ def conbus_download_actiontable(ctx: Context, serial_number: str) -> None:
         service.on_finish.connect(on_finish)
         service.on_actiontable_received.connect(on_actiontable_received)
         service.on_error.connect(on_error)
-        service.start(serial_number=serial_number)
+        service.configure(serial_number=serial_number)
         service.start_reactor()
 
 

{conson_xp-1.43.0 → conson_xp-1.45.0}/src/xp/services/conbus/actiontable/actiontable_download_service.py

@@ -2,7 +2,8 @@
 
 import logging
 from dataclasses import asdict
-from typing import Any, Dict, Optional
+from enum import Enum
+from typing import Any, Optional
 
 from psygnal import SignalInstance
 from statemachine import State, StateMachine
@@ -17,87 +18,130 @@ from xp.services.actiontable.actiontable_serializer import ActionTableSerializer
 from xp.services.protocol.conbus_event_protocol import ConbusEventProtocol
 from xp.services.telegram.telegram_service import TelegramService
 
+# Constants
+NO_ERROR_CODE = "00"
+CHUNK_HEADER_LENGTH = 2  # data_value format: 2-char counter + actiontable chunk
+MAX_ERROR_RETRIES = 3  # Max retries for error_status_received before giving up
+
+
+class Phase(Enum):
+    """Download workflow phases.
+
+    The download workflow consists of three sequential phases:
+    - INIT: Drain pending telegrams, query error status → proceed to DOWNLOAD
+    - DOWNLOAD: Request actiontable, receive chunks with ACK, until EOF
+    - CLEANUP: Drain pending telegrams, query error status → proceed to COMPLETED
+
+    Attributes:
+        INIT: Initial phase - drain pending telegrams and query error status.
+        DOWNLOAD: Download phase - request actiontable and receive chunks.
+        CLEANUP: Cleanup phase - drain remaining telegrams and verify status.
+    """
+
+    INIT = "init"
+    DOWNLOAD = "download"
+    CLEANUP = "cleanup"
+
 
 class ActionTableDownloadService(StateMachine):
-    """TCP client service for downloading action tables from Conbus modules.
+    """Service for downloading action tables from Conbus modules via TCP.
+
+    Inherits from StateMachine - the service IS the state machine. Uses guard
+    conditions to share states between INIT and CLEANUP phases.
+    see: Download-ActionTable-Workflow.dot
+
+    States (9 total):
+        idle -> receiving -> resetting -> waiting_ok -> requesting
+             -> waiting_data <-> receiving_chunk -> processing_eof -> completed
+
+    Phases - INIT and CLEANUP share the same states (receiving, resetting, waiting_ok):
+
+    INIT phase (drain → reset → wait_ok):
+        idle -> receiving -> resetting -> waiting_ok --(guard: is_init_phase)--> requesting
 
-    Inherits from StateMachine - the service IS the state machine.
+    DOWNLOAD phase (request → receive chunks → EOF):
+        requesting -> waiting_data <-> receiving_chunk -> processing_eof
 
-    Manages TCP socket connections, handles telegram generation and transmission,
-    and processes server responses for action table downloads.
+    CLEANUP phase (drain → reset → wait_ok):
+        processing_eof -> receiving -> resetting -> waiting_ok --(guard: is_cleanup_phase)--> completed
+
+    The drain/reset/wait_ok cycle:
+    1. Drain pending telegrams (receiving state discards telegram without reading them).
+       There may be a lot of telegram. We are listening and receiving until no more
+       telegram arrive and timeout occurs.
+    2. Timeout triggers error status query (resetting)
+    3. Wait for response (waiting_ok)
+    4. On no error: guard determines target (requesting or completed)
+       On error: retry from drain step
 
     Attributes:
-        on_progress: Signal emitted with telegram frame when progress is made.
-        on_error: Signal emitted with error message string when an error occurs.
-        on_finish: Signal emitted with (ActionTable, Dict[str, Any], list[str]) when complete.
-        idle: Initial state, waiting for connection.
-        receiving: Listening for telegrams, filtering relevant responses.
-        resetting: Timeout occurred, preparing error status query.
-        waiting_ok: Sent error status query, awaiting ACK/NAK.
-        requesting: Ready to send download request.
-        waiting_data: Awaiting actiontable chunk or EOF.
-        receiving_chunk: Processing received actiontable data.
-        processing_eof: Received EOF, deserializing actiontable.
-        completed: Download finished successfully.
+        on_progress: Signal emitted with "." for each chunk received.
+        on_error: Signal emitted with error message string.
+        on_actiontable_received: Signal emitted with (ActionTable, dict, list).
+        on_finish: Signal emitted when download and cleanup completed.
+        idle: Initial state - waiting for connection.
+        receiving: Drain telegrams state (INIT or CLEANUP phase).
+        resetting: Query error status state.
+        waiting_ok: Await error status response state.
+        requesting: DOWNLOAD phase - send download request state.
+        waiting_data: DOWNLOAD phase - await chunks state.
+        receiving_chunk: DOWNLOAD phase - process chunk state.
+        processing_eof: DOWNLOAD phase - deserialize result state.
+        completed: Final state - download finished.
         do_connect: Transition from idle to receiving.
-        do_timeout: Transition from receiving to resetting.
+        filter_telegram: Self-transition in receiving to drain telegrams.
+        do_timeout: Transition on timeout events.
         send_error_status: Transition from resetting to waiting_ok.
-        error_status_received: Transition from waiting_ok to receiving (retry).
-        no_error_status_received: Transition from waiting_ok to requesting or completed.
+        error_status_received: Transition when error status is received.
+        no_error_status_received: Transition when no error status received.
         send_download: Transition from requesting to waiting_data.
         receive_chunk: Transition from waiting_data to receiving_chunk.
         send_ack: Transition from receiving_chunk to waiting_data.
         receive_eof: Transition from waiting_data to processing_eof.
-        do_finish: Transition from processing_eof to receiving.
-        receiving2: Second receiving state after EOF processing.
-        resetting2: Second resetting state for finalization phase.
-        waiting_ok2: Second waiting_ok state for finalization phase.
-        filter_telegram: Self-transition for filtering telegrams in receiving state.
-        filter_telegram2: Self-transition for filtering telegrams in receiving2 state.
-        do_timeout2: Timeout transition for finalization phase.
-        send_error_status2: Error status query transition for finalization phase.
-        error_status_received2: Error received transition for finalization phase.
-        no_error_status_received2: No error received transition to completed state.
+        do_finish: Transition from processing_eof to receiving (cleanup).
+
+    Example:
+        >>> with download_service as service:
+        ...     service.configure(serial_number="12345678")
+        ...     service.on_actiontable_received.connect(handle_result)
+        ...     service.start_reactor()
     """
 
-    # States (9 states as per spec)
+    # States - unified for INIT and CLEANUP phases using guards
     idle = State(initial=True)
-    receiving = State()
-    resetting = State()
-    waiting_ok = State()
-
-    requesting = State()
-    waiting_data = State()
-    receiving_chunk = State()
-    processing_eof = State()
+    receiving = State()  # Drain telegrams (INIT or CLEANUP phase)
+    resetting = State()  # Query error status
+    waiting_ok = State()  # Await error status response
 
-    receiving2 = State()
-    resetting2 = State()
-    waiting_ok2 = State()
+    requesting = State()  # DOWNLOAD phase: send download request
+    waiting_data = State()  # DOWNLOAD phase: await chunks
+    receiving_chunk = State()  # DOWNLOAD phase: process chunk
+    processing_eof = State()  # DOWNLOAD phase: deserialize result
 
     completed = State(final=True)
 
-    # Phase 1: Connection & Initialization
+    # Phase transitions - shared states with guards for phase-dependent routing
     do_connect = idle.to(receiving)
-    filter_telegram = receiving.to(receiving)  # Self-transition for filtering
+    filter_telegram = receiving.to(receiving)  # Self-transition: drain to /dev/null
     do_timeout = receiving.to(resetting) | waiting_ok.to(receiving)
     send_error_status = resetting.to(waiting_ok)
-    error_status_received = waiting_ok.to(receiving)
-    no_error_status_received = waiting_ok.to(requesting)
+    error_status_received = waiting_ok.to(
+        receiving, cond="can_retry"
+    )  # Retry if under limit
 
-    # Phase 2: Download
+    # Conditional transitions based on phase
+    no_error_status_received = waiting_ok.to(
+        requesting, cond="is_init_phase"
+    ) | waiting_ok.to(completed, cond="is_cleanup_phase")
+
+    # DOWNLOAD phase transitions
     send_download = requesting.to(waiting_data)
     receive_chunk = waiting_data.to(receiving_chunk)
     send_ack = receiving_chunk.to(waiting_data)
     receive_eof = waiting_data.to(processing_eof)
 
-    # Phase 3: Finalization
-    do_finish = processing_eof.to(receiving2)
-    filter_telegram2 = receiving2.to(receiving2)  # Self-transition for filtering
-    do_timeout2 = receiving2.to(resetting2) | waiting_ok2.to(receiving2)
-    send_error_status2 = resetting2.to(waiting_ok2)
-    error_status_received2 = waiting_ok2.to(receiving2)
-    no_error_status_received2 = waiting_ok2.to(completed)
+    # Return to drain/reset cycle for CLEANUP phase
+    do_finish = processing_eof.to(receiving)
 
     def __init__(
         self,
@@ -118,42 +162,63 @@ class ActionTableDownloadService(StateMachine):
         self.serial_number: str = ""
         self.actiontable_data: list[str] = []
         self.logger = logging.getLogger(__name__)
+        self._phase: Phase = Phase.INIT
+        self._error_retry_count: int = 0
+        self._signals_connected: bool = False
 
         # Signals (instance attributes to avoid conflict with statemachine)
         self.on_progress: SignalInstance = SignalInstance((str,))
         self.on_error: SignalInstance = SignalInstance((str,))
         self.on_finish: SignalInstance = SignalInstance()
         self.on_actiontable_received: SignalInstance = SignalInstance(
-            (ActionTable, Dict[str, Any], list[str])
+            (ActionTable, dict[str, Any], list[str])
         )
 
+        # Initialize state machine first (before connecting signals)
+        super().__init__(allow_event_without_transition=True)
+
         # Connect protocol signals
-        self.conbus_protocol.on_connection_made.connect(self._on_connection_made)
-        self.conbus_protocol.on_telegram_sent.connect(self._on_telegram_sent)
-        self.conbus_protocol.on_telegram_received.connect(self._on_telegram_received)
-        self.conbus_protocol.on_timeout.connect(self._on_timeout)
-        self.conbus_protocol.on_failed.connect(self._on_failed)
+        self._connect_signals()
 
-        # Initialize state machine
-        super().__init__(allow_event_without_transition=True)
+    # Guard conditions for phase-dependent transitions
+
+    def is_init_phase(self) -> bool:
+        """Guard: check if currently in INIT phase.
+
+        Returns:
+            True if in INIT phase, False otherwise.
+        """
+        return self._phase == Phase.INIT
+
+    def is_cleanup_phase(self) -> bool:
+        """Guard: check if currently in CLEANUP phase.
+
+        Returns:
+            True if in CLEANUP phase, False otherwise.
+        """
+        return self._phase == Phase.CLEANUP
+
+    def can_retry(self) -> bool:
+        """Guard: check if retry is allowed (under max limit).
+
+        Returns:
+            True if retry count is below MAX_ERROR_RETRIES, False otherwise.
+        """
+        return self._error_retry_count < MAX_ERROR_RETRIES
 
     # State machine lifecycle hooks
+    # Note: receiving state is used to drain pending telegrams from the connection
+    # pipe. Any telegram received in this state is intentionally discarded (sent
+    # to /dev/null) to ensure a clean state before processing.
 
     def on_enter_receiving(self) -> None:
-        """Enter receiving state - listening for telegrams."""
-        self.logger.debug("Entering RECEIVING state - waiting for telegrams")
-        self.conbus_protocol.wait()
-
-    def on_enter_receiving2(self) -> None:
-        """Enter receiving state - listening for telegrams."""
-        self.logger.debug("Entering RECEIVING2 state - waiting for telegrams")
+        """Enter receiving state - drain pending telegrams."""
+        self.logger.debug(f"Entering RECEIVING state (phase={self._phase.value})")
         self.conbus_protocol.wait()
 
     def on_enter_resetting(self) -> None:
         """Enter resetting state - query error status."""
-        self.logger.debug("Entering RESETTING state - querying error status")
-
-        # query_datapoint_module_error_code
+        self.logger.debug(f"Entering RESETTING state (phase={self._phase.value})")
         self.conbus_protocol.send_telegram(
             telegram_type=TelegramType.SYSTEM,
             serial_number=self.serial_number,
@@ -162,37 +227,20 @@ class ActionTableDownloadService(StateMachine):
         )
         self.send_error_status()
 
-    def on_enter_resetting2(self) -> None:
-        """Enter resetting state - query error status."""
-        self.logger.debug("Entering RESETTING2 state - querying error status")
-
-        # query_datapoint_module_error_code
-        self.conbus_protocol.send_telegram(
-            telegram_type=TelegramType.SYSTEM,
-            serial_number=self.serial_number,
-            system_function=SystemFunction.READ_DATAPOINT,
-            data_value=DataPointType.MODULE_ERROR_CODE.value,
-        )
-        self.send_error_status2()
-
     def on_enter_waiting_ok(self) -> None:
-        """Enter waiting_ok state - awaiting ERROR/NO_ERROR."""
-        self.logger.debug("Entering WAITING_OK state - awaiting ERROR/NO_ERROR")
-        self.conbus_protocol.wait()
-
-    def on_enter_waiting_ok2(self) -> None:
-        """Enter waiting_ok state - awaiting ERROR/NO_ERROR."""
-        self.logger.debug("Entering WAITING_OK state - awaiting ERROR/NO_ERROR")
+        """Enter waiting_ok state - awaiting error status response."""
+        self.logger.debug(f"Entering WAITING_OK state (phase={self._phase.value})")
         self.conbus_protocol.wait()
 
     def on_enter_requesting(self) -> None:
         """Enter requesting state - send download request."""
+        self._phase = Phase.DOWNLOAD
         self.logger.debug("Entering REQUESTING state - sending download request")
         self.conbus_protocol.send_telegram(
             telegram_type=TelegramType.SYSTEM,
             serial_number=self.serial_number,
             system_function=SystemFunction.DOWNLOAD_ACTIONTABLE,
-            data_value="00",
+            data_value=NO_ERROR_CODE,
         )
         self.send_download()
 
@@ -208,12 +256,12 @@ class ActionTableDownloadService(StateMachine):
             telegram_type=TelegramType.SYSTEM,
             serial_number=self.serial_number,
             system_function=SystemFunction.ACK,
-            data_value="00",
+            data_value=NO_ERROR_CODE,
         )
         self.send_ack()
 
     def on_enter_processing_eof(self) -> None:
-        """Enter processing_eof state - deserialize and emit result."""
+        """Enter processing_eof state - deserialize and emit result, then cleanup."""
         self.logger.debug("Entering PROCESSING_EOF state - deserializing")
         all_data = "".join(self.actiontable_data)
         actiontable = self.serializer.from_encoded_string(all_data)
@@ -222,6 +270,8 @@ class ActionTableDownloadService(StateMachine):
         self.on_actiontable_received.emit(
             actiontable, actiontable_dict, actiontable_short
         )
+        # Switch to CLEANUP phase before returning to receiving state
+        self._phase = Phase.CLEANUP
         self.do_finish()
 
     def on_enter_completed(self) -> None:
@@ -259,44 +309,28 @@ class ActionTableDownloadService(StateMachine):
             )
             return
 
-        if reply_telegram.data_value == "00":
-            if self.waiting_ok.is_active:
-                self.no_error_status_received()
+        if not self.waiting_ok.is_active:
+            return
 
-        if reply_telegram.data_value != "00":
+        is_no_error = reply_telegram.data_value == NO_ERROR_CODE
+        if is_no_error:
+            self._error_retry_count = 0  # Reset on success
+            self.no_error_status_received()  # Guards determine target state
+        else:
+            self._error_retry_count += 1
+            self.logger.debug(
+                f"Error status received, retry {self._error_retry_count}/{MAX_ERROR_RETRIES}"
+            )
+            # Guard can_retry blocks transition if max retries exceeded
+            self.error_status_received()
+            # Check if guard blocked the transition (still in waiting_ok)
             if self.waiting_ok.is_active:
-                self.error_status_received()
-
-        if reply_telegram.data_value == "00":
-            if self.waiting_ok2.is_active:
-                self.no_error_status_received2()
-
-        if reply_telegram.data_value != "00":
-            if self.waiting_ok2.is_active:
-                self.error_status_received2()
-
-    def _on_ack_received(self, _reply_telegram: ReplyTelegram) -> None:
-        """Handle ACK telegram received.
-
-        Args:
-            _reply_telegram: The parsed reply telegram (unused).
-        """
-        self.logger.debug(f"Received ACK in {self.current_state}")
-        if self.waiting_ok.is_active:
-            self.ack_received()
-
-        if self.waiting_ok2.is_active:
-            self.ack_received2()
-
-    def _on_nack_received(self, _reply_telegram: ReplyTelegram) -> None:
-        """Handle NAK telegram received.
-
-        Args:
-            _reply_telegram: The parsed reply telegram (unused).
-        """
-        self.logger.debug(f"Received NAK in {self.current_state}")
-        if self.waiting_ok.is_active:
-            self.nak_received()
+                self.logger.error(
+                    f"Max error retries ({MAX_ERROR_RETRIES}) exceeded, giving up"
+                )
+                self.on_error.emit(
+                    f"Module error persists after {MAX_ERROR_RETRIES} retries"
+                )
 
     def _on_actiontable_chunk_received(self, reply_telegram: ReplyTelegram) -> None:
         """Handle actiontable chunk telegram received.
@@ -306,7 +340,7 @@ class ActionTableDownloadService(StateMachine):
         """
         self.logger.debug(f"Received actiontable chunk in {self.current_state}")
         if self.waiting_data.is_active:
-            data_part = reply_telegram.data_value[2:]
+            data_part = reply_telegram.data_value[CHUNK_HEADER_LENGTH:]
             self.actiontable_data.append(data_part)
             self.on_progress.emit(".")
             self.receive_chunk()
@@ -327,7 +361,10 @@ class ActionTableDownloadService(StateMachine):
         Args:
             telegram_received: The telegram received event.
         """
-        self.logger.debug(f"Received{telegram_received} in {self.current_state}")
+        self.logger.debug(f"Received {telegram_received} in {self.current_state}")
+
+        # In receiving state, drain pending telegrams from pipe (discard to /dev/null).
+        # This ensures clean state before processing by clearing any stale messages.
         if self.receiving.is_active:
             self.filter_telegram()
             return
@@ -336,11 +373,13 @@ class ActionTableDownloadService(StateMachine):
         if not telegram_received.checksum_valid:
             self.logger.debug("Filtered: invalid checksum")
             return
+
         if telegram_received.telegram_type != TelegramType.REPLY.value:
             self.logger.debug(
                 f"Filtered: not a reply (got {telegram_received.telegram_type})"
             )
             return
+
         if telegram_received.serial_number != self.serial_number:
             self.logger.debug(
                 f"Filtered: wrong serial {telegram_received.serial_number} != {self.serial_number}"
@@ -355,14 +394,6 @@ class ActionTableDownloadService(StateMachine):
             self._on_read_datapoint_received(reply_telegram)
             return
 
-        if reply_telegram.system_function == SystemFunction.ACK:
-            self._on_ack_received(reply_telegram)
-            return
-
-        if reply_telegram.system_function == SystemFunction.NAK:
-            self._on_nack_received(reply_telegram)
-            return
-
         if reply_telegram.system_function == SystemFunction.ACTIONTABLE:
             self._on_actiontable_chunk_received(reply_telegram)
             return
@@ -373,15 +404,14 @@ class ActionTableDownloadService(StateMachine):
 
     def _on_timeout(self) -> None:
         """Handle timeout event."""
-        self.logger.debug("Timeout occurred")
+        self.logger.debug(f"Timeout occurred (phase={self._phase.value})")
         if self.receiving.is_active:
             self.do_timeout()  # receiving -> resetting
         elif self.waiting_ok.is_active:
-            self.do_timeout()  # waiting_ok -> receiving
-        elif self.receiving2.is_active:
-            self.do_timeout2()  # receiving2 -> resetting2
-        elif self.waiting_ok2.is_active:
-            self.do_timeout2()  # waiting_ok2 -> receiving2
+            self.do_timeout()  # waiting_ok -> receiving (retry)
+        elif self.waiting_data.is_active:
+            self.logger.error("Timeout waiting for actiontable data")
+            self.on_error.emit("Timeout waiting for actiontable data")
         else:
             self.logger.debug("Timeout in non-recoverable state")
             self.on_error.emit("Timeout")
@@ -397,18 +427,26 @@ class ActionTableDownloadService(StateMachine):
 
     # Public API
 
-    def start(
+    def configure(
         self,
         serial_number: str,
         timeout_seconds: Optional[float] = 2.0,
     ) -> None:
-        """Run reactor in dedicated thread with its own event loop.
+        """Configure download parameters before starting.
+
+        Sets the target module serial number and timeout. Call this before
+        start_reactor() to configure the download target.
 
         Args:
-            serial_number: Module serial number.
-            timeout_seconds: Optional timeout in seconds.
+            serial_number: Module serial number to download from.
+            timeout_seconds: Timeout in seconds for each operation (default 2.0).
+
+        Raises:
+            RuntimeError: If called while download is in progress.
         """
-        self.logger.info("Starting actiontable download")
+        if not self.idle.is_active:
+            raise RuntimeError("Cannot configure while download in progress")
+        self.logger.info("Configuring actiontable download")
         self.serial_number = serial_number
         if timeout_seconds:
             self.conbus_protocol.timeout_seconds = timeout_seconds
@@ -429,17 +467,42 @@ class ActionTableDownloadService(StateMachine):
         """Stop the reactor."""
         self.conbus_protocol.stop_reactor()
 
+    def _connect_signals(self) -> None:
+        """Connect protocol signals to handlers (idempotent)."""
+        if self._signals_connected:
+            return
+        self.conbus_protocol.on_connection_made.connect(self._on_connection_made)
+        self.conbus_protocol.on_telegram_sent.connect(self._on_telegram_sent)
+        self.conbus_protocol.on_telegram_received.connect(self._on_telegram_received)
+        self.conbus_protocol.on_timeout.connect(self._on_timeout)
+        self.conbus_protocol.on_failed.connect(self._on_failed)
+        self._signals_connected = True
+
+    def _disconnect_signals(self) -> None:
+        """Disconnect protocol signals from handlers (idempotent)."""
+        if not self._signals_connected:
+            return
+        self.conbus_protocol.on_connection_made.disconnect(self._on_connection_made)
+        self.conbus_protocol.on_telegram_sent.disconnect(self._on_telegram_sent)
+        self.conbus_protocol.on_telegram_received.disconnect(self._on_telegram_received)
+        self.conbus_protocol.on_timeout.disconnect(self._on_timeout)
+        self.conbus_protocol.on_failed.disconnect(self._on_failed)
+        self._signals_connected = False
+
     def __enter__(self) -> "ActionTableDownloadService":
-        """Enter context manager - reset state for singleton reuse.
+        """Enter context manager - reset state and reconnect signals.
 
         Returns:
             Self for context manager protocol.
         """
         # Reset state for singleton reuse
         self.actiontable_data = []
-        self._download_complete = False
+        self._phase = Phase.INIT
+        self._error_retry_count = 0
         # Reset state machine to idle
         self._reset_state()
+        # Reconnect signals (in case previously disconnected)
+        self._connect_signals()
         return self
 
     def _reset_state(self) -> None:
@@ -447,21 +510,16 @@ class ActionTableDownloadService(StateMachine):
         # python-statemachine uses model.state to track current state
         # Set it directly to the initial state id
         self.model.state = self.idle.id
-        self._download_complete = False
 
     def __exit__(
         self, _exc_type: Optional[type], _exc_val: Optional[Exception], _exc_tb: Any
     ) -> None:
         """Exit context manager and disconnect signals."""
-        # Disconnect protocol signals
-        self.conbus_protocol.on_connection_made.disconnect(self._on_connection_made)
-        self.conbus_protocol.on_telegram_sent.disconnect(self._on_telegram_sent)
-        self.conbus_protocol.on_telegram_received.disconnect(self._on_telegram_received)
-        self.conbus_protocol.on_timeout.disconnect(self._on_timeout)
-        self.conbus_protocol.on_failed.disconnect(self._on_failed)
+        self._disconnect_signals()
         # Disconnect service signals
         self.on_progress.disconnect()
         self.on_error.disconnect()
+        self.on_actiontable_received.disconnect()
         self.on_finish.disconnect()
         # Stop reactor
         self.stop_reactor()

{conson_xp-1.43.0 → conson_xp-1.45.0}/tests/integration/test_actiontable_integration.py

@@ -165,7 +165,7 @@ class TestActionTableIntegration:
             # Do nothing in test
             pass
 
-        mock_service.start.side_effect = mock_start
+        mock_service.configure.side_effect = mock_start
         mock_service.start_reactor.side_effect = mock_start_reactor
 
         # Setup mock container
@@ -191,7 +191,7 @@ class TestActionTableIntegration:
         assert "actiontable" in result.output
 
         # Verify service.start was called
-        assert mock_service.start.called
+        assert mock_service.configure.called
 
     def test_bcd_encoding_decoding(self):
         """Test BCD encoding/decoding functionality."""

{conson_xp-1.43.0 → conson_xp-1.45.0}/tests/unit/test_cli/test_conbus_actiontable_commands.py

@@ -150,7 +150,7 @@ class TestConbusActionTableCommands:
 
         # Verify success
         assert result.exit_code == 0
-        mock_service.start.assert_called_once()
+        mock_service.configure.assert_called_once()
 
         # Verify output contains expected data
         assert "0000012345" in result.output