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

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: conson-xp
-Version: 1.49.0
+Version: 1.50.1
 Summary: XP Protocol Communication Tools
 Author-Email: ldvchosal <ldvchosal@github.com>
 License: MIT License
@@ -353,6 +353,7 @@ xp conbus event raw
 
 
 xp conbus export
+xp conbus export actiontable
 xp conbus export config
 
 

{conson_xp-1.49.0 → conson_xp-1.50.1}/README.md

@@ -299,6 +299,7 @@ xp conbus event raw
 
 
 xp conbus export
+xp conbus export actiontable
 xp conbus export config
 
 

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

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

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

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

{conson_xp-1.49.0 → conson_xp-1.50.1}/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.49.0 → conson_xp-1.50.1}/src/xp/cli/commands/conbus/conbus_export_commands.py

@@ -6,8 +6,12 @@ import click
 
 from xp.cli.commands.conbus.conbus import conbus_export
 from xp.cli.utils.decorators import connection_command
+from xp.models.actiontable.actiontable_type import ActionTableType
 from xp.models.conbus.conbus_export import ConbusExportResponse
 from xp.models.config.conson_module_config import ConsonModuleConfig
+from xp.services.conbus.conbus_export_actiontable_service import (
+    ConbusActiontableExportService,
+)
 from xp.services.conbus.conbus_export_service import ConbusExportService
 
 
@@ -91,3 +95,85 @@ def export_conbus_config(ctx: click.Context) -> None:
         service.on_finish.connect(on_finish)
         service.set_timeout(5)
         service.start_reactor()
+
+
+@conbus_export.command("actiontable")
+@click.pass_context
+@connection_command()
+def export_conbus_actiontable(ctx: click.Context) -> None:
+    r"""
+    Export Conbus device actiontable to YAML file.
+
+    Read device list from conson.yml
+    Export export.yml file in conson.yml format.
+
+    Args:
+        ctx: Click context object.
+
+    Examples:
+        \b
+        # Export device metadata to export.yml
+        xp conbus export
+        xp conbus export actiontable
+    """
+
+    def on_progress(serial_number: str, current: int, total: int) -> None:
+        """
+        Handle progress updates during export.
+
+        Args:
+            serial_number: Serial number of discovered device.
+            current: Current device number.
+            total: Total devices discovered.
+        """
+        click.echo(f"Querying device {current}/{total}: {serial_number}...")
+
+    def on_device_actiontable_exported(
+        module: ConsonModuleConfig,
+        actiontable_type: ActionTableType,
+        actiontable_short: str,
+    ) -> None:
+        """
+        Handle device export completion.
+
+        Args:
+            module: Exported module configuration.
+            actiontable_type: Type of action table exported.
+            actiontable_short: Short representation of the action table.
+        """
+        serial_number = module.serial_number or "UNKNOWN"
+        click.echo(f"  ✓ Module: {serial_number})")
+        click.echo(f"  ✓ Action type: {actiontable_type}")
+        click.echo(f"  ✓ Action table: {actiontable_short}")
+
+    def on_finish(result: ConbusExportResponse) -> None:
+        """
+        Handle export completion.
+
+        Args:
+            result: Export result.
+
+        Raises:
+            ClickException: When export fails with error message from result.
+        """
+        # Try to stop reactor (may already be stopped)
+        with suppress(Exception):
+            service.stop_reactor()
+
+        if result.success:
+            click.echo(
+                f"\nExport complete: {result.output_file} ({result.device_count} devices)"
+            )
+        else:
+            click.echo(f"Error: {result.error}", err=True)
+            raise click.ClickException(result.error or "Export failed")
+
+    service: ConbusActiontableExportService = (
+        ctx.obj.get("container").get_container().resolve(ConbusActiontableExportService)
+    )
+    with service:
+        service.on_progress.connect(on_progress)
+        service.on_device_actiontable_exported.connect(on_device_actiontable_exported)
+        service.on_finish.connect(on_finish)
+        service.set_timeout(5)
+        service.start_reactor()

{conson_xp-1.49.0 → conson_xp-1.50.1}/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.49.0 → conson_xp-1.50.1}/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.49.0 → conson_xp-1.50.1}/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: