conson-xp 1.18.0__py3-none-any.whl

xp/models/telegram/timeparam_type.py

@@ -0,0 +1,51 @@
+"""Time parameter enumeration for telegram actions."""
+
+from enum import IntEnum
+
+
+class TimeParam(IntEnum):
+    """Time parameter values for action timing.
+
+    Attributes:
+        NONE: No time parameter.
+        T05SEC: 0.5 second delay.
+        T1SEC: 1 second delay.
+        T2SEC: 2 second delay.
+        T5SEC: 5 second delay.
+        T10SEC: 10 second delay.
+        T15SEC: 15 second delay.
+        T20SEC: 20 second delay.
+        T30SEC: 30 second delay.
+        T45SEC: 45 second delay.
+        T1MIN: 1 minute delay.
+        T2MIN: 2 minute delay.
+        T5MIN: 5 minute delay.
+        T10MIN: 10 minute delay.
+        T15MIN: 15 minute delay.
+        T20MIN: 20 minute delay.
+        T30MIN: 30 minute delay.
+        T45MIN: 45 minute delay.
+        T60MIN: 60 minute delay.
+        T120MIN: 120 minute delay.
+    """
+
+    NONE = 0
+    T05SEC = 1
+    T1SEC = 2
+    T2SEC = 3
+    T5SEC = 4
+    T10SEC = 5
+    T15SEC = 6
+    T20SEC = 7
+    T30SEC = 8
+    T45SEC = 9
+    T1MIN = 10
+    T2MIN = 11
+    T5MIN = 12
+    T10MIN = 13
+    T15MIN = 14
+    T20MIN = 15
+    T30MIN = 16
+    T45MIN = 17
+    T60MIN = 18
+    T120MIN = 19

xp/models/write_config_type.py

@@ -0,0 +1,33 @@
+"""Write config type enumeration."""
+
+from enum import Enum
+from typing import Optional
+
+
+class WriteConfigType(str, Enum):
+    """Write Config types for system telegrams.
+
+    Attributes:
+        LINK_NUMBER: Link number configuration (code 04).
+        MODULE_NUMBER: Module number configuration (code 05).
+        SYSTEM_TYPE: System type configuration (code 06).
+    """
+
+    LINK_NUMBER = "04"
+    MODULE_NUMBER = "05"
+    SYSTEM_TYPE = "06"  # 00 CP, 01 XP, 02 MIXED
+
+    @classmethod
+    def from_code(cls, code: str) -> Optional["WriteConfigType"]:
+        """Get WriteConfigType from code string.
+
+        Args:
+            code: Configuration type code string.
+
+        Returns:
+            WriteConfigType instance if found, None otherwise.
+        """
+        for dp_type in cls:
+            if dp_type.value == code:
+                return dp_type
+        return None

xp/services/__init__.py

@@ -0,0 +1,26 @@
+"""Service layer for XP CLI tool."""
+
+from xp.services.log_file_service import LogFileParsingError, LogFileService
+from xp.services.module_type_service import ModuleTypeNotFoundError, ModuleTypeService
+from xp.services.telegram.telegram_discover_service import (
+    DiscoverError,
+    TelegramDiscoverService,
+)
+from xp.services.telegram.telegram_link_number_service import (
+    LinkNumberError,
+    LinkNumberService,
+)
+from xp.services.telegram.telegram_service import TelegramParsingError, TelegramService
+
+__all__ = [
+    "TelegramService",
+    "TelegramParsingError",
+    "ModuleTypeService",
+    "ModuleTypeNotFoundError",
+    "LogFileService",
+    "LogFileParsingError",
+    "LinkNumberService",
+    "LinkNumberError",
+    "TelegramDiscoverService",
+    "DiscoverError",
+]

xp/services/actiontable/__init__.py

@@ -0,0 +1 @@
+"""Action table utils."""

xp/services/actiontable/actiontable_serializer.py

@@ -0,0 +1,273 @@
+"""Serializer for ActionTable telegram encoding/decoding."""
+
+import re
+
+from xp.models import ModuleTypeCode
+from xp.models.actiontable.actiontable import ActionTable, ActionTableEntry
+from xp.models.telegram.input_action_type import InputActionType
+from xp.models.telegram.timeparam_type import TimeParam
+from xp.utils.serialization import (
+    byte_to_unsigned,
+    de_bcd,
+    de_nibbles,
+    highest_bit_set,
+    lower3,
+    nibbles,
+    remove_highest_bit,
+    to_bcd,
+    upper5,
+)
+
+
+class ActionTableSerializer:
+    """Handles serialization/deserialization of ActionTable to/from telegrams.
+
+    Attributes:
+        MAX_ENTRIES: Maximum number of entries in an ActionTable (96).
+    """
+
+    MAX_ENTRIES = 96  # ActionTable must always contain exactly 96 entries
+
+    @staticmethod
+    def from_data(data: bytes) -> ActionTable:
+        """Deserialize telegram data to ActionTable.
+
+        Args:
+            data: Raw byte data from telegram
+
+        Returns:
+            Decoded ActionTable
+        """
+        entries = []
+
+        # Process data in 5-byte chunks
+        for i in range(0, len(data), 5):
+            if i + 4 >= len(data):
+                break
+
+            # Extract fields from 5-byte chunk
+            module_type_raw = de_bcd(data[i])
+            link_number = de_bcd(data[i + 1])
+            module_input = de_bcd(data[i + 2])
+
+            # Extract output and command from byte 3
+            module_output = lower3(data[i + 3])
+            command_raw = upper5(data[i + 3])
+
+            parameter_raw = byte_to_unsigned(data[i + 4])
+            parameter_raw = remove_highest_bit(parameter_raw)
+
+            inverted = False
+            if highest_bit_set(data[i + 4]):
+                inverted = True
+
+            # Map raw values to enum types
+            try:
+                module_type = ModuleTypeCode(module_type_raw)
+            except ValueError:
+                module_type = ModuleTypeCode.NOMOD  # Default fallback
+
+            try:
+                command = InputActionType(command_raw)
+            except ValueError:
+                command = InputActionType.OFF  # Default fallback
+
+            try:
+                parameter = TimeParam(parameter_raw)
+            except ValueError:
+                parameter = TimeParam.NONE  # Default fallback
+
+            if module_type != ModuleTypeCode.NOMOD:
+                entry = ActionTableEntry(
+                    module_type=module_type,
+                    link_number=link_number,
+                    module_input=module_input,
+                    module_output=module_output,
+                    command=command,
+                    parameter=parameter,
+                    inverted=inverted,
+                )
+                entries.append(entry)
+
+        return ActionTable(entries=entries)
+
+    @staticmethod
+    def to_data(action_table: ActionTable) -> bytes:
+        """Serialize ActionTable to telegram byte data.
+
+        Args:
+            action_table: ActionTable to serialize
+
+        Returns:
+            Raw byte data for telegram (always 480 bytes for 96 entries)
+        """
+        data = bytearray()
+
+        for entry in action_table.entries:
+            # Encode each entry as 5 bytes
+            type_byte = to_bcd(entry.module_type.value)
+            link_byte = to_bcd(entry.link_number)
+            input_byte = to_bcd(entry.module_input)
+
+            # Combine output (lower 3 bits) and command (upper 5 bits)
+            output_command_byte = (entry.module_output & 0x07) | (
+                (entry.command.value & 0x1F) << 3
+            )
+
+            parameter_byte = entry.parameter.value
+
+            data.extend(
+                [type_byte, link_byte, input_byte, output_command_byte, parameter_byte]
+            )
+
+        # Pad to 96 entries with default NOMOD entries (00 00 00 00 00)
+        current_entries = len(action_table.entries)
+        if current_entries < ActionTableSerializer.MAX_ENTRIES:
+            # Default entry: NOMOD 0 0 > 0 OFF (all zeros)
+            padding_bytes = [0x00, 0x00, 0x00, 0x00, 0x00]
+            for _ in range(ActionTableSerializer.MAX_ENTRIES - current_entries):
+                data.extend(padding_bytes)
+
+        return bytes(data)
+
+    @staticmethod
+    def to_encoded_string(action_table: ActionTable) -> str:
+        """Convert ActionTable to base64-encoded string format.
+
+        Args:
+            action_table: ActionTable to encode
+
+        Returns:
+            Base64-encoded string representation
+        """
+        data = ActionTableSerializer.to_data(action_table)
+        return nibbles(data)
+
+    @staticmethod
+    def from_encoded_string(encoded_data: str) -> ActionTable:
+        """Convert base64-encoded string to ActionTable.
+
+        Args:
+            encoded_data: Base64-encoded string
+
+        Returns:
+            Decoded ActionTable
+        """
+        data = de_nibbles(encoded_data)
+        return ActionTableSerializer.from_data(data)
+
+    @staticmethod
+    def format_decoded_output(action_table: ActionTable) -> list[str]:
+        """Format ActionTable as human-readable decoded output.
+
+        Args:
+            action_table: ActionTable to format
+
+        Returns:
+            List of human-readable string representations
+        """
+        lines = []
+        for entry in action_table.entries:
+            # Format: CP20 0 0 > 1 OFF [param];
+            module_type = entry.module_type.name
+            link = entry.link_number
+            input_num = entry.module_input
+            output = entry.module_output
+            command = entry.command.name
+
+            # Add prefix for inverted commands
+            if entry.inverted:
+                command = f"~{command}"
+
+            # Build base line
+            line = f"{module_type} {link} {input_num} > {output} {command}"
+
+            # Add parameter if present and non-zero
+            if entry.parameter is not None and entry.parameter.value != 0:
+                line += f" {entry.parameter.value}"
+
+            # Add semicolon terminator
+            line += ";"
+
+            lines.append(line)
+
+        return lines
+
+    @staticmethod
+    def parse_action_string(action_str: str) -> ActionTableEntry:
+        """Parse action table entry from string format.
+
+        Args:
+            action_str: String in format "CP20 0 0 > 1 OFF" or "CP20 0 1 > 1 ~ON"
+
+        Returns:
+            Parsed ActionTableEntry
+
+        Raises:
+            ValueError: If string format is invalid
+        """
+        # Remove trailing semicolon if present
+        action_str = action_str.strip().rstrip(";")
+
+        # Pattern: <Type> <Link> <Input> > <Output> <Command> [Parameter]
+        pattern = r"^(\w+)\s+(\d+)\s+(\d+)\s+>\s+(\d+)\s+(~?)(\w+)(?:\s+(\d+))?$"
+        match = re.match(pattern, action_str)
+
+        if not match:
+            raise ValueError(f"Invalid action table format: {action_str}")
+
+        (
+            module_type_str,
+            link_str,
+            input_str,
+            output_str,
+            inverted_str,
+            command_str,
+            parameter_str,
+        ) = match.groups()
+
+        # Parse module type
+        try:
+            module_type = ModuleTypeCode[module_type_str]
+        except KeyError:
+            raise ValueError(f"Invalid module type: {module_type_str}")
+
+        # Parse command
+        try:
+            command = InputActionType[command_str]
+        except KeyError:
+            raise ValueError(f"Invalid command: {command_str}")
+
+        # Parse parameter (default to NONE)
+        parameter = TimeParam.NONE
+        if parameter_str:
+            try:
+                parameter = TimeParam(int(parameter_str))
+            except ValueError:
+                raise ValueError(f"Invalid parameter: {parameter_str}")
+
+        return ActionTableEntry(
+            module_type=module_type,
+            link_number=int(link_str),
+            module_input=int(input_str),
+            module_output=int(output_str),
+            command=command,
+            parameter=parameter,
+            inverted=bool(inverted_str),
+        )
+
+    @staticmethod
+    def parse_action_table(action_strings: list[str]) -> ActionTable:
+        """Parse action table from list of string entries.
+
+        Args:
+            action_strings: List of action strings from conson.yml
+
+        Returns:
+            Parsed ActionTable
+        """
+        entries = [
+            ActionTableSerializer.parse_action_string(action_str)
+            for action_str in action_strings
+        ]
+        return ActionTable(entries=entries)

xp/services/actiontable/msactiontable_serializer.py

@@ -0,0 +1,7 @@
+"""Generic MsActionTable serializer base class for type hints."""
+
+
+class MsActionTableSerializer:
+    """Serializer for ActionTable telegram encoding/decoding."""
+
+    pass

xp/services/actiontable/msactiontable_xp20_serializer.py

@@ -0,0 +1,169 @@
+"""Serializer for XP20 Action Table telegram encoding/decoding."""
+
+from xp.models.actiontable.msactiontable_xp20 import InputChannel, Xp20MsActionTable
+from xp.utils.serialization import byte_to_bits, de_nibbles, nibbles
+
+# Index constants for clarity in implementation
+SHORT_LONG_INDEX: int = 0
+GROUP_ON_OFF_INDEX: int = 1
+INVERT_INDEX: int = 2
+AND_FUNCTIONS_INDEX: int = 3  # starts at 3, uses indices 3-10
+SA_FUNCTION_INDEX: int = 11
+TA_FUNCTION_INDEX: int = 12
+
+
+class Xp20MsActionTableSerializer:
+    """Handles serialization/deserialization of XP20 action tables to/from telegrams."""
+
+    @staticmethod
+    def to_data(action_table: Xp20MsActionTable) -> str:
+        """Serialize XP20 action table to telegram hex string format.
+
+        Args:
+            action_table: XP20 action table to serialize
+
+        Returns:
+            64-character hex string (32 bytes) with A-P nibble encoding
+        """
+        # Initialize 32-byte raw data array
+        raw_bytes = bytearray(32)
+
+        # Get all input channels
+        input_channels = [
+            action_table.input1,
+            action_table.input2,
+            action_table.input3,
+            action_table.input4,
+            action_table.input5,
+            action_table.input6,
+            action_table.input7,
+            action_table.input8,
+        ]
+
+        # Encode each input channel
+        for input_index, input_channel in enumerate(input_channels):
+            Xp20MsActionTableSerializer._encode_input_channel(
+                input_channel, input_index, raw_bytes
+            )
+
+        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) -> Xp20MsActionTable:
+        """Deserialize telegram data to XP20 action table.
+
+        Args:
+            msactiontable_rawdata: 64-character hex string with A-P encoding
+
+        Returns:
+            Decoded XP20 action table
+
+        Raises:
+            ValueError: If input length is not 64 characters
+        """
+        raw_length = len(msactiontable_rawdata)
+        if raw_length < 68:  # Minimum: 4 char prefix + 64 chars data
+            raise ValueError(
+                f"XP20 action table data must be 68 characters long, got {len(msactiontable_rawdata)}"
+            )
+
+        # 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 input channels
+        input_channels = []
+        for input_index in range(8):
+            input_channel = Xp20MsActionTableSerializer._decode_input_channel(
+                raw_bytes, input_index
+            )
+            input_channels.append(input_channel)
+
+        # Create and return XP20 action table
+        return Xp20MsActionTable(
+            input1=input_channels[0],
+            input2=input_channels[1],
+            input3=input_channels[2],
+            input4=input_channels[3],
+            input5=input_channels[4],
+            input6=input_channels[5],
+            input7=input_channels[6],
+            input8=input_channels[7],
+        )
+
+    @staticmethod
+    def _decode_input_channel(raw_bytes: bytearray, input_index: int) -> InputChannel:
+        """Extract input channel configuration from raw bytes.
+
+        Args:
+            raw_bytes: Raw byte array from telegram
+            input_index: Input channel index (0-7)
+
+        Returns:
+            Decoded input channel configuration
+        """
+        # Extract bit flags from appropriate offsets
+        short_long_flags = byte_to_bits(raw_bytes[SHORT_LONG_INDEX])
+        group_on_off_flags = byte_to_bits(raw_bytes[GROUP_ON_OFF_INDEX])
+        invert_flags = byte_to_bits(raw_bytes[INVERT_INDEX])
+        sa_function_flags = byte_to_bits(raw_bytes[SA_FUNCTION_INDEX])
+        ta_function_flags = byte_to_bits(raw_bytes[TA_FUNCTION_INDEX])
+
+        # Extract AND functions for this input (full byte)
+        and_functions_byte = raw_bytes[AND_FUNCTIONS_INDEX + input_index]
+        and_functions = byte_to_bits(and_functions_byte)
+
+        # Create and return input channel
+        return InputChannel(
+            invert=invert_flags[input_index],
+            short_long=short_long_flags[input_index],
+            group_on_off=group_on_off_flags[input_index],
+            and_functions=and_functions,
+            sa_function=sa_function_flags[input_index],
+            ta_function=ta_function_flags[input_index],
+        )
+
+    @staticmethod
+    def _encode_input_channel(
+        input_channel: InputChannel, input_index: int, raw_bytes: bytearray
+    ) -> None:
+        """Encode input channel configuration into raw bytes.
+
+        Args:
+            input_channel: Input channel configuration to encode
+            input_index: Input channel index (0-7)
+            raw_bytes: Raw byte array to modify
+        """
+        # Set bit flags at appropriate positions
+        if input_channel.short_long:
+            raw_bytes[SHORT_LONG_INDEX] |= 1 << input_index
+
+        if input_channel.group_on_off:
+            raw_bytes[GROUP_ON_OFF_INDEX] |= 1 << input_index
+
+        if input_channel.invert:
+            raw_bytes[INVERT_INDEX] |= 1 << input_index
+
+        if input_channel.sa_function:
+            raw_bytes[SA_FUNCTION_INDEX] |= 1 << input_index
+
+        if input_channel.ta_function:
+            raw_bytes[TA_FUNCTION_INDEX] |= 1 << input_index
+
+        # Encode AND functions (ensure we have exactly 8 bits)
+        and_functions = input_channel.and_functions or [False] * 8
+        and_functions_byte = 0
+        for bit_index, bit_value in enumerate(
+            and_functions[:8]
+        ):  # Take only first 8 bits
+            if bit_value:
+                and_functions_byte |= 1 << bit_index
+
+        raw_bytes[AND_FUNCTIONS_INDEX + input_index] = and_functions_byte

xp/services/actiontable/msactiontable_xp24_serializer.py

@@ -0,0 +1,120 @@
+"""Serializer for XP24 Action Table telegram encoding/decoding."""
+
+from xp.models.actiontable.msactiontable_xp24 import InputAction, Xp24MsActionTable
+from xp.models.telegram.input_action_type import InputActionType
+from xp.models.telegram.timeparam_type import TimeParam
+from xp.utils.serialization import de_nibbles, nibbles
+
+
+class Xp24MsActionTableSerializer:
+    """Handles serialization/deserialization of XP24 action tables to/from telegrams."""
+
+    @staticmethod
+    def to_data(action_table: Xp24MsActionTable) -> str:
+        """Serialize action table to telegram format.
+
+        Args:
+            action_table: XP24 MS action table to serialize.
+
+        Returns:
+            Serialized action table data string (68 characters).
+        """
+        # Build byte array for the action table (32 bytes total)
+        raw_bytes = bytearray()
+
+        # Encode all 4 input actions (2 bytes each = 8 bytes total)
+        input_actions = [
+            action_table.input1_action,
+            action_table.input2_action,
+            action_table.input3_action,
+            action_table.input4_action,
+        ]
+
+        for action in input_actions:
+            raw_bytes.append(action.type.value)
+            raw_bytes.append(action.param.value)
+
+        # Add settings (5 bytes)
+        raw_bytes.append(0x01 if action_table.mutex12 else 0x00)
+        raw_bytes.append(0x01 if action_table.mutex34 else 0x00)
+        raw_bytes.append(action_table.mutual_deadtime)
+        raw_bytes.append(0x01 if action_table.curtain12 else 0x00)
+        raw_bytes.append(0x01 if action_table.curtain34 else 0x00)
+
+        # Add padding to reach 32 bytes (19 more bytes needed)
+        raw_bytes.extend([0x00] * 19)
+
+        # Encode to A-P nibbles (32 bytes -> 64 chars)
+        encoded_data = nibbles(bytes(raw_bytes))
+
+        # Prepend action table count "AAAA" (4 chars) -> total 68 chars
+        return "AAAA" + encoded_data
+
+    @staticmethod
+    def from_data(msactiontable_rawdata: str) -> Xp24MsActionTable:
+        """Deserialize action table from raw data parts.
+
+        Args:
+            msactiontable_rawdata: Raw action table data string.
+
+        Returns:
+            Deserialized XP24 MS action table.
+
+        Raises:
+            ValueError: If data length is not 68 bytes.
+        """
+        raw_length = len(msactiontable_rawdata)
+        if raw_length != 68:
+            raise ValueError(
+                f"Msactiontable is not 68 bytes long ({raw_length}): {msactiontable_rawdata}"
+            )
+
+        # Remove action table count AAAA, AAAB .
+        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 input actions from positions 0-3 (2 bytes each)
+        input_actions = []
+        for pos in range(4):
+            input_action = Xp24MsActionTableSerializer._decode_input_action(
+                raw_bytes, pos
+            )
+            input_actions.append(input_action)
+
+        action_table = Xp24MsActionTable(
+            input1_action=input_actions[0],
+            input2_action=input_actions[1],
+            input3_action=input_actions[2],
+            input4_action=input_actions[3],
+            mutex12=raw_bytes[8] != 0,  # With A-P encoding: AA=0 (False), AB=1 (True)
+            mutex34=raw_bytes[9] != 0,
+            mutual_deadtime=raw_bytes[10],
+            curtain12=raw_bytes[11] != 0,
+            curtain34=raw_bytes[12] != 0,
+        )
+        return action_table
+
+    @staticmethod
+    def _decode_input_action(raw_bytes: bytearray, pos: int) -> InputAction:
+        """Decode input action from raw bytes.
+
+        Args:
+            raw_bytes: Raw byte array containing action data.
+            pos: Position of the action to decode.
+
+        Returns:
+            Decoded input action.
+        """
+        function_id = raw_bytes[2 * pos]
+        param_id = raw_bytes[2 * pos + 1]
+
+        # Convert function ID to InputActionType
+        action_type = InputActionType(function_id)
+        param_type = TimeParam(param_id)
+
+        return InputAction(action_type, param_type)