conson-xp 1.48.0__tar.gz → 1.50.0__tar.gz

{conson_xp-1.48.0 → conson_xp-1.50.0}/PKG-INFO

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

{conson_xp-1.48.0 → conson_xp-1.50.0}/pyproject.toml

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

{conson_xp-1.48.0 → conson_xp-1.50.0}/src/xp/__init__.py

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

{conson_xp-1.48.0 → conson_xp-1.50.0}/src/xp/cli/commands/conbus/conbus_actiontable_commands.py

@@ -1,8 +1,6 @@
 """ActionTable CLI commands."""
 
 import json
-from contextlib import suppress
-from pathlib import Path
 
 import click
 from click import Context
@@ -13,10 +11,9 @@ from xp.cli.utils.decorators import (
 )
 from xp.cli.utils.serial_number_type import SERIAL
 from xp.models.actiontable.actiontable import ActionTable
-from xp.models.actiontable.actiontable_type import ActionTableType
+from xp.models.actiontable.actiontable_type import ActionTableType, ActionTableType2
 from xp.models.config.conson_module_config import (
     ConsonModuleConfig,
-    ConsonModuleListConfig,
 )
 from xp.services.conbus.actiontable.actiontable_download_service import (
     ActionTableDownloadService,
@@ -164,18 +161,12 @@ def conbus_upload_actiontable(ctx: Context, serial_number: str) -> None:
 
     with service:
         # Load config to get entry count for success message
-        config_path = Path.cwd() / "conson.yml"
-        if config_path.exists():
-            with suppress(Exception):
-                config = ConsonModuleListConfig.from_yaml(str(config_path))
-                module = config.find_module(serial_number)
-                if module and module.action_table:
-                    entries_count = len(module.action_table)
-
         service.on_progress.connect(progress_callback)
         service.on_finish.connect(on_finish)
         service.on_error.connect(on_error)
-        service.start(serial_number=serial_number)
+        service.start(
+            serial_number=serial_number, actiontable_type=ActionTableType2.ACTIONTABLE
+        )
         service.start_reactor()
 
 

{conson_xp-1.48.0 → conson_xp-1.50.0}/src/xp/cli/commands/conbus/conbus_msactiontable_commands.py

@@ -1,7 +1,7 @@
 """XP24 Action Table CLI commands."""
 
 import json
-from typing import Any, Union
+from typing import Any, Optional, Union
 
 import click
 from click import Context
@@ -11,8 +11,7 @@ from xp.cli.utils.decorators import (
     connection_command,
 )
 from xp.cli.utils.serial_number_type import SERIAL
-from xp.cli.utils.xp_module_type import XP_MODULE_TYPE
-from xp.models.actiontable.actiontable_type import ActionTableType
+from xp.models.actiontable.actiontable_type import ActionTableType, ActionTableType2
 from xp.models.config.conson_module_config import ConsonModuleConfig
 from xp.services.conbus.actiontable.actiontable_download_service import (
     ActionTableDownloadService,
@@ -23,11 +22,59 @@ from xp.services.conbus.actiontable.actiontable_list_service import (
 from xp.services.conbus.actiontable.actiontable_show_service import (
     ActionTableShowService,
 )
-from xp.services.conbus.msactiontable.msactiontable_upload_service import (
-    MsActionTableUploadService,
+from xp.services.conbus.actiontable.actiontable_upload_service import (
+    ActionTableUploadService,
 )
 
 
+class XpModuleTypeChoice(click.ParamType):
+    """
+    Click parameter type for validating XP module types.
+
+    Attributes:
+        name: The parameter type name.
+        choices: List of valid module type strings.
+    """
+
+    name = "xpmoduletype"
+
+    def __init__(self) -> None:
+        """Initialize the XpModuleTypeChoice parameter type."""
+        self.choices = ["xp20", "xp24", "xp31", "xp33"]
+
+    def convert(
+        self,
+        value: Any,
+        param: Optional[click.Parameter],
+        ctx: Optional[click.Context],
+    ) -> Any:
+        """
+        Convert and validate XP module type input.
+
+        Args:
+            value: The input value to convert.
+            param: The Click parameter.
+            ctx: The Click context.
+
+        Returns:
+            Lowercase module type string if valid, None if input is None.
+        """
+        if value is None:
+            return value
+        normalized_value = value.lower()
+        if normalized_value in self.choices:
+            return normalized_value
+        choices_list = "\n".join(f" - {choice}" for choice in sorted(self.choices))
+        self.fail(
+            f"{value!r} is not a valid choice. Choose from:\n{choices_list}",
+            param,
+            ctx,
+        )
+
+
+XP_MODULE_TYPE = XpModuleTypeChoice()
+
+
 def _get_actiontable_type(xpmoduletype: str) -> ActionTableType:
     """
     Map xpmoduletype string to ActionTableType enum.
@@ -244,22 +291,18 @@ def conbus_show_msactiontable(ctx: Context, serial_number: str) -> None:
 
 @conbus_msactiontable.command("upload", short_help="Upload MSActionTable")
 @click.argument("serial_number", type=SERIAL)
-@click.argument("xpmoduletype", type=XP_MODULE_TYPE)
 @click.pass_context
 @connection_command()
-def conbus_upload_msactiontable(
-    ctx: Context, serial_number: str, xpmoduletype: str
-) -> None:
+def conbus_upload_msactiontable(ctx: Context, serial_number: str) -> None:
     """
     Upload MS action table from conson.yml to XP module.
 
     Args:
         ctx: Click context object.
         serial_number: 10-digit module serial number.
-        xpmoduletype: XP module type.
     """
-    service: MsActionTableUploadService = (
-        ctx.obj.get("container").get_container().resolve(MsActionTableUploadService)
+    service: ActionTableUploadService = (
+        ctx.obj.get("container").get_container().resolve(ActionTableUploadService)
     )
 
     def on_progress(progress: str) -> None:
@@ -300,7 +343,7 @@ def conbus_upload_msactiontable(
         service.on_finish.connect(on_finish)
         service.start(
             serial_number=serial_number,
-            xpmoduletype=xpmoduletype,
+            actiontable_type=ActionTableType2.MSACTIONTABLE,
         )
         service.start_reactor()
 

{conson_xp-1.48.0 → conson_xp-1.50.0}/src/xp/models/actiontable/actiontable_type.py

@@ -18,3 +18,16 @@ class ActionTableType(str, Enum):
     MSACTIONTABLE_XP20 = "msactiontable_xp20"
     MSACTIONTABLE_XP24 = "msactiontable_xp24"
     MSACTIONTABLE_XP33 = "msactiontable_xp33"
+
+
+class ActionTableType2(str, Enum):
+    """
+    ActionTable types for download/upload operations.
+
+    Attributes:
+        ACTIONTABLE: Standard action table.
+        MSACTIONTABLE: MS action table.
+    """
+
+    ACTIONTABLE = "actiontable"
+    MSACTIONTABLE = "msactiontable"

{conson_xp-1.48.0 → conson_xp-1.50.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.48.0 → conson_xp-1.50.0}/src/xp/services/conbus/actiontable/actiontable_upload_service.py

@@ -5,18 +5,32 @@ from typing import Any, Optional
 
 from psygnal import Signal
 
-from xp.models.config.conson_module_config import ConsonModuleListConfig
+from xp.models.actiontable.actiontable_type import ActionTableType2
+from xp.models.config.conson_module_config import (
+    ConsonModuleConfig,
+    ConsonModuleListConfig,
+)
 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.actiontable.msactiontable_xp20_serializer import (
+    Xp20MsActionTableSerializer,
+)
+from xp.services.actiontable.msactiontable_xp24_serializer import (
+    Xp24MsActionTableSerializer,
+)
+from xp.services.actiontable.msactiontable_xp33_serializer import (
+    Xp33MsActionTableSerializer,
+)
 from xp.services.protocol.conbus_event_protocol import ConbusEventProtocol
 from xp.services.telegram.telegram_service import TelegramService
 
 
 class ActionTableUploadService:
     """
-    TCP client service for uploading action tables to Conbus modules.
+    TCP client service for uploading action tables and MS action tables to Conbus
+    modules.
 
     Manages TCP socket connections, handles telegram generation and transmission,
     and processes server responses for action table uploads.
@@ -35,6 +49,9 @@ class ActionTableUploadService:
         self,
         conbus_protocol: ConbusEventProtocol,
         actiontable_serializer: ActionTableSerializer,
+        xp20ms_serializer: Xp20MsActionTableSerializer,
+        xp24ms_serializer: Xp24MsActionTableSerializer,
+        xp33ms_serializer: Xp33MsActionTableSerializer,
         telegram_service: TelegramService,
         conson_config: ConsonModuleListConfig,
     ) -> None:
@@ -44,14 +61,22 @@ class ActionTableUploadService:
         Args:
             conbus_protocol: ConbusEventProtocol for communication.
             actiontable_serializer: Action table serializer.
+            xp20ms_serializer: XP20 MS action table serializer.
+            xp24ms_serializer: XP24 MS action table serializer.
+            xp33ms_serializer: XP33 MS action table serializer.
             telegram_service: Telegram service for parsing.
             conson_config: Conson module list configuration.
         """
         self.conbus_protocol = conbus_protocol
-        self.serializer = actiontable_serializer
+        self.actiontable_serializer = actiontable_serializer
+        self.xp20ms_serializer = xp20ms_serializer
+        self.xp24ms_serializer = xp24ms_serializer
+        self.xp33ms_serializer = xp33ms_serializer
         self.telegram_service = telegram_service
         self.conson_config = conson_config
         self.serial_number: str = ""
+        self.xpmoduletype: str = ""
+        self.actiontable_type: ActionTableType2 = ActionTableType2.ACTIONTABLE
 
         # Upload state
         self.upload_data_chunks: list[str] = []
@@ -70,10 +95,17 @@ class ActionTableUploadService:
     def connection_made(self) -> None:
         """Handle connection established event."""
         self.logger.debug("Connection established, sending upload actiontable telegram")
+
+        system_function = (
+            SystemFunction.UPLOAD_ACTIONTABLE
+            if self.actiontable_type == ActionTableType2.ACTIONTABLE
+            else SystemFunction.UPLOAD_MSACTIONTABLE
+        )
+
         self.conbus_protocol.send_telegram(
             telegram_type=TelegramType.SYSTEM,
             serial_number=self.serial_number,
-            system_function=SystemFunction.UPLOAD_ACTIONTABLE,
+            system_function=system_function,
             data_value="00",
         )
 
@@ -127,10 +159,16 @@ class ActionTableUploadService:
                 # Second character: 'A' + chunk_index (sequential counter A-O for 15 chunks)
                 prefix_hex = f"AAA{ord('A') + self.current_chunk_index:c}"
 
+                system_function = (
+                    SystemFunction.ACTIONTABLE
+                    if self.actiontable_type == ActionTableType2.ACTIONTABLE
+                    else SystemFunction.MSACTIONTABLE
+                )
+
                 self.conbus_protocol.send_telegram(
                     telegram_type=TelegramType.SYSTEM,
                     serial_number=self.serial_number,
-                    system_function=SystemFunction.ACTIONTABLE,
+                    system_function=system_function,
                     data_value=f"{prefix_hex}{chunk}",
                 )
                 self.current_chunk_index += 1
@@ -169,19 +207,24 @@ class ActionTableUploadService:
     def start(
         self,
         serial_number: str,
+        actiontable_type: ActionTableType2,
         timeout_seconds: Optional[float] = None,
     ) -> None:
         """
-        Upload action table to module.
+        Upload action table or MS action table to module.
 
         Uploads the action table configuration to the specified module.
+        Module type will decide which actiontable to use.
 
         Args:
             serial_number: Module serial number.
+            actiontable_type: True if actionTable false for MS action table.
             timeout_seconds: Optional timeout in seconds.
         """
         self.logger.info("Starting actiontable upload")
         self.serial_number = serial_number
+        self.actiontable_type = actiontable_type
+
         if timeout_seconds:
             self.conbus_protocol.timeout_seconds = timeout_seconds
 
@@ -193,29 +236,65 @@ class ActionTableUploadService:
 
         # Parse action table strings to ActionTable object
         try:
-            module_action_table = module.action_table or []
-            action_table = self.serializer.from_short_string(module_action_table)
+            encoded_data = self.get_encoded_action_table(module)
+            # Chunk the data into 64 byte chunks
+            chunk_size = 64
+            self.upload_data_chunks = [
+                encoded_data[i : i + chunk_size]
+                for i in range(0, len(encoded_data), chunk_size)
+            ]
+            self.current_chunk_index = 0
+
         except ValueError as e:
             self.logger.error(f"Invalid action table format: {e}")
             self.failed(f"Invalid action table format: {e}")
             return
 
-        # Encode action table to hex string
-        encoded_data = self.serializer.to_encoded_string(action_table)
-
-        # Chunk the data into 64 byte chunks
-        chunk_size = 64
-        self.upload_data_chunks = [
-            encoded_data[i : i + chunk_size]
-            for i in range(0, len(encoded_data), chunk_size)
-        ]
-        self.current_chunk_index = 0
-
         self.logger.debug(
             f"Upload data encoded: {len(encoded_data)} chars, "
             f"{len(self.upload_data_chunks)} chunks"
         )
 
+    def get_encoded_action_table(self, module: ConsonModuleConfig) -> str:
+        """
+        Get encoded action table string for upload.
+
+        Args:
+            module: Module configuration containing action table data.
+
+        Returns:
+            Hex-encoded action table string ready for transmission.
+        """
+        msactiontable = (
+            True if self.actiontable_type == ActionTableType2.MSACTIONTABLE else False
+        )
+        # Parse MS action table from short format (first element)
+        if msactiontable and module.module_type.lower() == "xp20":
+            xp20_short_table = module.xp20_msaction_table or []
+            xp20_actiontable = self.xp20ms_serializer.from_short_string(
+                xp20_short_table
+            )
+            encoded_string = self.xp20ms_serializer.to_encoded_string(xp20_actiontable)
+        elif msactiontable and module.module_type.lower() == "xp24":
+            xp24_short_table = module.xp24_msaction_table or []
+            xp24_actiontable = self.xp24ms_serializer.from_short_string(
+                xp24_short_table
+            )
+            encoded_string = self.xp24ms_serializer.to_encoded_string(xp24_actiontable)
+        elif msactiontable and module.module_type.lower() == "xp33":
+            xp33_short_table = module.xp33_msaction_table or []
+            xp33_actiontable = self.xp33ms_serializer.from_short_string(
+                xp33_short_table
+            )
+            encoded_string = self.xp33ms_serializer.to_encoded_string(xp33_actiontable)
+        else:
+            short_table = module.action_table or []
+            actiontable = self.actiontable_serializer.from_short_string(short_table)
+            encoded_string = self.actiontable_serializer.to_encoded_string(actiontable)
+
+        # Serialize to telegram data (64 characters: AAAA + 64 data chars)
+        return encoded_string
+
     def set_timeout(self, timeout_seconds: float) -> None:
         """
         Set operation timeout.
@@ -243,6 +322,7 @@ class ActionTableUploadService:
         self.upload_data_chunks = []
         self.current_chunk_index = 0
         self.serial_number = ""
+        self.xpmoduletype = ""
         return self
 
     def __exit__(self, _exc_type: Any, _exc_val: Any, _exc_tb: Any) -> None:

{conson_xp-1.48.0 → conson_xp-1.50.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.48.0 → conson_xp-1.50.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.48.0 → conson_xp-1.50.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.

{conson_xp-1.48.0 → conson_xp-1.50.0}/src/xp/utils/dependencies.py

@@ -51,9 +51,6 @@ from xp.services.conbus.conbus_output_service import ConbusOutputService
 from xp.services.conbus.conbus_raw_service import ConbusRawService
 from xp.services.conbus.conbus_receive_service import ConbusReceiveService
 from xp.services.conbus.conbus_scan_service import ConbusScanService
-from xp.services.conbus.msactiontable.msactiontable_upload_service import (
-    MsActionTableUploadService,
-)
 from xp.services.conbus.write_config_service import WriteConfigService
 from xp.services.homekit.homekit_cache_service import HomeKitCacheService
 from xp.services.homekit.homekit_conbus_service import HomeKitConbusService
@@ -336,6 +333,9 @@ class ServiceContainer:
             factory=lambda: ActionTableUploadService(
                 conbus_protocol=self.container.resolve(ConbusEventProtocol),
                 actiontable_serializer=self.container.resolve(ActionTableSerializer),
+                xp20ms_serializer=self.container.resolve(Xp20MsActionTableSerializer),
+                xp24ms_serializer=self.container.resolve(Xp24MsActionTableSerializer),
+                xp33ms_serializer=self.container.resolve(Xp33MsActionTableSerializer),
                 telegram_service=self.container.resolve(TelegramService),
                 conson_config=self.container.resolve(ConsonModuleListConfig),
             ),
@@ -372,37 +372,6 @@ class ServiceContainer:
             scope=punq.Scope.singleton,
         )
 
-        self.container.register(
-            ActionTableDownloadService,
-            factory=lambda: ActionTableDownloadService(
-                conbus_protocol=self.container.resolve(ConbusEventProtocol),
-                actiontable_serializer=self.container.resolve(ActionTableSerializer),
-                msactiontable_serializer_xp20=self.container.resolve(
-                    Xp20MsActionTableSerializer
-                ),
-                msactiontable_serializer_xp24=self.container.resolve(
-                    Xp24MsActionTableSerializer
-                ),
-                msactiontable_serializer_xp33=self.container.resolve(
-                    Xp33MsActionTableSerializer
-                ),
-            ),
-            scope=punq.Scope.singleton,
-        )
-
-        self.container.register(
-            MsActionTableUploadService,
-            factory=lambda: MsActionTableUploadService(
-                conbus_protocol=self.container.resolve(ConbusEventProtocol),
-                xp20ms_serializer=self.container.resolve(Xp20MsActionTableSerializer),
-                xp24ms_serializer=self.container.resolve(Xp24MsActionTableSerializer),
-                xp33ms_serializer=self.container.resolve(Xp33MsActionTableSerializer),
-                telegram_service=self.container.resolve(TelegramService),
-                conson_config=self.container.resolve(ConsonModuleListConfig),
-            ),
-            scope=punq.Scope.singleton,
-        )
-
         self.container.register(
             ConbusCustomService,
             factory=lambda: ConbusCustomService(