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

xp/services/conbus/conbus_blink_service.py

@@ -5,62 +5,116 @@ various types of telegrams including discover, version, and sensor data requests
 """
 
 import logging
-from typing import Any, Optional
+from datetime import datetime
+from typing import Callable, Optional
 
-from xp.models import ConbusResponse
+from twisted.internet.posixbase import PosixReactorBase
+
+from xp.models import ConbusClientConfig
 from xp.models.conbus.conbus_blink import ConbusBlinkResponse
-from xp.models.telegram.reply_telegram import ReplyTelegram
+from xp.models.protocol.conbus_protocol import TelegramReceivedEvent
 from xp.models.telegram.system_function import SystemFunction
-from xp.services import TelegramDiscoverService
-from xp.services.conbus.conbus_service import ConbusService
-from xp.services.telegram.telegram_blink_service import TelegramBlinkService
+from xp.models.telegram.telegram_type import TelegramType
+from xp.services.protocol import ConbusProtocol
 from xp.services.telegram.telegram_service import TelegramService
 
 
-class ConbusBlinkService:
+class ConbusBlinkService(ConbusProtocol):
     """
-    TCP client service for sending telegrams to Conbus servers.
+    Service for receiving telegrams from Conbus servers.
 
-    Manages TCP socket connections, handles telegram generation and transmission,
-    and processes server responses.
+    Uses composition with ConbusService to provide receive-only functionality
+    for collecting waiting event telegrams from the server.
     """
 
     def __init__(
         self,
-        conbus_service: ConbusService,
-        telegram_discover_service: TelegramDiscoverService,
-        telegram_blink_service: TelegramBlinkService,
         telegram_service: TelegramService,
-    ):
+        cli_config: ConbusClientConfig,
+        reactor: PosixReactorBase,
+    ) -> None:
         """Initialize the Conbus client send service"""
-
-        # Service dependencies
-        self.conbus_service = conbus_service
-        self.telegram_discover_service = telegram_discover_service
-        self.telegram_blink_service = telegram_blink_service
-        self.blink_service = (
-            self.telegram_blink_service
-        )  # Alias for backward compatibility
+        super().__init__(cli_config, reactor)
         self.telegram_service = telegram_service
+        self.serial_number: str = ""
+        self.on_or_off = "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 __enter__(self) -> "ConbusBlinkService":
-        return self
+    def connection_established(self) -> None:
+        self.logger.debug("Connection established, retrieving autoreport status...")
+        # Blink is 05, Unblink is 06
+        system_function = SystemFunction.UNBLINK
+        if self.on_or_off.lower() == "on":
+            system_function = SystemFunction.BLINK
 
-    def __exit__(
-        self,
-        _exc_type: Optional[type],
-        _exc_val: Optional[Exception],
-        _exc_tb: Optional[Any],
-    ) -> None:
-        # Cleanup logic if needed
-        pass
+        self.send_telegram(
+            telegram_type=TelegramType.SYSTEM,
+            serial_number=self.serial_number,
+            system_function=system_function,
+            data_value="00",
+        )
+        self.service_response.system_function = system_function
+        self.service_response.operation = self.on_or_off
+
+    def telegram_sent(self, telegram_sent: str) -> None:
+        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:
+
+        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")
+            return
+
+        reply_telegram = self.telegram_service.parse_reply_telegram(
+            telegram_received.frame
+        )
+        if reply_telegram is not None and reply_telegram.system_function in (
+            SystemFunction.ACK,
+            SystemFunction.NAK,
+        ):
+            self.logger.debug("Received blink response")
+            self.service_response.success = True
+            self.service_response.timestamp = datetime.now()
+            self.service_response.serial_number = self.serial_number
+            self.service_response.reply_telegram = reply_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.error = message
+        if self.finish_callback:
+            self.finish_callback(self.service_response)
 
     def send_blink_telegram(
-        self, serial_number: str, on_or_off: str
-    ) -> ConbusBlinkResponse:
+        self,
+        serial_number: str,
+        on_or_off: str,
+        finish_callback: Callable[[ConbusBlinkResponse], None],
+        timeout_seconds: Optional[float] = None,
+    ) -> None:
         """
         Send blink command to start blinking module LED.
 
@@ -70,127 +124,11 @@ class ConbusBlinkService:
             xp conbus blink 0012345008 on
             xp conbus blink 0012345008 off
         """
-        # Blink is 05, Unblink is 06
-        system_function = SystemFunction.UNBLINK
-        if on_or_off.lower() == "on":
-            system_function = SystemFunction.BLINK
-
-        # Send blink telegram using custom method (F05D00)
-        with self.conbus_service:
-
-            response = self.conbus_service.send_telegram(
-                serial_number,
-                system_function,  # Blink or Unblink function code
-                "00",  # Status data point
-            )
-
-            reply_telegram = None
-            if (
-                response.success
-                and response.received_telegrams is not None
-                and len(response.received_telegrams) > 0
-            ):
-                ack_or_nak = response.received_telegrams[0]
-                parsed_telegram = self.telegram_service.parse_telegram(ack_or_nak)
-                if isinstance(parsed_telegram, ReplyTelegram):
-                    reply_telegram = parsed_telegram
-
-            return ConbusBlinkResponse(
-                serial_number=serial_number,
-                operation=on_or_off,
-                system_function=system_function,
-                response=response,
-                reply_telegram=reply_telegram,
-                success=response.success,
-                timestamp=response.timestamp,
-            )
-
-    def blink_all(self, on_or_off: str) -> ConbusBlinkResponse:
-        """
-        Send blink command to all discovered devices.
 
-        Args:
-            on_or_off: "on" or "off" to control blink state
-
-        Returns:
-            ConbusBlinkResponse: Aggregated response for all devices
-        """
-        # Use a single ConbusService instance for both discover and blinking
-        # to avoid connection conflicts
-        with self.conbus_service:
-            # First discover all devices using the same connection
-            telegram = self.telegram_discover_service.generate_discover_telegram()
-            discover_responses = self.conbus_service.send_raw_telegram(telegram)
-
-            if not discover_responses.success:
-                return ConbusBlinkResponse(
-                    success=False,
-                    serial_number="all",
-                    operation=on_or_off,
-                    system_function=(
-                        SystemFunction.BLINK
-                        if on_or_off == "on"
-                        else SystemFunction.UNBLINK
-                    ),
-                    error="Failed to discover devices",
-                )
-
-            # Parse received telegrams to extract device information
-            discovered_devices = self.parse_discovered_devices(discover_responses)
-
-            # If no devices discovered, return success with appropriate message
-            if not discovered_devices:
-                return ConbusBlinkResponse(
-                    success=True,
-                    serial_number="all",
-                    operation=on_or_off,
-                    system_function=(
-                        SystemFunction.BLINK
-                        if on_or_off == "on"
-                        else SystemFunction.UNBLINK
-                    ),
-                    error="No devices discovered",
-                )
-
-            # Send blink command to each discovered device
-            all_blink_telegram = []
-            for serial_number in discovered_devices:
-                blink_telegram = self.telegram_blink_service.generate_blink_telegram(
-                    serial_number, on_or_off
-                )
-                all_blink_telegram.append(blink_telegram)
-
-            # Send all blink telegrams using the same connection
-            response = self.conbus_service.send_raw_telegrams(all_blink_telegram)
-
-            return ConbusBlinkResponse(
-                success=response.success,
-                serial_number="all",
-                operation=on_or_off,
-                system_function=(
-                    SystemFunction.BLINK
-                    if on_or_off == "on"
-                    else SystemFunction.UNBLINK
-                ),
-                received_telegrams=response.received_telegrams,
-            )
-
-    def parse_discovered_devices(self, responses: ConbusResponse) -> list[str]:
-        discovered_devices: list[str] = []
-        if responses.received_telegrams is None:
-            return discovered_devices
-        for telegrams_str in responses.received_telegrams:
-            for telegram_str in telegrams_str.split("\n"):
-                try:
-                    # Parse telegram using TelegramService
-                    telegram_result = self.telegram_service.parse_telegram(telegram_str)
-                    # Only process telegrams that have a serial_number attribute
-                    if hasattr(telegram_result, "serial_number"):
-                        discovered_devices.append(telegram_result.serial_number)
-
-                except Exception as e:
-                    self.logger.warning(
-                        f"Failed to parse telegram '{telegram_str}': {e}"
-                    )
-                    continue
-        return discovered_devices
+        self.logger.info("Starting get_autoreport_status")
+        if timeout_seconds:
+            self.timeout_seconds = timeout_seconds
+        self.finish_callback = finish_callback
+        self.serial_number = serial_number
+        self.on_or_off = on_or_off
+        self.start_reactor()

xp/services/conbus/conbus_discover_service.py

@@ -59,8 +59,8 @@ class ConbusDiscoverService(ConbusProtocol):
         self.discovered_device_result.received_telegrams.append(telegram_received.frame)
 
         if (
-            telegram_received.telegram_type == TelegramType.REPLY.value
-            and telegram_received.checksum_valid
+            telegram_received.checksum_valid
+            and telegram_received.telegram_type == TelegramType.REPLY.value
             and telegram_received.payload[11:16] == "F01D"
             and len(telegram_received.payload) == 15
         ):

xp/services/conbus/conbus_lightlevel_get_service.py

@@ -0,0 +1,149 @@
+"""Conbus Auto Report Service for getting and setting module auto report status.
+
+This service handles auto report status operations 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_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.telegram.telegram_service import TelegramService
+
+
+class ConbusLightlevelGetService(ConbusProtocol):
+    """
+    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__(cli_config, reactor)
+        self.telegram_service = telegram_service
+        self.serial_number: str = ""
+        self.output_number: int = 0
+        self.finish_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)
+
+        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
+
+        reply_telegram = self.telegram_service.parse_reply_telegram(
+            telegram_received.frame
+        )
+
+        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)
+
+    def get_light_level(
+        self,
+        serial_number: str,
+        output_number: int,
+        finish_callback: Callable[[ConbusLightlevelResponse], 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  output_number: output module number
+            :param  finish_callback: callback function to call when the lightlevel status is
+            :param  timeout_seconds: timeout in seconds
+
+        """
+        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.start_reactor()

xp/services/conbus/conbus_lightlevel_set_service.py

@@ -0,0 +1,205 @@
+"""Conbus Lightlevel Service for controlling light levels on Conbus modules.
+
+This service implements lightlevel control operations for XP modules,
+including setting specific light levels, turning lights on/off, and
+querying current light levels.
+"""
+
+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_lightlevel import ConbusLightlevelResponse
+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
+
+
+class ConbusLightlevelError(Exception):
+    """Raised when Conbus lightlevel operations fail"""
+
+    pass
+
+
+class ConbusLightlevelSetService(ConbusProtocol):
+    """
+    Service for controlling light levels on Conbus modules.
+
+    Manages lightlevel operations including setting specific levels,
+    turning lights on/off, and querying current states.
+    """
+
+    def __init__(
+        self,
+        cli_config: ConbusClientConfig,
+        reactor: PosixReactorBase,
+    ):
+        """Initialize the Conbus lightlevel service"""
+        super().__init__(cli_config, reactor)
+        self.serial_number: str = ""
+        self.output_number: int = 0
+        self.level: int = 0
+        self.finish_callback: Optional[Callable[[ConbusLightlevelResponse], None]] = (
+            None
+        )
+        self.service_response: ConbusLightlevelResponse = ConbusLightlevelResponse(
+            success=False,
+            serial_number=self.serial_number,
+            output_number=self.output_number,
+            level=None,
+            timestamp=datetime.now(),
+        )
+
+        # Set up logging
+        self.logger = logging.getLogger(__name__)
+
+    def connection_established(self) -> None:
+        self.logger.debug(
+            f"Connection established, setting light level for output {self.output_number} to {self.level}%..."
+        )
+
+        # Format data as output_number:level (e.g., ""15" + "02:050")
+        data_value = f"{DataPointType.MODULE_LIGHT_LEVEL.value}{self.output_number:02d}:{self.level:03d}"
+
+        # Send telegram using WRITE_CONFIG function with MODULE_LIGHT_LEVEL datapoint
+        self.send_telegram(
+            telegram_type=TelegramType.SYSTEM,
+            serial_number=self.serial_number,
+            system_function=SystemFunction.WRITE_CONFIG,  # "04"
+            data_value=data_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)
+
+        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
+
+        # Any valid reply means success (ACK or NAK)
+        if telegram_received.telegram_type == TelegramType.REPLY:
+            self.logger.debug("Received lightlevel response")
+            self.succeed()
+
+    def succeed(self) -> None:
+        self.logger.debug("Succeed")
+        self.service_response.success = True
+        self.service_response.serial_number = self.serial_number
+        self.service_response.output_number = self.output_number
+        self.service_response.level = self.level
+        self.service_response.timestamp = datetime.now()
+
+        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.serial_number = self.serial_number
+        self.service_response.output_number = self.output_number
+        self.service_response.level = self.level
+        self.service_response.timestamp = datetime.now()
+        self.service_response.error = message
+
+        if self.finish_callback:
+            self.finish_callback(self.service_response)
+
+    def set_lightlevel(
+        self,
+        serial_number: str,
+        output_number: int,
+        level: int,
+        finish_callback: Callable[[ConbusLightlevelResponse], None],
+        timeout_seconds: Optional[float] = None,
+    ) -> None:
+        """Set light level for a specific output on a module.
+
+        Args:
+            serial_number: Module serial number
+            output_number: Output number (0-based, 0-8)
+            level: Light level percentage (0-100)
+            finish_callback: Callback function to call when operation completes
+            timeout_seconds: Optional timeout in seconds
+
+        Examples:
+            \b
+                xp conbus lightlevel set 0012345008 2 50
+                xp conbus lightlevel set 0012345008 0 100
+        """
+
+        self.logger.info(
+            f"Setting light level for {serial_number} output {output_number} to {level}%"
+        )
+        if timeout_seconds:
+            self.timeout_seconds = timeout_seconds
+        self.finish_callback = finish_callback
+        self.serial_number = serial_number
+        self.output_number = output_number
+        self.level = level
+
+        # Validate output_number range (0-8)
+        if not 0 <= self.output_number <= 8:
+            self.failed(
+                f"Output number must be between 0 and 8, got {self.output_number}"
+            )
+            return
+
+        # Validate level range
+        if not 0 <= self.level <= 100:
+            self.failed(f"Light level must be between 0 and 100, got {self.level}")
+            return
+
+        self.start_reactor()
+
+    def turn_off(
+        self,
+        serial_number: str,
+        output_number: int,
+        finish_callback: Callable[[ConbusLightlevelResponse], None],
+        timeout_seconds: Optional[float] = None,
+    ) -> None:
+        """Turn off light (set level to 0) for a specific output.
+
+        Args:
+            serial_number: Module serial number
+            output_number: Output number (0-8)
+            finish_callback: Callback function to call when operation completes
+            timeout_seconds: Optional timeout in seconds
+        """
+        self.set_lightlevel(
+            serial_number, output_number, 0, finish_callback, timeout_seconds
+        )
+
+    def turn_on(
+        self,
+        serial_number: str,
+        output_number: int,
+        finish_callback: Callable[[ConbusLightlevelResponse], None],
+        timeout_seconds: Optional[float] = None,
+    ) -> None:
+        """Turn on light (set level to 80%) for a specific output.
+
+        Args:
+            serial_number: Module serial number
+            output_number: Output number (0-8)
+            finish_callback: Callback function to call when operation completes
+            timeout_seconds: Optional timeout in seconds
+        """
+        self.set_lightlevel(
+            serial_number, output_number, 80, finish_callback, timeout_seconds
+        )