conson-xp 1.6.0__tar.gz → 1.8.0__tar.gz

{conson_xp-1.6.0 → conson_xp-1.8.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: conson-xp
-Version: 1.6.0
+Version: 1.8.0
 Summary: XP Protocol Communication Tools
 Author-Email: ldvchosal <ldvchosal@github.com>
 License: MIT License

{conson_xp-1.6.0 → conson_xp-1.8.0}/pyproject.toml

@@ -20,7 +20,7 @@ dependencies = [
 ]
 requires-python = ">=3.11"
 readme = "README.md"
-version = "1.6.0"
+version = "1.8.0"
 
 [project.license]
 file = "LICENSE"

{conson_xp-1.6.0 → conson_xp-1.8.0}/src/xp/__init__.py

@@ -3,7 +3,7 @@
 conson-xp package.
 """
 
-__version__ = "1.6.0"
+__version__ = "1.8.0"
 __manufacturer__ = "salchichon"
 __model__ = "xp.cli"
 __serial__ = "2025.09.23.000"

{conson_xp-1.6.0 → conson_xp-1.8.0}/src/xp/cli/commands/conbus/conbus_msactiontable_commands.py

@@ -49,13 +49,22 @@ def conbus_download_msactiontable(
         click.echo(progress, nl=False)
 
     def on_finish(
-        action_table: Union[Xp20MsActionTable | Xp24MsActionTable | Xp33MsActionTable],
+        action_table: Union[
+            Xp20MsActionTable, Xp24MsActionTable, Xp33MsActionTable, None
+        ],
     ) -> None:
         """Handle successful completion of MS action table download.
 
         Args:
-            action_table: Downloaded MS action table object.
+            action_table: Downloaded MS action table object or None if failed.
+
+        Raises:
+            Abort: If action table download failed.
         """
+        if action_table is None:
+            click.echo("Error: Failed to download MS action table")
+            raise click.Abort()
+
         output = {
             "serial_number": serial_number,
             "xpmoduletype": xpmoduletype,

{conson_xp-1.6.0 → conson_xp-1.8.0}/src/xp/models/telegram/input_action_type.py

@@ -1,9 +1,9 @@
 """Input action types for XP24 module based on Feature-Action-Table.md."""
 
-from enum import IntEnum
+from enum import Enum
 
 
-class InputActionType(IntEnum):
+class InputActionType(Enum):
     """Input action types for XP24 module (based on Feature-Action-Table.md).
 
     Attributes:

{conson_xp-1.6.0 → conson_xp-1.8.0}/src/xp/services/actiontable/msactiontable_xp20_serializer.py

@@ -46,8 +46,9 @@ class Xp20MsActionTableSerializer:
                 input_channel, input_index, raw_bytes
             )
 
+        encoded_data = nibbles(raw_bytes)
         # Convert raw bytes to hex string with A-P encoding
-        return nibbles(raw_bytes)
+        return "AAAA" + encoded_data
 
     @staticmethod
     def from_data(msactiontable_rawdata: str) -> Xp20MsActionTable:
@@ -62,13 +63,20 @@ class Xp20MsActionTableSerializer:
         Raises:
             ValueError: If input length is not 64 characters
         """
-        if len(msactiontable_rawdata) != 64:
+        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 64 characters long, got {len(msactiontable_rawdata)}"
+                f"XP20 action table data must be 68 characters long, got {len(msactiontable_rawdata)}"
             )
 
-        # Convert hex string to bytes using de_nibble (A-P encoding)
-        raw_bytes = de_nibbles(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 = []
@@ -159,23 +167,3 @@ class Xp20MsActionTableSerializer:
                 and_functions_byte |= 1 << bit_index
 
         raw_bytes[AND_FUNCTIONS_INDEX + input_index] = and_functions_byte
-
-    @staticmethod
-    def from_telegrams(ms_telegrams: str) -> Xp20MsActionTable:
-        """Legacy method for backward compatibility. Use from_data() instead.
-
-        Args:
-            ms_telegrams: Full telegram string
-
-        Returns:
-            Decoded XP20 action table
-        """
-        # Extract data portion from telegram (skip header, take action table data)
-        # Based on XP24 pattern: telegram[16:84] gives us the 68-char data portion
-        # For XP20, we need 64 chars, so we take the first 64 chars after removing count
-        data_parts = ms_telegrams[16:84]
-
-        # Remove action table count (first 4 chars: AAAA, AAAB, etc.)
-        hex_data = data_parts[4:68]  # Take 64 chars after count
-
-        return Xp20MsActionTableSerializer.from_data(hex_data)

{conson_xp-1.6.0 → conson_xp-1.8.0}/src/xp/services/actiontable/msactiontable_xp24_serializer.py

@@ -3,7 +3,7 @@
 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
+from xp.utils.serialization import de_nibbles, nibbles
 
 
 class Xp24MsActionTableSerializer:
@@ -17,11 +17,12 @@ class Xp24MsActionTableSerializer:
             action_table: XP24 MS action table to serialize.
 
         Returns:
-            Serialized action table data string.
+            Serialized action table data string (68 characters).
         """
-        data_parts: list[str] = []
+        # Build byte array for the action table (32 bytes total)
+        raw_bytes = bytearray()
 
-        # Encode all 4 input actions
+        # Encode all 4 input actions (2 bytes each = 8 bytes total)
         input_actions = [
             action_table.input1_action,
             action_table.input2_action,
@@ -30,26 +31,24 @@ class Xp24MsActionTableSerializer:
         ]
 
         for action in input_actions:
-            # Use enum value directly as function ID
-            function_id = action.type.value
-            # Convert parameter to int (None becomes 0)
-            param_id = action.param.value
-            data_parts.append(f"{function_id:02X}{param_id:02X}")
-
-        # Add settings as hex values
-        data_parts.extend(
-            [
-                "AB" if action_table.mutex12 else "AA",
-                "AB" if action_table.mutex34 else "AA",
-                f"{action_table.mutual_deadtime:02X}",
-                "AB" if action_table.curtain12 else "AA",
-                "AB" if action_table.curtain34 else "AA",
-                "A" * 38,  # padding
-            ]
-        )
+            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))
 
-        data = "AAAA".join(data_parts)
-        return data
+        # Prepend action table count "AAAA" (4 chars) -> total 68 chars
+        return "AAAA" + encoded_data
 
     @staticmethod
     def from_data(msactiontable_rawdata: str) -> Xp24MsActionTable:
@@ -66,7 +65,9 @@ class Xp24MsActionTableSerializer:
         """
         raw_length = len(msactiontable_rawdata)
         if raw_length != 68:
-            raise ValueError(f"Msactiontable is not 68 bytes long ({raw_length})")
+            raise ValueError(
+                f"Msactiontable is not 68 bytes long ({raw_length}): {msactiontable_rawdata}"
+            )
 
         # Remove action table count AAAA, AAAB .
         data = msactiontable_rawdata[4:]
@@ -117,18 +118,3 @@ class Xp24MsActionTableSerializer:
         param_type = TimeParam(param_id)
 
         return InputAction(action_type, param_type)
-
-    @staticmethod
-    def from_telegrams(ms_telegrams: str) -> Xp24MsActionTable:
-        """Legacy method for backward compatibility. Use from_data() instead.
-
-        Args:
-            ms_telegrams: Telegram data string.
-
-        Returns:
-            Deserialized XP24 MS action table.
-        """
-        # For backward compatibility, assume full telegrams and extract data
-        data_parts = ms_telegrams[16:84]
-
-        return Xp24MsActionTableSerializer.from_data(data_parts)

{conson_xp-1.6.0 → conson_xp-1.8.0}/src/xp/services/actiontable/msactiontable_xp33_serializer.py

@@ -6,7 +6,7 @@ from xp.models.actiontable.msactiontable_xp33 import (
     Xp33Scene,
 )
 from xp.models.telegram.timeparam_type import TimeParam
-from xp.utils.serialization import bits_to_byte, byte_to_bits, de_nibbles, nibble
+from xp.utils.serialization import bits_to_byte, byte_to_bits, de_nibbles, nibbles
 
 
 class Xp33MsActionTableSerializer:
@@ -96,13 +96,11 @@ class Xp33MsActionTableSerializer:
         raw_bytes[24] = bits_to_byte(leading_edge_bits)
 
         # Bytes 25-31 are padding (already 0)
-
         # Convert to hex string using nibble encoding
-        hex_data = "AAAA"
-        for byte_val in raw_bytes:
-            hex_data += nibble(byte_val)
+        encoded_data = nibbles(raw_bytes)
 
-        return hex_data
+        # Convert raw bytes to hex string with A-P encoding
+        return "AAAA" + encoded_data
 
     @staticmethod
     def from_data(msactiontable_rawdata: str) -> Xp33MsActionTable:
@@ -239,18 +237,3 @@ class Xp33MsActionTableSerializer:
             output3_level=output3_level,
             time=time_param,
         )
-
-    @staticmethod
-    def from_telegrams(ms_telegrams: str) -> Xp33MsActionTable:
-        """Legacy method for backward compatibility. Use from_data() instead.
-
-        Args:
-            ms_telegrams: Telegram data string.
-
-        Returns:
-            Deserialized XP33 MS action table.
-        """
-        # For backward compatibility, assume full telegrams and extract data
-        data_parts = ms_telegrams[16:152]  # Adjusted for XP33 length
-
-        return Xp33MsActionTableSerializer.from_data(data_parts)

{conson_xp-1.6.0 → conson_xp-1.8.0}/src/xp/services/conbus/actiontable/actiontable_service.py

@@ -51,7 +51,9 @@ class ActionTableService(ConbusProtocol):
 
     def connection_established(self) -> None:
         """Handle connection established event."""
-        self.logger.debug("Connection established, sending discover telegram")
+        self.logger.debug(
+            "Connection established, sending download actiontable telegram"
+        )
         self.send_telegram(
             telegram_type=TelegramType.SYSTEM,
             serial_number=self.serial_number,
@@ -82,7 +84,9 @@ class ActionTableService(ConbusProtocol):
             self.logger.debug("Not a reply response")
             return
 
-        reply_telegram = self.telegram_service.parse_reply_telegram(telegram_received)
+        reply_telegram = self.telegram_service.parse_reply_telegram(
+            telegram_received.frame
+        )
         if reply_telegram.system_function not in (
             SystemFunction.ACTIONTABLE,
             SystemFunction.EOF,

{conson_xp-1.6.0 → conson_xp-1.8.0}/src/xp/services/conbus/actiontable/msactiontable_service.py

@@ -74,7 +74,8 @@ class MsActionTableService(ConbusProtocol):
         self.error_callback: Optional[Callable[[str], None]] = None
         self.finish_callback: Optional[
             Callable[
-                [Union[Xp20MsActionTable, Xp24MsActionTable, Xp33MsActionTable]], None
+                [Union[Xp20MsActionTable, Xp24MsActionTable, Xp33MsActionTable, None]],
+                None,
             ]
         ] = None
         self.msactiontable_data: list[str] = []
@@ -83,7 +84,9 @@ class MsActionTableService(ConbusProtocol):
 
     def connection_established(self) -> None:
         """Handle connection established event."""
-        self.logger.debug("Connection established, sending discover telegram")
+        self.logger.debug(
+            "Connection established, sending download msactiontable telegram"
+        )
         self.send_telegram(
             telegram_type=TelegramType.SYSTEM,
             serial_number=self.serial_number,
@@ -114,17 +117,32 @@ class MsActionTableService(ConbusProtocol):
             self.logger.debug("Not a reply response")
             return
 
-        reply_telegram = self.telegram_service.parse_reply_telegram(telegram_received)
+        reply_telegram = self.telegram_service.parse_reply_telegram(
+            telegram_received.frame
+        )
         if reply_telegram.system_function not in (
             SystemFunction.MSACTIONTABLE,
+            SystemFunction.ACK,
+            SystemFunction.NAK,
             SystemFunction.EOF,
         ):
             self.logger.debug("Not a msactiontable response")
             return
 
-        if reply_telegram.system_function == SystemFunction.ACTIONTABLE:
-            self.logger.debug("Saving msactiontable response")
-            self.msactiontable_data.append(reply_telegram.data_value)
+        if reply_telegram.system_function == SystemFunction.ACK:
+            self.logger.debug("Received ACK")
+            return
+
+        if reply_telegram.system_function == SystemFunction.NAK:
+            self.logger.debug("Received NAK")
+            self.failed("Received NAK")
+            return
+
+        if reply_telegram.system_function == SystemFunction.MSACTIONTABLE:
+            self.logger.debug("Received MSACTIONTABLE")
+            self.msactiontable_data.extend(
+                (reply_telegram.data, reply_telegram.data_value)
+            )
             if self.progress_callback:
                 self.progress_callback(".")
 
@@ -137,11 +155,14 @@ class MsActionTableService(ConbusProtocol):
             return
 
         if reply_telegram.system_function == SystemFunction.EOF:
+            self.logger.debug("Received EOF")
             all_data = "".join(self.msactiontable_data)
             # Deserialize from received data
             msactiontable = self.serializer.from_data(all_data)
-            if self.finish_callback:
-                self.finish_callback(msactiontable)
+            self.succeed(msactiontable)
+            return
+
+        self.logger.debug("Invalid msactiontable response")
 
     def failed(self, message: str) -> None:
         """Handle failed connection event.
@@ -152,6 +173,20 @@ class MsActionTableService(ConbusProtocol):
         self.logger.debug(f"Failed: {message}")
         if self.error_callback:
             self.error_callback(message)
+        self._stop_reactor()
+
+    def succeed(
+        self,
+        msactiontable: Union[Xp20MsActionTable, Xp24MsActionTable, Xp33MsActionTable],
+    ) -> None:
+        """Handle succeed connection event.
+
+        Args:
+            msactiontable: result.
+        """
+        if self.finish_callback:
+            self.finish_callback(msactiontable)
+        self._stop_reactor()
 
     def start(
         self,
@@ -160,7 +195,7 @@ class MsActionTableService(ConbusProtocol):
         progress_callback: Callable[[str], None],
         error_callback: Callable[[str], None],
         finish_callback: Callable[
-            [Union[Xp20MsActionTable, Xp24MsActionTable, Xp33MsActionTable]], None
+            [Union[Xp20MsActionTable, Xp24MsActionTable, Xp33MsActionTable, None]], None
         ],
         timeout_seconds: Optional[float] = None,
     ) -> None:

{conson_xp-1.6.0 → conson_xp-1.8.0}/src/xp/services/protocol/conbus_protocol.py

@@ -230,13 +230,11 @@ class ConbusProtocol(protocol.Protocol, protocol.ClientFactory):
         self.timeout_call = self.reactor.callLater(
             self.timeout_seconds, self._on_timeout
         )
-        self.logger.debug(f"Timeout set for {self.timeout_seconds} seconds")
 
     def _cancel_timeout(self) -> None:
         """Cancel the inactivity timeout."""
         if self.timeout_call and self.timeout_call.active():
             self.timeout_call.cancel()
-            self.logger.debug("Timeout cancelled")
 
     def _on_timeout(self) -> None:
         """Handle inactivity timeout expiration."""

{conson_xp-1.6.0 → conson_xp-1.8.0}/src/xp/services/server/base_server_service.py

@@ -185,15 +185,25 @@ class BaseServerService(ABC):
         Returns:
             ACK telegram if request is valid, NAK otherwise.
         """
-        if (
-            request.system_function == SystemFunction.DOWNLOAD_MSACTIONTABLE
-            and self.msactiontable_download_state is None
-        ):
-            self.msactiontable_download_state = "ack_sent"
-            # Send ACK and queue data telegram
-            return self._build_response_telegram(f"R{self.serial_number}F18D")  # ACK
+        serializer = self._get_msactiontable_serializer()
+        msactiontable = self._get_msactiontable()
 
-        return self._build_response_telegram(f"R{self.serial_number}F19D")  # NAK
+        # Only handle if serializer and msactiontable are available
+        if not serializer or msactiontable is None:
+            return None
+
+        # Send ACK and queue data telegram
+        ack_data = self._build_response_telegram(f"R{self.serial_number}F18D")  # ACK
+
+        # Send MsActionTable data
+        encoded_data = serializer.to_data(msactiontable)
+        data_telegram = self._build_response_telegram(
+            f"R{self.serial_number}F17D{encoded_data}"
+        )
+        self.msactiontable_download_state = "data_sent"
+
+        # Return ACK and TABLE
+        return ack_data + data_telegram
 
     def _handle_download_msactiontable_ack_request(
         self, _request: SystemTelegram
@@ -206,24 +216,7 @@ class BaseServerService(ABC):
         Returns:
             Data telegram, EOF telegram, or NAK if state is invalid.
         """
-        serializer = self._get_msactiontable_serializer()
-        msactiontable = self._get_msactiontable()
-
-        # Only handle if serializer and msactiontable are available
-        if not serializer or msactiontable is None:
-            return None
-
-        # Handle F18D - CONTINUE (after ACK or data)
-        if self.msactiontable_download_state == "ack_sent":
-            # Send MsActionTable data
-            encoded_data = serializer.to_data(msactiontable)
-            data_telegram = self._build_response_telegram(
-                f"R{self.serial_number}F17D{encoded_data}"
-            )
-            self.msactiontable_download_state = "data_sent"
-            return data_telegram
-
-        elif self.msactiontable_download_state == "data_sent":
+        if self.msactiontable_download_state == "data_sent":
             # Send EOF
             eof_telegram = self._build_response_telegram(f"R{self.serial_number}F16D")
             self.msactiontable_download_state = None
@@ -367,11 +360,7 @@ class BaseServerService(ABC):
         Returns:
             List of telegram strings from the buffer. The buffer is cleared after collection.
         """
-        self.logger.debug(
-            f"Collecting {self.serial_number} telegrams from buffer: {len(self.telegram_buffer)}"
-        )
         with self.telegram_buffer_lock:
             result = self.telegram_buffer.copy()
-            self.logger.debug(f"Resetting {self.serial_number} buffer")
             self.telegram_buffer.clear()
             return result

{conson_xp-1.6.0 → conson_xp-1.8.0}/src/xp/services/server/server_service.py

@@ -209,14 +209,11 @@ class ServerService:
                     self.logger.debug(f"Sent buffer to {client_address}")
 
                 # Receive data from client
-                self.logger.debug(f"Receiving data {client_address}")
                 data = None
                 try:
                     data = client_socket.recv(1024)
                 except socket.timeout:
-                    self.logger.debug(
-                        f"Timeout receiving data {client_address} ({timeout})"
-                    )
+                    pass
                 finally:
                     timeout -= 1
 
@@ -421,9 +418,6 @@ class ServerService:
         self.logger.info("Collector thread starting")
 
         while True:
-            self.logger.debug(
-                f"Collector thread collecting ({len(self.collector_buffer)})"
-            )
             collected = 0
             for device_service in self.device_services.values():
                 telegram_buffer = device_service.collect_telegram_buffer()
@@ -431,5 +425,4 @@ class ServerService:
                 collected += len(telegram_buffer)
 
             # Wait a bit before checking again
-            self.logger.debug(f"Collector thread collected ({collected})")
             self.collector_stop_event.wait(timeout=1)

{conson_xp-1.6.0 → conson_xp-1.8.0}/src/xp/services/telegram/telegram_service.py

@@ -3,6 +3,7 @@
 This module provides telegram parsing functionality for event, system, and reply telegrams.
 """
 
+import logging
 import re
 from typing import Union
 
@@ -48,7 +49,8 @@ class TelegramService:
 
     def __init__(self) -> None:
         """Initialize the telegram service."""
-        pass
+        # Set up logging
+        self.logger = logging.getLogger(__name__)
 
     def parse_event_telegram(self, raw_telegram: str) -> EventTelegram:
         """Parse a raw telegram string into an EventTelegram object.
@@ -242,6 +244,7 @@ class TelegramService:
             raise TelegramParsingError("Empty telegram string")
 
         # Validate and parse using regex
+        self.logger.debug(f"Parsing reply telegram {raw_telegram}")
         match = self.REPLY_TELEGRAM_PATTERN.match(raw_telegram.strip())
         if not match:
             raise TelegramParsingError(f"Invalid reply telegram format: {raw_telegram}")

{conson_xp-1.6.0 → conson_xp-1.8.0}/src/xp/utils/dependencies.py

@@ -326,6 +326,12 @@ class ServiceContainer:
         # Module type services layer
         self.container.register(ModuleTypeService, scope=punq.Scope.singleton)
 
+        # MsActionTable serializers
+        self.container.register(MsActionTableSerializer, scope=punq.Scope.singleton)
+        self.container.register(Xp20MsActionTableSerializer, scope=punq.Scope.singleton)
+        self.container.register(Xp24MsActionTableSerializer, scope=punq.Scope.singleton)
+        self.container.register(Xp33MsActionTableSerializer, scope=punq.Scope.singleton)
+
         # Device service factory
         self.container.register(
             DeviceServiceFactory,

{conson_xp-1.6.0 → conson_xp-1.8.0}/tests/integration/test_xp20_action_table_integration.py

@@ -33,16 +33,8 @@ class TestXp20ActionTableIntegration:
         # Serialize it
         serialized = Xp20MsActionTableSerializer.to_data(action_table)
 
-        # Create mock telegram data
-        mock_telegram = (
-            "0123456789ABCDEF"  # 16 chars header
-            "AAAA"
-            + serialized  # 4 chars count + 64 chars data
-            + "PADDING"  # Additional padding
-        )
-
-        # Test legacy from_telegrams method
-        result = Xp20MsActionTableSerializer.from_telegrams(mock_telegram)
+        # Deserialize from data
+        result = Xp20MsActionTableSerializer.from_data(serialized)
 
         # Verify the round-trip worked
         assert result.input1.invert == action_table.input1.invert
@@ -166,7 +158,7 @@ class TestXp20ActionTableIntegration:
     def test_specification_compliance(self):
         """Test compliance with the specification example."""
         spec_example = (
-            "AAAAAAAAAAABACAEAIBACAEAIAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA"
+            "AAAAAAAAAAAAAAABACAEAIBACAEAIAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA"
         )
 
         # Should decode without errors
@@ -177,7 +169,7 @@ class TestXp20ActionTableIntegration:
 
         # Test that we can re-encode it
         re_encoded = Xp20MsActionTableSerializer.to_data(result)
-        assert len(re_encoded) == 64
+        assert len(re_encoded) == 68
 
         # Round-trip should work
         final_result = Xp20MsActionTableSerializer.from_data(re_encoded)

{conson_xp-1.6.0 → conson_xp-1.8.0}/tests/integration/test_xp24_action_table_integration.py

@@ -92,9 +92,9 @@ class TestXp24ActionTableIntegration:
 
         # Verify action table structure
         action_table = output["action_table"]
-        assert action_table["input1_action"]["type"] == InputActionType.TOGGLE.value
+        assert action_table["input1_action"]["type"] == str(InputActionType.TOGGLE)
         assert action_table["input1_action"]["param"] == TimeParam.NONE.value
-        assert action_table["input2_action"]["type"] == InputActionType.TURNON.value
+        assert action_table["input2_action"]["type"] == str(InputActionType.TURNON)
         assert action_table["input2_action"]["param"] == TimeParam.T5SEC.value
         assert action_table["mutex34"] is True
         assert action_table["curtain34"] is True