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

xp/cli/commands/conbus/conbus_output_commands.py

@@ -5,9 +5,7 @@ import json
 import click
 
 from xp.cli.commands.conbus.conbus import conbus_output
-from xp.cli.utils.decorators import (
-    connection_command,
-)
+from xp.cli.utils.decorators import connection_command
 from xp.cli.utils.serial_number_type import SERIAL
 from xp.models import ConbusDatapointResponse
 from xp.models.conbus.conbus_output import ConbusOutputResponse
@@ -45,14 +43,16 @@ def xp_output_on(ctx: click.Context, serial_number: str, output_number: int) ->
             response: Output response object.
         """
         click.echo(json.dumps(response.to_dict(), indent=2))
+        service.stop_reactor()
 
     with service:
+        service.on_finish.connect(on_finish)
         service.send_action(
             serial_number=serial_number,
             output_number=output_number,
             action_type=ActionType.ON_RELEASE,
-            finish_callback=on_finish,
         )
+        service.start_reactor()
 
 
 @conbus_output.command("off")
@@ -83,14 +83,16 @@ def xp_output_off(ctx: click.Context, serial_number: str, output_number: int) ->
             response: Output response object.
         """
         click.echo(json.dumps(response.to_dict(), indent=2))
+        service.stop_reactor()
 
     with service:
+        service.on_finish.connect(on_finish)
         service.send_action(
             serial_number=serial_number,
             output_number=output_number,
             action_type=ActionType.OFF_PRESS,
-            finish_callback=on_finish,
         )
+        service.start_reactor()
 
 
 @conbus_output.command("status")
@@ -121,10 +123,10 @@ def xp_output_status(ctx: click.Context, serial_number: str) -> None:
         click.echo(json.dumps(response.to_dict(), indent=2))
 
     with service:
+        service.on_finish.connect(on_finish)
         service.query_datapoint(
             serial_number=serial_number,
             datapoint_type=DataPointType.MODULE_OUTPUT_STATE,
-            finish_callback=on_finish,
         )
 
 
@@ -156,8 +158,8 @@ def xp_module_state(ctx: click.Context, serial_number: str) -> None:
         click.echo(json.dumps(response.to_dict(), indent=2))
 
     with service:
+        service.on_finish.connect(on_finish)
         service.query_datapoint(
             serial_number=serial_number,
             datapoint_type=DataPointType.MODULE_STATE,
-            finish_callback=on_finish,
         )

xp/cli/commands/conbus/conbus_raw_commands.py

@@ -52,11 +52,16 @@ def send_raw_telegrams(ctx: Context, raw_telegrams: str) -> None:
             service_response: Raw response object.
         """
         click.echo(json.dumps(service_response.to_dict(), indent=2))
+        service.stop_reactor()
 
     with service:
+        # Connect service signals
+        service.on_progress.connect(on_progress)
+        service.on_finish.connect(on_finish)
+        # Setup
         service.send_raw_telegram(
             raw_input=raw_telegrams,
-            progress_callback=on_progress,
-            finish_callback=on_finish,
             timeout_seconds=5.0,
         )
+        # Start (blocks until completion)
+        service.start_reactor()

xp/cli/commands/conbus/conbus_scan_commands.py

@@ -48,11 +48,13 @@ def scan_module(ctx: Context, serial_number: str, function_code: str) -> None:
             service_response: Scan response object.
         """
         click.echo(json.dumps(service_response.to_dict(), indent=2))
+        service.stop_reactor()
 
     with service:
+        service.on_progress.connect(on_progress)
+        service.on_finish.connect(on_finish)
         service.scan_module(
             serial_number=serial_number,
             function_code=function_code,
-            progress_callback=on_progress,
-            finish_callback=on_finish,
         )
+        service.start_reactor()

xp/services/conbus/actiontable/actiontable_download_service.py

@@ -2,62 +2,68 @@
 
 import logging
 from dataclasses import asdict
-from typing import Any, Callable, Dict, Optional
+from typing import Any, Optional
 
-from twisted.internet.posixbase import PosixReactorBase
+from psygnal import Signal
 
-from xp.models import ConbusClientConfig
-from xp.models.actiontable.actiontable import ActionTable
 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.actiontable.actiontable_serializer import ActionTableSerializer
-from xp.services.protocol import ConbusProtocol
+from xp.services.protocol.conbus_event_protocol import ConbusEventProtocol
 from xp.services.telegram.telegram_service import TelegramService
 
 
-class ActionTableService(ConbusProtocol):
+class ActionTableService:
     """TCP client service for downloading action tables from Conbus modules.
 
     Manages TCP socket connections, handles telegram generation and transmission,
     and processes server responses for action table downloads.
+
+    Attributes:
+        on_progress: Signal emitted with telegram frame when progress is made.
+        on_error: Signal emitted with error message string when an error occurs.
+        on_finish: Signal emitted with (ActionTable, Dict[str, Any], list[str]) when complete.
     """
 
+    on_progress: Signal = Signal(str)
+    on_error: Signal = Signal(str)
+    on_finish: Signal = Signal(object)  # (ActionTable, Dict[str, Any], list[str])
+
     def __init__(
         self,
-        cli_config: ConbusClientConfig,
-        reactor: PosixReactorBase,
+        conbus_protocol: ConbusEventProtocol,
         actiontable_serializer: ActionTableSerializer,
         telegram_service: TelegramService,
     ) -> None:
         """Initialize the action table download service.
 
         Args:
-            cli_config: Conbus client configuration.
-            reactor: Twisted reactor instance.
+            conbus_protocol: ConbusEventProtocol instance.
             actiontable_serializer: Action table serializer.
             telegram_service: Telegram service for parsing.
         """
-        super().__init__(cli_config, reactor)
+        self.conbus_protocol = conbus_protocol
         self.serializer = actiontable_serializer
         self.telegram_service = telegram_service
         self.serial_number: str = ""
-        self.progress_callback: Optional[Callable[[str], None]] = None
-        self.error_callback: Optional[Callable[[str], None]] = None
-        self.finish_callback: Optional[
-            Callable[[ActionTable, Dict[str, Any], list[str]], None]
-        ] = None
-
         self.actiontable_data: list[str] = []
         # Set up logging
         self.logger = logging.getLogger(__name__)
 
-    def connection_established(self) -> None:
+        # 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 established event."""
         self.logger.debug(
             "Connection established, sending download actiontable telegram"
         )
-        self.send_telegram(
+        self.conbus_protocol.send_telegram(
             telegram_type=TelegramType.SYSTEM,
             serial_number=self.serial_number,
             system_function=SystemFunction.DOWNLOAD_ACTIONTABLE,
@@ -101,10 +107,9 @@ class ActionTableService(ConbusProtocol):
             self.logger.debug("Saving actiontable response")
             data_part = reply_telegram.data_value[2:]
             self.actiontable_data.append(data_part)
-            if self.progress_callback:
-                self.progress_callback(".")
+            self.on_progress.emit(".")
 
-            self.send_telegram(
+            self.conbus_protocol.send_telegram(
                 telegram_type=TelegramType.SYSTEM,
                 serial_number=self.serial_number,
                 system_function=SystemFunction.ACK,
@@ -118,8 +123,12 @@ class ActionTableService(ConbusProtocol):
             actiontable = self.serializer.from_encoded_string(all_data)
             actiontable_dict = asdict(actiontable)
             actiontable_short = self.serializer.format_decoded_output(actiontable)
-            if self.finish_callback:
-                self.finish_callback(actiontable, actiontable_dict, actiontable_short)
+            self.on_finish.emit((actiontable, actiontable_dict, actiontable_short))
+
+    def timeout(self) -> None:
+        """Handle timeout event."""
+        self.logger.debug("Timeout occurred")
+        self.failed("Timeout")
 
     def failed(self, message: str) -> None:
         """Handle failed connection event.
@@ -128,31 +137,64 @@ class ActionTableService(ConbusProtocol):
             message: Failure message.
         """
         self.logger.debug(f"Failed: {message}")
-        if self.error_callback:
-            self.error_callback(message)
+        self.on_error.emit(message)
 
     def start(
         self,
         serial_number: str,
-        progress_callback: Callable[[str], None],
-        error_callback: Callable[[str], None],
-        finish_callback: Callable[[ActionTable, Dict[str, Any], list[str]], None],
         timeout_seconds: Optional[float] = None,
     ) -> None:
         """Run reactor in dedicated thread with its own event loop.
 
         Args:
             serial_number: Module serial number.
-            progress_callback: Callback for progress updates.
-            error_callback: Callback for errors.
-            finish_callback: Callback when download completes.
             timeout_seconds: Optional timeout in seconds.
         """
         self.logger.info("Starting actiontable")
         self.serial_number = serial_number
         if timeout_seconds:
-            self.timeout_seconds = timeout_seconds
-        self.progress_callback = progress_callback
-        self.error_callback = error_callback
-        self.finish_callback = finish_callback
-        self.start_reactor()
+            self.conbus_protocol.timeout_seconds = timeout_seconds
+        # 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) -> "ActionTableService":
+        """Enter context manager - reset state for singleton reuse.
+
+        Returns:
+            Self for context manager protocol.
+        """
+        # Reset state for singleton reuse
+        self.actiontable_data = []
+        return self
+
+    def __exit__(
+        self, _exc_type: Optional[type], _exc_val: Optional[Exception], _exc_tb: Any
+    ) -> None:
+        """Exit context manager and disconnect signals."""
+        # 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_error.disconnect()
+        self.on_finish.disconnect()
+        # Stop reactor
+        self.stop_reactor()

xp/services/conbus/actiontable/actiontable_list_service.py

@@ -2,7 +2,9 @@
 
 import logging
 from pathlib import Path
-from typing import Any, Callable, Optional
+from typing import Any, Optional
+
+from psygnal import Signal
 
 
 class ActionTableListService:
@@ -10,13 +12,18 @@ class ActionTableListService:
 
     Reads conson.yml and returns a list of all modules that have action table
     configurations defined.
+
+    Attributes:
+        on_finish: Signal emitted with dict[str, Any] when listing completes.
+        on_error: Signal emitted with error message string when an error occurs.
     """
 
+    on_finish: Signal = Signal(object)  # dict[str, Any]
+    on_error: Signal = Signal(str)
+
     def __init__(self) -> None:
         """Initialize the action table list service."""
         self.logger = logging.getLogger(__name__)
-        self.finish_callback: Optional[Callable[[dict[str, Any]], None]] = None
-        self.error_callback: Optional[Callable[[str], None]] = None
 
     def __enter__(self) -> "ActionTableListService":
         """Context manager entry.
@@ -28,24 +35,19 @@ class ActionTableListService:
 
     def __exit__(self, _exc_type: Any, _exc_val: Any, _exc_tb: Any) -> None:
         """Context manager exit."""
-        pass
+        # Disconnect service signals
+        self.on_finish.disconnect()
+        self.on_error.disconnect()
 
     def start(
         self,
-        finish_callback: Callable[[dict[str, Any]], None],
-        error_callback: Callable[[str], None],
         config_path: Optional[Path] = None,
     ) -> None:
         """List all modules with action table configurations.
 
         Args:
-            finish_callback: Callback to invoke with the module list.
-            error_callback: Callback to invoke on error.
             config_path: Optional path to conson.yml. Defaults to current directory.
         """
-        self.finish_callback = finish_callback
-        self.error_callback = error_callback
-
         # Default to current directory if not specified
         if config_path is None:
             config_path = Path.cwd() / "conson.yml"
@@ -77,15 +79,13 @@ class ActionTableListService:
         # Prepare result
         result = {"modules": modules_with_actiontable}
 
-        # Invoke callback
-        if self.finish_callback is not None:
-            self.finish_callback(result)
+        # Emit finish signal
+        self.on_finish.emit(result)
 
     def _handle_error(self, message: str) -> None:
-        """Handle error and invoke error callback.
+        """Handle error and emit error signal.
 
         Args:
             message: Error message.
         """
-        if self.error_callback is not None:
-            self.error_callback(message)
+        self.on_error.emit(message)

xp/services/conbus/actiontable/actiontable_upload_service.py

@@ -1,31 +1,38 @@
 """Service for uploading ActionTable via Conbus protocol."""
 
 import logging
-from typing import Any, 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.homekit.homekit_conson_config import ConsonModuleListConfig
 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.actiontable.actiontable_serializer import ActionTableSerializer
-from xp.services.protocol import ConbusProtocol
+from xp.services.protocol.conbus_event_protocol import ConbusEventProtocol
 from xp.services.telegram.telegram_service import TelegramService
 
 
-class ActionTableUploadService(ConbusProtocol):
+class ActionTableUploadService:
     """TCP client service for uploading action tables to Conbus modules.
 
     Manages TCP socket connections, handles telegram generation and transmission,
     and processes server responses for action table uploads.
+
+    Attributes:
+        on_progress: Signal emitted with telegram frame when progress is made.
+        on_error: Signal emitted with error message string when an error occurs.
+        on_finish: Signal emitted with bool (True on success) when upload completes.
     """
 
+    on_progress: Signal = Signal(str)
+    on_error: Signal = Signal(str)
+    on_finish: Signal = Signal(bool)  # True on success
+
     def __init__(
         self,
-        cli_config: ConbusClientConfig,
-        reactor: PosixReactorBase,
+        conbus_protocol: ConbusEventProtocol,
         actiontable_serializer: ActionTableSerializer,
         telegram_service: TelegramService,
         conson_config: ConsonModuleListConfig,
@@ -33,20 +40,16 @@ class ActionTableUploadService(ConbusProtocol):
         """Initialize the action table upload service.
 
         Args:
-            cli_config: Conbus client configuration.
-            reactor: Twisted reactor instance.
+            conbus_protocol: ConbusEventProtocol for communication.
             actiontable_serializer: Action table serializer.
             telegram_service: Telegram service for parsing.
             conson_config: Conson module list configuration.
         """
-        super().__init__(cli_config, reactor)
+        self.conbus_protocol = conbus_protocol
         self.serializer = actiontable_serializer
         self.telegram_service = telegram_service
         self.conson_config = conson_config
         self.serial_number: str = ""
-        self.progress_callback: Optional[Callable[[str], None]] = None
-        self.error_callback: Optional[Callable[[str], None]] = None
-        self.success_callback: Optional[Callable[[], None]] = None
 
         # Upload state
         self.upload_data_chunks: list[str] = []
@@ -55,10 +58,17 @@ class ActionTableUploadService(ConbusProtocol):
         # Set up logging
         self.logger = logging.getLogger(__name__)
 
-    def connection_established(self) -> None:
+        # 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 established event."""
         self.logger.debug("Connection established, sending upload actiontable telegram")
-        self.send_telegram(
+        self.conbus_protocol.send_telegram(
             telegram_type=TelegramType.SYSTEM,
             serial_number=self.serial_number,
             system_function=SystemFunction.UPLOAD_ACTIONTABLE,
@@ -112,33 +122,35 @@ class ActionTableUploadService(ConbusProtocol):
                 # Second character: 'A' + chunk_index (sequential counter A-O for 15 chunks)
                 prefix_hex = f"AAA{ord('A') + self.current_chunk_index:c}"
 
-                self.send_telegram(
+                self.conbus_protocol.send_telegram(
                     telegram_type=TelegramType.SYSTEM,
                     serial_number=self.serial_number,
                     system_function=SystemFunction.ACTIONTABLE,
                     data_value=f"{prefix_hex}{chunk}",
                 )
                 self.current_chunk_index += 1
-                if self.progress_callback:
-                    self.progress_callback(".")
+                self.on_progress.emit(".")
             else:
                 # All chunks sent, send EOF
                 self.logger.debug("All chunks sent, sending EOF")
-                self.send_telegram(
+                self.conbus_protocol.send_telegram(
                     telegram_type=TelegramType.SYSTEM,
                     serial_number=self.serial_number,
                     system_function=SystemFunction.EOF,
                     data_value="00",
                 )
-                if self.success_callback:
-                    self.success_callback()
-                self._stop_reactor()
+                self.on_finish.emit(True)
         elif reply_telegram.system_function == SystemFunction.NAK:
             self.logger.debug("Received NAK during upload")
             self.failed("Upload failed: NAK received")
         else:
             self.logger.debug(f"Unexpected response during upload: {reply_telegram}")
 
+    def timeout(self) -> None:
+        """Handle timeout event."""
+        self.logger.debug("Upload timeout")
+        self.failed("Upload timeout")
+
     def failed(self, message: str) -> None:
         """Handle failed connection event.
 
@@ -146,16 +158,11 @@ class ActionTableUploadService(ConbusProtocol):
             message: Failure message.
         """
         self.logger.debug(f"Failed: {message}")
-        if self.error_callback:
-            self.error_callback(message)
-        self._stop_reactor()
+        self.on_error.emit(message)
 
     def start(
         self,
         serial_number: str,
-        progress_callback: Callable[[str], None],
-        error_callback: Callable[[str], None],
-        success_callback: Callable[[], None],
         timeout_seconds: Optional[float] = None,
     ) -> None:
         """Upload action table to module.
@@ -164,18 +171,12 @@ class ActionTableUploadService(ConbusProtocol):
 
         Args:
             serial_number: Module serial number.
-            progress_callback: Callback for progress updates.
-            error_callback: Callback for errors.
-            success_callback: Callback when upload completes successfully.
             timeout_seconds: Optional timeout in seconds.
         """
         self.logger.info("Starting actiontable upload")
         self.serial_number = serial_number
         if timeout_seconds:
-            self.timeout_seconds = timeout_seconds
-        self.progress_callback = progress_callback
-        self.error_callback = error_callback
-        self.success_callback = success_callback
+            self.conbus_protocol.timeout_seconds = timeout_seconds
 
         # Find module
         module = self.conson_config.find_module(serial_number)
@@ -208,4 +209,45 @@ class ActionTableUploadService(ConbusProtocol):
             f"{len(self.upload_data_chunks)} chunks"
         )
 
-        self.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) -> "ActionTableUploadService":
+        """Enter context manager - reset state for singleton reuse.
+
+        Returns:
+            Self for context manager protocol.
+        """
+        # Reset state
+        self.upload_data_chunks = []
+        self.current_chunk_index = 0
+        self.serial_number = ""
+        return self
+
+    def __exit__(self, _exc_type: Any, _exc_val: Any, _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_error.disconnect()
+        self.on_finish.disconnect()
+        # Stop reactor
+        self.stop_reactor()