conson-xp 1.18.0__py3-none-any.whl

xp/services/actiontable/msactiontable_xp33_serializer.py

@@ -0,0 +1,239 @@
+"""Serializer for XP33 Action Table telegram encoding/decoding."""
+
+from xp.models.actiontable.msactiontable_xp33 import (
+    Xp33MsActionTable,
+    Xp33Output,
+    Xp33Scene,
+)
+from xp.models.telegram.timeparam_type import TimeParam
+from xp.utils.serialization import bits_to_byte, byte_to_bits, de_nibbles, nibbles
+
+
+class Xp33MsActionTableSerializer:
+    """Handles serialization/deserialization of XP33 action tables to/from telegrams."""
+
+    @staticmethod
+    def _percentage_to_byte(percentage: int) -> int:
+        """Convert percentage (0-100) to byte value for telegram encoding."""
+        return min(max(percentage, 0), 100)
+
+    @staticmethod
+    def _byte_to_percentage(byte_val: int) -> int:
+        """Convert byte value from telegram to percentage (0-100)."""
+        return min(max(byte_val, 0), 100)
+
+    @staticmethod
+    def _time_param_to_byte(time_param: TimeParam) -> int:
+        """Convert TimeParam enum to byte value for telegram encoding."""
+        return time_param.value
+
+    @staticmethod
+    def _byte_to_time_param(byte_val: int) -> TimeParam:
+        """Convert byte value from telegram to TimeParam enum."""
+        try:
+            return TimeParam(byte_val)
+        except ValueError:
+            return TimeParam.NONE
+
+    @staticmethod
+    def to_data(action_table: Xp33MsActionTable) -> str:
+        """Serialize action table to telegram format.
+
+        Args:
+            action_table: XP33 MS action table to serialize.
+
+        Returns:
+            Serialized action table data string.
+        """
+        # Create 32-byte array
+        raw_bytes = bytearray(32)
+
+        # Encode output min/max levels (bytes 0-5)
+        outputs = [action_table.output1, action_table.output2, action_table.output3]
+        for i, output in enumerate(outputs):
+            raw_bytes[2 * i] = Xp33MsActionTableSerializer._percentage_to_byte(
+                output.min_level
+            )
+            raw_bytes[2 * i + 1] = Xp33MsActionTableSerializer._percentage_to_byte(
+                output.max_level
+            )
+
+        # Encode scenes (bytes 6-21)
+        scenes = [
+            action_table.scene1,
+            action_table.scene2,
+            action_table.scene3,
+            action_table.scene4,
+        ]
+        for scene_idx, scene in enumerate(scenes):
+            offset = 6 + (4 * scene_idx)
+            raw_bytes[offset] = Xp33MsActionTableSerializer._time_param_to_byte(
+                scene.time
+            )
+            raw_bytes[offset + 1] = Xp33MsActionTableSerializer._percentage_to_byte(
+                scene.output1_level
+            )
+            raw_bytes[offset + 2] = Xp33MsActionTableSerializer._percentage_to_byte(
+                scene.output2_level
+            )
+            raw_bytes[offset + 3] = Xp33MsActionTableSerializer._percentage_to_byte(
+                scene.output3_level
+            )
+
+        # Encode bit flags (bytes 22-24)
+        scene_outputs_bits = [False] * 8
+        start_at_full_bits = [False] * 8
+        leading_edge_bits = [False] * 8
+
+        for i, output in enumerate(outputs):
+            if i < 3:  # Only 3 outputs
+                scene_outputs_bits[i] = output.scene_outputs
+                start_at_full_bits[i] = output.start_at_full
+                leading_edge_bits[i] = output.leading_edge
+
+        raw_bytes[22] = bits_to_byte(scene_outputs_bits)
+        raw_bytes[23] = bits_to_byte(start_at_full_bits)
+        raw_bytes[24] = bits_to_byte(leading_edge_bits)
+
+        # Bytes 25-31 are padding (already 0)
+        # Convert to hex string using nibble encoding
+        encoded_data = nibbles(raw_bytes)
+
+        # Convert raw bytes to hex string with A-P encoding
+        return "AAAA" + encoded_data
+
+    @staticmethod
+    def from_data(msactiontable_rawdata: str) -> Xp33MsActionTable:
+        """Deserialize action table from raw data parts.
+
+        Args:
+            msactiontable_rawdata: Raw action table data string.
+
+        Returns:
+            Deserialized XP33 MS action table.
+
+        Raises:
+            ValueError: If data length is less than 68 characters.
+        """
+        raw_length = len(msactiontable_rawdata)
+        if raw_length < 68:  # Minimum: 4 char prefix + 64 chars data
+            raise ValueError(
+                f"Msactiontable is too short ({raw_length}), minimum 68 characters required"
+            )
+
+        # Remove action table count prefix (first 4 characters: AAAA, AAAB, etc.)
+        data = msactiontable_rawdata[4:]
+
+        # Take first 64 chars (32 bytes) as per pseudocode
+        hex_data = data[:64]
+
+        # Convert hex string to bytes using deNibble (A-P encoding)
+        raw_bytes = de_nibbles(hex_data)
+
+        # Decode outputs
+        output1 = Xp33MsActionTableSerializer._decode_output(raw_bytes, 0)
+        output2 = Xp33MsActionTableSerializer._decode_output(raw_bytes, 1)
+        output3 = Xp33MsActionTableSerializer._decode_output(raw_bytes, 2)
+
+        # Decode scenes
+        scene1 = Xp33MsActionTableSerializer._decode_scene(raw_bytes, 0)
+        scene2 = Xp33MsActionTableSerializer._decode_scene(raw_bytes, 1)
+        scene3 = Xp33MsActionTableSerializer._decode_scene(raw_bytes, 2)
+        scene4 = Xp33MsActionTableSerializer._decode_scene(raw_bytes, 3)
+
+        return Xp33MsActionTable(
+            output1=output1,
+            output2=output2,
+            output3=output3,
+            scene1=scene1,
+            scene2=scene2,
+            scene3=scene3,
+            scene4=scene4,
+        )
+
+    @staticmethod
+    def _decode_output(raw_bytes: bytearray, output_index: int) -> Xp33Output:
+        """Extract output configuration from raw bytes.
+
+        Args:
+            raw_bytes: Raw byte array containing output data.
+            output_index: Index of the output to decode.
+
+        Returns:
+            Decoded XP33 output configuration.
+        """
+        # Read min/max levels from appropriate offsets
+        min_level = Xp33MsActionTableSerializer._byte_to_percentage(
+            raw_bytes[2 * output_index]
+        )
+        max_level = Xp33MsActionTableSerializer._byte_to_percentage(
+            raw_bytes[2 * output_index + 1]
+        )
+
+        # Extract bit flags from bytes 22-24
+        scene_outputs_bits = byte_to_bits(raw_bytes[22])
+        start_at_full_bits = byte_to_bits(raw_bytes[23])
+
+        # Handle dimFunction with exception handling as per specification
+        if len(raw_bytes) > 24:
+            leading_edge_bits = byte_to_bits(raw_bytes[24])
+        else:
+            leading_edge_bits = [False] * 8
+
+        # Map bit flags to output properties
+        scene_outputs = (
+            scene_outputs_bits[output_index]
+            if output_index < len(scene_outputs_bits)
+            else False
+        )
+        start_at_full = (
+            start_at_full_bits[output_index]
+            if output_index < len(start_at_full_bits)
+            else False
+        )
+        leading_edge = (
+            leading_edge_bits[output_index]
+            if output_index < len(leading_edge_bits)
+            else False
+        )
+
+        return Xp33Output(
+            min_level=min_level,
+            max_level=max_level,
+            scene_outputs=scene_outputs,
+            start_at_full=start_at_full,
+            leading_edge=leading_edge,
+        )
+
+    @staticmethod
+    def _decode_scene(raw_bytes: bytearray, scene_index: int) -> Xp33Scene:
+        """Extract scene configuration from raw bytes.
+
+        Args:
+            raw_bytes: Raw byte array containing scene data.
+            scene_index: Index of the scene to decode.
+
+        Returns:
+            Decoded XP33 scene configuration.
+        """
+        # Calculate scene offset: 6 + (4 * scene_index)
+        offset = 6 + (4 * scene_index)
+
+        # Parse time parameter and output levels
+        time_param = Xp33MsActionTableSerializer._byte_to_time_param(raw_bytes[offset])
+        output1_level = Xp33MsActionTableSerializer._byte_to_percentage(
+            raw_bytes[offset + 1]
+        )
+        output2_level = Xp33MsActionTableSerializer._byte_to_percentage(
+            raw_bytes[offset + 2]
+        )
+        output3_level = Xp33MsActionTableSerializer._byte_to_percentage(
+            raw_bytes[offset + 3]
+        )
+
+        return Xp33Scene(
+            output1_level=output1_level,
+            output2_level=output2_level,
+            output3_level=output3_level,
+            time=time_param,
+        )

xp/services/conbus/__init__.py

@@ -0,0 +1 @@
+"""Conbus service layer."""

xp/services/conbus/actiontable/__init__.py

@@ -0,0 +1 @@
+"""Action table services for Conbus."""

xp/services/conbus/actiontable/actiontable_download_service.py

@@ -0,0 +1,158 @@
+"""Service for downloading ActionTable via Conbus protocol."""
+
+import logging
+from dataclasses import asdict
+from typing import Any, Callable, Dict, Optional
+
+from twisted.internet.posixbase import PosixReactorBase
+
+from xp.models import ConbusClientConfig
+from xp.models.actiontable.actiontable import ActionTable
+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 ActionTableService(ConbusProtocol):
+    """TCP client service for downloading action tables from Conbus modules.
+
+    Manages TCP socket connections, handles telegram generation and transmission,
+    and processes server responses for action table downloads.
+    """
+
+    def __init__(
+        self,
+        cli_config: ConbusClientConfig,
+        reactor: PosixReactorBase,
+        actiontable_serializer: ActionTableSerializer,
+        telegram_service: TelegramService,
+    ) -> None:
+        """Initialize the action table download service.
+
+        Args:
+            cli_config: Conbus client configuration.
+            reactor: Twisted reactor instance.
+            actiontable_serializer: Action table serializer.
+            telegram_service: Telegram service for parsing.
+        """
+        super().__init__(cli_config, reactor)
+        self.serializer = actiontable_serializer
+        self.telegram_service = telegram_service
+        self.serial_number: str = ""
+        self.progress_callback: Optional[Callable[[str], None]] = None
+        self.error_callback: Optional[Callable[[str], None]] = None
+        self.finish_callback: Optional[
+            Callable[[ActionTable, Dict[str, Any], list[str]], None]
+        ] = None
+
+        self.actiontable_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 actiontable telegram"
+        )
+        self.send_telegram(
+            telegram_type=TelegramType.SYSTEM,
+            serial_number=self.serial_number,
+            system_function=SystemFunction.DOWNLOAD_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
+        )
+        if reply_telegram.system_function not in (
+            SystemFunction.ACTIONTABLE,
+            SystemFunction.EOF,
+        ):
+            self.logger.debug("Not a actiontable response")
+            return
+
+        if reply_telegram.system_function == SystemFunction.ACTIONTABLE:
+            self.logger.debug("Saving actiontable response")
+            data_part = reply_telegram.data_value[2:]
+            self.actiontable_data.append(data_part)
+            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:
+            all_data = "".join(self.actiontable_data)
+            # Deserialize from received data
+            actiontable = self.serializer.from_encoded_string(all_data)
+            actiontable_dict = asdict(actiontable)
+            actiontable_short = self.serializer.format_decoded_output(actiontable)
+            if self.finish_callback:
+                self.finish_callback(actiontable, actiontable_dict, actiontable_short)
+
+    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)
+
+    def start(
+        self,
+        serial_number: str,
+        progress_callback: Callable[[str], None],
+        error_callback: Callable[[str], None],
+        finish_callback: Callable[[ActionTable, Dict[str, Any], list[str]], None],
+        timeout_seconds: Optional[float] = None,
+    ) -> None:
+        """Run reactor in dedicated thread with its own event loop.
+
+        Args:
+            serial_number: Module serial number.
+            progress_callback: Callback for progress updates.
+            error_callback: Callback for errors.
+            finish_callback: Callback when download completes.
+            timeout_seconds: Optional timeout in seconds.
+        """
+        self.logger.info("Starting actiontable")
+        self.serial_number = serial_number
+        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/actiontable/actiontable_list_service.py

@@ -0,0 +1,91 @@
+"""Service for listing modules with action table configurations from conson.yml."""
+
+import logging
+from pathlib import Path
+from typing import Any, Callable, Optional
+
+
+class ActionTableListService:
+    """Service for listing modules with action table configurations.
+
+    Reads conson.yml and returns a list of all modules that have action table
+    configurations defined.
+    """
+
+    def __init__(self) -> None:
+        """Initialize the action table list service."""
+        self.logger = logging.getLogger(__name__)
+        self.finish_callback: Optional[Callable[[dict[str, Any]], None]] = None
+        self.error_callback: Optional[Callable[[str], None]] = None
+
+    def __enter__(self) -> "ActionTableListService":
+        """Context manager entry.
+
+        Returns:
+            Self for context manager use.
+        """
+        return self
+
+    def __exit__(self, _exc_type: Any, _exc_val: Any, _exc_tb: Any) -> None:
+        """Context manager exit."""
+        pass
+
+    def start(
+        self,
+        finish_callback: Callable[[dict[str, Any]], None],
+        error_callback: Callable[[str], None],
+        config_path: Optional[Path] = None,
+    ) -> None:
+        """List all modules with action table configurations.
+
+        Args:
+            finish_callback: Callback to invoke with the module list.
+            error_callback: Callback to invoke on error.
+            config_path: Optional path to conson.yml. Defaults to current directory.
+        """
+        self.finish_callback = finish_callback
+        self.error_callback = error_callback
+
+        # Default to current directory if not specified
+        if config_path is None:
+            config_path = Path.cwd() / "conson.yml"
+
+        # Check if config file exists
+        if not config_path.exists():
+            self._handle_error("Error: conson.yml not found in current directory")
+            return
+
+        # Load configuration
+        try:
+            from xp.models.homekit.homekit_conson_config import ConsonModuleListConfig
+
+            config = ConsonModuleListConfig.from_yaml(str(config_path))
+        except Exception as e:
+            self.logger.error(f"Failed to load conson.yml: {e}")
+            self._handle_error(f"Error: Failed to load conson.yml: {e}")
+            return
+
+        # Filter modules that have action_table configured
+        modules_with_actiontable = [
+            {
+                "serial_number": module.serial_number,
+                "module_type": module.module_type,
+            }
+            for module in config.root
+        ]
+
+        # Prepare result
+        result = {"modules": modules_with_actiontable}
+
+        # Invoke callback
+        if self.finish_callback is not None:
+            self.finish_callback(result)
+
+    def _handle_error(self, message: str) -> None:
+        """Handle error and invoke error callback.
+
+        Args:
+            message: Error message.
+        """
+        if self.error_callback is not None:
+            self.error_callback(message)

xp/services/conbus/actiontable/actiontable_show_service.py

@@ -0,0 +1,89 @@
+"""Service for showing action table configuration for a specific module."""
+
+import logging
+from pathlib import Path
+from typing import Any, Callable, Optional
+
+from xp.models.homekit.homekit_conson_config import ConsonModuleConfig
+
+
+class ActionTableShowService:
+    """Service for showing action table configuration for a specific module.
+
+    Reads conson.yml and returns the action table configuration for the specified
+    module serial number.
+    """
+
+    def __init__(self) -> None:
+        """Initialize the action table show service."""
+        self.logger = logging.getLogger(__name__)
+        self.finish_callback: Optional[Callable[[ConsonModuleConfig], None]] = None
+        self.error_callback: Optional[Callable[[str], None]] = None
+
+    def __enter__(self) -> "ActionTableShowService":
+        """Context manager entry.
+
+        Returns:
+            Self for context manager use.
+        """
+        return self
+
+    def __exit__(self, _exc_type: Any, _exc_val: Any, _exc_tb: Any) -> None:
+        """Context manager exit."""
+        pass
+
+    def start(
+        self,
+        serial_number: str,
+        finish_callback: Callable[[ConsonModuleConfig], None],
+        error_callback: Callable[[str], None],
+        config_path: Optional[Path] = None,
+    ) -> None:
+        """Show action table configuration for a specific module.
+
+        Args:
+            serial_number: Module serial number.
+            finish_callback: Callback to invoke with the module configuration.
+            error_callback: Callback to invoke on error.
+            config_path: Optional path to conson.yml. Defaults to current directory.
+        """
+        self.finish_callback = finish_callback
+        self.error_callback = error_callback
+
+        # Default to current directory if not specified
+        if config_path is None:
+            config_path = Path.cwd() / "conson.yml"
+
+        # Check if config file exists
+        if not config_path.exists():
+            self._handle_error("Error: conson.yml not found in current directory")
+            return
+
+        # Load configuration
+        try:
+            from xp.models.homekit.homekit_conson_config import ConsonModuleListConfig
+
+            config = ConsonModuleListConfig.from_yaml(str(config_path))
+        except Exception as e:
+            self.logger.error(f"Failed to load conson.yml: {e}")
+            self._handle_error(f"Error: Failed to load conson.yml: {e}")
+            return
+
+        # Find module
+        module = config.find_module(serial_number)
+        if not module:
+            self._handle_error(f"Error: Module {serial_number} not found in conson.yml")
+            return
+
+        # Invoke callback
+        if self.finish_callback is not None:
+            self.finish_callback(module)
+
+    def _handle_error(self, message: str) -> None:
+        """Handle error and invoke error callback.
+
+        Args:
+            message: Error message.
+        """
+        if self.error_callback is not None:
+            self.error_callback(message)