conson-xp 1.18.0__py3-none-any.whl

xp/services/conbus/actiontable/actiontable_upload_service.py

@@ -0,0 +1,211 @@
+"""Service for uploading ActionTable via Conbus protocol."""
+
+import logging
+from typing import Any, Callable, Optional
+
+from twisted.internet.posixbase import PosixReactorBase
+
+from xp.models import ConbusClientConfig
+from xp.models.homekit.homekit_conson_config import ConsonModuleListConfig
+from xp.models.protocol.conbus_protocol import TelegramReceivedEvent
+from xp.models.telegram.system_function import SystemFunction
+from xp.models.telegram.telegram_type import TelegramType
+from xp.services.actiontable.actiontable_serializer import ActionTableSerializer
+from xp.services.protocol import ConbusProtocol
+from xp.services.telegram.telegram_service import TelegramService
+
+
+class ActionTableUploadService(ConbusProtocol):
+    """TCP client service for uploading action tables to Conbus modules.
+
+    Manages TCP socket connections, handles telegram generation and transmission,
+    and processes server responses for action table uploads.
+    """
+
+    def __init__(
+        self,
+        cli_config: ConbusClientConfig,
+        reactor: PosixReactorBase,
+        actiontable_serializer: ActionTableSerializer,
+        telegram_service: TelegramService,
+        conson_config: ConsonModuleListConfig,
+    ) -> None:
+        """Initialize the action table upload service.
+
+        Args:
+            cli_config: Conbus client configuration.
+            reactor: Twisted reactor instance.
+            actiontable_serializer: Action table serializer.
+            telegram_service: Telegram service for parsing.
+            conson_config: Conson module list configuration.
+        """
+        super().__init__(cli_config, reactor)
+        self.serializer = actiontable_serializer
+        self.telegram_service = telegram_service
+        self.conson_config = conson_config
+        self.serial_number: str = ""
+        self.progress_callback: Optional[Callable[[str], None]] = None
+        self.error_callback: Optional[Callable[[str], None]] = None
+        self.success_callback: Optional[Callable[[], None]] = None
+
+        # Upload state
+        self.upload_data_chunks: list[str] = []
+        self.current_chunk_index: int = 0
+
+        # Set up logging
+        self.logger = logging.getLogger(__name__)
+
+    def connection_established(self) -> None:
+        """Handle connection established event."""
+        self.logger.debug("Connection established, sending upload actiontable telegram")
+        self.send_telegram(
+            telegram_type=TelegramType.SYSTEM,
+            serial_number=self.serial_number,
+            system_function=SystemFunction.UPLOAD_ACTIONTABLE,
+            data_value="00",
+        )
+
+    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}")
+
+    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 telegram_received.checksum_valid
+            or telegram_received.telegram_type != TelegramType.REPLY.value
+            or telegram_received.serial_number != self.serial_number
+        ):
+            self.logger.debug("Not a reply response")
+            return
+
+        reply_telegram = self.telegram_service.parse_reply_telegram(
+            telegram_received.frame
+        )
+
+        self._handle_upload_response(reply_telegram)
+
+    def _handle_upload_response(self, reply_telegram: Any) -> None:
+        """Handle telegram responses during upload.
+
+        Args:
+            reply_telegram: Parsed reply telegram.
+        """
+        if reply_telegram.system_function == SystemFunction.ACK:
+            self.logger.debug("Received ACK for upload")
+            # Send next chunk or EOF
+            if self.current_chunk_index < len(self.upload_data_chunks):
+                chunk = self.upload_data_chunks[self.current_chunk_index]
+                self.logger.debug(f"Sending chunk {self.current_chunk_index + 1}")
+
+                # Calculate prefix: AA, AB, AC, AD, AE, AF, AG, AH, AI, AJ, AK, AL, AM, AN, AO
+                # First character: 'A' (fixed)
+                # Second character: 'A' + chunk_index (sequential counter A-O for 15 chunks)
+                prefix_hex = f"AAA{ord('A') + self.current_chunk_index:c}"
+
+                self.send_telegram(
+                    telegram_type=TelegramType.SYSTEM,
+                    serial_number=self.serial_number,
+                    system_function=SystemFunction.ACTIONTABLE,
+                    data_value=f"{prefix_hex}{chunk}",
+                )
+                self.current_chunk_index += 1
+                if self.progress_callback:
+                    self.progress_callback(".")
+            else:
+                # All chunks sent, send EOF
+                self.logger.debug("All chunks sent, sending EOF")
+                self.send_telegram(
+                    telegram_type=TelegramType.SYSTEM,
+                    serial_number=self.serial_number,
+                    system_function=SystemFunction.EOF,
+                    data_value="00",
+                )
+                if self.success_callback:
+                    self.success_callback()
+                self._stop_reactor()
+        elif reply_telegram.system_function == SystemFunction.NAK:
+            self.logger.debug("Received NAK during upload")
+            self.failed("Upload failed: NAK received")
+        else:
+            self.logger.debug(f"Unexpected response during upload: {reply_telegram}")
+
+    def failed(self, message: str) -> None:
+        """Handle failed connection event.
+
+        Args:
+            message: Failure message.
+        """
+        self.logger.debug(f"Failed: {message}")
+        if self.error_callback:
+            self.error_callback(message)
+        self._stop_reactor()
+
+    def start(
+        self,
+        serial_number: str,
+        progress_callback: Callable[[str], None],
+        error_callback: Callable[[str], None],
+        success_callback: Callable[[], None],
+        timeout_seconds: Optional[float] = None,
+    ) -> None:
+        """Upload action table to module.
+
+        Uploads the action table configuration to the specified module.
+
+        Args:
+            serial_number: Module serial number.
+            progress_callback: Callback for progress updates.
+            error_callback: Callback for errors.
+            success_callback: Callback when upload completes successfully.
+            timeout_seconds: Optional timeout in seconds.
+        """
+        self.logger.info("Starting actiontable upload")
+        self.serial_number = serial_number
+        if timeout_seconds:
+            self.timeout_seconds = timeout_seconds
+        self.progress_callback = progress_callback
+        self.error_callback = error_callback
+        self.success_callback = success_callback
+
+        # Find module
+        module = self.conson_config.find_module(serial_number)
+        if not module:
+            self.failed(f"Module {serial_number} not found in conson.yml")
+            return
+
+        # Parse action table strings to ActionTable object
+        try:
+            module_action_table = module.action_table or []
+            action_table = self.serializer.parse_action_table(module_action_table)
+        except ValueError as e:
+            self.logger.error(f"Invalid action table format: {e}")
+            self.failed(f"Invalid action table format: {e}")
+            return
+
+        # Encode action table to hex string
+        encoded_data = self.serializer.to_encoded_string(action_table)
+
+        # Chunk the data into 64 byte chunks
+        chunk_size = 64
+        self.upload_data_chunks = [
+            encoded_data[i : i + chunk_size]
+            for i in range(0, len(encoded_data), chunk_size)
+        ]
+        self.current_chunk_index = 0
+
+        self.logger.debug(
+            f"Upload data encoded: {len(encoded_data)} chars, "
+            f"{len(self.upload_data_chunks)} chunks"
+        )
+
+        self.start_reactor()

xp/services/conbus/actiontable/msactiontable_service.py

@@ -0,0 +1,232 @@
+"""Service for downloading XP24 action tables via Conbus protocol."""
+
+import logging
+from typing import Callable, Optional, Union
+
+from twisted.internet.posixbase import PosixReactorBase
+
+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
+from xp.models.protocol.conbus_protocol import TelegramReceivedEvent
+from xp.models.telegram.system_function import SystemFunction
+from xp.models.telegram.telegram_type import TelegramType
+from xp.services.actiontable.msactiontable_xp20_serializer import (
+    Xp20MsActionTableSerializer,
+)
+from xp.services.actiontable.msactiontable_xp24_serializer import (
+    Xp24MsActionTableSerializer,
+)
+from xp.services.actiontable.msactiontable_xp33_serializer import (
+    Xp33MsActionTableSerializer,
+)
+from xp.services.protocol import ConbusProtocol
+from xp.services.telegram.telegram_service import TelegramService
+
+
+class MsActionTableError(Exception):
+    """Raised when XP24 action table operations fail."""
+
+    pass
+
+
+class MsActionTableService(ConbusProtocol):
+    """
+    TCP client service for sending telegrams to Conbus servers.
+
+    Manages TCP socket connections, handles telegram generation and transmission,
+    and processes server responses.
+    """
+
+    def __init__(
+        self,
+        cli_config: ConbusClientConfig,
+        reactor: PosixReactorBase,
+        xp20ms_serializer: Xp20MsActionTableSerializer,
+        xp24ms_serializer: Xp24MsActionTableSerializer,
+        xp33ms_serializer: Xp33MsActionTableSerializer,
+        telegram_service: TelegramService,
+    ) -> None:
+        """Initialize the Conbus client send service.
+
+        Args:
+            cli_config: Conbus client configuration.
+            reactor: Twisted reactor 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.xp20ms_serializer = xp20ms_serializer
+        self.xp24ms_serializer = xp24ms_serializer
+        self.xp33ms_serializer = xp33ms_serializer
+        self.serializer: Union[
+            Xp20MsActionTableSerializer,
+            Xp24MsActionTableSerializer,
+            Xp33MsActionTableSerializer,
+        ] = xp20ms_serializer
+        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."""
+        self.logger.debug(
+            "Connection established, sending download msactiontable telegram"
+        )
+        self.send_telegram(
+            telegram_type=TelegramType.SYSTEM,
+            serial_number=self.serial_number,
+            system_function=SystemFunction.DOWNLOAD_MSACTIONTABLE,
+            data_value="00",
+        )
+
+    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}")
+
+    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 telegram_received.checksum_valid
+            or telegram_received.telegram_type != TelegramType.REPLY.value
+            or telegram_received.serial_number != self.serial_number
+        ):
+            self.logger.debug("Not a reply response")
+            return
+
+        reply_telegram = self.telegram_service.parse_reply_telegram(
+            telegram_received.frame
+        )
+        if reply_telegram.system_function not in (
+            SystemFunction.MSACTIONTABLE,
+            SystemFunction.ACK,
+            SystemFunction.NAK,
+            SystemFunction.EOF,
+        ):
+            self.logger.debug("Not a msactiontable response")
+            return
+
+        if reply_telegram.system_function == SystemFunction.ACK:
+            self.logger.debug("Received ACK")
+            return
+
+        if reply_telegram.system_function == SystemFunction.NAK:
+            self.logger.debug("Received NAK")
+            self.failed("Received NAK")
+            return
+
+        if reply_telegram.system_function == SystemFunction.MSACTIONTABLE:
+            self.logger.debug("Received MSACTIONTABLE")
+            self.msactiontable_data.extend(
+                (reply_telegram.data, reply_telegram.data_value)
+            )
+            if self.progress_callback:
+                self.progress_callback(".")
+
+            self.send_telegram(
+                telegram_type=TelegramType.SYSTEM,
+                serial_number=self.serial_number,
+                system_function=SystemFunction.ACK,
+                data_value="00",
+            )
+            return
+
+        if reply_telegram.system_function == SystemFunction.EOF:
+            self.logger.debug("Received EOF")
+            all_data = "".join(self.msactiontable_data)
+            # Deserialize from received data
+            msactiontable = self.serializer.from_data(all_data)
+            self.succeed(msactiontable)
+            return
+
+        self.logger.debug("Invalid msactiontable response")
+
+    def failed(self, message: str) -> None:
+        """Handle failed connection event.
+
+        Args:
+            message: Failure message.
+        """
+        self.logger.debug(f"Failed: {message}")
+        if self.error_callback:
+            self.error_callback(message)
+        self._stop_reactor()
+
+    def succeed(
+        self,
+        msactiontable: Union[Xp20MsActionTable, Xp24MsActionTable, Xp33MsActionTable],
+    ) -> None:
+        """Handle succeed connection event.
+
+        Args:
+            msactiontable: result.
+        """
+        if self.finish_callback:
+            self.finish_callback(msactiontable)
+        self._stop_reactor()
+
+    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.
+
+        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:
+            MsActionTableError: If unsupported module type is provided.
+        """
+        self.logger.info("Starting msactiontable")
+        self.serial_number = serial_number
+        self.xpmoduletype = xpmoduletype
+        if xpmoduletype == "xp20":
+            self.serializer = self.xp20ms_serializer
+        elif xpmoduletype == "xp24":
+            self.serializer = self.xp24ms_serializer
+        elif xpmoduletype == "xp33":
+            self.serializer = self.xp33ms_serializer
+        else:
+            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()

xp/services/conbus/conbus_blink_all_service.py

@@ -0,0 +1,181 @@
+"""Conbus Blink All Service for TCP communication with Conbus servers.
+
+This service implements a TCP client that connects to Conbus servers and sends
+blink/unblink telegrams to all discovered modules on the network.
+"""
+
+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_blink import ConbusBlinkResponse
+from xp.models.protocol.conbus_protocol import TelegramReceivedEvent
+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 ConbusBlinkAllService(ConbusProtocol):
+    """
+    Service for blinking all modules on Conbus servers.
+
+    Uses ConbusProtocol to provide blink/unblink functionality
+    for all discovered modules on the network.
+    """
+
+    def __init__(
+        self,
+        telegram_service: TelegramService,
+        cli_config: ConbusClientConfig,
+        reactor: PosixReactorBase,
+    ) -> None:
+        """Initialize the Conbus blink all 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.on_or_off = "none"
+        self.progress_callback: Optional[Callable[[str], None]] = None
+        self.finish_callback: Optional[Callable[[ConbusBlinkResponse], None]] = None
+        self.service_response: ConbusBlinkResponse = ConbusBlinkResponse(
+            success=False,
+            serial_number=self.serial_number,
+            system_function=SystemFunction.NONE,
+            operation=self.on_or_off,
+        )
+
+        # Set up logging
+        self.logger = logging.getLogger(__name__)
+
+    def connection_established(self) -> None:
+        """Handle connection established event."""
+        self.logger.debug("Connection established, send discover telegram.")
+        self.send_telegram(
+            telegram_type=TelegramType.SYSTEM,
+            serial_number="0000000000",
+            system_function=SystemFunction.DISCOVERY,
+            data_value="00",
+        )
+        if self.progress_callback:
+            self.progress_callback(".")
+
+    def send_blink(self, serial_number: str) -> None:
+        """Send blink or unblink telegram to a discovered module.
+
+        Args:
+            serial_number: 10-digit module serial number.
+        """
+        self.logger.debug("Device discovered, send blink.")
+
+        # Blink is 05, Unblink is 06
+        system_function = SystemFunction.UNBLINK
+        if self.on_or_off.lower() == "on":
+            system_function = SystemFunction.BLINK
+
+        self.send_telegram(
+            telegram_type=TelegramType.SYSTEM,
+            serial_number=serial_number,
+            system_function=system_function,
+            data_value="00",
+        )
+        self.service_response.system_function = system_function
+        self.service_response.operation = self.on_or_off
+
+        if self.progress_callback:
+            self.progress_callback(".")
+
+    def telegram_sent(self, telegram_sent: str) -> None:
+        """Handle telegram sent event.
+
+        Args:
+            telegram_sent: The telegram that was sent.
+        """
+        system_telegram = self.telegram_service.parse_system_telegram(telegram_sent)
+        self.service_response.sent_telegram = system_telegram
+
+    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 (
+            not telegram_received.checksum_valid
+            or telegram_received.telegram_type != TelegramType.REPLY
+        ):
+            self.logger.debug("Not a reply")
+            return
+
+        reply_telegram = self.telegram_service.parse_reply_telegram(
+            telegram_received.frame
+        )
+        if (
+            reply_telegram
+            and reply_telegram.system_function == SystemFunction.DISCOVERY
+        ):
+            self.logger.debug("Received discovery response")
+            self.send_blink(reply_telegram.serial_number)
+            if self.progress_callback:
+                self.progress_callback(".")
+            return
+
+        if reply_telegram and reply_telegram.system_function in (
+            SystemFunction.BLINK,
+            SystemFunction.UNBLINK,
+        ):
+            self.logger.debug("Received blink response")
+            if self.progress_callback:
+                self.progress_callback(".")
+            return
+
+        self.logger.debug("Received unexpected 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.error = message
+        if self.finish_callback:
+            self.finish_callback(self.service_response)
+
+    def send_blink_all_telegram(
+        self,
+        on_or_off: str,
+        progress_callback: Callable[[str], None],
+        finish_callback: Callable[[ConbusBlinkResponse], None],
+        timeout_seconds: Optional[float] = None,
+    ) -> None:
+        """Send blink command to all discovered modules.
+
+        Args:
+            on_or_off: "on" to blink or "off" to unblink all devices.
+            progress_callback: Callback function to call with progress updates.
+            finish_callback: Callback function to call when the operation completes.
+            timeout_seconds: Timeout in seconds.
+        """
+        self.logger.info("Starting send_blink_all_telegram")
+        if timeout_seconds:
+            self.timeout_seconds = timeout_seconds
+        self.progress_callback = progress_callback
+        self.finish_callback = finish_callback
+        self.on_or_off = on_or_off
+        self.start_reactor()