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

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

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

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

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

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

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

{conson_xp-1.50.1 → conson_xp-1.51.0}/src/xp/cli/commands/conbus/conbus_export_commands.py

@@ -117,16 +117,21 @@ def export_conbus_actiontable(ctx: click.Context) -> None:
         xp conbus export actiontable
     """
 
-    def on_progress(serial_number: str, current: int, total: int) -> None:
+    def on_progress(
+        serial_number: str, actiontable_type: str, current: int, total: int
+    ) -> None:
         """
         Handle progress updates during export.
 
         Args:
             serial_number: Serial number of discovered device.
+            actiontable_type: Type of action table being exported.
             current: Current device number.
             total: Total devices discovered.
         """
-        click.echo(f"Querying device {current}/{total}: {serial_number}...")
+        click.echo(
+            f"Querying device {current}/{total}: {serial_number} / {actiontable_type}."
+        )
 
     def on_device_actiontable_exported(
         module: ConsonModuleConfig,
@@ -176,4 +181,5 @@ def export_conbus_actiontable(ctx: click.Context) -> None:
         service.on_device_actiontable_exported.connect(on_device_actiontable_exported)
         service.on_finish.connect(on_finish)
         service.set_timeout(5)
+        service.configure()
         service.start_reactor()

{conson_xp-1.50.1 → conson_xp-1.51.0}/src/xp/services/conbus/actiontable/actiontable_download_service.py

@@ -292,6 +292,8 @@ class ActionTableDownloadService(DownloadStateMachine):
             raise RuntimeError("Cannot configure while download in progress")
         self.logger.info("Configuring actiontable download")
         self.serial_number = serial_number
+        self.actiontable_data = []
+
         if actiontable_type == ActionTableType.ACTIONTABLE:
             self.serializer = self.actiontable_serializer
         elif actiontable_type == ActionTableType.MSACTIONTABLE_XP20:

{conson_xp-1.50.1 → conson_xp-1.51.0}/src/xp/services/conbus/conbus_export_actiontable_service.py

@@ -3,7 +3,7 @@
 import asyncio
 import logging
 from pathlib import Path
-from queue import SimpleQueue
+from queue import Empty, SimpleQueue
 from typing import Any, Optional, Tuple
 
 import yaml
@@ -38,7 +38,7 @@ class ConbusActiontableExportService:
     """
 
     # Signals (class attributes)
-    on_progress: Signal = Signal(str, int, int)  # serial, current, total
+    on_progress: Signal = Signal(str, str, int, int)  # serial, current, total
     on_device_actiontable_exported: Signal = Signal(
         ConsonModuleConfig, ActionTableType, str
     )
@@ -64,25 +64,35 @@ class ConbusActiontableExportService:
         self.logger = logging.getLogger(__name__)
         self.download_service = download_service
         self._module_list: ConsonModuleListConfig = module_list
+        self._module_dic: dict[str, ConsonModuleConfig] = {
+            module.serial_number: module for module in module_list.root
+        }
         # State management
-        self.device_queue: SimpleQueue[Tuple[ConsonModuleConfig, ActionTableType]] = (
+        self.device_queue: SimpleQueue[Tuple[str, 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.logger.info("Export module %s", module)
+            if module.module_type.lower() == "xp20":
+                self.device_queue.put(
+                    (module.serial_number, ActionTableType.MSACTIONTABLE_XP20)
+                )
+            if module.module_type.lower() == "xp24":
+                self.device_queue.put(
+                    (module.serial_number, ActionTableType.MSACTIONTABLE_XP24)
+                )
+            if module.module_type.lower() == "xp33":
+                self.device_queue.put(
+                    (module.serial_number, ActionTableType.MSACTIONTABLE_XP33)
+                )
+            self.device_queue.put((module.serial_number, ActionTableType.ACTIONTABLE))
+
+        self.logger.info("Export module %s", self.device_queue.qsize())
 
         self.current_module: Optional[ConsonModuleConfig] = None
-        self.curent_actiontable_type: Optional[ActionTableType] = None
+        self.current_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]
@@ -94,7 +104,7 @@ class ConbusActiontableExportService:
             actiontable: Full actiontable data.
             short_actiontable: Short representation of the actiontable.
         """
-        if not self.curent_actiontable_type:
+        if not self.current_actiontable_type:
             self._fail("Invalid state (curent_actiontable_type)")
             return
 
@@ -102,17 +112,17 @@ class ConbusActiontableExportService:
             self._fail("Invalid state (current_module)")
             return
 
-        if self.curent_actiontable_type == ActionTableType.ACTIONTABLE:
+        if self.current_actiontable_type == ActionTableType.ACTIONTABLE:
             self.current_module.action_table = short_actiontable
-        elif self.curent_actiontable_type == ActionTableType.MSACTIONTABLE_XP20:
+        elif self.current_actiontable_type == ActionTableType.MSACTIONTABLE_XP20:
             self.current_module.xp20_msaction_table = short_actiontable
-        elif self.curent_actiontable_type == ActionTableType.MSACTIONTABLE_XP24:
+        elif self.current_actiontable_type == ActionTableType.MSACTIONTABLE_XP24:
             self.current_module.xp24_msaction_table = short_actiontable
-        elif self.curent_actiontable_type == ActionTableType.MSACTIONTABLE_XP33:
+        elif self.current_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
+            self.current_module, self.current_actiontable_type, short_actiontable
         )
 
     def on_module_finish(self) -> None:
@@ -127,10 +137,13 @@ class ConbusActiontableExportService:
         serial_number = (
             self.current_module.serial_number if self.current_module else "UNKNOWN"
         )
+        current_actiontable_type = self.current_actiontable_type or "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)
+        self.on_progress.emit(
+            serial_number, current_actiontable_type, current_index, total_modules
+        )
 
     def on_module_error(self, error_message: str) -> None:
         """
@@ -162,7 +175,6 @@ class ConbusActiontableExportService:
                             "enabled",
                             "conbus_ip",
                             "conbus_port",
-                            "action_table",
                         }
                     }
                 },
@@ -203,16 +215,24 @@ class ConbusActiontableExportService:
             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):
+        try:
+            (current_serial_number, self.current_actiontable_type) = (
+                self.device_queue.get_nowait()
+            )
+        except Empty:
+            return False
+
+        self.current_module = self._module_dic[current_serial_number]
+        if not (self.current_module or self.current_actiontable_type):
             self.logger.error("No module to export")
             return False
 
+        self.logger.info(
+            f"Downloading {self.current_module.serial_number} / {self.current_actiontable_type}"
+        )
         self.download_service.configure(
             self.current_module.serial_number,
-            self.curent_actiontable_type,
+            self.current_actiontable_type,
         )
         self.download_service.do_connect()
         return True
@@ -275,7 +295,7 @@ class ConbusActiontableExportService:
 
     def _disconnect_signals(self) -> None:
         """Disconnect download service signals from handlers."""
-        self.download_service.on_actiontable_received.connect(
+        self.download_service.on_actiontable_received.disconnect(
             self.on_module_actiontable_received
         )
         self.download_service.on_finish.disconnect(self.on_module_finish)

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

@@ -46,6 +46,9 @@ from xp.services.conbus.conbus_datapoint_service import (
 from xp.services.conbus.conbus_discover_service import ConbusDiscoverService
 from xp.services.conbus.conbus_event_list_service import ConbusEventListService
 from xp.services.conbus.conbus_event_raw_service import ConbusEventRawService
+from xp.services.conbus.conbus_export_actiontable_service import (
+    ConbusActiontableExportService,
+)
 from xp.services.conbus.conbus_export_service import ConbusExportService
 from xp.services.conbus.conbus_output_service import ConbusOutputService
 from xp.services.conbus.conbus_raw_service import ConbusRawService
@@ -217,6 +220,15 @@ class ServiceContainer:
             scope=punq.Scope.singleton,
         )
 
+        self.container.register(
+            ConbusActiontableExportService,
+            factory=lambda: ConbusActiontableExportService(
+                download_service=self.container.resolve(ActionTableDownloadService),
+                module_list=self.container.resolve(ConsonModuleListConfig),
+            ),
+            scope=punq.Scope.singleton,
+        )
+
         # Terminal UI
         self.container.register(
             ProtocolMonitorService,