conson-xp 1.32.0__py3-none-any.whl → 1.34.0__py3-none-any.whl

{conson_xp-1.32.0.dist-info → conson_xp-1.34.0.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: conson-xp
-Version: 1.32.0
+Version: 1.34.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.dist-info → conson_xp-1.34.0.dist-info}/RECORD

@@ -1,8 +1,8 @@
-conson_xp-1.32.0.dist-info/METADATA,sha256=7pNhSUQaahCS55NfZHY_NR7e7d3VZ73oDUXwcCirr4A,10329
-conson_xp-1.32.0.dist-info/WHEEL,sha256=tsUv_t7BDeJeRHaSrczbGeuK-TtDpGsWi_JfpzD255I,90
-conson_xp-1.32.0.dist-info/entry_points.txt,sha256=1OcdIcDM1hz3ljCXgybaPUh1IOFEwkaTgLIW9u9zGeg,50
-conson_xp-1.32.0.dist-info/licenses/LICENSE,sha256=rxj6woMM-r3YCyGq_UHFtbh7kHTAJgrccH6O-33IDE4,1419
-xp/__init__.py,sha256=WvYNIdtUKhtQhMR_bDasGkHpOfRlda8a-wO0v7kBE5c,181
+conson_xp-1.34.0.dist-info/METADATA,sha256=9ID-C2KoLbshYqzErSWWIRc0q_O9loTVJIOJxGe57NY,11246
+conson_xp-1.34.0.dist-info/WHEEL,sha256=tsUv_t7BDeJeRHaSrczbGeuK-TtDpGsWi_JfpzD255I,90
+conson_xp-1.34.0.dist-info/entry_points.txt,sha256=1OcdIcDM1hz3ljCXgybaPUh1IOFEwkaTgLIW9u9zGeg,50
+conson_xp-1.34.0.dist-info/licenses/LICENSE,sha256=rxj6woMM-r3YCyGq_UHFtbh7kHTAJgrccH6O-33IDE4,1419
+xp/__init__.py,sha256=vXeJqE3QI_Fjqi5W7xgUMPTwKhql9XhCnkj3f7fKMjs,181
 xp/cli/__init__.py,sha256=QjnKB1KaI2aIyKlzrnvCwfbBuUj8HNgwNMvNJVQofbI,81
 xp/cli/__main__.py,sha256=l2iKwMdat5rTGd3JWs-uGksnYYDDffp_Npz05QdKEeU,117
 xp/cli/commands/__init__.py,sha256=noh8fdZAWq-ihJEboP8WugbIgq4LJ3jUWMRA7720xWE,4909
@@ -10,7 +10,7 @@ xp/cli/commands/conbus/__init__.py,sha256=gE3K5OEoXkkZX8UOc2v3nreQQzwkOQi7n0VZ-Z
 xp/cli/commands/conbus/conbus.py,sha256=eqdY8ArapvD08Z4p7Xk7eh4z0dESHuMSw7PKtwTJRYU,3021
 xp/cli/commands/conbus/conbus_actiontable_commands.py,sha256=cdjLV9cnm7teEOlu5Jf1MS_aL7lNy8KiDIyjCQa5Nzw,7138
 xp/cli/commands/conbus/conbus_autoreport_commands.py,sha256=oZgyUUFNsb4yf2WO81l2w1PrasNwdC__QwxNkJ2jCaU,3794
-xp/cli/commands/conbus/conbus_blink_commands.py,sha256=UK-Ey4K0FvaPQ96U0gyMid236RlBmUhPNRes9y0SlkM,4848
+xp/cli/commands/conbus/conbus_blink_commands.py,sha256=HRn4Lr_BO7_WynsaUnO_hKezOi3MVhkPYEOnh0rMMlg,5324
 xp/cli/commands/conbus/conbus_config_commands.py,sha256=BugIbgNX6_s4MySGvI6tWZkwguciajHUX2Xz8XBux7k,716
 xp/cli/commands/conbus/conbus_custom_commands.py,sha256=lICT93ijMdhVRm8KjNMLo7kQ2BLlnOZvMPbR3SxSmZ4,1692
 xp/cli/commands/conbus/conbus_datapoint_commands.py,sha256=r36OuTjREtbGKL-bskAGa0-WLw7x06td6woZn3GYJNA,3630
@@ -127,15 +127,15 @@ xp/services/conbus/actiontable/actiontable_list_service.py,sha256=6izVZkM2hlWXUM
 xp/services/conbus/actiontable/actiontable_show_service.py,sha256=jqNZ4UvZPHH66OYuryjnU1Km-a83OCwYvK0vc56oL8I,3017
 xp/services/conbus/actiontable/actiontable_upload_service.py,sha256=txhMumjcIHPI4TZk6CERhjyyTKUNhUb7fdSmaylYC48,8189
 xp/services/conbus/actiontable/msactiontable_service.py,sha256=K0TiYL8g4ac8BS1tqS0UAIYJigOlNhxVLIb8ZFybnVE,8393
-xp/services/conbus/conbus_blink_all_service.py,sha256=OaEg4b8AEiEruHSkZ5jDtaoI81vwwxLq4KWXO7zBdD0,6582
-xp/services/conbus/conbus_blink_service.py,sha256=x9uM-sLnIEV8wSNsvJgo08E042g-Hh2ZF3rXkz-k_9s,5824
+xp/services/conbus/conbus_blink_all_service.py,sha256=6XsqtgHUgPDPWG0Mx2W2gnG_1eiaHrt2DiPXGqGHS50,8472
+xp/services/conbus/conbus_blink_service.py,sha256=wFCUbHYInbzfE4Ks_qjkav0FhtHXsxM9IY6tD5r0oAk,7898
 xp/services/conbus/conbus_custom_service.py,sha256=4aneYdPObiZOGxPFYg5Wr70cl_xFxlQIdJBPQSa0enI,5826
 xp/services/conbus/conbus_datapoint_queryall_service.py,sha256=p9R02cVimhdJILHQ6BoeZj8Hog4oRpqBnMo3t4R8ecY,6816
 xp/services/conbus/conbus_datapoint_service.py,sha256=SYhHj9RmTmaJ750tyZ1IW2kl7tgDQ1xm_EM1zUjk1aQ,6421
 xp/services/conbus/conbus_discover_service.py,sha256=ZwjYBlgP6FgpHBJk7pcKr4JHfH7WUHDxe4he4F_HblQ,12740
 xp/services/conbus/conbus_event_list_service.py,sha256=0xyXXNU44epN5bFkU6oiZMyhxfUguul3evqClvPJDcA,3618
 xp/services/conbus/conbus_event_raw_service.py,sha256=FZFu-LNLInrTKTpiGLyootozvyIF5Si5FMrxNk2ALD0,7000
-xp/services/conbus/conbus_export_service.py,sha256=-EIDiXOitLwXTKCfw1zv4XIuIKWaT-3FkxtQwms7PgM,17920
+xp/services/conbus/conbus_export_service.py,sha256=3Zb58qqRDNR9gA4rQ_fyT--ZgRIK_lkqnXJFbQnrZOA,17300
 xp/services/conbus/conbus_output_service.py,sha256=mHFOAPx2zo0TStZ3pokp6v94AQjIamcwZDeg5YH_-eo,7240
 xp/services/conbus/conbus_raw_service.py,sha256=4yZLLTIAOxpgByUTWZXw1ihGa6Xtl98ckj9T7VfprDI,4335
 xp/services/conbus/conbus_receive_service.py,sha256=7wOaEDrdoXwZE9MeUM89eB3hobYpvtbYk_YLv3MVAtc,5352
@@ -198,10 +198,10 @@ xp/term/widgets/protocol_log.py,sha256=CJUpckWj7GC1kVqixDadteyGnI4aHyzd4kkH-pSbz
 xp/term/widgets/status_footer.py,sha256=bxrcqKzJ9V0aPSn_WwraVpJz7NxBUh3yIjA3fwv5nVA,3256
 xp/utils/__init__.py,sha256=_avMF_UOkfR3tNeDIPqQ5odmbq5raKkaq1rZ9Cn1CJs,332
 xp/utils/checksum.py,sha256=HDpiQxmdIedbCbZ4o_Box0i_Zig417BtCV_46ZyhiTk,1711
-xp/utils/dependencies.py,sha256=d91Xt4PwnyeMB_tLB-hNDpm95QGMg5uiq52yvOM9BBE,24557
+xp/utils/dependencies.py,sha256=jN2FNwUUacmrEXsOA-zWe-1yWr16x9BaVfLjmFxIJKg,24437
 xp/utils/event_helper.py,sha256=W-A_xmoXlpWZBbJH6qdaN50o3-XrwFsDgvAGMJDiAgo,1001
 xp/utils/logging.py,sha256=rZDXwlBrYK8A6MPq5StsMNpgsRowzJXM6fvROPwJdGM,3750
 xp/utils/serialization.py,sha256=RWHHk86feaB4ZP7rjE4qOWK0900yg2joUBDkP76gfOY,4618
 xp/utils/state_machine.py,sha256=Oe2sLwCh9z_vr1tF6X0ZRGTeuckRQAGzmef7xc9CNdc,2413
 xp/utils/time_utils.py,sha256=dEyViDlAG9GWU-J3D_YVa-sGma6yiyyMTgN4h2x3PY4,3781
-conson_xp-1.32.0.dist-info/RECORD,,
+conson_xp-1.34.0.dist-info/RECORD,,

xp/__init__.py

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

xp/cli/commands/conbus/conbus_blink_commands.py

@@ -41,12 +41,15 @@ def send_blink_on_telegram(ctx: Context, serial_number: str) -> None:
             service_response: Blink response object.
         """
         click.echo(json.dumps(service_response.to_dict(), indent=2))
+        service.stop_reactor()
 
     service: ConbusBlinkService = (
         ctx.obj.get("container").get_container().resolve(ConbusBlinkService)
     )
     with service:
-        service.send_blink_telegram(serial_number, "on", on_finish, 0.5)
+        service.on_finish.connect(on_finish)
+        service.send_blink_telegram(serial_number, "on", 0.5)
+        service.start_reactor()
 
 
 @conbus_blink.command("off")
@@ -73,12 +76,15 @@ def send_blink_off_telegram(ctx: Context, serial_number: str) -> None:
             service_response: Blink response object.
         """
         click.echo(json.dumps(service_response.to_dict(), indent=2))
+        service.stop_reactor()
 
     service: ConbusBlinkService = (
         ctx.obj.get("container").get_container().resolve(ConbusBlinkService)
     )
     with service:
-        service.send_blink_telegram(serial_number, "off", on_finish, 0.5)
+        service.on_finish.connect(on_finish)
+        service.send_blink_telegram(serial_number, "off", 0.5)
+        service.start_reactor()
 
 
 @conbus_blink.group("all", short_help="Control blink state for all devices")
@@ -109,6 +115,7 @@ def blink_all_off(ctx: Context) -> None:
             discovered_devices: Blink response with all devices.
         """
         click.echo(json.dumps(discovered_devices.to_dict(), indent=2))
+        service.stop_reactor()
 
     def progress(message: str) -> None:
         """Handle progress updates during blink all off operation.
@@ -116,13 +123,16 @@ def blink_all_off(ctx: Context) -> None:
         Args:
             message: Progress message string.
         """
-        click.echo(message)
+        click.echo(message, nl=False)
 
     service: ConbusBlinkAllService = (
         ctx.obj.get("container").get_container().resolve(ConbusBlinkAllService)
     )
     with service:
-        service.send_blink_all_telegram("off", progress, on_finish, 0.5)
+        service.on_progress.connect(progress)
+        service.on_finish.connect(on_finish)
+        service.send_blink_all_telegram("off", 5)
+        service.start_reactor()
 
 
 @conbus_blink_all.command("on", short_help="Turn on blinking for all devices")
@@ -147,6 +157,7 @@ def blink_all_on(ctx: Context) -> None:
             discovered_devices: Blink response with all devices.
         """
         click.echo(json.dumps(discovered_devices.to_dict(), indent=2))
+        service.stop_reactor()
 
     def progress(message: str) -> None:
         """Handle progress updates during blink all on operation.
@@ -154,10 +165,13 @@ def blink_all_on(ctx: Context) -> None:
         Args:
             message: Progress message string.
         """
-        click.echo(message)
+        click.echo(message, nl=False)
 
     service: ConbusBlinkAllService = (
         ctx.obj.get("container").get_container().resolve(ConbusBlinkAllService)
     )
     with service:
-        service.send_blink_all_telegram("on", progress, on_finish, 0.5)
+        service.on_progress.connect(progress)
+        service.on_finish.connect(on_finish)
+        service.send_blink_all_telegram("on", 5)
+        service.start_reactor()

xp/services/conbus/conbus_blink_all_service.py

@@ -6,46 +6,48 @@ blink/unblink telegrams to all discovered modules on the network.
 
 import logging
 from datetime import datetime
-from typing import Callable, Optional
+from typing import Any, Optional
 
-from twisted.internet.posixbase import PosixReactorBase
+from psygnal import Signal
 
-from xp.models import ConbusClientConfig
 from xp.models.conbus.conbus_blink import ConbusBlinkResponse
 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.protocol import ConbusProtocol
+from xp.services.protocol.conbus_event_protocol import ConbusEventProtocol
 from xp.services.telegram.telegram_service import TelegramService
 
 
-class ConbusBlinkAllService(ConbusProtocol):
+class ConbusBlinkAllService:
     """
     Service for blinking all modules on Conbus servers.
 
-    Uses ConbusProtocol to provide blink/unblink functionality
+    Uses ConbusEventProtocol to provide blink/unblink functionality
     for all discovered modules on the network.
+
+    Attributes:
+        on_progress: Signal emitted during blink operation progress (with message).
+        on_finish: Signal emitted when blink operation completes (with response).
     """
 
+    on_progress: Signal = Signal(str)
+    on_finish: Signal = Signal(ConbusBlinkResponse)
+
     def __init__(
         self,
+        conbus_protocol: ConbusEventProtocol,
         telegram_service: TelegramService,
-        cli_config: ConbusClientConfig,
-        reactor: PosixReactorBase,
     ) -> None:
         """Initialize the Conbus blink all service.
 
         Args:
+            conbus_protocol: ConbusEventProtocol instance for communication.
             telegram_service: Service for parsing telegrams.
-            cli_config: Configuration for Conbus client connection.
-            reactor: Twisted reactor for event loop.
         """
-        super().__init__(cli_config, reactor)
+        self.conbus_protocol = conbus_protocol
         self.telegram_service = telegram_service
         self.serial_number: str = ""
         self.on_or_off = "none"
-        self.progress_callback: Optional[Callable[[str], None]] = None
-        self.finish_callback: Optional[Callable[[ConbusBlinkResponse], None]] = None
         self.service_response: ConbusBlinkResponse = ConbusBlinkResponse(
             success=False,
             serial_number=self.serial_number,
@@ -56,17 +58,23 @@ class ConbusBlinkAllService(ConbusProtocol):
         # Set up logging
         self.logger = logging.getLogger(__name__)
 
-    def connection_established(self) -> None:
-        """Handle connection established event."""
+        # Connect protocol signals
+        self.conbus_protocol.on_connection_made.connect(self.connection_made)
+        self.conbus_protocol.on_telegram_sent.connect(self.telegram_sent)
+        self.conbus_protocol.on_telegram_received.connect(self.telegram_received)
+        self.conbus_protocol.on_timeout.connect(self.timeout)
+        self.conbus_protocol.on_failed.connect(self.failed)
+
+    def connection_made(self) -> None:
+        """Handle connection made event."""
         self.logger.debug("Connection established, send discover telegram.")
-        self.send_telegram(
+        self.conbus_protocol.send_telegram(
             telegram_type=TelegramType.SYSTEM,
             serial_number="0000000000",
             system_function=SystemFunction.DISCOVERY,
             data_value="00",
         )
-        if self.progress_callback:
-            self.progress_callback(".")
+        self.on_progress.emit(".")
 
     def send_blink(self, serial_number: str) -> None:
         """Send blink or unblink telegram to a discovered module.
@@ -81,7 +89,7 @@ class ConbusBlinkAllService(ConbusProtocol):
         if self.on_or_off.lower() == "on":
             system_function = SystemFunction.BLINK
 
-        self.send_telegram(
+        self.conbus_protocol.send_telegram(
             telegram_type=TelegramType.SYSTEM,
             serial_number=serial_number,
             system_function=system_function,
@@ -90,8 +98,7 @@ class ConbusBlinkAllService(ConbusProtocol):
         self.service_response.system_function = system_function
         self.service_response.operation = self.on_or_off
 
-        if self.progress_callback:
-            self.progress_callback(".")
+        self.on_progress.emit(".")
 
     def telegram_sent(self, telegram_sent: str) -> None:
         """Handle telegram sent event.
@@ -129,8 +136,7 @@ class ConbusBlinkAllService(ConbusProtocol):
         ):
             self.logger.debug("Received discovery response")
             self.send_blink(reply_telegram.serial_number)
-            if self.progress_callback:
-                self.progress_callback(".")
+            self.on_progress.emit(".")
             return
 
         if reply_telegram and reply_telegram.system_function in (
@@ -138,12 +144,18 @@ class ConbusBlinkAllService(ConbusProtocol):
             SystemFunction.UNBLINK,
         ):
             self.logger.debug("Received blink response")
-            if self.progress_callback:
-                self.progress_callback(".")
+            self.on_progress.emit(".")
             return
 
         self.logger.debug("Received unexpected response")
 
+    def timeout(self) -> None:
+        """Handle timeout event to stop operation."""
+        self.logger.info("Blink all operation timeout")
+        self.service_response.success = False
+        self.service_response.error = "Blink all operation timeout"
+        self.on_finish.emit(self.service_response)
+
     def failed(self, message: str) -> None:
         """Handle failed connection event.
 
@@ -154,28 +166,70 @@ class ConbusBlinkAllService(ConbusProtocol):
         self.service_response.success = False
         self.service_response.timestamp = datetime.now()
         self.service_response.error = message
-        if self.finish_callback:
-            self.finish_callback(self.service_response)
+        self.on_finish.emit(self.service_response)
 
     def send_blink_all_telegram(
         self,
         on_or_off: str,
-        progress_callback: Callable[[str], None],
-        finish_callback: Callable[[ConbusBlinkResponse], None],
         timeout_seconds: Optional[float] = None,
     ) -> None:
         """Send blink command to all discovered modules.
 
         Args:
             on_or_off: "on" to blink or "off" to unblink all devices.
-            progress_callback: Callback function to call with progress updates.
-            finish_callback: Callback function to call when the operation completes.
             timeout_seconds: Timeout in seconds.
         """
         self.logger.info("Starting send_blink_all_telegram")
         if timeout_seconds:
-            self.timeout_seconds = timeout_seconds
-        self.progress_callback = progress_callback
-        self.finish_callback = finish_callback
+            self.conbus_protocol.timeout_seconds = timeout_seconds
         self.on_or_off = on_or_off
-        self.start_reactor()
+        # Caller invokes start_reactor()
+
+    def set_timeout(self, timeout_seconds: float) -> None:
+        """Set operation timeout.
+
+        Args:
+            timeout_seconds: Timeout in seconds.
+        """
+        self.conbus_protocol.timeout_seconds = timeout_seconds
+
+    def start_reactor(self) -> None:
+        """Start the reactor."""
+        self.conbus_protocol.start_reactor()
+
+    def stop_reactor(self) -> None:
+        """Stop the reactor."""
+        self.conbus_protocol.stop_reactor()
+
+    def __enter__(self) -> "ConbusBlinkAllService":
+        """Enter context manager - reset state for singleton reuse.
+
+        Returns:
+            Self for context manager protocol.
+        """
+        # Reset state for singleton reuse
+        self.service_response = ConbusBlinkResponse(
+            success=False,
+            serial_number="",
+            system_function=SystemFunction.NONE,
+            operation="none",
+        )
+        self.serial_number = ""
+        self.on_or_off = "none"
+        return self
+
+    def __exit__(
+        self, _exc_type: Optional[type], _exc_val: Optional[Exception], _exc_tb: Any
+    ) -> None:
+        """Exit context manager - cleanup signals and reactor."""
+        # Disconnect protocol signals
+        self.conbus_protocol.on_connection_made.disconnect(self.connection_made)
+        self.conbus_protocol.on_telegram_sent.disconnect(self.telegram_sent)
+        self.conbus_protocol.on_telegram_received.disconnect(self.telegram_received)
+        self.conbus_protocol.on_timeout.disconnect(self.timeout)
+        self.conbus_protocol.on_failed.disconnect(self.failed)
+        # Disconnect service signals
+        self.on_progress.disconnect()
+        self.on_finish.disconnect()
+        # Stop reactor
+        self.stop_reactor()

xp/services/conbus/conbus_blink_service.py

@@ -6,45 +6,46 @@ blink/unblink telegrams to control module LED indicators.
 
 import logging
 from datetime import datetime
-from typing import Callable, Optional
+from typing import Any, Optional
 
-from twisted.internet.posixbase import PosixReactorBase
+from psygnal import Signal
 
-from xp.models import ConbusClientConfig
 from xp.models.conbus.conbus_blink import ConbusBlinkResponse
 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.protocol import ConbusProtocol
+from xp.services.protocol.conbus_event_protocol import ConbusEventProtocol
 from xp.services.telegram.telegram_service import TelegramService
 
 
-class ConbusBlinkService(ConbusProtocol):
+class ConbusBlinkService:
     """
     Service for blinking module LEDs on Conbus servers.
 
-    Uses ConbusProtocol to provide blink/unblink functionality
+    Uses ConbusEventProtocol to provide blink/unblink functionality
     for controlling module LED indicators.
+
+    Attributes:
+        on_finish: Signal emitted when blink operation completes (with response).
     """
 
+    on_finish: Signal = Signal(ConbusBlinkResponse)
+
     def __init__(
         self,
+        conbus_protocol: ConbusEventProtocol,
         telegram_service: TelegramService,
-        cli_config: ConbusClientConfig,
-        reactor: PosixReactorBase,
     ) -> None:
         """Initialize the Conbus blink service.
 
         Args:
+            conbus_protocol: ConbusEventProtocol instance for communication.
             telegram_service: Service for parsing telegrams.
-            cli_config: Configuration for Conbus client connection.
-            reactor: Twisted reactor for event loop.
         """
-        super().__init__(cli_config, reactor)
+        self.conbus_protocol = conbus_protocol
         self.telegram_service = telegram_service
         self.serial_number: str = ""
         self.on_or_off = "none"
-        self.finish_callback: Optional[Callable[[ConbusBlinkResponse], None]] = None
         self.service_response: ConbusBlinkResponse = ConbusBlinkResponse(
             success=False,
             serial_number=self.serial_number,
@@ -55,15 +56,22 @@ class ConbusBlinkService(ConbusProtocol):
         # Set up logging
         self.logger = logging.getLogger(__name__)
 
-    def connection_established(self) -> None:
-        """Handle connection established event."""
+        # Connect signals
+        self.conbus_protocol.on_connection_made.connect(self.connection_made)
+        self.conbus_protocol.on_telegram_sent.connect(self.telegram_sent)
+        self.conbus_protocol.on_telegram_received.connect(self.telegram_received)
+        self.conbus_protocol.on_timeout.connect(self.timeout)
+        self.conbus_protocol.on_failed.connect(self.failed)
+
+    def connection_made(self) -> None:
+        """Handle connection made event."""
         self.logger.debug("Connection established, sending blink command.")
         # Blink is 05, Unblink is 06
         system_function = SystemFunction.UNBLINK
         if self.on_or_off.lower() == "on":
             system_function = SystemFunction.BLINK
 
-        self.send_telegram(
+        self.conbus_protocol.send_telegram(
             telegram_type=TelegramType.SYSTEM,
             serial_number=self.serial_number,
             system_function=system_function,
@@ -113,8 +121,14 @@ class ConbusBlinkService(ConbusProtocol):
             self.service_response.serial_number = self.serial_number
             self.service_response.reply_telegram = reply_telegram
 
-            if self.finish_callback:
-                self.finish_callback(self.service_response)
+            self.on_finish.emit(self.service_response)
+
+    def timeout(self) -> None:
+        """Handle timeout event to stop operation."""
+        self.logger.info("Blink operation timeout")
+        self.service_response.success = False
+        self.service_response.error = "Blink operation timeout"
+        self.on_finish.emit(self.service_response)
 
     def failed(self, message: str) -> None:
         """Handle failed connection event.
@@ -126,14 +140,12 @@ class ConbusBlinkService(ConbusProtocol):
         self.service_response.success = False
         self.service_response.timestamp = datetime.now()
         self.service_response.error = message
-        if self.finish_callback:
-            self.finish_callback(self.service_response)
+        self.on_finish.emit(self.service_response)
 
     def send_blink_telegram(
         self,
         serial_number: str,
         on_or_off: str,
-        finish_callback: Callable[[ConbusBlinkResponse], None],
         timeout_seconds: Optional[float] = None,
     ) -> None:
         r"""Send blink command to start blinking module LED.
@@ -141,7 +153,6 @@ class ConbusBlinkService(ConbusProtocol):
         Args:
             serial_number: 10-digit module serial number.
             on_or_off: "on" to blink or "off" to unblink.
-            finish_callback: Callback function to call when the reply is received.
             timeout_seconds: Timeout in seconds.
 
         Examples:
@@ -151,8 +162,55 @@ class ConbusBlinkService(ConbusProtocol):
         """
         self.logger.info("Starting send_blink_telegram")
         if timeout_seconds:
-            self.timeout_seconds = timeout_seconds
-        self.finish_callback = finish_callback
+            self.conbus_protocol.timeout_seconds = timeout_seconds
         self.serial_number = serial_number
         self.on_or_off = on_or_off
-        self.start_reactor()
+        # Caller invokes start_reactor()
+
+    def set_timeout(self, timeout_seconds: float) -> None:
+        """Set operation timeout.
+
+        Args:
+            timeout_seconds: Timeout in seconds.
+        """
+        self.conbus_protocol.timeout_seconds = timeout_seconds
+
+    def start_reactor(self) -> None:
+        """Start the reactor."""
+        self.conbus_protocol.start_reactor()
+
+    def stop_reactor(self) -> None:
+        """Stop the reactor."""
+        self.conbus_protocol.stop_reactor()
+
+    def __enter__(self) -> "ConbusBlinkService":
+        """Enter context manager - reset state for singleton reuse.
+
+        Returns:
+            Self for context manager protocol.
+        """
+        # Reset state for singleton reuse
+        self.service_response = ConbusBlinkResponse(
+            success=False,
+            serial_number="",
+            system_function=SystemFunction.NONE,
+            operation="none",
+        )
+        self.serial_number = ""
+        self.on_or_off = "none"
+        return self
+
+    def __exit__(
+        self, _exc_type: Optional[type], _exc_val: Optional[Exception], _exc_tb: Any
+    ) -> None:
+        """Exit context manager - cleanup signals and reactor."""
+        # Disconnect protocol signals
+        self.conbus_protocol.on_connection_made.disconnect(self.connection_made)
+        self.conbus_protocol.on_telegram_sent.disconnect(self.telegram_sent)
+        self.conbus_protocol.on_telegram_received.disconnect(self.telegram_received)
+        self.conbus_protocol.on_timeout.disconnect(self.timeout)
+        self.conbus_protocol.on_failed.disconnect(self.failed)
+        # Disconnect service signals
+        self.on_finish.disconnect()
+        # Stop reactor
+        self.stop_reactor()

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

xp/utils/dependencies.py

@@ -265,8 +265,7 @@ class ServiceContainer:
         self.container.register(
             ConbusBlinkService,
             factory=lambda: ConbusBlinkService(
-                cli_config=self.container.resolve(ConbusClientConfig),
-                reactor=self.container.resolve(PosixReactorBase),
+                conbus_protocol=self.container.resolve(ConbusEventProtocol),
                 telegram_service=self.container.resolve(TelegramService),
             ),
             scope=punq.Scope.singleton,
@@ -275,8 +274,7 @@ class ServiceContainer:
         self.container.register(
             ConbusBlinkAllService,
             factory=lambda: ConbusBlinkAllService(
-                cli_config=self.container.resolve(ConbusClientConfig),
-                reactor=self.container.resolve(PosixReactorBase),
+                conbus_protocol=self.container.resolve(ConbusEventProtocol),
                 telegram_service=self.container.resolve(TelegramService),
             ),
             scope=punq.Scope.singleton,