conson-xp 1.32.0__tar.gz → 1.33.0__tar.gz

{conson_xp-1.32.0 → conson_xp-1.33.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: conson-xp
-Version: 1.32.0
+Version: 1.33.0
 Summary: XP Protocol Communication Tools
 Author-Email: ldvchosal <ldvchosal@github.com>
 License: MIT License
@@ -91,6 +91,9 @@ Comprehensive type safety and robust error handling
 # Install with PIP (recommended)
 pip install conson-xp
 
+# Export your Conbus device configuration (recommended first step)
+xp conbus export
+
 # Parse a telegram
 xp telegram parse "<E14L00I02MAK>"
 
@@ -133,7 +136,29 @@ xp telegram validate "<E14L00I02MAK>"
 ```
 
 **Device Communication**
+
+> **⚠️ Important**: Bridge modules (XP130, XP230) accept **only one TCP connection at a time**.
+> Close any existing connections (including the official app) before using xp commands.
+
 ```bash
+# Export device configuration (RECOMMENDED - run this first!)
+# Discovers all devices and exports complete configuration to export.yml
+xp conbus export
+
+# What it does:
+# - Automatically discovers all devices on the Conbus network
+# - Queries 7 datapoints per device (type, version, link number, etc.)
+# - Generates export.yml in conson.yml format
+# - Shows real-time progress for each device
+# - Handles timeouts gracefully with partial exports
+#
+# Example output:
+#   Querying device 1/12: 0020041013...
+#     ✓ Module type: X130 (1)
+#     ✓ Link number: 1
+#     ✓ Software version: V2.3
+#   Export complete: export.yml (12 devices)
+
 # Discover XP servers on your network
 xp conbus discover
 

{conson_xp-1.32.0 → conson_xp-1.33.0}/README.md

@@ -38,6 +38,9 @@ Comprehensive type safety and robust error handling
 # Install with PIP (recommended)
 pip install conson-xp
 
+# Export your Conbus device configuration (recommended first step)
+xp conbus export
+
 # Parse a telegram
 xp telegram parse "<E14L00I02MAK>"
 
@@ -80,7 +83,29 @@ xp telegram validate "<E14L00I02MAK>"
 ```
 
 **Device Communication**
+
+> **⚠️ Important**: Bridge modules (XP130, XP230) accept **only one TCP connection at a time**.
+> Close any existing connections (including the official app) before using xp commands.
+
 ```bash
+# Export device configuration (RECOMMENDED - run this first!)
+# Discovers all devices and exports complete configuration to export.yml
+xp conbus export
+
+# What it does:
+# - Automatically discovers all devices on the Conbus network
+# - Queries 7 datapoints per device (type, version, link number, etc.)
+# - Generates export.yml in conson.yml format
+# - Shows real-time progress for each device
+# - Handles timeouts gracefully with partial exports
+#
+# Example output:
+#   Querying device 1/12: 0020041013...
+#     ✓ Module type: X130 (1)
+#     ✓ Link number: 1
+#     ✓ Software version: V2.3
+#   Export complete: export.yml (12 devices)
+
 # Discover XP servers on your network
 xp conbus discover
 

{conson_xp-1.32.0 → conson_xp-1.33.0}/pyproject.toml

@@ -22,7 +22,7 @@ dependencies = [
 ]
 requires-python = ">=3.11"
 readme = "README.md"
-version = "1.32.0"
+version = "1.33.0"
 
 [project.license]
 file = "LICENSE"

{conson_xp-1.32.0 → conson_xp-1.33.0}/src/xp/__init__.py

@@ -3,7 +3,7 @@
 conson-xp package.
 """
 
-__version__ = "1.32.0"
+__version__ = "1.33.0"
 __manufacturer__ = "salchichon"
 __model__ = "xp.cli"
 __serial__ = "2025.09.23.000"

{conson_xp-1.32.0 → conson_xp-1.33.0}/src/xp/services/conbus/conbus_export_service.py

@@ -31,8 +31,7 @@ class ConbusExportService:
     Attributes:
         conbus_protocol: Protocol for Conbus communication.
         discovered_devices: List of discovered device serial numbers.
-        device_configs: Partial device configurations being built.
-        device_datapoints_received: Set of datapoints received per device.
+        device_configs: Device configurations (ConsonModuleConfig instances).
         export_result: Final export result.
         export_status: Export status (OK, FAILED_TIMEOUT, etc.).
         on_progress: Signal emitted on device discovery (serial, current, total).
@@ -69,8 +68,7 @@ class ConbusExportService:
 
         # State management
         self.discovered_devices: list[str] = []
-        self.device_configs: dict[str, dict[str, Any]] = {}
-        self.device_datapoints_received: dict[str, set[str]] = {}
+        self.device_configs: dict[str, ConsonModuleConfig] = {}
         self.export_result = ConbusExportResponse(success=False)
         self.export_status = "OK"
         self._finalized = False  # Track if export has been finalized
@@ -146,8 +144,16 @@ class ConbusExportService:
 
         self.logger.debug(f"Device discovered: {serial_number}")
         self.discovered_devices.append(serial_number)
-        self.device_configs[serial_number] = {"serial_number": serial_number}
-        self.device_datapoints_received[serial_number] = set()
+
+        # Create ConsonModuleConfig with placeholder values for required fields
+        module = ConsonModuleConfig(
+            name="UNKNOWN",  # Will be updated when link_number arrives
+            serial_number=serial_number,
+            module_type="UNKNOWN",  # Required field
+            module_type_code=0,  # Required field
+            link_number=0,  # Required field
+        )
+        self.device_configs[serial_number] = module
 
         # Emit progress signal
         current = len(self.discovered_devices)
@@ -188,7 +194,6 @@ class ConbusExportService:
         datapoint = DataPointType.from_code(datapoint_code)
         if datapoint:
             self._store_datapoint_value(serial_number, datapoint, value)
-            self.device_datapoints_received[serial_number].add(datapoint_code)
             self._check_device_complete(serial_number)
         else:
             self.logger.warning(f"Unknown datapoint code: {datapoint_code}")
@@ -203,31 +208,49 @@ class ConbusExportService:
             datapoint: Datapoint type.
             value: Datapoint value.
         """
-        config = self.device_configs[serial_number]
-
-        if datapoint == DataPointType.MODULE_TYPE:
-            config["module_type"] = value
-        elif datapoint == DataPointType.MODULE_TYPE_CODE:
-            try:
-                config["module_type_code"] = int(value)
-            except ValueError:
-                self.logger.warning(f"Invalid module_type_code: {value}")
-        elif datapoint == DataPointType.LINK_NUMBER:
-            try:
-                config["link_number"] = int(value)
-            except ValueError:
-                self.logger.warning(f"Invalid link_number: {value}")
-        elif datapoint == DataPointType.MODULE_NUMBER:
-            try:
-                config["module_number"] = int(value)
-            except ValueError:
-                self.logger.warning(f"Invalid module_number: {value}")
-        elif datapoint == DataPointType.SW_VERSION:
-            config["sw_version"] = value
-        elif datapoint == DataPointType.HW_VERSION:
-            config["hw_version"] = value
-        elif datapoint == DataPointType.AUTO_REPORT_STATUS:
-            config["auto_report_status"] = value
+        module = self.device_configs[serial_number]
+
+        try:
+            if datapoint == DataPointType.MODULE_TYPE:
+                module.module_type = value
+            elif datapoint == DataPointType.MODULE_TYPE_CODE:
+                module.module_type_code = int(value)
+            elif datapoint == DataPointType.LINK_NUMBER:
+                link = int(value)
+                module.link_number = link
+                module.name = f"A{link}"
+            elif datapoint == DataPointType.MODULE_NUMBER:
+                module.module_number = int(value)
+            elif datapoint == DataPointType.SW_VERSION:
+                module.sw_version = value
+            elif datapoint == DataPointType.HW_VERSION:
+                module.hw_version = value
+            elif datapoint == DataPointType.AUTO_REPORT_STATUS:
+                module.auto_report_status = value
+        except (ValueError, TypeError) as e:
+            self.logger.warning(f"Invalid value '{value}' for {datapoint.name}: {e}")
+
+    def _is_device_complete(self, serial_number: str) -> bool:
+        """Check if a device has all required datapoints.
+
+        Args:
+            serial_number: Serial number of device.
+
+        Returns:
+            True if device is complete, False otherwise.
+        """
+        module = self.device_configs[serial_number]
+        return all(
+            [
+                module.module_type not in ("UNKNOWN", None, ""),
+                module.module_type_code is not None and module.module_type_code > 0,
+                module.link_number is not None and module.link_number > 0,
+                module.sw_version is not None,
+                module.hw_version is not None,
+                module.auto_report_status is not None,
+                module.module_number is not None,
+            ]
+        )
 
     def _check_device_complete(self, serial_number: str) -> None:
         """Check if device has all datapoints and emit completion signal.
@@ -235,29 +258,13 @@ class ConbusExportService:
         Args:
             serial_number: Serial number of device.
         """
-        received = self.device_datapoints_received[serial_number]
-        expected = {dp.value for dp in self.DATAPOINT_SEQUENCE}
-
-        if received == expected:
+        if self._is_device_complete(serial_number):
             self.logger.debug(f"Device {serial_number} complete (7/7 datapoints)")
-            config = self.device_configs[serial_number]
-
-            # Build ConsonModuleConfig with name based on link_number
-            try:
-                # Add required 'name' field as A{link_number}
-                if "name" not in config:
-                    link_number = config.get("link_number", 0)
-                    config["name"] = f"A{link_number}"
-                module_config = ConsonModuleConfig(**config)
-                self.on_device_exported.emit(module_config)
-            except Exception as e:
-                self.logger.error(f"Failed to build config for {serial_number}: {e}")
+            module = self.device_configs[serial_number]
+            self.on_device_exported.emit(module)
 
             # Check if all devices complete
-            if all(
-                len(self.device_datapoints_received[sn]) == len(self.DATAPOINT_SEQUENCE)
-                for sn in self.discovered_devices
-            ):
+            if all(self._is_device_complete(sn) for sn in self.discovered_devices):
                 self.logger.debug("All devices complete")
                 self._finalize_export()
 
@@ -278,20 +285,8 @@ class ConbusExportService:
             self.on_finish.emit(self.export_result)
             return
 
-        # Build module list (including partial devices)
-        modules = []
-        for serial_number in self.discovered_devices:
-            config = self.device_configs[serial_number].copy()
-            try:
-                # Add required 'name' field as A{link_number} if not present
-                if "name" not in config:
-                    link_number = config.get("link_number", 0)
-                    config["name"] = f"A{link_number}"
-                # Only include fields that were received
-                module_config = ConsonModuleConfig(**config)
-                modules.append(module_config)
-            except Exception as e:
-                self.logger.warning(f"Partial device {serial_number}: {e}")
+        # Convert dict values to list (already ConsonModuleConfig instances!)
+        modules = list(self.device_configs.values())
 
         # Sort modules by link_number
         modules.sort(key=lambda m: m.link_number if m.link_number is not None else 999)
@@ -380,9 +375,7 @@ class ConbusExportService:
 
         # Check if any devices incomplete
         incomplete = [
-            sn
-            for sn in self.discovered_devices
-            if len(self.device_datapoints_received[sn]) < len(self.DATAPOINT_SEQUENCE)
+            sn for sn in self.discovered_devices if not self._is_device_complete(sn)
         ]
 
         if incomplete:
@@ -439,7 +432,6 @@ class ConbusExportService:
         # Reset state for reuse
         self.discovered_devices = []
         self.device_configs = {}
-        self.device_datapoints_received = {}
         self.export_result = ConbusExportResponse(success=False)
         self.export_status = "OK"
         self._finalized = False