conson-xp 1.49.0__py3-none-any.whl → 1.50.1__py3-none-any.whl

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)

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] = []

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
@@ -214,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,
         )
@@ -336,6 +334,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 +373,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(

xp/cli/utils/xp_module_type.py

@@ -1,55 +0,0 @@
-"""Click parameter type for XP module type validation."""
-
-from typing import Any, Optional
-
-import click
-
-
-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
-
-        # Convert to lower for comparison
-        normalized_value = value.lower()
-
-        if normalized_value in self.choices:
-            return normalized_value
-
-        # If not found, show error with available choices
-        choices_list = "\n".join(f" - {choice}" for choice in sorted(self.choices))
-        self.fail(
-            f"{value!r} is not a valid choice. " f"Choose from:\n{choices_list}",
-            param,
-            ctx,
-        )
-
-
-XP_MODULE_TYPE = XpModuleTypeChoice()

xp/services/conbus/msactiontable/__init__.py

@@ -1 +0,0 @@
-"""MsAction table services for Conbus."""