conson-xp 1.1.0__py3-none-any.whl → 1.3.0__py3-none-any.whl

xp/services/conbus/conbus_datapoint_queryall_service.py

@@ -1,3 +1,8 @@
+"""Conbus DataPoint Query All Service.
+
+This module provides service for querying all datapoint types from a module.
+"""
+
 import logging
 from datetime import datetime
 from typing import Callable, Optional
@@ -28,12 +33,12 @@ class ConbusDatapointQueryAllService(ConbusProtocol):
         cli_config: ConbusClientConfig,
         reactor: PosixReactorBase,
     ) -> None:
-        """Initialize the query all service
+        """Initialize the query all service.
 
         Args:
-            telegram_service: TelegramService for dependency injection
-            cli_config: ConbusClientConfig for connection settings
-            reactor: PosixReactorBase for async operations
+            telegram_service: TelegramService for dependency injection.
+            cli_config: ConbusClientConfig for connection settings.
+            reactor: PosixReactorBase for async operations.
         """
         super().__init__(cli_config, reactor)
         self.telegram_service = telegram_service
@@ -51,11 +56,16 @@ class ConbusDatapointQueryAllService(ConbusProtocol):
         self.logger = logging.getLogger(__name__)
 
     def connection_established(self) -> None:
-        self.logger.debug("Connection established, querying datapoints...")
+        """Handle connection established event."""
+        self.logger.debug("Connection established, querying datapoints.")
         self.next_datapoint()
 
     def next_datapoint(self) -> bool:
+        """Query the next datapoint type.
 
+        Returns:
+            True if there are more datapoints to query, False otherwise.
+        """
         self.logger.debug("Querying next datapoint")
 
         if self.current_index >= len(self.datapoint_types):
@@ -75,6 +85,11 @@ class ConbusDatapointQueryAllService(ConbusProtocol):
         return True
 
     def timeout(self) -> bool:
+        """Handle timeout event by querying next datapoint.
+
+        Returns:
+            True to continue, False to stop the reactor.
+        """
         self.logger.debug("Timeout, querying next datapoint")
         query_next_datapoint = self.next_datapoint()
         if not query_next_datapoint:
@@ -89,10 +104,19 @@ class ConbusDatapointQueryAllService(ConbusProtocol):
         return True
 
     def telegram_sent(self, telegram_sent: str) -> None:
+        """Handle telegram sent event.
+
+        Args:
+            telegram_sent: The telegram that was sent.
+        """
         self.service_response.sent_telegram = telegram_sent
 
     def telegram_received(self, telegram_received: TelegramReceivedEvent) -> None:
+        """Handle telegram received event.
 
+        Args:
+            telegram_received: The telegram received event.
+        """
         self.logger.debug(f"Telegram received: {telegram_received}")
         if not self.service_response.received_telegrams:
             self.service_response.received_telegrams = []
@@ -122,6 +146,11 @@ class ConbusDatapointQueryAllService(ConbusProtocol):
             self.progress_callback(datapoint_telegram)
 
     def failed(self, message: str) -> None:
+        """Handle failed connection event.
+
+        Args:
+            message: Failure message.
+        """
         self.logger.debug(f"Failed with message: {message}")
         self.service_response.success = False
         self.service_response.timestamp = datetime.now()
@@ -136,20 +165,15 @@ class ConbusDatapointQueryAllService(ConbusProtocol):
         progress_callback: Callable[[ReplyTelegram], None],
         timeout_seconds: Optional[float] = None,
     ) -> None:
-        """
-        Query a specific datapoint from a module.
+        """Query all datapoints from a module.
 
         Args:
-            serial_number: 10-digit module serial number
-            finish_callback: callback function to call when all the datapoint are received
-            progress_callback: callback function to call when a datapoint is received
-            timeout_seconds: timeout in seconds
-
-        Returns:
-            ConbusDatapointResponse with operation result and datapoint value
+            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_datapoint")
+        self.logger.info("Starting query_all_datapoints")
         if timeout_seconds:
             self.timeout_seconds = timeout_seconds
         self.finish_callback = finish_callback

xp/services/conbus/conbus_datapoint_service.py

@@ -33,12 +33,20 @@ class ConbusDatapointService(ConbusProtocol):
         cli_config: ConbusClientConfig,
         reactor: PosixReactorBase,
     ) -> None:
-        """Initialize the Conbus datapoint service"""
+        """Initialize the Conbus datapoint service.
+
+        Args:
+            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.telegram_service = telegram_service
         self.serial_number: str = ""
         self.datapoint_type: Optional[DataPointType] = None
-        self.finish_callback: Optional[Callable[[ConbusDatapointResponse], None]] = None
+        self.datapoint_finished_callback: Optional[
+            Callable[[ConbusDatapointResponse], None]
+        ] = None
         self.service_response: ConbusDatapointResponse = ConbusDatapointResponse(
             success=False,
             serial_number=self.serial_number,
@@ -48,8 +56,9 @@ class ConbusDatapointService(ConbusProtocol):
         self.logger = logging.getLogger(__name__)
 
     def connection_established(self) -> None:
+        """Handle connection established event."""
         self.logger.debug(
-            f"Connection established, querying datapoint {self.datapoint_type}..."
+            f"Connection established, querying datapoint {self.datapoint_type}."
         )
         if self.datapoint_type is None:
             self.failed("Datapoint type not set")
@@ -63,10 +72,19 @@ class ConbusDatapointService(ConbusProtocol):
         )
 
     def telegram_sent(self, telegram_sent: str) -> None:
+        """Handle telegram sent event.
+
+        Args:
+            telegram_sent: The telegram that was sent.
+        """
         self.service_response.sent_telegram = telegram_sent
 
     def telegram_received(self, telegram_received: TelegramReceivedEvent) -> None:
+        """Handle telegram received event.
 
+        Args:
+            telegram_received: The telegram received event.
+        """
         self.logger.debug(f"Telegram received: {telegram_received}")
         if not self.service_response.received_telegrams:
             self.service_response.received_telegrams = []
@@ -97,6 +115,11 @@ class ConbusDatapointService(ConbusProtocol):
         self.succeed(datapoint_telegram)
 
     def succeed(self, datapoint_telegram: ReplyTelegram) -> None:
+        """Handle successful datapoint query.
+
+        Args:
+            datapoint_telegram: The parsed datapoint telegram.
+        """
         self.logger.debug("Succeed querying datapoint")
         self.service_response.success = True
         self.service_response.timestamp = datetime.now()
@@ -104,17 +127,23 @@ class ConbusDatapointService(ConbusProtocol):
         self.service_response.system_function = SystemFunction.READ_DATAPOINT
         self.service_response.datapoint_type = self.datapoint_type
         self.service_response.datapoint_telegram = datapoint_telegram
-        if self.finish_callback:
-            self.finish_callback(self.service_response)
+        self.service_response.data_value = datapoint_telegram.data_value
+        if self.datapoint_finished_callback:
+            self.datapoint_finished_callback(self.service_response)
 
     def failed(self, message: str) -> None:
+        """Handle failed connection event.
+
+        Args:
+            message: Failure message.
+        """
         self.logger.debug(f"Failed with message: {message}")
         self.service_response.success = False
         self.service_response.timestamp = datetime.now()
         self.service_response.serial_number = self.serial_number
         self.service_response.error = message
-        if self.finish_callback:
-            self.finish_callback(self.service_response)
+        if self.datapoint_finished_callback:
+            self.datapoint_finished_callback(self.service_response)
 
     def query_datapoint(
         self,
@@ -123,23 +152,18 @@ class ConbusDatapointService(ConbusProtocol):
         finish_callback: Callable[[ConbusDatapointResponse], None],
         timeout_seconds: Optional[float] = None,
     ) -> None:
-        """
-        Query a specific datapoint from a module.
+        """Query a specific datapoint from a module.
 
         Args:
-            serial_number: 10-digit module serial number
-            datapoint_type: Type of datapoint to query
-            finish_callback: callback function to call when the datapoint is received
-            timeout_seconds: timeout in seconds
-
-        Returns:
-            ConbusDatapointResponse with operation result and datapoint value
+            serial_number: 10-digit module serial number.
+            datapoint_type: Type of datapoint to query.
+            finish_callback: Callback function to call when the datapoint is received.
+            timeout_seconds: Timeout in seconds.
         """
-
         self.logger.info("Starting query_datapoint")
         if timeout_seconds:
             self.timeout_seconds = timeout_seconds
-        self.finish_callback = finish_callback
+        self.datapoint_finished_callback = finish_callback
         self.serial_number = serial_number
         self.datapoint_type = datapoint_type
         self.start_reactor()

xp/services/conbus/conbus_discover_service.py

@@ -1,7 +1,7 @@
-"""Conbus Client Send Service for TCP communication with Conbus servers.
+"""Conbus Discover Service for TCP communication with Conbus servers.
 
 This service implements a TCP client that connects to Conbus servers and sends
-various types of telegrams including discover, version, and sensor data requests.
+discover telegrams to find modules on the network.
 """
 
 import logging
@@ -18,10 +18,10 @@ from xp.services.protocol.conbus_protocol import ConbusProtocol
 
 class ConbusDiscoverService(ConbusProtocol):
     """
-    TCP client service for sending telegrams to Conbus servers.
+    Service for discovering modules on Conbus servers.
 
-    Manages TCP socket connections, handles telegram generation and transmission,
-    and processes server responses.
+    Uses ConbusProtocol to provide discovery functionality for finding
+    modules connected to the Conbus network.
     """
 
     def __init__(
@@ -29,7 +29,12 @@ class ConbusDiscoverService(ConbusProtocol):
         cli_config: ConbusClientConfig,
         reactor: PosixReactorBase,
     ) -> None:
-        """Initialize the Conbus client send service"""
+        """Initialize the Conbus discover service.
+
+        Args:
+            cli_config: Conbus client configuration.
+            reactor: Twisted reactor instance.
+        """
         super().__init__(cli_config, reactor)
         self.progress_callback: Optional[Callable[[str], None]] = None
         self.finish_callback: Optional[Callable[[ConbusDiscoverResponse], None]] = None
@@ -39,6 +44,7 @@ class ConbusDiscoverService(ConbusProtocol):
         self.logger = logging.getLogger(__name__)
 
     def connection_established(self) -> None:
+        """Handle connection established event."""
         self.logger.debug("Connection established, sending discover telegram")
         self.send_telegram(
             telegram_type=TelegramType.SYSTEM,
@@ -48,11 +54,20 @@ class ConbusDiscoverService(ConbusProtocol):
         )
 
     def telegram_sent(self, telegram_sent: str) -> None:
+        """Handle telegram sent event.
+
+        Args:
+            telegram_sent: The telegram that was sent.
+        """
         self.logger.debug(f"Telegram sent: {telegram_sent}")
         self.discovered_device_result.sent_telegram = telegram_sent
 
     def telegram_received(self, telegram_received: TelegramReceivedEvent) -> None:
+        """Handle telegram received event.
 
+        Args:
+            telegram_received: The telegram received event.
+        """
         self.logger.debug(f"Telegram received: {telegram_received}")
         if not self.discovered_device_result.received_telegrams:
             self.discovered_device_result.received_telegrams = []
@@ -69,6 +84,11 @@ class ConbusDiscoverService(ConbusProtocol):
             self.logger.debug("Not a discover response")
 
     def discovered_device(self, serial_number: str) -> None:
+        """Handle discovered device event.
+
+        Args:
+            serial_number: Serial number of the discovered device.
+        """
         self.logger.info("discovered_device: %s", serial_number)
         if not self.discovered_device_result.discovered_devices:
             self.discovered_device_result.discovered_devices = []
@@ -77,6 +97,11 @@ class ConbusDiscoverService(ConbusProtocol):
             self.progress_callback(serial_number)
 
     def timeout(self) -> bool:
+        """Handle timeout event to stop discovery.
+
+        Returns:
+            False to stop the reactor.
+        """
         self.logger.info("Discovery stopped after: %ss", self.timeout_seconds)
         self.discovered_device_result.success = True
         if self.finish_callback:
@@ -84,6 +109,11 @@ class ConbusDiscoverService(ConbusProtocol):
         return False
 
     def failed(self, message: str) -> None:
+        """Handle failed connection event.
+
+        Args:
+            message: Failure message.
+        """
         self.logger.debug(f"Failed: {message}")
         self.discovered_device_result.success = False
         self.discovered_device_result.error = message
@@ -96,7 +126,13 @@ class ConbusDiscoverService(ConbusProtocol):
         finish_callback: Callable[[ConbusDiscoverResponse], None],
         timeout_seconds: Optional[float] = None,
     ) -> None:
-        """Run reactor in dedicated thread with its own event loop"""
+        """Run reactor in dedicated thread with its own event loop.
+
+        Args:
+            progress_callback: Callback for each discovered device.
+            finish_callback: Callback when discovery completes.
+            timeout_seconds: Optional timeout in seconds.
+        """
         self.logger.info("Starting discovery")
         if timeout_seconds:
             self.timeout_seconds = timeout_seconds

xp/services/conbus/conbus_output_service.py

@@ -25,7 +25,7 @@ from xp.services.telegram.telegram_output_service import (
 
 
 class ConbusOutputError(Exception):
-    """Raised when Conbus output operations fail"""
+    """Raised when Conbus output operations fail."""
 
     pass
 
@@ -44,12 +44,12 @@ class ConbusOutputService(ConbusProtocol):
         cli_config: ConbusClientConfig,
         reactor: PosixReactorBase,
     ):
-        """Initialize the Conbus output service
+        """Initialize the Conbus output service.
 
         Args:
-            telegram_output_service: TelegramOutputService for telegram generation/parsing
-            cli_config: Conbus client configuration
-            reactor: Twisted reactor for async operations
+            telegram_output_service: TelegramOutputService for telegram generation/parsing.
+            cli_config: Conbus client configuration.
+            reactor: Twisted reactor for async operations.
         """
         super().__init__(cli_config, reactor)
         self.telegram_output_service = telegram_output_service
@@ -69,8 +69,9 @@ class ConbusOutputService(ConbusProtocol):
         self.logger = logging.getLogger(__name__)
 
     def connection_established(self) -> None:
+        """Handle connection established event."""
         self.logger.debug(
-            f"Connection established, sending action {self.action_type} to output {self.output_number}..."
+            f"Connection established, sending action {self.action_type} to output {self.output_number}."
         )
 
         # Validate parameters before sending
@@ -91,9 +92,19 @@ class ConbusOutputService(ConbusProtocol):
         )
 
     def telegram_sent(self, telegram_sent: str) -> None:
+        """Handle telegram sent event.
+
+        Args:
+            telegram_sent: The telegram that was sent.
+        """
         self.service_response.sent_telegram = telegram_sent
 
     def telegram_received(self, telegram_received: TelegramReceivedEvent) -> None:
+        """Handle telegram received event.
+
+        Args:
+            telegram_received: The telegram received event.
+        """
         self.logger.debug(f"Telegram received: {telegram_received}")
 
         if not self.service_response.received_telegrams:
@@ -125,6 +136,11 @@ class ConbusOutputService(ConbusProtocol):
             )
 
     def succeed(self, output_telegram: OutputTelegram) -> None:
+        """Handle successful output action.
+
+        Args:
+            output_telegram: The output telegram received as response.
+        """
         self.logger.debug("Successfully sent action to output")
         self.service_response.success = True
         self.service_response.timestamp = datetime.now()
@@ -136,6 +152,11 @@ class ConbusOutputService(ConbusProtocol):
             self.finish_callback(self.service_response)
 
     def failed(self, message: str) -> None:
+        """Handle failed connection event.
+
+        Args:
+            message: Failure message.
+        """
         self.logger.debug(f"Failed with message: {message}")
         self.service_response.success = False
         self.service_response.timestamp = datetime.now()
@@ -154,15 +175,14 @@ class ConbusOutputService(ConbusProtocol):
         finish_callback: Callable[[ConbusOutputResponse], None],
         timeout_seconds: Optional[float] = None,
     ) -> None:
-        """
-        Send an action telegram to a module output.
+        """Send an action telegram to a module output.
 
         Args:
-            serial_number: 10-digit module serial number
-            output_number: Output number (0-99)
-            action_type: Action to perform (ON_RELEASE, OFF_PRESS, etc.)
-            finish_callback: Callback function to call when operation completes
-            timeout_seconds: Optional timeout in seconds
+            serial_number: 10-digit module serial number.
+            output_number: Output number (0-99).
+            action_type: Action to perform (ON_RELEASE, OFF_PRESS, etc.).
+            finish_callback: Callback function to call when operation completes.
+            timeout_seconds: Optional timeout in seconds.
         """
         self.logger.info("Starting send_action")
         if timeout_seconds:

xp/services/conbus/conbus_raw_service.py

@@ -17,10 +17,10 @@ from xp.services.protocol import ConbusProtocol
 
 class ConbusRawService(ConbusProtocol):
     """
-    Service for querying datapoints from Conbus modules.
+    Service for sending raw telegram sequences to Conbus modules.
 
-    Uses ConbusProtocol to provide datapoint query functionality
-    for reading sensor data and module information.
+    Uses ConbusProtocol to provide raw telegram functionality
+    for sending arbitrary telegram strings without validation.
     """
 
     def __init__(
@@ -28,7 +28,12 @@ class ConbusRawService(ConbusProtocol):
         cli_config: ConbusClientConfig,
         reactor: PosixReactorBase,
     ) -> None:
-        """Initialize the Conbus datapoint service"""
+        """Initialize the Conbus raw service.
+
+        Args:
+            cli_config: Configuration for Conbus client connection.
+            reactor: Twisted reactor for event loop.
+        """
         super().__init__(cli_config, reactor)
         self.raw_input: str = ""
         self.progress_callback: Optional[Callable[[str], None]] = None
@@ -40,17 +45,27 @@ class ConbusRawService(ConbusProtocol):
         self.logger = logging.getLogger(__name__)
 
     def connection_established(self) -> None:
+        """Handle connection established event."""
         self.logger.debug(f"Connection established, sending {self.raw_input}")
         self.sendFrame(self.raw_input.encode())
 
     def telegram_sent(self, telegram_sent: str) -> None:
+        """Handle telegram sent event.
+
+        Args:
+            telegram_sent: The telegram that was sent.
+        """
         self.service_response.success = True
         self.service_response.sent_telegrams = telegram_sent
         self.service_response.timestamp = datetime.now()
         self.service_response.received_telegrams = []
-        pass
 
     def telegram_received(self, telegram_received: TelegramReceivedEvent) -> None:
+        """Handle telegram received event.
+
+        Args:
+            telegram_received: The telegram received event.
+        """
         self.logger.debug(f"Telegram received: {telegram_received}")
         if not self.service_response.received_telegrams:
             self.service_response.received_telegrams = []
@@ -60,12 +75,22 @@ class ConbusRawService(ConbusProtocol):
             self.progress_callback(telegram_received.frame)
 
     def timeout(self) -> bool:
+        """Handle timeout event.
+
+        Returns:
+            False to indicate connection should be closed.
+        """
         self.logger.debug(f"Timeout: {self.timeout_seconds}s")
         if self.finish_callback:
             self.finish_callback(self.service_response)
         return False
 
     def failed(self, message: str) -> None:
+        """Handle failed connection event.
+
+        Args:
+            message: Failure message.
+        """
         self.logger.debug(f"Failed with message: {message}")
         self.service_response.success = False
         self.service_response.timestamp = datetime.now()
@@ -80,20 +105,15 @@ class ConbusRawService(ConbusProtocol):
         finish_callback: Callable[[ConbusRawResponse], None],
         timeout_seconds: Optional[float] = None,
     ) -> None:
-        """
-        Query a specific datapoint from a module.
+        """Send a raw telegram string to the Conbus server.
 
         Args:
-            serial_number: 10-digit module serial number
-            datapoint_type: Type of datapoint to query
-            finish_callback: callback function to call when the datapoint is received
-            timeout_seconds: timeout in seconds
-
-        Returns:
-            ConbusDatapointResponse with operation result and datapoint value
+            raw_input: Raw telegram string to send.
+            progress_callback: Callback to handle progress updates.
+            finish_callback: Callback function to call when the operation is complete.
+            timeout_seconds: Timeout in seconds.
         """
-
-        self.logger.info("Starting query_datapoint")
+        self.logger.info("Starting send_raw_telegram")
         if timeout_seconds:
             self.timeout_seconds = timeout_seconds
         self.progress_callback = progress_callback

xp/services/conbus/conbus_receive_service.py

@@ -1,6 +1,6 @@
 """Conbus Receive Service for receiving telegrams from Conbus servers.
 
-This service uses composition with ConbusService to provide receive-only functionality,
+This service uses ConbusProtocol to provide receive-only functionality,
 allowing clients to receive waiting event telegrams using empty telegram sends.
 """
 
@@ -19,7 +19,7 @@ class ConbusReceiveService(ConbusProtocol):
     """
     Service for receiving telegrams from Conbus servers.
 
-    Uses composition with ConbusService to provide receive-only functionality
+    Uses ConbusProtocol to provide receive-only functionality
     for collecting waiting event telegrams from the server.
     """
 
@@ -28,7 +28,12 @@ class ConbusReceiveService(ConbusProtocol):
         cli_config: ConbusClientConfig,
         reactor: PosixReactorBase,
     ) -> None:
-        """Initialize the Conbus client send service"""
+        """Initialize the Conbus receive service.
+
+        Args:
+            cli_config: Conbus client configuration.
+            reactor: Twisted reactor instance.
+        """
         super().__init__(cli_config, reactor)
         self.progress_callback: Optional[Callable[[str], None]] = None
         self.finish_callback: Optional[Callable[[ConbusReceiveResponse], None]] = None
@@ -40,12 +45,23 @@ class ConbusReceiveService(ConbusProtocol):
         self.logger = logging.getLogger(__name__)
 
     def connection_established(self) -> None:
-        self.logger.debug("Connection established, waiting for telegrams...")
+        """Handle connection established event."""
+        self.logger.debug("Connection established, waiting for telegrams.")
 
     def telegram_sent(self, telegram_sent: str) -> None:
+        """Handle telegram sent event.
+
+        Args:
+            telegram_sent: The telegram that was sent.
+        """
         pass
 
     def telegram_received(self, telegram_received: TelegramReceivedEvent) -> None:
+        """Handle telegram received event.
+
+        Args:
+            telegram_received: The telegram received event.
+        """
         self.logger.debug(f"Telegram received: {telegram_received}")
         if self.progress_callback:
             self.progress_callback(telegram_received.frame)
@@ -55,6 +71,11 @@ class ConbusReceiveService(ConbusProtocol):
         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)
         self.receive_response.success = True
         if self.finish_callback:
@@ -62,6 +83,11 @@ class ConbusReceiveService(ConbusProtocol):
         return False
 
     def failed(self, message: str) -> None:
+        """Handle failed connection event.
+
+        Args:
+            message: Failure message.
+        """
         self.logger.debug("Failed %s:", message)
         self.receive_response.success = False
         self.receive_response.error = message
@@ -74,8 +100,14 @@ class ConbusReceiveService(ConbusProtocol):
         finish_callback: Callable[[ConbusReceiveResponse], None],
         timeout_seconds: Optional[float] = None,
     ) -> None:
-        """Run reactor in dedicated thread with its own event loop"""
-        self.logger.info("Starting discovery")
+        """Run reactor in dedicated thread with its own event loop.
+
+        Args:
+            progress_callback: Callback for each received telegram.
+            finish_callback: Callback when receiving completes.
+            timeout_seconds: Optional timeout in seconds.
+        """
+        self.logger.info("Starting receive")
         if timeout_seconds:
             self.timeout_seconds = timeout_seconds
         self.progress_callback = progress_callback