conson-xp 1.45.0__py3-none-any.whl → 1.47.0__py3-none-any.whl

xp/services/actiontable/msactiontable_xp24_serializer.py

@@ -2,28 +2,77 @@
 
 from xp.models.actiontable.msactiontable_xp24 import InputAction, Xp24MsActionTable
 from xp.models.telegram.input_action_type import InputActionType
+from xp.models.telegram.system_function import SystemFunction
 from xp.models.telegram.timeparam_type import TimeParam
+from xp.services.actiontable.serializer_protocol import ActionTableSerializerProtocol
 from xp.utils.serialization import de_nibbles, nibbles
 
 
-class Xp24MsActionTableSerializer:
+class Xp24MsActionTableSerializer(ActionTableSerializerProtocol):
     """Handles serialization/deserialization of XP24 action tables to/from telegrams."""
 
     @staticmethod
-    def format_decoded_output(action_table: Xp24MsActionTable) -> list[str]:
-        """Serialize XP24 action table to humane compact readable format.
+    def download_type() -> SystemFunction:
+        """
+        Get the download system function type.
+
+        Returns:
+            The download system function: DOWNLOAD_MSACTIONTABLE
+        """
+        return SystemFunction.DOWNLOAD_MSACTIONTABLE
+
+    @staticmethod
+    def from_encoded_string(encoded_data: str) -> Xp24MsActionTable:
+        """
+        Deserialize action table from raw data parts.
 
         Args:
-            action_table: XP24 action table to serialize
+            encoded_data: Raw action table data string.
 
         Returns:
-            Human-readable string describing XP24 action table
+            Deserialized XP24 MS action table.
+
+        Raises:
+            ValueError: If data length is not 68 bytes.
         """
-        return action_table.to_short_format()
+        raw_length = len(encoded_data)
+        if raw_length != 68:
+            raise ValueError(
+                f"Msactiontable is not 68 bytes long ({raw_length}): {encoded_data}"
+            )
+
+        # Remove action table count AAAA, AAAB .
+        stripped_data = encoded_data[4:]
+
+        # Take first 64 chars (32 bytes) as per pseudocode
+        hex_data = stripped_data[:64]
+
+        # Convert hex string to bytes using deNibble (A-P encoding)
+        data = 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(data, 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=data[8] != 0,  # With A-P encoding: AA=0 (False), AB=1 (True)
+            mutex34=data[9] != 0,
+            mutual_deadtime=data[10],
+            curtain12=data[11] != 0,
+            curtain34=data[12] != 0,
+        )
+        return action_table
 
     @staticmethod
-    def to_data(action_table: Xp24MsActionTable) -> str:
-        """Serialize action table to telegram format.
+    def to_encoded_string(action_table: Xp24MsActionTable) -> str:
+        """
+        Serialize action table to telegram format.
 
         Args:
             action_table: XP24 MS action table to serialize.
@@ -56,64 +105,40 @@ class Xp24MsActionTableSerializer:
         # 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))
-
+        # Build byte array for the action table (32 bytes total)
         # Prepend action table count "AAAA" (4 chars) -> total 68 chars
-        return "AAAA" + encoded_data
+        return "AAAA" + nibbles(raw_bytes)
 
     @staticmethod
-    def from_data(msactiontable_rawdata: str) -> Xp24MsActionTable:
-        """Deserialize action table from raw data parts.
+    def to_short_string(action_table: Xp24MsActionTable) -> list[str]:
+        """
+        Serialize XP24 action table to humane compact readable format.
 
         Args:
-            msactiontable_rawdata: Raw action table data string.
+            action_table: XP24 action table to serialize
 
         Returns:
-            Deserialized XP24 MS action table.
-
-        Raises:
-            ValueError: If data length is not 68 bytes.
+            Human-readable string describing XP24 action table
         """
-        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]
+        return action_table.to_short_format()
 
-        # Convert hex string to bytes using deNibble (A-P encoding)
-        raw_bytes = de_nibbles(hex_data)
+    @staticmethod
+    def from_short_string(action_strings: list[str]) -> Xp24MsActionTable:
+        """
+        Serialize XP24 action table to humane compact readable format.
 
-        # 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)
+        Args:
+            action_strings: XP24 action table to serialize
 
-        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
+        Returns:
+            Human-readable string describing XP24 action table
+        """
+        return Xp24MsActionTable.from_short_format(action_strings)
 
     @staticmethod
-    def _decode_input_action(raw_bytes: bytearray, pos: int) -> InputAction:
-        """Decode input action from raw bytes.
+    def _decode_input_action(raw_bytes: bytes, pos: int) -> InputAction:
+        """
+        Decode input action from raw bytes.
 
         Args:
             raw_bytes: Raw byte array containing action data.

xp/services/actiontable/msactiontable_xp33_serializer.py

@@ -5,16 +5,29 @@ from xp.models.actiontable.msactiontable_xp33 import (
     Xp33Output,
     Xp33Scene,
 )
+from xp.models.telegram.system_function import SystemFunction
 from xp.models.telegram.timeparam_type import TimeParam
+from xp.services.actiontable.serializer_protocol import ActionTableSerializerProtocol
 from xp.utils.serialization import bits_to_byte, byte_to_bits, de_nibbles, nibbles
 
 
-class Xp33MsActionTableSerializer:
+class Xp33MsActionTableSerializer(ActionTableSerializerProtocol):
     """Handles serialization/deserialization of XP33 action tables to/from telegrams."""
 
     @staticmethod
-    def format_decoded_output(action_table: Xp33MsActionTable) -> list[str]:
-        """Serialize XP33 action table to humane compact readable format.
+    def download_type() -> SystemFunction:
+        """
+        Get the download system function type.
+
+        Returns:
+            The download system function: DOWNLOAD_MSACTIONTABLE
+        """
+        return SystemFunction.DOWNLOAD_MSACTIONTABLE
+
+    @staticmethod
+    def to_short_string(action_table: Xp33MsActionTable) -> list[str]:
+        """
+        Serialize XP33 action table to humane compact readable format.
 
         Args:
             action_table: XP33 action table to serialize
@@ -24,6 +37,19 @@ class Xp33MsActionTableSerializer:
         """
         return action_table.to_short_format()
 
+    @staticmethod
+    def from_short_string(action_strings: list[str]) -> Xp33MsActionTable:
+        """
+        Serialize XP33 action table to humane compact readable format.
+
+        Args:
+            action_strings: XP33 action table to serialize
+
+        Returns:
+            Human-readable string describing XP33 action table
+        """
+        return Xp33MsActionTable.from_short_format(action_strings)
+
     @staticmethod
     def _percentage_to_byte(percentage: int) -> int:
         """Convert percentage (0-100) to byte value for telegram encoding."""
@@ -48,8 +74,9 @@ class Xp33MsActionTableSerializer:
             return TimeParam.NONE
 
     @staticmethod
-    def to_data(action_table: Xp33MsActionTable) -> str:
-        """Serialize action table to telegram format.
+    def to_encoded_string(action_table: Xp33MsActionTable) -> str:
+        """
+        Serialize action table to telegram format.
 
         Args:
             action_table: XP33 MS action table to serialize.
@@ -115,8 +142,9 @@ class Xp33MsActionTableSerializer:
         return "AAAA" + encoded_data
 
     @staticmethod
-    def from_data(msactiontable_rawdata: str) -> Xp33MsActionTable:
-        """Deserialize action table from raw data parts.
+    def from_encoded_string(msactiontable_rawdata: str) -> Xp33MsActionTable:
+        """
+        Deserialize action table from raw data parts.
 
         Args:
             msactiontable_rawdata: Raw action table data string.
@@ -165,7 +193,8 @@ class Xp33MsActionTableSerializer:
 
     @staticmethod
     def _decode_output(raw_bytes: bytearray, output_index: int) -> Xp33Output:
-        """Extract output configuration from raw bytes.
+        """
+        Extract output configuration from raw bytes.
 
         Args:
             raw_bytes: Raw byte array containing output data.
@@ -219,7 +248,8 @@ class Xp33MsActionTableSerializer:
 
     @staticmethod
     def _decode_scene(raw_bytes: bytearray, scene_index: int) -> Xp33Scene:
-        """Extract scene configuration from raw bytes.
+        """
+        Extract scene configuration from raw bytes.
 
         Args:
             raw_bytes: Raw byte array containing scene data.

xp/services/actiontable/serializer_protocol.py

@@ -0,0 +1,76 @@
+"""Protocol for action table serializers."""
+
+from typing import Any, Protocol
+
+from xp.models.telegram.system_function import SystemFunction
+
+
+class ActionTableSerializerProtocol(Protocol):
+    """
+    Protocol defining the interface for action table serializers.
+
+    All action table serializers (ActionTableSerializer, Xp20MsActionTableSerializer,
+    Xp24MsActionTableSerializer, Xp33MsActionTableSerializer) implement this protocol.
+    """
+
+    @staticmethod
+    def download_type() -> SystemFunction:
+        """
+        Get the download system function type.
+
+        Returns:
+            The download system function: DOWNLOAD_MSACTIONTABLE or DOWNLOAD_ACTIONTABLE
+        """
+        ...
+
+    @staticmethod
+    def from_encoded_string(encoded_data: str) -> Any:
+        """
+        Deserialize encoded telegram data to action table model.
+
+        Args:
+            encoded_data: Encoded string from telegram (A-P nibble encoding).
+
+        Returns:
+            Deserialized action table model.
+        """
+        ...
+
+    @staticmethod
+    def to_encoded_string(action_table: Any) -> str:
+        """
+        Serialize action table model to encoded telegram format.
+
+        Args:
+            action_table: Action table model to serialize.
+
+        Returns:
+            Encoded string for telegram transmission.
+        """
+        ...
+
+    @staticmethod
+    def from_short_string(action_strings: list[str]) -> Any:
+        """
+        Deserialize human-readable short format to action table model.
+
+        Args:
+            action_strings: List of short format strings.
+
+        Returns:
+            Deserialized action table model.
+        """
+        ...
+
+    @staticmethod
+    def to_short_string(action_table: Any) -> list[str]:
+        """
+        Serialize action table model to human-readable short format.
+
+        Args:
+            action_table: Action table model to serialize.
+
+        Returns:
+            List of human-readable short format strings.
+        """
+        ...