conson-xp 0.11.21__py3-none-any.whl → 1.0.1__py3-none-any.whl

xp/services/conbus/conbus_lightlevel_get_service.py

@@ -9,18 +9,14 @@ from typing import Callable, Optional
 
 from twisted.internet.posixbase import PosixReactorBase
 
-from xp.models import ConbusClientConfig
+from xp.models import ConbusClientConfig, ConbusDatapointResponse
 from xp.models.conbus.conbus_lightlevel import ConbusLightlevelResponse
-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.protocol import ConbusProtocol
+from xp.services.conbus.conbus_datapoint_service import ConbusDatapointService
 from xp.services.telegram.telegram_service import TelegramService
 
 
-class ConbusLightlevelGetService(ConbusProtocol):
+class ConbusLightlevelGetService(ConbusDatapointService):
     """
     Service for receiving telegrams from Conbus servers.
 
@@ -35,93 +31,46 @@ class ConbusLightlevelGetService(ConbusProtocol):
         reactor: PosixReactorBase,
     ) -> None:
         """Initialize the Conbus client send service"""
-        super().__init__(cli_config, reactor)
-        self.telegram_service = telegram_service
-        self.serial_number: str = ""
+        super().__init__(telegram_service, cli_config, reactor)
         self.output_number: int = 0
-        self.finish_callback: Optional[Callable[[ConbusLightlevelResponse], None]] = (
+        self.service_callback: Optional[Callable[[ConbusLightlevelResponse], None]] = (
             None
         )
-        self.service_response: ConbusLightlevelResponse = ConbusLightlevelResponse(
-            success=False,
-            serial_number=self.serial_number,
-            output_number=self.output_number,
-            level=0,
-            timestamp=datetime.now(),
-        )
 
         # Set up logging
         self.logger = logging.getLogger(__name__)
 
-    def connection_established(self) -> None:
-        self.logger.debug("Connection established, retrieving lightlevel status...")
-        self.send_telegram(
-            telegram_type=TelegramType.SYSTEM,
-            serial_number=self.serial_number,
-            system_function=SystemFunction.READ_DATAPOINT,
-            data_value=str(DataPointType.MODULE_LIGHT_LEVEL.value),
-        )
-
-    def telegram_sent(self, telegram_sent: str) -> None:
-        self.service_response.sent_telegram = telegram_sent
-
-    def telegram_received(self, telegram_received: TelegramReceivedEvent) -> None:
-
-        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)
+    def finish_service_callback(
+        self, datapoint_response: ConbusDatapointResponse
+    ) -> None:
 
-        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")
-            return
+        self.logger.debug("Parsing datapoint response")
 
-        reply_telegram = self.telegram_service.parse_reply_telegram(
-            telegram_received.frame
+        level = 0
+        if datapoint_response.success and datapoint_response.datapoint_telegram:
+            for output_data in datapoint_response.datapoint_telegram.data_value.split(
+                ","
+            ):
+                if ":" in output_data:
+                    output_str, level_str = output_data.split(":")
+                    if int(output_str) == self.output_number:
+                        level_str = level_str.replace("[%]", "")
+                        level = int(level_str)
+                        break
+
+        service_response = ConbusLightlevelResponse(
+            success=datapoint_response.success,
+            serial_number=self.serial_number,
+            output_number=self.output_number,
+            level=level,
+            error=datapoint_response.error,
+            sent_telegram=datapoint_response.sent_telegram,
+            received_telegrams=datapoint_response.received_telegrams,
+            timestamp=datetime.now(),
         )
 
-        if (
-            not reply_telegram
-            or reply_telegram.system_function != SystemFunction.READ_DATAPOINT
-            or reply_telegram.datapoint_type != DataPointType.MODULE_LIGHT_LEVEL
-        ):
-            self.logger.debug("Not a lightlevel telegram")
-            return
-
-        self.logger.debug("Received lightlevel status telegram")
-        lightlevel = self.extract_lightlevel(reply_telegram)
-        self.succeed(lightlevel)
-
-    def extract_lightlevel(self, reply_telegram: ReplyTelegram) -> int:
-        level = 0
-        for output_data in reply_telegram.data_value.split(","):
-            if ":" in output_data:
-                output_str, level_str = output_data.split(":")
-                if int(output_str) == self.output_number:
-                    level_str = level_str.replace("[%]", "")
-                    level = int(level_str)
-                    break
-        return level
-
-    def succeed(self, lightlevel: int) -> None:
-        self.service_response.success = True
-        self.service_response.timestamp = datetime.now()
-        self.service_response.serial_number = self.serial_number
-        self.service_response.level = lightlevel
-        if self.finish_callback:
-            self.finish_callback(self.service_response)
-
-    def failed(self, message: str) -> None:
-        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)
+        if self.service_callback:
+            self.service_callback(service_response)
 
     def get_light_level(
         self,
@@ -143,7 +92,10 @@ class ConbusLightlevelGetService(ConbusProtocol):
         self.logger.info("Starting get_lightlevel_status")
         if timeout_seconds:
             self.timeout_seconds = timeout_seconds
-        self.finish_callback = finish_callback
         self.serial_number = serial_number
         self.output_number = output_number
+        self.datapoint_type = DataPointType.MODULE_LIGHT_LEVEL
+
+        self.finish_callback = self.finish_service_callback
+        self.service_callback = finish_callback
         self.start_reactor()

xp/services/conbus/conbus_linknumber_get_service.py

@@ -0,0 +1,86 @@
+"""Conbus Link Number Service for setting module link numbers.
+
+This service handles setting link numbers for modules through Conbus telegrams.
+"""
+
+import logging
+from typing import Callable, Optional
+
+from twisted.internet.posixbase import PosixReactorBase
+
+from xp.models import ConbusClientConfig, ConbusDatapointResponse
+from xp.models.conbus.conbus_linknumber import ConbusLinknumberResponse
+from xp.models.telegram.datapoint_type import DataPointType
+from xp.services.conbus.conbus_datapoint_service import ConbusDatapointService
+from xp.services.telegram.telegram_service import TelegramService
+
+
+class ConbusLinknumberGetService(ConbusDatapointService):
+    """
+    Service for receiving telegrams from Conbus servers.
+
+    Uses composition with ConbusService to provide receive-only functionality
+    for collecting waiting event telegrams from the server.
+    """
+
+    def __init__(
+        self,
+        telegram_service: TelegramService,
+        cli_config: ConbusClientConfig,
+        reactor: PosixReactorBase,
+    ) -> None:
+        """Initialize the Conbus client send service"""
+        super().__init__(telegram_service, cli_config, reactor)
+        self.service_callback: Optional[Callable[[ConbusLinknumberResponse], None]] = (
+            None
+        )
+
+        # Set up logging
+        self.logger = logging.getLogger(__name__)
+
+    def finish_service_callback(
+        self, datapoint_response: ConbusDatapointResponse
+    ) -> None:
+
+        self.logger.debug("Parsing datapoint response")
+        link_number_value = 0
+        if datapoint_response.success and datapoint_response.datapoint_telegram:
+            link_number_value = int(datapoint_response.datapoint_telegram.data_value)
+
+        linknumber_response = ConbusLinknumberResponse(
+            success=datapoint_response.success,
+            result="SUCCESS" if datapoint_response.success else "FAILURE",
+            link_number=link_number_value,
+            serial_number=self.serial_number,
+            error=datapoint_response.error,
+            sent_telegram=datapoint_response.sent_telegram,
+            received_telegrams=datapoint_response.received_telegrams,
+            timestamp=datapoint_response.timestamp,
+        )
+
+        if self.service_callback:
+            self.service_callback(linknumber_response)
+
+    def get_linknumber(
+        self,
+        serial_number: str,
+        finish_callback: Callable[[ConbusLinknumberResponse], None],
+        timeout_seconds: Optional[float] = None,
+    ) -> None:
+        """
+        Get the current auto report status for a specific module.
+
+        Args:
+            :param  serial_number: 10-digit module serial number
+            :param  finish_callback: callback function to call when the linknumber status is
+            :param  timeout_seconds: timeout in seconds
+
+        """
+        self.logger.info("Starting get_linknumber")
+        if timeout_seconds:
+            self.timeout_seconds = timeout_seconds
+        self.serial_number = serial_number
+        self.datapoint_type = DataPointType.LINK_NUMBER
+        self.finish_callback = self.finish_service_callback
+        self.service_callback = finish_callback
+        self.start_reactor()

xp/services/conbus/conbus_linknumber_set_service.py

@@ -0,0 +1,155 @@
+"""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_linknumber import ConbusLinknumberResponse
+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 ConbusLinknumberSetService(ConbusProtocol):
+    """
+    Service for setting module link numbers via Conbus telegrams.
+
+    Handles link number assignment by sending F04D04 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"""
+        super().__init__(cli_config, reactor)
+        self.telegram_service = telegram_service
+        self.serial_number: str = ""
+        self.link_number: int = 0
+        self.finish_callback: Optional[Callable[[ConbusLinknumberResponse], None]] = (
+            None
+        )
+        self.service_response: ConbusLinknumberResponse = ConbusLinknumberResponse(
+            success=False, serial_number=self.serial_number, result=""
+        )
+
+        # Set up logging
+        self.logger = logging.getLogger(__name__)
+
+    def connection_established(self) -> None:
+        self.logger.debug(
+            f"Connection established, setting link number {self.link_number}..."
+        )
+
+        # 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 not (0 <= self.link_number <= 99):
+            self.failed(f"Link number must be between 0-99, got: {self.link_number}")
+            return
+
+        # Send F04D04{link_number} telegram
+        # F04 = WRITE_CONFIG, D04 = LINK_NUMBER datapoint type
+        self.send_telegram(
+            telegram_type=TelegramType.SYSTEM,
+            serial_number=self.serial_number,
+            system_function=SystemFunction.WRITE_CONFIG,
+            data_value=f"{DataPointType.LINK_NUMBER.value}{self.link_number:02d}",
+        )
+
+    def telegram_sent(self, telegram_sent: str) -> None:
+        self.service_response.sent_telegram = telegram_sent
+
+    def telegram_received(self, telegram_received: TelegramReceivedEvent) -> None:
+        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
+            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:
+            self.logger.debug("Failed to parse reply telegram")
+            return
+
+        # Check for ACK or NAK response
+        if reply_telegram.system_function == SystemFunction.ACK:
+            self.logger.debug("Received ACK response")
+            self.succeed(SystemFunction.ACK)
+        elif reply_telegram.system_function == SystemFunction.NAK:
+            self.logger.debug("Received NAK response")
+            self.failed("Module responded with NAK")
+        else:
+            self.logger.debug(
+                f"Unexpected system function: {reply_telegram.system_function}"
+            )
+
+    def succeed(self, system_function: SystemFunction) -> None:
+        self.logger.debug("Successfully set link number")
+        self.service_response.success = True
+        self.service_response.timestamp = datetime.now()
+        self.service_response.serial_number = self.serial_number
+        self.service_response.result = "ACK"
+        self.service_response.link_number = self.link_number
+        if self.finish_callback:
+            self.finish_callback(self.service_response)
+
+    def failed(self, message: str) -> None:
+        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.result = "NAK"
+        self.service_response.error = message
+        if self.finish_callback:
+            self.finish_callback(self.service_response)
+
+    def set_linknumber(
+        self,
+        serial_number: str,
+        link_number: int,
+        finish_callback: Callable[[ConbusLinknumberResponse], None],
+        timeout_seconds: Optional[float] = None,
+    ) -> None:
+        """
+        Set the link number for a specific module.
+
+        Args:
+            serial_number: 10-digit module serial number
+            link_number: Link number to set (0-99)
+            finish_callback: Callback function to call when operation completes
+            timeout_seconds: Optional timeout in seconds
+        """
+        self.logger.info("Starting set_linknumber")
+        if timeout_seconds:
+            self.timeout_seconds = timeout_seconds
+        self.serial_number = serial_number
+        self.link_number = link_number
+        self.finish_callback = finish_callback
+        self.start_reactor()

xp/services/conbus/conbus_output_service.py

@@ -1,137 +1,174 @@
-"""Conbus Client Send Service for TCP communication with Conbus servers.
+"""Conbus Output Service for sending action telegrams to Conbus modules.
 
-This service implements a TCP client that connects to Conbus servers and sends
-various types of telegrams including discover, version, and sensor data requests.
+This service handles sending action telegrams (ON/OFF) to module outputs
+and processing ACK/NAK responses.
 """
 
 import logging
 from datetime import datetime
-from typing import Any, Optional
+from typing import Callable, Optional
 
-from xp.models import ConbusDatapointResponse
+from twisted.internet.posixbase import PosixReactorBase
+
+from xp.models import ConbusClientConfig
 from xp.models.conbus.conbus_output import ConbusOutputResponse
+from xp.models.protocol.conbus_protocol import TelegramReceivedEvent
 from xp.models.telegram.action_type import ActionType
-from xp.models.telegram.datapoint_type import DataPointType
+from xp.models.telegram.output_telegram import OutputTelegram
 from xp.models.telegram.system_function import SystemFunction
-from xp.services.conbus.conbus_datapoint_service import ConbusDatapointService
-from xp.services.conbus.conbus_service import ConbusService
-from xp.services.telegram.telegram_output_service import TelegramOutputService
-from xp.services.telegram.telegram_service import TelegramService
+from xp.models.telegram.telegram_type import TelegramType
+from xp.services.protocol import ConbusProtocol
+from xp.services.telegram.telegram_output_service import (
+    TelegramOutputService,
+    XPOutputError,
+)
 
 
 class ConbusOutputError(Exception):
-    """Raised when Conbus client send operations fail"""
+    """Raised when Conbus output operations fail"""
 
     pass
 
 
-class ConbusOutputService:
+class ConbusOutputService(ConbusProtocol):
     """
-    TCP client service for sending telegrams to Conbus servers.
+    Service for sending action telegrams to Conbus module outputs.
 
-    Manages TCP socket connections, handles telegram generation and transmission,
-    and processes server responses.
+    Manages action telegram transmission (ON/OFF) and processes
+    ACK/NAK responses from modules.
     """
 
     def __init__(
         self,
-        telegram_service: TelegramService,
         telegram_output_service: TelegramOutputService,
-        datapoint_service: ConbusDatapointService,
-        conbus_service: ConbusService,
+        cli_config: ConbusClientConfig,
+        reactor: PosixReactorBase,
     ):
-        """Initialize the Conbus client send service
+        """Initialize the Conbus output service
 
         Args:
-            telegram_service: TelegramService for dependency injection
-            telegram_output_service: TelegramOutputService for dependency injection
-            datapoint_service: ConbusDatapointService for dependency injection
-            conbus_service: ConbusService for dependency injection
+            telegram_output_service: TelegramOutputService for telegram generation/parsing
+            cli_config: Conbus client configuration
+            reactor: Twisted reactor for async operations
         """
-
-        # Service dependencies
-        self.telegram_service = telegram_service
+        super().__init__(cli_config, reactor)
         self.telegram_output_service = telegram_output_service
-        self.datapoint_service = datapoint_service
-        self.conbus_service = conbus_service
+        self.serial_number: str = ""
+        self.output_number: int = 0
+        self.action_type: ActionType = ActionType.ON_RELEASE
+        self.finish_callback: Optional[Callable[[ConbusOutputResponse], None]] = None
+        self.service_response: ConbusOutputResponse = ConbusOutputResponse(
+            success=False,
+            serial_number=self.serial_number,
+            output_number=self.output_number,
+            action_type=self.action_type,
+            timestamp=datetime.now(),
+        )
 
         # Set up logging
         self.logger = logging.getLogger(__name__)
 
-    def __enter__(self) -> "ConbusOutputService":
-        return self
-
-    def __exit__(
-        self,
-        _exc_type: Optional[type],
-        _exc_val: Optional[Exception],
-        _exc_tb: Optional[Any],
-    ) -> None:
-        # Cleanup logic if needed
-        pass
-
-    def get_output_state(self, serial_number: str) -> ConbusDatapointResponse:
-        # TODO: Migrate to new ConbusDatapointService callback-based API
-        # Send status query using custom telegram method
-        response = self.datapoint_service.query_datapoint(  # type: ignore[call-arg,func-returns-value]
-            serial_number=serial_number,
-            datapoint_type=DataPointType.MODULE_OUTPUT_STATE,  # "12"
+    def connection_established(self) -> None:
+        self.logger.debug(
+            f"Connection established, sending action {self.action_type} to output {self.output_number}..."
         )
 
-        return response  # type: ignore[no-any-return]
-
-    def get_module_state(self, serial_number: str) -> ConbusDatapointResponse:
-        # TODO: Migrate to new ConbusDatapointService callback-based API
-        # Send status query using custom telegram method
-        response = self.datapoint_service.query_datapoint(  # type: ignore[call-arg,func-returns-value]
-            serial_number=serial_number, datapoint_type=DataPointType.MODULE_STATE
+        # Validate parameters before sending
+        try:
+            self.telegram_output_service.validate_output_number(self.output_number)
+            self.telegram_output_service.validate_serial_number(self.serial_number)
+        except XPOutputError as e:
+            self.failed(str(e))
+            return
+
+        # Send F27D{output:02d}{action} telegram
+        # F27 = ACTION, D = data with output number and action type
+        self.send_telegram(
+            telegram_type=TelegramType.SYSTEM,
+            serial_number=self.serial_number,
+            system_function=SystemFunction.ACTION,
+            data_value=f"{self.output_number:02d}{self.action_type.value}",
         )
 
-        return response  # type: ignore[no-any-return]
+    def telegram_sent(self, telegram_sent: str) -> None:
+        self.service_response.sent_telegram = telegram_sent
 
-    def send_action(
-        self, serial_number: str, output_number: int, action_type: ActionType
-    ) -> ConbusOutputResponse:
+    def telegram_received(self, telegram_received: TelegramReceivedEvent) -> None:
+        self.logger.debug(f"Telegram received: {telegram_received}")
 
-        # Parse input number and send action
-        self.telegram_output_service.validate_output_number(output_number)
+        if not self.service_response.received_telegrams:
+            self.service_response.received_telegrams = []
+        self.service_response.received_telegrams.append(telegram_received.frame)
 
-        # Send action telegram using custom telegram method
-        # Format: F27D{input:02d}AA (Function 27, input number, PRESS action)
-        action_value = action_type.value
+        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
 
-        input_action = f"{output_number:02d}{action_value}"
-        response = self.conbus_service.send_telegram(
-            serial_number,
-            SystemFunction.ACTION,  # "27"
-            input_action,  # "00AA", "01AA", etc.
+        # Parse the reply telegram to get ACK/NAK
+        output_telegram = self.telegram_output_service.parse_reply_telegram(
+            telegram_received.frame
         )
 
-        if (
-            not response.success
-            or response.received_telegrams is None
-            or len(response.received_telegrams) <= 0
+        if output_telegram and output_telegram.system_function in (
+            SystemFunction.ACK,
+            SystemFunction.NAK,
         ):
-
-            return ConbusOutputResponse(
-                success=response.success,
-                serial_number=serial_number,
-                output_number=output_number,
-                action_type=action_type,
-                error=response.error,
-                timestamp=response.timestamp or datetime.now(),
-                received_telegrams=response.received_telegrams,
+            self.logger.debug(f"Received {output_telegram.system_function} response")
+            self.succeed(output_telegram)
+        else:
+            self.logger.debug(
+                f"Unexpected system function: {output_telegram.system_function}"
             )
 
-        telegram = response.received_telegrams[0]
-        output_telegram = self.telegram_output_service.parse_reply_telegram(telegram)
-
-        return ConbusOutputResponse(
-            success=response.success,
-            serial_number=serial_number,
-            output_number=output_number,
-            action_type=action_type,
-            output_telegram=output_telegram,
-            timestamp=response.timestamp or datetime.now(),
-            received_telegrams=response.received_telegrams,
-        )
+    def succeed(self, output_telegram: OutputTelegram) -> None:
+        self.logger.debug("Successfully sent action to output")
+        self.service_response.success = True
+        self.service_response.timestamp = datetime.now()
+        self.service_response.serial_number = self.serial_number
+        self.service_response.output_number = self.output_number
+        self.service_response.action_type = self.action_type
+        self.service_response.output_telegram = output_telegram
+        if self.finish_callback:
+            self.finish_callback(self.service_response)
+
+    def failed(self, message: str) -> None:
+        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.output_number = self.output_number
+        self.service_response.action_type = self.action_type
+        self.service_response.error = message
+        if self.finish_callback:
+            self.finish_callback(self.service_response)
+
+    def send_action(
+        self,
+        serial_number: str,
+        output_number: int,
+        action_type: ActionType,
+        finish_callback: Callable[[ConbusOutputResponse], None],
+        timeout_seconds: Optional[float] = None,
+    ) -> None:
+        """
+        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
+        """
+        self.logger.info("Starting send_action")
+        if timeout_seconds:
+            self.timeout_seconds = timeout_seconds
+        self.serial_number = serial_number
+        self.output_number = output_number
+        self.action_type = action_type
+        self.finish_callback = finish_callback
+        self.start_reactor()