conson-xp 1.34.0__py3-none-any.whl → 1.35.0__py3-none-any.whl

xp/services/conbus/actiontable/msactiontable_service.py

@@ -1,11 +1,10 @@
 """Service for downloading XP24 action tables via Conbus protocol."""
 
 import logging
-from typing import Callable, Optional, Union
+from typing import Any, Optional, Union
 
-from twisted.internet.posixbase import PosixReactorBase
+from psygnal import Signal
 
-from xp.models import ConbusClientConfig
 from xp.models.actiontable.msactiontable_xp20 import Xp20MsActionTable
 from xp.models.actiontable.msactiontable_xp24 import Xp24MsActionTable
 from xp.models.actiontable.msactiontable_xp33 import Xp33MsActionTable
@@ -21,7 +20,7 @@ from xp.services.actiontable.msactiontable_xp24_serializer import (
 from xp.services.actiontable.msactiontable_xp33_serializer import (
     Xp33MsActionTableSerializer,
 )
-from xp.services.protocol import ConbusProtocol
+from xp.services.protocol.conbus_event_protocol import ConbusEventProtocol
 from xp.services.telegram.telegram_service import TelegramService
 
 
@@ -31,34 +30,42 @@ class MsActionTableError(Exception):
     pass
 
 
-class MsActionTableService(ConbusProtocol):
+class MsActionTableService:
     """
-    TCP client service for sending telegrams to Conbus servers.
+    Service for downloading MS action tables via Conbus protocol.
 
-    Manages TCP socket connections, handles telegram generation and transmission,
-    and processes server responses.
+    Uses ConbusEventProtocol to download action tables from XP20, XP24, or XP33 modules.
+    Emits signals for progress updates, errors, and completion.
+
+    Attributes:
+        conbus_protocol: Protocol instance for Conbus communication.
+        on_progress: Signal emitted for progress updates (str).
+        on_error: Signal emitted for errors (str).
+        on_finish: Signal emitted when download completes (MsActionTable or None).
     """
 
+    on_progress: Signal = Signal(str)
+    on_error: Signal = Signal(str)
+    on_finish: Signal = Signal(object)  # Union type for Xp20/24/33 or None
+
     def __init__(
         self,
-        cli_config: ConbusClientConfig,
-        reactor: PosixReactorBase,
+        conbus_protocol: ConbusEventProtocol,
         xp20ms_serializer: Xp20MsActionTableSerializer,
         xp24ms_serializer: Xp24MsActionTableSerializer,
         xp33ms_serializer: Xp33MsActionTableSerializer,
         telegram_service: TelegramService,
     ) -> None:
-        """Initialize the Conbus client send service.
+        """Initialize the MS action table service.
 
         Args:
-            cli_config: Conbus client configuration.
-            reactor: Twisted reactor instance.
+            conbus_protocol: ConbusEventProtocol instance.
             xp20ms_serializer: XP20 MS action table serializer.
             xp24ms_serializer: XP24 MS action table serializer.
             xp33ms_serializer: XP33 MS action table serializer.
             telegram_service: Telegram service for parsing.
         """
-        super().__init__(cli_config, reactor)
+        self.conbus_protocol = conbus_protocol
         self.xp20ms_serializer = xp20ms_serializer
         self.xp24ms_serializer = xp24ms_serializer
         self.xp33ms_serializer = xp33ms_serializer
@@ -70,24 +77,23 @@ class MsActionTableService(ConbusProtocol):
         self.telegram_service = telegram_service
         self.serial_number: str = ""
         self.xpmoduletype: str = ""
-        self.progress_callback: Optional[Callable[[str], None]] = None
-        self.error_callback: Optional[Callable[[str], None]] = None
-        self.finish_callback: Optional[
-            Callable[
-                [Union[Xp20MsActionTable, Xp24MsActionTable, Xp33MsActionTable, None]],
-                None,
-            ]
-        ] = None
         self.msactiontable_data: list[str] = []
         # Set up logging
         self.logger = logging.getLogger(__name__)
 
-    def connection_established(self) -> None:
-        """Handle connection established event."""
+        # Connect protocol signals
+        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)
+
+    def connection_made(self) -> None:
+        """Handle connection made event."""
         self.logger.debug(
             "Connection established, sending download msactiontable telegram"
         )
-        self.send_telegram(
+        self.conbus_protocol.send_telegram(
             telegram_type=TelegramType.SYSTEM,
             serial_number=self.serial_number,
             system_function=SystemFunction.DOWNLOAD_MSACTIONTABLE,
@@ -143,10 +149,9 @@ class MsActionTableService(ConbusProtocol):
             self.msactiontable_data.extend(
                 (reply_telegram.data, reply_telegram.data_value)
             )
-            if self.progress_callback:
-                self.progress_callback(".")
+            self.on_progress.emit(".")
 
-            self.send_telegram(
+            self.conbus_protocol.send_telegram(
                 telegram_type=TelegramType.SYSTEM,
                 serial_number=self.serial_number,
                 system_function=SystemFunction.ACK,
@@ -164,6 +169,11 @@ class MsActionTableService(ConbusProtocol):
 
         self.logger.debug("Invalid msactiontable response")
 
+    def timeout(self) -> None:
+        """Handle timeout event."""
+        self.logger.debug("Timeout occurred")
+        self.failed("Timeout")
+
     def failed(self, message: str) -> None:
         """Handle failed connection event.
 
@@ -171,9 +181,8 @@ class MsActionTableService(ConbusProtocol):
             message: Failure message.
         """
         self.logger.debug(f"Failed: {message}")
-        if self.error_callback:
-            self.error_callback(message)
-        self._stop_reactor()
+        self.on_error.emit(message)
+        self.on_finish.emit(None)
 
     def succeed(
         self,
@@ -184,29 +193,19 @@ class MsActionTableService(ConbusProtocol):
         Args:
             msactiontable: result.
         """
-        if self.finish_callback:
-            self.finish_callback(msactiontable)
-        self._stop_reactor()
+        self.on_finish.emit(msactiontable)
 
     def start(
         self,
         serial_number: str,
         xpmoduletype: str,
-        progress_callback: Callable[[str], None],
-        error_callback: Callable[[str], None],
-        finish_callback: Callable[
-            [Union[Xp20MsActionTable, Xp24MsActionTable, Xp33MsActionTable, None]], None
-        ],
         timeout_seconds: Optional[float] = None,
     ) -> None:
-        """Run reactor in dedicated thread with its own event loop.
+        """Setup download parameters.
 
         Args:
             serial_number: Module serial number.
             xpmoduletype: XP module type (xp20, xp24, xp33).
-            progress_callback: Callback for progress updates.
-            error_callback: Callback for errors.
-            finish_callback: Callback when download completes.
             timeout_seconds: Optional timeout in seconds.
 
         Raises:
@@ -225,8 +224,49 @@ class MsActionTableService(ConbusProtocol):
             raise MsActionTableError(f"Unsupported module type: {xpmoduletype}")
 
         if timeout_seconds:
-            self.timeout_seconds = timeout_seconds
-        self.progress_callback = progress_callback
-        self.error_callback = error_callback
-        self.finish_callback = finish_callback
-        self.start_reactor()
+            self.conbus_protocol.timeout_seconds = timeout_seconds
+
+    def set_timeout(self, timeout_seconds: float) -> None:
+        """Set operation timeout.
+
+        Args:
+            timeout_seconds: Timeout in seconds.
+        """
+        self.conbus_protocol.timeout_seconds = timeout_seconds
+
+    def start_reactor(self) -> None:
+        """Start the reactor."""
+        self.conbus_protocol.start_reactor()
+
+    def stop_reactor(self) -> None:
+        """Stop the reactor."""
+        self.conbus_protocol.stop_reactor()
+
+    def __enter__(self) -> "MsActionTableService":
+        """Enter context manager.
+
+        Returns:
+            Self for context manager protocol.
+        """
+        # Reset state for singleton reuse
+        self.msactiontable_data = []
+        self.serial_number = ""
+        self.xpmoduletype = ""
+        return self
+
+    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.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)
+        # Disconnect service signals
+        self.on_progress.disconnect()
+        self.on_error.disconnect()
+        self.on_finish.disconnect()
+        # Stop reactor
+        self.stop_reactor()

xp/services/conbus/conbus_custom_service.py

@@ -5,47 +5,49 @@ This service handles custom telegram operations for modules through Conbus teleg
 
 import logging
 from datetime import datetime
-from typing import Callable, Optional
+from typing import Any, Optional
 
-from twisted.internet.posixbase import PosixReactorBase
+from psygnal import Signal
 
-from xp.models import ConbusClientConfig
 from xp.models.conbus.conbus_custom import ConbusCustomResponse
 from xp.models.protocol.conbus_protocol import TelegramReceivedEvent
 from xp.models.telegram.reply_telegram import ReplyTelegram
 from xp.models.telegram.system_function import SystemFunction
 from xp.models.telegram.telegram_type import TelegramType
-from xp.services.protocol import ConbusProtocol
+from xp.services.protocol.conbus_event_protocol import ConbusEventProtocol
 from xp.services.telegram.telegram_service import TelegramService
 
 
-class ConbusCustomService(ConbusProtocol):
-    """
-    Service for sending custom telegrams to Conbus modules.
+class ConbusCustomService:
+    """Service for sending custom telegrams to Conbus modules.
 
-    Uses ConbusProtocol to provide custom telegram functionality
+    Uses ConbusEventProtocol to provide custom telegram functionality
     for sending arbitrary function codes and data to modules.
+
+    Attributes:
+        conbus_protocol: Protocol instance for Conbus communication.
+        telegram_service: Service for parsing telegrams.
+        on_finish: Signal emitted when custom operation completes (with response).
     """
 
+    on_finish: Signal = Signal(ConbusCustomResponse)
+
     def __init__(
         self,
+        conbus_protocol: ConbusEventProtocol,
         telegram_service: TelegramService,
-        cli_config: ConbusClientConfig,
-        reactor: PosixReactorBase,
     ) -> None:
         """Initialize the Conbus custom service.
 
         Args:
+            conbus_protocol: Protocol instance for Conbus communication.
             telegram_service: Service for parsing telegrams.
-            cli_config: Configuration for Conbus client connection.
-            reactor: Twisted reactor for event loop.
         """
-        super().__init__(cli_config, reactor)
+        self.conbus_protocol = conbus_protocol
         self.telegram_service = telegram_service
         self.serial_number: str = ""
         self.function_code: str = ""
         self.data: str = ""
-        self.finish_callback: Optional[Callable[[ConbusCustomResponse], None]] = None
         self.service_response: ConbusCustomResponse = ConbusCustomResponse(
             success=False,
             serial_number=self.serial_number,
@@ -54,7 +56,14 @@ class ConbusCustomService(ConbusProtocol):
         # Set up logging
         self.logger = logging.getLogger(__name__)
 
-    def connection_established(self) -> None:
+        # Connect protocol signals
+        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)
+
+    def connection_made(self) -> None:
         """Handle connection established event."""
         self.logger.debug(
             f"Connection established, sending custom telegram F{self.function_code}D{self.data}."
@@ -65,7 +74,7 @@ class ConbusCustomService(ConbusProtocol):
             self.failed(f"Invalid function code {self.function_code}")
             return
 
-        self.send_telegram(
+        self.conbus_protocol.send_telegram(
             serial_number=self.serial_number,
             telegram_type=TelegramType.SYSTEM,
             system_function=system_function,
@@ -113,8 +122,13 @@ class ConbusCustomService(ConbusProtocol):
         self.service_response.data = self.data
         self.service_response.reply_telegram = reply_telegram
 
-        if self.finish_callback:
-            self.finish_callback(self.service_response)
+        # Emit finish signal
+        self.on_finish.emit(self.service_response)
+
+    def timeout(self) -> None:
+        """Handle timeout event."""
+        self.logger.debug("Timeout occurred")
+        self.failed("Timeout")
 
     def failed(self, message: str) -> None:
         """Handle failed connection event.
@@ -126,15 +140,15 @@ class ConbusCustomService(ConbusProtocol):
         self.service_response.success = False
         self.service_response.timestamp = datetime.now()
         self.service_response.error = message
-        if self.finish_callback:
-            self.finish_callback(self.service_response)
+
+        # Emit finish signal
+        self.on_finish.emit(self.service_response)
 
     def send_custom_telegram(
         self,
         serial_number: str,
         function_code: str,
         data: str,
-        finish_callback: Callable[[ConbusCustomResponse], None],
         timeout_seconds: Optional[float] = None,
     ) -> None:
         """Send a custom telegram to a module.
@@ -143,14 +157,55 @@ class ConbusCustomService(ConbusProtocol):
             serial_number: 10-digit module serial number.
             function_code: Function code (e.g., "02", "17").
             data: Data code (e.g., "E2", "AA").
-            finish_callback: Callback function to call when the reply is received.
             timeout_seconds: Timeout in seconds.
         """
         self.logger.info("Starting send_custom_telegram")
-        if timeout_seconds:
-            self.timeout_seconds = timeout_seconds
-        self.finish_callback = finish_callback
         self.serial_number = serial_number
         self.function_code = function_code
         self.data = data
-        self.start_reactor()
+        if timeout_seconds:
+            self.set_timeout(timeout_seconds)
+
+    def set_timeout(self, timeout_seconds: float) -> None:
+        """Set operation timeout.
+
+        Args:
+            timeout_seconds: Timeout in seconds.
+        """
+        self.conbus_protocol.timeout_seconds = timeout_seconds
+
+    def start_reactor(self) -> None:
+        """Start the reactor."""
+        self.conbus_protocol.start_reactor()
+
+    def stop_reactor(self) -> None:
+        """Stop the reactor."""
+        self.conbus_protocol.stop_reactor()
+
+    def __enter__(self) -> "ConbusCustomService":
+        """Enter context manager - reset state for singleton reuse.
+
+        Returns:
+            Self for context manager protocol.
+        """
+        # Reset state for singleton reuse
+        self.service_response = ConbusCustomResponse(success=False)
+        self.serial_number = ""
+        self.function_code = ""
+        self.data = ""
+        return self
+
+    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.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)
+        # Disconnect service signals
+        self.on_finish.disconnect()
+        # Stop reactor
+        self.stop_reactor()

xp/services/conbus/conbus_datapoint_queryall_service.py

@@ -5,46 +5,58 @@ This module provides service for querying all datapoint types from a module.
 
 import logging
 from datetime import datetime
-from typing import Callable, Optional
+from typing import Any, Optional
 
-from twisted.internet.posixbase import PosixReactorBase
+from psygnal import Signal
 
-from xp.models import ConbusClientConfig, ConbusDatapointResponse
+from xp.models import ConbusDatapointResponse
 from xp.models.protocol.conbus_protocol import TelegramReceivedEvent
 from xp.models.telegram.datapoint_type import DataPointType
 from xp.models.telegram.reply_telegram import ReplyTelegram
 from xp.models.telegram.system_function import SystemFunction
 from xp.models.telegram.telegram_type import TelegramType
 from xp.services import TelegramService
-from xp.services.protocol import ConbusProtocol
+from xp.services.protocol.conbus_event_protocol import ConbusEventProtocol
 
 
-class ConbusDatapointQueryAllService(ConbusProtocol):
-    """
-    Utility service for querying all datapoints from a module.
+class ConbusDatapointQueryAllService:
+    """Utility service for querying all datapoints from a module.
 
     This service orchestrates multiple ConbusDatapointService calls to query
     all available datapoint types sequentially.
+
+    Attributes:
+        conbus_protocol: ConbusEventProtocol for protocol communication.
+        telegram_service: TelegramService for dependency injection.
+        on_progress: Signal emitted for each datapoint response received.
+        on_finish: Signal emitted when all datapoints queried (with response).
     """
 
+    on_progress: Signal = Signal(ReplyTelegram)
+    on_finish: Signal = Signal(ConbusDatapointResponse)
+
     def __init__(
         self,
+        conbus_protocol: ConbusEventProtocol,
         telegram_service: TelegramService,
-        cli_config: ConbusClientConfig,
-        reactor: PosixReactorBase,
     ) -> None:
         """Initialize the query all service.
 
         Args:
+            conbus_protocol: ConbusEventProtocol for protocol communication.
             telegram_service: TelegramService for dependency injection.
-            cli_config: ConbusClientConfig for connection settings.
-            reactor: PosixReactorBase for async operations.
         """
-        super().__init__(cli_config, reactor)
+        self.conbus_protocol = conbus_protocol
         self.telegram_service = telegram_service
+
+        # Connect protocol signals
+        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)
+
         self.serial_number: str = ""
-        self.finish_callback: Optional[Callable[[ConbusDatapointResponse], None]] = None
-        self.progress_callback: Optional[Callable[[ReplyTelegram], None]] = None
         self.service_response: ConbusDatapointResponse = ConbusDatapointResponse(
             success=False,
             serial_number=self.serial_number,
@@ -55,7 +67,7 @@ class ConbusDatapointQueryAllService(ConbusProtocol):
         # Set up logging
         self.logger = logging.getLogger(__name__)
 
-    def connection_established(self) -> None:
+    def connection_made(self) -> None:
         """Handle connection established event."""
         self.logger.debug("Connection established, querying datapoints.")
         self.next_datapoint()
@@ -75,7 +87,7 @@ class ConbusDatapointQueryAllService(ConbusProtocol):
         datapoint_type = DataPointType(datapoint_type_code)
 
         self.logger.debug(f"Datapoint: {datapoint_type}")
-        self.send_telegram(
+        self.conbus_protocol.send_telegram(
             telegram_type=TelegramType.SYSTEM,
             serial_number=self.serial_number,
             system_function=SystemFunction.READ_DATAPOINT,
@@ -84,24 +96,19 @@ class ConbusDatapointQueryAllService(ConbusProtocol):
         self.current_index += 1
         return True
 
-    def timeout(self) -> bool:
-        """Handle timeout event by querying next datapoint.
-
-        Returns:
-            True to continue, False to stop the reactor.
-        """
+    def timeout(self) -> None:
+        """Handle timeout event by querying next datapoint."""
         self.logger.debug("Timeout, querying next datapoint")
         query_next_datapoint = self.next_datapoint()
         if not query_next_datapoint:
-            if self.finish_callback:
-                self.logger.debug("Received all datapoints telegram")
-                self.service_response.success = True
-                self.service_response.timestamp = datetime.now()
-                self.service_response.serial_number = self.serial_number
-                self.service_response.system_function = SystemFunction.READ_DATAPOINT
-                self.finish_callback(self.service_response)
-                return False
-        return True
+            self.logger.debug("Received all datapoints telegram")
+            self.service_response.success = True
+            self.service_response.timestamp = datetime.now()
+            self.service_response.serial_number = self.serial_number
+            self.service_response.system_function = SystemFunction.READ_DATAPOINT
+
+            # Emit finish signal
+            self.on_finish.emit(self.service_response)
 
     def telegram_sent(self, telegram_sent: str) -> None:
         """Handle telegram sent event.
@@ -142,8 +149,7 @@ class ConbusDatapointQueryAllService(ConbusProtocol):
             return
 
         self.logger.debug("Received a datapoint telegram")
-        if self.progress_callback:
-            self.progress_callback(datapoint_telegram)
+        self.on_progress.emit(datapoint_telegram)
 
     def failed(self, message: str) -> None:
         """Handle failed connection event.
@@ -155,28 +161,69 @@ class ConbusDatapointQueryAllService(ConbusProtocol):
         self.service_response.success = False
         self.service_response.timestamp = datetime.now()
         self.service_response.error = message
-        if self.finish_callback:
-            self.finish_callback(self.service_response)
+
+        # Emit finish signal
+        self.on_finish.emit(self.service_response)
 
     def query_all_datapoints(
         self,
         serial_number: str,
-        finish_callback: Callable[[ConbusDatapointResponse], None],
-        progress_callback: Callable[[ReplyTelegram], None],
         timeout_seconds: Optional[float] = None,
     ) -> None:
         """Query all datapoints from a module.
 
         Args:
             serial_number: 10-digit module serial number.
-            finish_callback: Callback function to call when all datapoints are received.
-            progress_callback: Callback function to call when each datapoint is received.
             timeout_seconds: Timeout in seconds.
         """
         self.logger.info("Starting query_all_datapoints")
         if timeout_seconds:
-            self.timeout_seconds = timeout_seconds
-        self.finish_callback = finish_callback
-        self.progress_callback = progress_callback
+            self.conbus_protocol.timeout_seconds = timeout_seconds
         self.serial_number = serial_number
-        self.start_reactor()
+
+    def set_timeout(self, timeout_seconds: float) -> None:
+        """Set operation timeout.
+
+        Args:
+            timeout_seconds: Timeout in seconds.
+        """
+        self.conbus_protocol.timeout_seconds = timeout_seconds
+
+    def start_reactor(self) -> None:
+        """Start the reactor."""
+        self.conbus_protocol.start_reactor()
+
+    def stop_reactor(self) -> None:
+        """Stop the reactor."""
+        self.conbus_protocol.stop_reactor()
+
+    def __enter__(self) -> "ConbusDatapointQueryAllService":
+        """Enter context manager - reset state for singleton reuse.
+
+        Returns:
+            Self for context manager protocol.
+        """
+        # Reset state for singleton reuse
+        self.service_response = ConbusDatapointResponse(
+            success=False,
+            serial_number="",
+        )
+        self.datapoint_types = list(DataPointType)
+        self.current_index = 0
+        self.serial_number = ""
+        return self
+
+    def __exit__(
+        self, _exc_type: Optional[type], _exc_val: Optional[Exception], _exc_tb: Any
+    ) -> None:
+        """Exit context manager - cleanup signals and reactor."""
+        # Disconnect protocol 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)
+        # Disconnect service signals
+        self.on_progress.disconnect()
+        # Stop reactor
+        self.stop_reactor()