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

xp/services/conbus/conbus_lightlevel_get_service.py

@@ -1,101 +0,0 @@
-"""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, ConbusDatapointResponse
-from xp.models.conbus.conbus_lightlevel import ConbusLightlevelResponse
-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 ConbusLightlevelGetService(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.output_number: int = 0
-        self.service_callback: Optional[Callable[[ConbusLightlevelResponse], 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")
-
-        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 self.service_callback:
-            self.service_callback(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.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_lightlevel_set_service.py

@@ -1,205 +0,0 @@
-"""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
-        )

xp/services/conbus/conbus_linknumber_get_service.py

@@ -1,86 +0,0 @@
-"""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

@@ -1,155 +0,0 @@
-"""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()