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

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: conson-xp
-Version: 1.50.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.50.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.50.0 → conson_xp-1.50.1}/pyproject.toml

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

{conson_xp-1.50.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.50.0"
+__version__ = "1.50.1"
 __manufacturer__ = "salchichon"
 __model__ = "xp.cli"
 __serial__ = "2025.09.23.000"

{conson_xp-1.50.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.50.1/src/xp/services/conbus/conbus_export_actiontable_service.py

@@ -0,0 +1,308 @@
+"""Conbus export service for exporting device configurations."""
+
+import asyncio
+import logging
+from pathlib import Path
+from queue import SimpleQueue
+from typing import Any, Optional, Tuple
+
+import yaml
+from psygnal import Signal
+
+from xp.models.actiontable.actiontable_type import ActionTableType, ActionTableType2
+from xp.models.conbus.conbus_export import ConbusExportResponse
+from xp.models.config.conson_module_config import (
+    ConsonModuleConfig,
+    ConsonModuleListConfig,
+)
+from xp.services.conbus.actiontable.actiontable_download_service import (
+    ActionTableDownloadService,
+)
+
+
+class ConbusActiontableExportService:
+    """
+    Service for exporting Conbus device configurations.
+
+    Discovers all devices on the Conbus network and queries their configuration
+    datapoints to generate a structured export file compatible with conson.yml format.
+
+    Attributes:
+        download_service: Download service for exporting device configurations.
+        export_result: Final export result.
+        export_status: Export status (OK, FAILED_TIMEOUT, etc.).
+        on_progress: Signal emitted on device discovery (serial, current, total).
+        on_device_actiontable_exported: Signal emitted when device export completes.
+        on_finish: Signal emitted when export finishes.
+        ACTIONTABLE_SEQUENCE: Sequence of actiontable to query for each device.
+    """
+
+    # Signals (class attributes)
+    on_progress: Signal = Signal(str, int, int)  # serial, current, total
+    on_device_actiontable_exported: Signal = Signal(
+        ConsonModuleConfig, ActionTableType, str
+    )
+    on_finish: Signal = Signal(ConbusExportResponse)
+
+    ACTIONTABLE_SEQUENCE = [
+        ActionTableType2.ACTIONTABLE,
+        ActionTableType2.MSACTIONTABLE,
+    ]
+
+    def __init__(
+        self,
+        download_service: ActionTableDownloadService,
+        module_list: ConsonModuleListConfig,
+    ) -> None:
+        """
+        Initialize the Conbus export service.
+
+        Args:
+            download_service: Protocol for downloading actiontables.
+            module_list: module to export.
+        """
+        self.logger = logging.getLogger(__name__)
+        self.download_service = download_service
+        self._module_list: ConsonModuleListConfig = module_list
+        # State management
+        self.device_queue: SimpleQueue[Tuple[ConsonModuleConfig, ActionTableType]] = (
+            SimpleQueue()
+        )  # FIFO
+        for module in self._module_list.root:
+            self.device_queue.put((module, ActionTableType.ACTIONTABLE))
+            if module.module_type == "xp20":
+                self.device_queue.put((module, ActionTableType.MSACTIONTABLE_XP20))
+            if module.module_type == "xp24":
+                self.device_queue.put((module, ActionTableType.MSACTIONTABLE_XP24))
+            if module.module_type == "xp33":
+                self.device_queue.put((module, ActionTableType.MSACTIONTABLE_XP33))
+
+        self.current_module: Optional[ConsonModuleConfig] = None
+        self.curent_actiontable_type: Optional[ActionTableType] = None
+        self.export_result = ConbusExportResponse(success=False)
+        self.export_status = "OK"
+        # Connect protocol signals
+        self._connect_signals()
+
+    def on_module_actiontable_received(
+        self, actiontable: Any, short_actiontable: list[str]
+    ) -> None:
+        """
+        Handle actiontable received event.
+
+        Args:
+            actiontable: Full actiontable data.
+            short_actiontable: Short representation of the actiontable.
+        """
+        if not self.curent_actiontable_type:
+            self._fail("Invalid state (curent_actiontable_type)")
+            return
+
+        if not self.current_module:
+            self._fail("Invalid state (current_module)")
+            return
+
+        if self.curent_actiontable_type == ActionTableType.ACTIONTABLE:
+            self.current_module.action_table = short_actiontable
+        elif self.curent_actiontable_type == ActionTableType.MSACTIONTABLE_XP20:
+            self.current_module.xp20_msaction_table = short_actiontable
+        elif self.curent_actiontable_type == ActionTableType.MSACTIONTABLE_XP24:
+            self.current_module.xp24_msaction_table = short_actiontable
+        elif self.curent_actiontable_type == ActionTableType.MSACTIONTABLE_XP33:
+            self.current_module.xp33_msaction_table = short_actiontable
+
+        self.on_device_actiontable_exported.emit(
+            self.current_module, self.curent_actiontable_type, actiontable
+        )
+
+    def on_module_finish(self) -> None:
+        """Handle module export completion."""
+        self._save_action_table()
+        has_next_module = self.configure()
+        if not has_next_module:
+            self._succeed()
+
+    def on_module_progress(self) -> None:
+        """Handle module progress event and emit progress signal."""
+        serial_number = (
+            self.current_module.serial_number if self.current_module else "UNKNOWN"
+        )
+        total_modules = len(self._module_list.root)
+        current_index = total_modules - self.device_queue.qsize()
+
+        self.on_progress.emit(serial_number, current_index, total_modules)
+
+    def on_module_error(self, error_message: str) -> None:
+        """
+        Handle module error event.
+
+        Args:
+            error_message: Error message from module.
+        """
+        self._fail(error_message)
+
+    def _save_action_table(self) -> None:
+        """Write export to YAML file."""
+        self.logger.info("Saving action table")
+
+        if not self._module_list:
+            self._fail("FAILED_NO_DEVICES")
+            return
+
+        try:
+            # Write to file
+            path = "export.yml"
+            output_path = Path(path)
+
+            # Use Pydantic's model_dump to serialize, excluding only internal fields
+            data = self._module_list.model_dump(
+                exclude={
+                    "root": {
+                        "__all__": {
+                            "enabled",
+                            "conbus_ip",
+                            "conbus_port",
+                            "action_table",
+                        }
+                    }
+                },
+                exclude_none=True,
+            )
+
+            # Export as list at root level (not wrapped in 'root:' key)
+            modules_list = data.get("root", [])
+
+            with output_path.open("w") as f:
+                # Dump each module separately with blank lines between them
+                for i, module in enumerate(modules_list):
+                    # Add blank line before each module except the first
+                    if i > 0:
+                        f.write("\n")
+
+                    # Dump single item as list element
+                    yaml_str = yaml.safe_dump(
+                        [module],
+                        default_flow_style=False,
+                        sort_keys=False,
+                        allow_unicode=True,
+                    )
+                    # Remove the trailing newline and write
+                    f.write(yaml_str.rstrip("\n") + "\n")
+
+            self.logger.info(f"Export written to {path}")
+            self.export_result.output_file = path
+
+        except Exception as e:
+            self._fail(f"Failed to create export: {e}")
+
+    def configure(self) -> bool:
+        """
+        Configure export service.
+
+        Returns:
+            True if there is a module to export, False otherwise.
+        """
+        self.download_service.reset()
+        (self.current_module, self.curent_actiontable_type) = (
+            self.device_queue.get_nowait()
+        )
+        if not (self.current_module or self.curent_actiontable_type):
+            self.logger.error("No module to export")
+            return False
+
+        self.download_service.configure(
+            self.current_module.serial_number,
+            self.curent_actiontable_type,
+        )
+        self.download_service.do_connect()
+        return True
+
+    def set_event_loop(self, event_loop: asyncio.AbstractEventLoop) -> None:
+        """
+        Set event loop for async operations.
+
+        Args:
+            event_loop: Event loop to use.
+        """
+        self.logger.debug("Set event loop")
+        self.download_service.set_event_loop(event_loop)
+
+    def set_timeout(self, timeout_seconds: float) -> None:
+        """
+        Set timeout.
+
+        Args:
+            timeout_seconds: Timeout in seconds.
+        """
+        self.download_service.set_timeout(timeout_seconds)
+
+    def start_reactor(self) -> None:
+        """Start the reactor."""
+        self.download_service.start_reactor()
+
+    def stop_reactor(self) -> None:
+        """Stop the reactor."""
+        self.download_service.stop_reactor()
+
+    def __enter__(self) -> "ConbusActiontableExportService":
+        """
+        Enter context manager.
+
+        Returns:
+            Self for context manager protocol.
+        """
+        # Reset state for reuse
+        self.export_result = ConbusExportResponse(success=False)
+        self.export_status = "OK"
+        self._connect_signals()
+        return self
+
+    def __exit__(
+        self, _exc_type: Optional[type], _exc_val: Optional[Exception], _exc_tb: Any
+    ) -> None:
+        """Exit context manager and disconnect signals."""
+        self._disconnect_signals()
+        self.stop_reactor()
+
+    def _connect_signals(self) -> None:
+        """Connect download service signals to handlers."""
+        self.download_service.on_actiontable_received.connect(
+            self.on_module_actiontable_received
+        )
+        self.download_service.on_finish.connect(self.on_module_finish)
+        self.download_service.on_progress.connect(self.on_module_progress)
+        self.download_service.on_error.connect(self.on_module_error)
+
+    def _disconnect_signals(self) -> None:
+        """Disconnect download service signals from handlers."""
+        self.download_service.on_actiontable_received.connect(
+            self.on_module_actiontable_received
+        )
+        self.download_service.on_finish.disconnect(self.on_module_finish)
+        self.download_service.on_progress.disconnect(self.on_module_progress)
+        self.download_service.on_error.disconnect(self.on_module_error)
+
+        self.on_progress.disconnect()
+        self.on_device_actiontable_exported.disconnect()
+        self.on_finish.disconnect()
+
+    def _fail(self, error: str) -> None:
+        """
+        Handle export failure.
+
+        Args:
+            error: Error message.
+        """
+        self.logger.error(error)
+        self.export_result.success = False
+        self.export_result.error = error
+        self.export_result.export_status = "FAILED"
+        self.on_finish.emit(self.export_result)
+
+    def _succeed(self) -> None:
+        """Handle export success."""
+        self.logger.info("Export succeed")
+        self.export_result.success = True
+        self.export_result.error = None
+        self.export_result.export_status = "OK"
+        self.on_finish.emit(self.export_result)

{conson_xp-1.50.0 → conson_xp-1.50.1}/src/xp/services/conbus/conbus_export_service.py

@@ -57,16 +57,19 @@ class ConbusExportService:
         DataPointType.AUTO_REPORT_STATUS,
     ]
 
-    def __init__(self, conbus_protocol: ConbusEventProtocol) -> None:
+    def __init__(
+        self, conbus_protocol: ConbusEventProtocol, telegram_service: TelegramService
+    ) -> None:
         """
         Initialize the Conbus export service.
 
         Args:
             conbus_protocol: Protocol for Conbus communication.
+            telegram_service: TelegramService for telegram parsing.
         """
         self.logger = logging.getLogger(__name__)
         self.conbus_protocol = conbus_protocol
-        self.telegram_service = TelegramService()
+        self.telegram_service = telegram_service
 
         # State management
         self.discovered_devices: list[str] = []

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

@@ -211,7 +211,8 @@ class ServiceContainer:
         self.container.register(
             ConbusExportService,
             factory=lambda: ConbusExportService(
-                conbus_protocol=self.container.resolve(ConbusEventProtocol)
+                conbus_protocol=self.container.resolve(ConbusEventProtocol),
+                telegram_service=self.container.resolve(TelegramService),
             ),
             scope=punq.Scope.singleton,
         )