conson-xp 1.47.0__tar.gz → 1.49.0__tar.gz

{conson_xp-1.47.0 → conson_xp-1.49.0}/PKG-INFO

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

{conson_xp-1.47.0 → conson_xp-1.49.0}/pyproject.toml

@@ -23,7 +23,7 @@ dependencies = [
 ]
 requires-python = ">=3.11"
 readme = "README.md"
-version = "1.47.0"
+version = "1.49.0"
 
 [project.license]
 file = "LICENSE"

{conson_xp-1.47.0 → conson_xp-1.49.0}/src/xp/__init__.py

@@ -4,7 +4,7 @@ XP CLI tool for remote console bus operations.
 conson-xp package.
 """
 
-__version__ = "1.47.0"
+__version__ = "1.49.0"
 __manufacturer__ = "salchichon"
 __model__ = "xp.cli"
 __serial__ = "2025.09.23.000"

{conson_xp-1.47.0 → conson_xp-1.49.0}/src/xp/cli/commands/conbus/conbus_actiontable_commands.py

@@ -3,7 +3,6 @@
 import json
 from contextlib import suppress
 from pathlib import Path
-from typing import Any, Dict
 
 import click
 from click import Context
@@ -66,7 +65,6 @@ def conbus_download_actiontable(ctx: Context, serial_number: str) -> None:
 
     def on_actiontable_received(
         _actiontable: ActionTable,
-        actiontable_dict: Dict[str, Any],
         actiontable_short: list[str],
     ) -> None:
         """
@@ -74,13 +72,11 @@ def conbus_download_actiontable(ctx: Context, serial_number: str) -> None:
 
         Args:
             _actiontable: a list of ActionTableEntries.
-            actiontable_dict: action table in a dictionary.
             actiontable_short: short representation of action table.
         """
         output = {
             "serial_number": serial_number,
             "actiontable_short": actiontable_short,
-            "actiontable": actiontable_dict,
         }
         click.echo(json.dumps(output, indent=2, default=str))
 

{conson_xp-1.47.0 → conson_xp-1.49.0}/src/xp/models/protocol/conbus_protocol.py

@@ -13,7 +13,6 @@ from xp.models.telegram.datapoint_type import DataPointType
 
 if TYPE_CHECKING:
     from xp.services.protocol.conbus_event_protocol import ConbusEventProtocol
-    from xp.services.protocol.conbus_protocol import ConbusProtocol
     from xp.services.protocol.telegram_protocol import TelegramProtocol
 
 
@@ -266,7 +265,7 @@ class TelegramEvent(BaseEvent):
         checksum_valid: Checksum valid true or false.
     """
 
-    protocol: Union[TelegramProtocol, ConbusProtocol, ConbusEventProtocol] = Field(
+    protocol: Union[TelegramProtocol, ConbusEventProtocol] = Field(
         description="TelegramProtocol instance"
     )
     frame: str = Field(description="Frame <S0123450001F02D12FK>")

{conson_xp-1.47.0 → conson_xp-1.49.0}/src/xp/services/actiontable/msactiontable_xp20_serializer.py

@@ -42,17 +42,12 @@ class Xp20MsActionTableSerializer(ActionTableSerializerProtocol):
             ValueError: If input length is not 64 characters
         """
         raw_length = len(encoded_data)
-        if raw_length < 68:  # Minimum: 4 char prefix + 64 chars data
+        if raw_length < 64:  # Minimum: 4 char prefix + 64 chars data
             raise ValueError(
-                f"XP20 action table data must be 68 characters long, got {len(encoded_data)}"
+                f"XP20 action table data must be 64 characters long, got {len(encoded_data)}"
             )
 
-        # Remove action table count prefix (first 4 characters: AAAA, AAAB, etc.)
-        data = encoded_data[4:]
-
-        # Take first 64 chars (32 bytes) as per pseudocode
-        hex_data = data[:64]
-        raw_bytes = de_nibbles(hex_data)
+        raw_bytes = de_nibbles(encoded_data)
 
         # Decode input channels
         input_channels = []
@@ -108,7 +103,7 @@ class Xp20MsActionTableSerializer(ActionTableSerializerProtocol):
 
         encoded_data = nibbles(raw_bytes)
         # Convert raw bytes to hex string with A-P encoding
-        return "AAAA" + encoded_data
+        return encoded_data
 
     @staticmethod
     def to_short_string(action_table: Xp20MsActionTable) -> list[str]:

{conson_xp-1.47.0 → conson_xp-1.49.0}/src/xp/services/actiontable/msactiontable_xp24_serializer.py

@@ -36,19 +36,13 @@ class Xp24MsActionTableSerializer(ActionTableSerializerProtocol):
             ValueError: If data length is not 68 bytes.
         """
         raw_length = len(encoded_data)
-        if raw_length != 68:
+        if raw_length != 64:
             raise ValueError(
-                f"Msactiontable is not 68 bytes long ({raw_length}): {encoded_data}"
+                f"Msactiontable is not 64 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)
+        data = de_nibbles(encoded_data)
 
         # Decode input actions from positions 0-3 (2 bytes each)
         input_actions = []
@@ -78,7 +72,7 @@ class Xp24MsActionTableSerializer(ActionTableSerializerProtocol):
             action_table: XP24 MS action table to serialize.
 
         Returns:
-            Serialized action table data string (68 characters).
+            Serialized action table data string (64 characters).
         """
         # Build byte array for the action table (32 bytes total)
         raw_bytes = bytearray()
@@ -107,7 +101,7 @@ class Xp24MsActionTableSerializer(ActionTableSerializerProtocol):
 
         # Build byte array for the action table (32 bytes total)
         # Prepend action table count "AAAA" (4 chars) -> total 68 chars
-        return "AAAA" + nibbles(raw_bytes)
+        return nibbles(raw_bytes)
 
     @staticmethod
     def to_short_string(action_table: Xp24MsActionTable) -> list[str]:

{conson_xp-1.47.0 → conson_xp-1.49.0}/src/xp/services/actiontable/msactiontable_xp33_serializer.py

@@ -139,7 +139,7 @@ class Xp33MsActionTableSerializer(ActionTableSerializerProtocol):
         encoded_data = nibbles(raw_bytes)
 
         # Convert raw bytes to hex string with A-P encoding
-        return "AAAA" + encoded_data
+        return encoded_data
 
     @staticmethod
     def from_encoded_string(msactiontable_rawdata: str) -> Xp33MsActionTable:
@@ -153,22 +153,16 @@ class Xp33MsActionTableSerializer(ActionTableSerializerProtocol):
             Deserialized XP33 MS action table.
 
         Raises:
-            ValueError: If data length is less than 68 characters.
+            ValueError: If data length is less than 64 characters.
         """
         raw_length = len(msactiontable_rawdata)
-        if raw_length < 68:  # Minimum: 4 char prefix + 64 chars data
+        if raw_length < 64:  # Minimum: 4 char prefix + 64 chars data
             raise ValueError(
-                f"Msactiontable is too short ({raw_length}), minimum 68 characters required"
+                f"Msactiontable is too short ({raw_length}), minimum 64 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)
+        raw_bytes = de_nibbles(msactiontable_rawdata)
 
         # Decode outputs
         output1 = Xp33MsActionTableSerializer._decode_output(raw_bytes, 0)

{conson_xp-1.47.0 → conson_xp-1.49.0}/src/xp/services/conbus/actiontable/actiontable_download_service.py

@@ -51,7 +51,7 @@ class ActionTableDownloadService(DownloadStateMachine):
     Attributes:
         on_progress: Signal emitted with "." for each chunk received.
         on_error: Signal emitted with error message string.
-        on_actiontable_received: Signal emitted with (ActionTable, dict, list).
+        on_actiontable_received: Signal emitted with (ActionTable, list).
         on_finish: Signal emitted when download and cleanup completed.
 
     Example:
@@ -65,7 +65,7 @@ class ActionTableDownloadService(DownloadStateMachine):
     on_progress: Signal = Signal(str)
     on_error: Signal = Signal(str)
     on_finish: Signal = Signal()
-    on_actiontable_received: Signal = Signal(Any, dict[str, Any], list[str])
+    on_actiontable_received: Signal = Signal(Any, list[str])
 
     def __init__(
         self,
@@ -126,7 +126,10 @@ class ActionTableDownloadService(DownloadStateMachine):
     def on_enter_requesting(self) -> None:
         """Enter requesting state - send download request."""
         self.enter_download_phase()  # Sets phase to DOWNLOAD
-        self.conbus_protocol.send_download_request(serial_number=self.serial_number)
+        self.conbus_protocol.send_download_request(
+            serial_number=self.serial_number,
+            actiontable_type=self.serializer.download_type(),
+        )
         self.send_download()
 
     def on_enter_waiting_data(self) -> None:

{conson_xp-1.47.0 → conson_xp-1.49.0}/src/xp/services/conbus/conbus_discover_service.py

@@ -25,7 +25,7 @@ class ConbusDiscoverService:
     """
     Service for discovering modules on Conbus servers.
 
-    Uses ConbusProtocol to provide discovery functionality for finding
+    Uses ConbusEventProtocol to provide discovery functionality for finding
     modules connected to the Conbus network.
 
     Attributes:
@@ -45,7 +45,7 @@ class ConbusDiscoverService:
         Initialize the Conbus discover service.
 
         Args:
-            conbus_protocol: ConbusProtocol.
+            conbus_protocol: ConbusEventProtocol instance for communication.
         """
         self.conbus_protocol: ConbusEventProtocol = conbus_protocol
         self.conbus_protocol.on_connection_made.connect(self.connection_made)

{conson_xp-1.47.0 → conson_xp-1.49.0}/src/xp/services/conbus/msactiontable/msactiontable_upload_service.py

@@ -279,8 +279,8 @@ class MsActionTableUploadService:
             self.failed(f"Invalid msactiontable format: {e}")
             return
 
-        # Serialize to telegram data (68 characters: AAAA + 64 data chars)
-        self.upload_data = self.serializer.to_encoded_string(msactiontable)  # type: ignore[arg-type]
+        # Serialize to telegram data (64 characters: AAAA + 64 data chars)
+        self.upload_data = "AAAA" + self.serializer.to_encoded_string(msactiontable)  # type: ignore[arg-type]
 
         self.logger.debug(
             f"Upload data encoded: {len(self.upload_data)} chars (single chunk)"

{conson_xp-1.47.0 → conson_xp-1.49.0}/src/xp/services/protocol/__init__.py

@@ -8,12 +8,11 @@ from xp.models.protocol.conbus_protocol import (
     TelegramReceivedEvent,
 )
 from xp.services.protocol.conbus_event_protocol import ConbusEventProtocol
-from xp.services.protocol.conbus_protocol import ConbusProtocol
 from xp.services.protocol.telegram_protocol import TelegramProtocol
 
-__all__ = ["TelegramProtocol", "ConbusProtocol", "ConbusEventProtocol"]
+__all__ = ["TelegramProtocol", "ConbusEventProtocol"]
 
-# Rebuild models after TelegramProtocol and ConbusProtocol are imported to resolve forward references
+# Rebuild models after TelegramProtocol and ConbusEventProtocol are imported to resolve forward references
 ConnectionMadeEvent.model_rebuild()
 InvalidTelegramReceivedEvent.model_rebuild()
 ModuleDiscoveredEvent.model_rebuild()

{conson_xp-1.47.0 → conson_xp-1.49.0}/src/xp/services/protocol/conbus_event_protocol.py

@@ -98,7 +98,7 @@ class ConbusEventProtocol(protocol.Protocol, protocol.ClientFactory):
         telegram_service: TelegramService,
     ) -> None:
         """
-        Initialize ConbusProtocol.
+        Initialize ConbusEventProtocol.
 
         Args:
             cli_config: Configuration for Conbus client connection.
@@ -326,17 +326,20 @@ class ConbusEventProtocol(protocol.Protocol, protocol.ClientFactory):
             data_value=DataPointType.MODULE_ERROR_CODE.value,
         )
 
-    def send_download_request(self, serial_number: str) -> None:
+    def send_download_request(
+        self, serial_number: str, actiontable_type: SystemFunction
+    ) -> None:
         """
         Send download request telegram.
 
         Args:
             serial_number: Device serial number.
+            actiontable_type: DOWNLOAD_ACTIONTABLE or DOWNLOAD_MSACTIONTABLE.
         """
         self.send_telegram(
             telegram_type=TelegramType.SYSTEM,
             serial_number=serial_number,
-            system_function=SystemFunction.DOWNLOAD_ACTIONTABLE,
+            system_function=actiontable_type,
             data_value=NO_ERROR_CODE,
         )
 

{conson_xp-1.47.0 → conson_xp-1.49.0}/tests/integration/test_actiontable_integration.py

@@ -159,14 +159,13 @@ class TestActionTableIntegration:
         def mock_start_reactor_impl():
             """Mock reactor start method that triggers callbacks."""
             # Generate dict and short format like the service does
-            actiontable_dict = sample_actiontable.model_dump()
             actiontable_short = ActionTableSerializer.to_short_string(
                 sample_actiontable
             )
             # Call the on_actiontable_received callback with data
             if callbacks["on_actiontable_received"]:
                 callbacks["on_actiontable_received"](
-                    sample_actiontable, actiontable_dict, actiontable_short
+                    sample_actiontable, actiontable_short
                 )
             # Call the on_finish callback without arguments
             if callbacks["on_finish"]:

{conson_xp-1.47.0 → conson_xp-1.49.0}/tests/integration/test_xp20_action_table_integration.py

@@ -169,7 +169,7 @@ class TestXp20ActionTableIntegration:
     def test_specification_compliance(self):
         """Test compliance with the specification example."""
         spec_example = (
-            "AAAAAAAAAAAAAAABACAEAIBACAEAIAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA"
+            "AAAAAAAAAAABACAEAIBACAEAIAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA"
         )
 
         # Should decode without errors
@@ -180,7 +180,7 @@ class TestXp20ActionTableIntegration:
 
         # Test that we can re-encode it
         re_encoded = Xp20MsActionTableSerializer.to_encoded_string(result)
-        assert len(re_encoded) == 68
+        assert len(re_encoded) == 64
 
         # Round-trip should work
         final_result = Xp20MsActionTableSerializer.from_encoded_string(re_encoded)

{conson_xp-1.47.0 → conson_xp-1.49.0}/tests/unit/test_cli/test_conbus_actiontable_commands.py

@@ -118,13 +118,12 @@ class TestConbusActionTableCommands:
             else:
                 if actiontable:
                     # Generate dict and short format like the service does
-                    actiontable_dict = actiontable.model_dump()
                     actiontable_short = ActionTableSerializer.to_short_string(
                         actiontable
                     )
                     # Emit on_actiontable_received with data
                     for callback in actiontable_received_callbacks:
-                        callback(actiontable, actiontable_dict, actiontable_short)
+                        callback(actiontable, actiontable_short)
                     # Emit on_finish without arguments
                     for callback in finish_callbacks:
                         callback()
@@ -186,8 +185,7 @@ class TestConbusActionTableCommands:
         # The output should contain JSON with the actiontable data
         # It may be on multiple lines due to indentation
         assert "0000012345" in result.output
-        assert "actiontable" in result.output
-        assert "entries" in result.output
+        assert "actiontable_short" in result.output
 
     def test_conbus_download_actiontable_error_handling(self, runner):
         """Test actiontable download command error handling."""
@@ -287,8 +285,7 @@ class TestConbusActionTableCommands:
         # The output should contain the actiontable data
         # It may be on multiple lines due to indentation and include progress dots
         assert "0000012345" in result.output
-        assert "actiontable" in result.output
-        assert "entries" in result.output
+        assert "actiontable_short" in result.output
 
     def test_download_actiontable_includes_short_format(
         self, runner, sample_actiontable
@@ -367,8 +364,6 @@ class TestConbusActionTableCommands:
 
         # Verify both formats are present
         assert "actiontable_short" in result.output
-        assert "actiontable" in result.output
-        assert "entries" in result.output
 
     def test_download_actiontable_short_with_parameter(self, runner):
         """Test actiontable_short displays parameter when non-zero."""

{conson_xp-1.47.0 → conson_xp-1.49.0}/tests/unit/test_services/test_msactiontable_upload_service.py

@@ -5,7 +5,6 @@ from unittest.mock import Mock, patch
 import pytest
 
 from xp.models.actiontable.msactiontable_xp20 import Xp20MsActionTable
-from xp.models.actiontable.msactiontable_xp24 import Xp24MsActionTable
 from xp.models.actiontable.msactiontable_xp33 import Xp33MsActionTable
 from xp.models.config.conson_module_config import ConsonModuleConfig
 from xp.models.protocol.conbus_protocol import TelegramReceivedEvent
@@ -146,37 +145,6 @@ class TestMsActionTableUploadService:
             data_value="00",
         )
 
-    def test_upload_xp24_msactiontable_success(
-        self, service, mock_conson_config, mock_xp24_serializer, mock_conbus_protocol
-    ):
-        """Test successful XP24 msactiontable upload."""
-        # Setup module config
-        module = Mock(spec=ConsonModuleConfig)
-        module.module_type = "XP24"
-        module.xp24_msaction_table = [
-            "T:1 T:2 ON:0 OF:0 | M12:0 M34:0 C12:0 C34:0 DT:12"
-        ]
-        mock_conson_config.find_module.return_value = module
-
-        # Setup serializer - mock to_encoded_string to return 68-char string
-        mock_msactiontable = Mock(spec=Xp24MsActionTable)
-        mock_xp24_serializer.to_encoded_string.return_value = "AAAA" + "A" * 64
-
-        # Mock from_short_format
-        with patch(
-            "xp.models.actiontable.msactiontable_xp24.Xp24MsActionTable.from_short_format",
-            return_value=mock_msactiontable,
-        ):
-            service.start(
-                serial_number="0020044991",
-                xpmoduletype="xp24",
-            )
-
-        assert service.serial_number == "0020044991"
-        assert service.xpmoduletype == "xp24"
-        assert service.upload_data == "AAAA" + "A" * 64
-        assert service.serializer == mock_xp24_serializer
-
     def test_upload_xp20_msactiontable_success(
         self, service, mock_conson_config, mock_xp20_serializer
     ):

{conson_xp-1.47.0 → conson_xp-1.49.0}/tests/unit/test_services/test_xp20_action_table_serializer.py

@@ -55,14 +55,14 @@ class TestXp20MsActionTableSerializer:
     @pytest.fixture
     def sample_telegram_data(self):
         """Sample telegram data based on specification example (68 chars)."""
-        return "AAAAAAAAAAAAAAABACAEAIBACAEAIAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA"
+        return "AAAAAAAAAAABACAEAIBACAEAIAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA"
 
     def test_to_data_serialization(self, sample_action_table):
         """Test serialization to telegram format."""
         result = Xp20MsActionTableSerializer.to_encoded_string(sample_action_table)
 
         # Should return 64-character hex string
-        assert len(result) == 68
+        assert len(result) == 64
         assert all(c in "ABCDEFGHIJKLMNOP" for c in result)
 
     def test_from_data_deserialization(self, sample_telegram_data):
@@ -119,7 +119,7 @@ class TestXp20MsActionTableSerializer:
 
     def test_invalid_data_length(self):
         """Test that invalid data length raises ValueError."""
-        with pytest.raises(ValueError, match="must be 68 characters long"):
+        with pytest.raises(ValueError, match="must be 64 characters long"):
             Xp20MsActionTableSerializer.from_encoded_string("INVALID")
 
     def test_byte_to_bits_conversion(self):
@@ -220,8 +220,7 @@ class TestXp20MsActionTableSerializer:
         action_table.input8.ta_function = True
 
         serialized = Xp20MsActionTableSerializer.to_encoded_string(action_table)
-        # Skip the 4-character "AAAA" prefix when de-nibbling
-        raw_bytes = de_nibbles(serialized[4:])
+        raw_bytes = de_nibbles(serialized)
 
         # Check bit positions
         assert raw_bytes[SHORT_LONG_INDEX] & 1 != 0  # input1 bit 0
@@ -233,7 +232,7 @@ class TestXp20MsActionTableSerializer:
     def test_specification_example(self):
         """Test with the example telegram from specification."""
         example_data = (
-            "AAAAAAAAAAAAAAABACAEAIBACAEAIAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA"
+            "AAAAAAAAAAABACAEAIBACAEAIAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA"
         )
 
         # This should decode without errors
@@ -260,7 +259,7 @@ class TestXp20MsActionTableSerializer:
         """Test round-trip serialization with default/empty action table data."""
         # 64 characters - all A's represent a completely empty/default action table
         valid_msactiontable = (
-            "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA"
+            "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA"
         )
 
         # Deserialize from data
@@ -293,8 +292,8 @@ class TestXp20MsActionTableSerializer:
         telegram = "<R0020041824F17DAAAAAAAAAAABACAEAIBACAEAIAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAFP>"
 
         # Extract data portion (skip header at 0-15, skip count at 16-19, take 64 chars at 20-83)
-        data = telegram[16:84]
-        assert len(data) == 68
+        data = telegram[20:84]
+        assert len(data) == 64
 
         # Deserialize the action table
         action_table = Xp20MsActionTableSerializer.from_encoded_string(data)
@@ -329,7 +328,7 @@ class TestXp20MsActionTableSerializer:
         telegram = "<R0020037487F17DAAAAAAAAAAABACAEAIBACAEAIAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAFL>"
 
         # Test serialization with defaults
-        serialized_table = telegram[16:84]
+        serialized_table = telegram[20:84]
         deserialized = Xp20MsActionTableSerializer.from_encoded_string(serialized_table)
         serialized = Xp20MsActionTableSerializer.to_encoded_string(deserialized)
 

{conson_xp-1.47.0 → conson_xp-1.49.0}/tests/unit/test_services/test_xp24_action_table_serializer.py

@@ -53,7 +53,7 @@ class TestXp24MsActionTableSerializer:
         # This telegram contains non-hex characters that cause from_hex() to fail
         # Based on the debug log: '<R0020044989F17DAAAAADAAADAAADAAADAAAAAAAMAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAFA>'
         valid_telegram = (
-            "AAAAADAAADAAADAAADAAAAAAAMAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA"
+            "ADAAADAAADAAADAAAAAAAMAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA"
         )
 
         msactiontable = Xp24MsActionTableSerializer.from_encoded_string(valid_telegram)
@@ -79,7 +79,7 @@ class TestXp24MsActionTableSerializer:
         # This telegram contains non-hex characters that cause from_hex() to fail
         # Based on the debug log: '<R0020044989F17DAAAAADAAADAAADAAADAAAAAAAMAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAFA>'
         valid_msactiontable = (
-            "AAAAADAAADAAADAAADAAAAAAAMAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA"
+            "ADAAADAAADAAADAAAAAAAMAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA"
         )
 
         msactiontable = Xp24MsActionTableSerializer.from_encoded_string(
@@ -97,7 +97,7 @@ class TestXp24MsActionTableSerializer:
         # This telegram contains non-hex characters that cause from_hex() to fail
         # Based on the debug log: '<R0020044964F17DAAAAABAGADAAADAAADAAAAAAAMAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAFD>'
         valid_telegram = (
-            "AAAAABAGADAAADAAADAAAAAAAMAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA"
+            "ABAGADAAADAAADAAAAAAAMAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA"
         )
 
         msactiontable = Xp24MsActionTableSerializer.from_encoded_string(valid_telegram)

{conson_xp-1.47.0 → conson_xp-1.49.0}/tests/unit/test_services/test_xp33_action_table_serializer.py

@@ -424,7 +424,7 @@ class TestXp33MsActionTableSerializer:
         # Create action table with default values
 
         # Test serialization with defaults
-        serialized_table = telegram[16:84]
+        serialized_table = telegram[20:84]
         deserialized = Xp33MsActionTableSerializer.from_encoded_string(serialized_table)
         serialized = Xp33MsActionTableSerializer.to_encoded_string(deserialized)