conson-xp 1.18.0__py3-none-any.whl

xp/services/conbus/conbus_raw_service.py

@@ -0,0 +1,122 @@
+"""Conbus Raw Service for sending raw telegram sequences.
+
+This service handles sending raw telegram strings without prior validation.
+"""
+
+import logging
+from datetime import datetime
+from typing import Callable, Optional
+
+from twisted.internet.posixbase import PosixReactorBase
+
+from xp.models import ConbusClientConfig
+from xp.models.conbus.conbus_raw import ConbusRawResponse
+from xp.models.protocol.conbus_protocol import TelegramReceivedEvent
+from xp.services.protocol import ConbusProtocol
+
+
+class ConbusRawService(ConbusProtocol):
+    """
+    Service for sending raw telegram sequences to Conbus modules.
+
+    Uses ConbusProtocol to provide raw telegram functionality
+    for sending arbitrary telegram strings without validation.
+    """
+
+    def __init__(
+        self,
+        cli_config: ConbusClientConfig,
+        reactor: PosixReactorBase,
+    ) -> None:
+        """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
+        self.finish_callback: Optional[Callable[[ConbusRawResponse], None]] = None
+        self.service_response: ConbusRawResponse = ConbusRawResponse(
+            success=False,
+        )
+        # Set up logging
+        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 = []
+
+    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 = []
+        self.service_response.received_telegrams.append(telegram_received.frame)
+
+        if self.progress_callback:
+            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()
+        self.service_response.error = message
+        if self.finish_callback:
+            self.finish_callback(self.service_response)
+
+    def send_raw_telegram(
+        self,
+        raw_input: str,
+        progress_callback: Callable[[str], None],
+        finish_callback: Callable[[ConbusRawResponse], None],
+        timeout_seconds: Optional[float] = None,
+    ) -> None:
+        """Send a raw telegram string to the Conbus server.
+
+        Args:
+            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 send_raw_telegram")
+        if timeout_seconds:
+            self.timeout_seconds = timeout_seconds
+        self.progress_callback = progress_callback
+        self.finish_callback = finish_callback
+        self.raw_input = raw_input
+        self.start_reactor()

xp/services/conbus/conbus_receive_service.py

@@ -0,0 +1,115 @@
+"""Conbus Receive Service for receiving telegrams from Conbus servers.
+
+This service uses ConbusProtocol to provide receive-only functionality,
+allowing clients to receive waiting event telegrams using empty telegram sends.
+"""
+
+import logging
+from typing import Callable, Optional
+
+from twisted.internet.posixbase import PosixReactorBase
+
+from xp.models import ConbusClientConfig
+from xp.models.conbus.conbus_receive import ConbusReceiveResponse
+from xp.models.protocol.conbus_protocol import TelegramReceivedEvent
+from xp.services.protocol import ConbusProtocol
+
+
+class ConbusReceiveService(ConbusProtocol):
+    """
+    Service for receiving telegrams from Conbus servers.
+
+    Uses ConbusProtocol to provide receive-only functionality
+    for collecting waiting event telegrams from the server.
+    """
+
+    def __init__(
+        self,
+        cli_config: ConbusClientConfig,
+        reactor: PosixReactorBase,
+    ) -> None:
+        """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
+        self.receive_response: ConbusReceiveResponse = ConbusReceiveResponse(
+            success=True
+        )
+
+        # Set up logging
+        self.logger = logging.getLogger(__name__)
+
+    def connection_established(self) -> None:
+        """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)
+
+        if not self.receive_response.received_telegrams:
+            self.receive_response.received_telegrams = []
+        self.receive_response.received_telegrams.append(telegram_received.frame)
+
+    def timeout(self) -> bool:
+        """Handle timeout event to stop receiving.
+
+        Returns:
+            False to stop the reactor.
+        """
+        self.logger.info("Receive stopped after: %ss", self.timeout_seconds)
+        self.receive_response.success = True
+        if self.finish_callback:
+            self.finish_callback(self.receive_response)
+        return False
+
+    def failed(self, message: str) -> None:
+        """Handle failed connection event.
+
+        Args:
+            message: Failure message.
+        """
+        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)
+
+    def start(
+        self,
+        progress_callback: Callable[[str], None],
+        finish_callback: Callable[[ConbusReceiveResponse], None],
+        timeout_seconds: Optional[float] = None,
+    ) -> None:
+        """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
+        self.finish_callback = finish_callback
+        self.start_reactor()

xp/services/conbus/conbus_scan_service.py

@@ -0,0 +1,150 @@
+"""Conbus Scan Service for TCP communication with Conbus servers.
+
+This service implements a TCP client that scans Conbus servers and sends
+telegrams to scan modules for all datapoints by function code.
+"""
+
+import logging
+from datetime import datetime
+from typing import Callable, Optional
+
+from twisted.internet.posixbase import PosixReactorBase
+
+from xp.models import (
+    ConbusClientConfig,
+    ConbusResponse,
+)
+from xp.models.protocol.conbus_protocol import TelegramReceivedEvent
+from xp.services.protocol import ConbusProtocol
+
+
+class ConbusScanService(ConbusProtocol):
+    """
+    Service for scanning modules for all datapoints by function code.
+
+    Uses ConbusProtocol to provide scan functionality for discovering
+    all available datapoints on a module.
+    """
+
+    def __init__(
+        self,
+        cli_config: ConbusClientConfig,
+        reactor: PosixReactorBase,
+    ) -> None:
+        """Initialize the Conbus scan service.
+
+        Args:
+            cli_config: Conbus client configuration.
+            reactor: Twisted reactor instance.
+        """
+        super().__init__(cli_config, reactor)
+        self.serial_number: str = ""
+        self.function_code: str = ""
+        self.datapoint_value: int = -1
+        self.progress_callback: Optional[Callable[[str], None]] = None
+        self.finish_callback: Optional[Callable[[ConbusResponse], None]] = None
+        self.service_response: ConbusResponse = ConbusResponse(
+            success=False,
+            serial_number=self.serial_number,
+            sent_telegrams=[],
+            received_telegrams=[],
+            timestamp=datetime.now(),
+        )
+        # Set up logging
+        self.logger = logging.getLogger(__name__)
+
+    def connection_established(self) -> None:
+        """Handle connection established event."""
+        self.logger.debug("Connection established, starting scan")
+        self.scan_next_datacode()
+
+    def scan_next_datacode(self) -> bool:
+        """Scan the next data code.
+
+        Returns:
+            True if scanning should continue, False if complete.
+        """
+        self.datapoint_value += 1
+        if self.datapoint_value >= 100:
+            if self.finish_callback:
+                self.finish_callback(self.service_response)
+            return False
+
+        self.logger.debug(f"Scanning next datacode: {self.datapoint_value:02d}")
+        data = f"{self.datapoint_value:02d}"
+        telegram_body = f"S{self.serial_number}F{self.function_code}D{data}"
+        self.sendFrame(telegram_body.encode())
+        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.success = True
+        self.service_response.sent_telegrams.append(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 = []
+        self.service_response.received_telegrams.append(telegram_received.frame)
+
+        if self.progress_callback:
+            self.progress_callback(telegram_received.frame)
+
+    def timeout(self) -> bool:
+        """Handle timeout event by scanning next data code.
+
+        Returns:
+            True to continue scanning, False to stop.
+        """
+        self.logger.debug(f"Timeout: {self.timeout_seconds}s")
+        continue_scan = self.scan_next_datacode()
+        return continue_scan
+
+    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.error = message
+        if self.finish_callback:
+            self.finish_callback(self.service_response)
+
+    def scan_module(
+        self,
+        serial_number: str,
+        function_code: str,
+        progress_callback: Callable[[str], None],
+        finish_callback: Callable[[ConbusResponse], None],
+        timeout_seconds: float = 0.25,
+    ) -> None:
+        """Scan a module for all datapoints by function code.
+
+        Args:
+            serial_number: 10-digit module serial number.
+            function_code: The function code to scan.
+            progress_callback: Callback to handle progress.
+            finish_callback: Callback function to call when the scan is complete.
+            timeout_seconds: Timeout in seconds.
+        """
+        self.logger.info("Starting scan_module")
+        if timeout_seconds:
+            self.timeout_seconds = timeout_seconds
+
+        self.serial_number = serial_number
+        self.function_code = function_code
+        self.progress_callback = progress_callback
+        self.finish_callback = finish_callback
+        self.start_reactor()

xp/services/conbus/write_config_service.py

@@ -0,0 +1,194 @@
+"""Conbus Link Number Service for setting module link numbers.
+
+This service handles setting link numbers for modules through Conbus telegrams.
+"""
+
+import logging
+from datetime import datetime
+from typing import Callable, Optional
+
+from twisted.internet.posixbase import PosixReactorBase
+
+from xp.models import ConbusClientConfig
+from xp.models.conbus.conbus_writeconfig import ConbusWriteConfigResponse
+from xp.models.protocol.conbus_protocol import TelegramReceivedEvent
+from xp.models.telegram.datapoint_type import DataPointType
+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.telegram.telegram_service import TelegramService
+
+
+class WriteConfigService(ConbusProtocol):
+    """
+    Service for writing module settings via Conbus telegrams.
+
+    Handles setting assignment by sending F04DXX telegrams and processing
+    ACK/NAK responses from modules.
+    """
+
+    def __init__(
+        self,
+        telegram_service: TelegramService,
+        cli_config: ConbusClientConfig,
+        reactor: PosixReactorBase,
+    ) -> None:
+        """Initialize the Conbus link number set 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.datapoint_type: Optional[DataPointType] = None
+        self.serial_number: str = ""
+        self.data_value: str = ""
+        self.write_config_finished_callback: Optional[
+            Callable[[ConbusWriteConfigResponse], None]
+        ] = None
+        self.write_config_response: ConbusWriteConfigResponse = (
+            ConbusWriteConfigResponse(
+                success=False,
+                serial_number=self.serial_number,
+            )
+        )
+
+        # Set up logging
+        self.logger = logging.getLogger(__name__)
+
+    def connection_established(self) -> None:
+        """Handle connection established event."""
+        self.logger.debug(f"Connection established, writing config {self.data_value}.")
+
+        # Validate parameters before sending
+        if not self.serial_number or len(self.serial_number) != 10:
+            self.failed(f"Serial number must be 10 digits, got: {self.serial_number}")
+            return
+
+        if len(self.data_value) < 2:
+            self.failed(f"data_value must be at least 2 bytes, got: {self.data_value}")
+            return
+
+        if not self.datapoint_type:
+            self.failed(f"datapoint_type must be defined, got: {self.datapoint_type}")
+            return
+
+        # Send WRITE_CONFIG telegram
+        # Function F04 = WRITE_CONFIG,
+        # Datapoint = D datapoint_type
+        # Data = XX
+        self.send_telegram(
+            telegram_type=TelegramType.SYSTEM,
+            serial_number=self.serial_number,
+            system_function=SystemFunction.WRITE_CONFIG,
+            data_value=f"{self.datapoint_type.value}{self.data_value}",
+        )
+
+    def telegram_sent(self, telegram_sent: str) -> None:
+        """Handle telegram sent event.
+
+        Args:
+            telegram_sent: The telegram that was sent.
+        """
+        self.write_config_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.write_config_response.received_telegrams:
+            self.write_config_response.received_telegrams = []
+        self.write_config_response.received_telegrams.append(telegram_received.frame)
+
+        if (
+            not telegram_received.checksum_valid
+            or telegram_received.telegram_type != TelegramType.REPLY
+            or telegram_received.serial_number != self.serial_number
+        ):
+            self.logger.debug("Not a reply for our serial number")
+            return
+
+        # Parse the reply telegram
+        reply_telegram = self.telegram_service.parse_reply_telegram(
+            telegram_received.frame
+        )
+
+        if not reply_telegram or reply_telegram.system_function not in (
+            SystemFunction.ACK,
+            SystemFunction.NAK,
+        ):
+            self.logger.debug("Not a write config reply")
+            return
+
+        succeed = (
+            True if reply_telegram.system_function == SystemFunction.ACK else False
+        )
+        self.finished(
+            succeed_or_failed=succeed, system_function=reply_telegram.system_function
+        )
+
+    def failed(self, message: str) -> None:
+        """Handle telegram failed event.
+
+        Args:
+            message: The error message.
+        """
+        self.logger.debug("Failed to send telegram")
+        self.finished(succeed_or_failed=False, message=message)
+
+    def finished(
+        self,
+        succeed_or_failed: bool,
+        message: Optional[str] = None,
+        system_function: Optional[SystemFunction] = None,
+    ) -> None:
+        """Handle successful link number set operation.
+
+        Args:
+            succeed_or_failed: succeed true, failed false.
+            message: error message if any.
+            system_function: The system function from the reply telegram.
+        """
+        self.logger.debug("finished writing config")
+        self.write_config_response.success = succeed_or_failed
+        self.write_config_response.error = message
+        self.write_config_response.timestamp = datetime.now()
+        self.write_config_response.serial_number = self.serial_number
+        self.write_config_response.system_function = system_function
+        self.write_config_response.datapoint_type = self.datapoint_type
+        self.write_config_response.data_value = self.data_value
+        if self.write_config_finished_callback:
+            self.write_config_finished_callback(self.write_config_response)
+        self._stop_reactor()
+
+    def write_config(
+        self,
+        serial_number: str,
+        datapoint_type: DataPointType,
+        data_value: str,
+        finish_callback: Callable[[ConbusWriteConfigResponse], None],
+        timeout_seconds: Optional[float] = None,
+    ) -> None:
+        """Write config to a specific module.
+
+        Args:
+            serial_number: 10-digit module serial number.
+            datapoint_type: the datapoint type to write to.
+            data_value: the data to write.
+            finish_callback: Callback function to call when operation completes.
+            timeout_seconds: Optional timeout in seconds.
+        """
+        self.logger.info("Starting write_config")
+        if timeout_seconds:
+            self.timeout_seconds = timeout_seconds
+        self.serial_number = serial_number
+        self.datapoint_type = datapoint_type
+        self.data_value = data_value
+        self.write_config_finished_callback = finish_callback
+        self.start_reactor()

xp/services/homekit/__init__.py

@@ -0,0 +1 @@
+"""HomeKit integration services."""