conson-xp 0.11.21__py3-none-any.whl → 1.1.0__py3-none-any.whl

xp/services/conbus/conbus_output_service.py

@@ -1,137 +1,174 @@
-"""Conbus Client Send Service for TCP communication with Conbus servers.
+"""Conbus Output Service for sending action telegrams to Conbus modules.
 
-This service implements a TCP client that connects to Conbus servers and sends
-various types of telegrams including discover, version, and sensor data requests.
+This service handles sending action telegrams (ON/OFF) to module outputs
+and processing ACK/NAK responses.
 """
 
 import logging
 from datetime import datetime
-from typing import Any, Optional
+from typing import Callable, Optional
 
-from xp.models import ConbusDatapointResponse
+from twisted.internet.posixbase import PosixReactorBase
+
+from xp.models import ConbusClientConfig
 from xp.models.conbus.conbus_output import ConbusOutputResponse
+from xp.models.protocol.conbus_protocol import TelegramReceivedEvent
 from xp.models.telegram.action_type import ActionType
-from xp.models.telegram.datapoint_type import DataPointType
+from xp.models.telegram.output_telegram import OutputTelegram
 from xp.models.telegram.system_function import SystemFunction
-from xp.services.conbus.conbus_datapoint_service import ConbusDatapointService
-from xp.services.conbus.conbus_service import ConbusService
-from xp.services.telegram.telegram_output_service import TelegramOutputService
-from xp.services.telegram.telegram_service import TelegramService
+from xp.models.telegram.telegram_type import TelegramType
+from xp.services.protocol import ConbusProtocol
+from xp.services.telegram.telegram_output_service import (
+    TelegramOutputService,
+    XPOutputError,
+)
 
 
 class ConbusOutputError(Exception):
-    """Raised when Conbus client send operations fail"""
+    """Raised when Conbus output operations fail"""
 
     pass
 
 
-class ConbusOutputService:
+class ConbusOutputService(ConbusProtocol):
     """
-    TCP client service for sending telegrams to Conbus servers.
+    Service for sending action telegrams to Conbus module outputs.
 
-    Manages TCP socket connections, handles telegram generation and transmission,
-    and processes server responses.
+    Manages action telegram transmission (ON/OFF) and processes
+    ACK/NAK responses from modules.
     """
 
     def __init__(
         self,
-        telegram_service: TelegramService,
         telegram_output_service: TelegramOutputService,
-        datapoint_service: ConbusDatapointService,
-        conbus_service: ConbusService,
+        cli_config: ConbusClientConfig,
+        reactor: PosixReactorBase,
     ):
-        """Initialize the Conbus client send service
+        """Initialize the Conbus output service
 
         Args:
-            telegram_service: TelegramService for dependency injection
-            telegram_output_service: TelegramOutputService for dependency injection
-            datapoint_service: ConbusDatapointService for dependency injection
-            conbus_service: ConbusService for dependency injection
+            telegram_output_service: TelegramOutputService for telegram generation/parsing
+            cli_config: Conbus client configuration
+            reactor: Twisted reactor for async operations
         """
-
-        # Service dependencies
-        self.telegram_service = telegram_service
+        super().__init__(cli_config, reactor)
         self.telegram_output_service = telegram_output_service
-        self.datapoint_service = datapoint_service
-        self.conbus_service = conbus_service
+        self.serial_number: str = ""
+        self.output_number: int = 0
+        self.action_type: ActionType = ActionType.ON_RELEASE
+        self.finish_callback: Optional[Callable[[ConbusOutputResponse], None]] = None
+        self.service_response: ConbusOutputResponse = ConbusOutputResponse(
+            success=False,
+            serial_number=self.serial_number,
+            output_number=self.output_number,
+            action_type=self.action_type,
+            timestamp=datetime.now(),
+        )
 
         # Set up logging
         self.logger = logging.getLogger(__name__)
 
-    def __enter__(self) -> "ConbusOutputService":
-        return self
-
-    def __exit__(
-        self,
-        _exc_type: Optional[type],
-        _exc_val: Optional[Exception],
-        _exc_tb: Optional[Any],
-    ) -> None:
-        # Cleanup logic if needed
-        pass
-
-    def get_output_state(self, serial_number: str) -> ConbusDatapointResponse:
-        # TODO: Migrate to new ConbusDatapointService callback-based API
-        # Send status query using custom telegram method
-        response = self.datapoint_service.query_datapoint(  # type: ignore[call-arg,func-returns-value]
-            serial_number=serial_number,
-            datapoint_type=DataPointType.MODULE_OUTPUT_STATE,  # "12"
+    def connection_established(self) -> None:
+        self.logger.debug(
+            f"Connection established, sending action {self.action_type} to output {self.output_number}..."
         )
 
-        return response  # type: ignore[no-any-return]
-
-    def get_module_state(self, serial_number: str) -> ConbusDatapointResponse:
-        # TODO: Migrate to new ConbusDatapointService callback-based API
-        # Send status query using custom telegram method
-        response = self.datapoint_service.query_datapoint(  # type: ignore[call-arg,func-returns-value]
-            serial_number=serial_number, datapoint_type=DataPointType.MODULE_STATE
+        # Validate parameters before sending
+        try:
+            self.telegram_output_service.validate_output_number(self.output_number)
+            self.telegram_output_service.validate_serial_number(self.serial_number)
+        except XPOutputError as e:
+            self.failed(str(e))
+            return
+
+        # Send F27D{output:02d}{action} telegram
+        # F27 = ACTION, D = data with output number and action type
+        self.send_telegram(
+            telegram_type=TelegramType.SYSTEM,
+            serial_number=self.serial_number,
+            system_function=SystemFunction.ACTION,
+            data_value=f"{self.output_number:02d}{self.action_type.value}",
         )
 
-        return response  # type: ignore[no-any-return]
+    def telegram_sent(self, telegram_sent: str) -> None:
+        self.service_response.sent_telegram = telegram_sent
 
-    def send_action(
-        self, serial_number: str, output_number: int, action_type: ActionType
-    ) -> ConbusOutputResponse:
+    def telegram_received(self, telegram_received: TelegramReceivedEvent) -> None:
+        self.logger.debug(f"Telegram received: {telegram_received}")
 
-        # Parse input number and send action
-        self.telegram_output_service.validate_output_number(output_number)
+        if not self.service_response.received_telegrams:
+            self.service_response.received_telegrams = []
+        self.service_response.received_telegrams.append(telegram_received.frame)
 
-        # Send action telegram using custom telegram method
-        # Format: F27D{input:02d}AA (Function 27, input number, PRESS action)
-        action_value = action_type.value
+        if (
+            not telegram_received.checksum_valid
+            or telegram_received.telegram_type != TelegramType.REPLY
+            or telegram_received.serial_number != self.serial_number
+        ):
+            self.logger.debug("Not a reply for our serial number")
+            return
 
-        input_action = f"{output_number:02d}{action_value}"
-        response = self.conbus_service.send_telegram(
-            serial_number,
-            SystemFunction.ACTION,  # "27"
-            input_action,  # "00AA", "01AA", etc.
+        # Parse the reply telegram to get ACK/NAK
+        output_telegram = self.telegram_output_service.parse_reply_telegram(
+            telegram_received.frame
         )
 
-        if (
-            not response.success
-            or response.received_telegrams is None
-            or len(response.received_telegrams) <= 0
+        if output_telegram and output_telegram.system_function in (
+            SystemFunction.ACK,
+            SystemFunction.NAK,
         ):
-
-            return ConbusOutputResponse(
-                success=response.success,
-                serial_number=serial_number,
-                output_number=output_number,
-                action_type=action_type,
-                error=response.error,
-                timestamp=response.timestamp or datetime.now(),
-                received_telegrams=response.received_telegrams,
+            self.logger.debug(f"Received {output_telegram.system_function} response")
+            self.succeed(output_telegram)
+        else:
+            self.logger.debug(
+                f"Unexpected system function: {output_telegram.system_function}"
             )
 
-        telegram = response.received_telegrams[0]
-        output_telegram = self.telegram_output_service.parse_reply_telegram(telegram)
-
-        return ConbusOutputResponse(
-            success=response.success,
-            serial_number=serial_number,
-            output_number=output_number,
-            action_type=action_type,
-            output_telegram=output_telegram,
-            timestamp=response.timestamp or datetime.now(),
-            received_telegrams=response.received_telegrams,
-        )
+    def succeed(self, output_telegram: OutputTelegram) -> None:
+        self.logger.debug("Successfully sent action to output")
+        self.service_response.success = True
+        self.service_response.timestamp = datetime.now()
+        self.service_response.serial_number = self.serial_number
+        self.service_response.output_number = self.output_number
+        self.service_response.action_type = self.action_type
+        self.service_response.output_telegram = output_telegram
+        if self.finish_callback:
+            self.finish_callback(self.service_response)
+
+    def failed(self, message: str) -> None:
+        self.logger.debug(f"Failed with message: {message}")
+        self.service_response.success = False
+        self.service_response.timestamp = datetime.now()
+        self.service_response.serial_number = self.serial_number
+        self.service_response.output_number = self.output_number
+        self.service_response.action_type = self.action_type
+        self.service_response.error = message
+        if self.finish_callback:
+            self.finish_callback(self.service_response)
+
+    def send_action(
+        self,
+        serial_number: str,
+        output_number: int,
+        action_type: ActionType,
+        finish_callback: Callable[[ConbusOutputResponse], None],
+        timeout_seconds: Optional[float] = None,
+    ) -> None:
+        """
+        Send an action telegram to a module output.
+
+        Args:
+            serial_number: 10-digit module serial number
+            output_number: Output number (0-99)
+            action_type: Action to perform (ON_RELEASE, OFF_PRESS, etc.)
+            finish_callback: Callback function to call when operation completes
+            timeout_seconds: Optional timeout in seconds
+        """
+        self.logger.info("Starting send_action")
+        if timeout_seconds:
+            self.timeout_seconds = timeout_seconds
+        self.serial_number = serial_number
+        self.output_number = output_number
+        self.action_type = action_type
+        self.finish_callback = finish_callback
+        self.start_reactor()

xp/services/conbus/conbus_scan_service.py

@@ -5,124 +5,120 @@ various types of telegrams including discover, version, and sensor data requests
 """
 
 import logging
-import threading
-from typing import Any, Callable, List, Optional
+from datetime import datetime
+from typing import Callable, Optional
+
+from twisted.internet.posixbase import PosixReactorBase
 
 from xp.models import (
-    ConbusRequest,
+    ConbusClientConfig,
     ConbusResponse,
 )
-from xp.services.conbus.conbus_service import ConbusService
-from xp.services.telegram.telegram_service import TelegramService
-
-
-class ConbusScanError(Exception):
-    """Raised when Conbus client send operations fail"""
+from xp.models.protocol.conbus_protocol import TelegramReceivedEvent
+from xp.services.protocol import ConbusProtocol
 
-    pass
 
-
-class ConbusScanService:
+class ConbusScanService(ConbusProtocol):
     """
-    TCP client service for sending telegrams to Conbus servers.
+    Service for querying datapoints from Conbus modules.
 
-    Manages TCP socket connections, handles telegram generation and transmission,
-    and processes server responses.
+    Uses ConbusProtocol to provide datapoint query functionality
+    for reading sensor data and module information.
     """
 
     def __init__(
         self,
-        telegram_service: TelegramService,
-        conbus_service: ConbusService,
-    ):
-        """Initialize the Conbus client send service
-
-        Args:
-            telegram_service: TelegramService for dependency injection
-            conbus_service: ConbusService for dependency injection
-        """
-
-        # Service dependencies
-        self.telegram_service = telegram_service
-        self.conbus_service = conbus_service
-
+        cli_config: ConbusClientConfig,
+        reactor: PosixReactorBase,
+    ) -> None:
+        """Initialize the Conbus datapoint service"""
+        super().__init__(cli_config, reactor)
+        self.serial_number: str = ""
+        self.function_code: str = ""
+        self.datapoint_value: int = -1
+        self.progress_callback: Optional[Callable[[str], None]] = None
+        self.finish_callback: Optional[Callable[[ConbusResponse], None]] = None
+        self.service_response: ConbusResponse = ConbusResponse(
+            success=False,
+            serial_number=self.serial_number,
+            sent_telegrams=[],
+            received_telegrams=[],
+            timestamp=datetime.now(),
+        )
         # Set up logging
         self.logger = logging.getLogger(__name__)
 
+    def connection_established(self) -> None:
+        self.logger.debug("Connection established, starting scan")
+        self.scan_next_datacode()
+
+    def scan_next_datacode(self) -> bool:
+        self.datapoint_value += 1
+        if self.datapoint_value >= 100:
+            if self.finish_callback:
+                self.finish_callback(self.service_response)
+            return False
+
+        self.logger.debug(f"Scanning next datacode: {self.datapoint_value:02d}")
+        data = f"{self.datapoint_value:02d}"
+        telegram_body = f"S{self.serial_number}F{self.function_code}D{data}"
+        self.sendFrame(telegram_body.encode())
+        return True
+
+    def telegram_sent(self, telegram_sent: str) -> None:
+        self.service_response.success = True
+        self.service_response.sent_telegrams.append(telegram_sent)
+
+    def telegram_received(self, telegram_received: TelegramReceivedEvent) -> None:
+        self.logger.debug(f"Telegram received: {telegram_received}")
+        if not self.service_response.received_telegrams:
+            self.service_response.received_telegrams = []
+        self.service_response.received_telegrams.append(telegram_received.frame)
+
+        if self.progress_callback:
+            self.progress_callback(telegram_received.frame)
+
+    def timeout(self) -> bool:
+        self.logger.debug(f"Timeout: {self.timeout_seconds}s")
+        continue_scan = self.scan_next_datacode()
+        return continue_scan
+
+    def failed(self, message: str) -> None:
+        self.logger.debug(f"Failed with message: {message}")
+        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)
+
     def scan_module(
         self,
         serial_number: str,
         function_code: str,
-        progress_callback: Optional[Callable[[ConbusResponse, int, int], Any]] = None,
-    ) -> List[ConbusResponse]:
-        """Scan all functions and datapoints for a module with live output"""
-        results = []
-        total_combinations = 100  # 65536 combinations
-        count = 0
-
-        for datapoint_hex in range(99):
-            data = f"{datapoint_hex:02d}"
-            count += 1
-
-            try:
-                telegram_body = f"S{serial_number}F{function_code}D{data}"
-                response = self.conbus_service.send_telegram_body(telegram_body)
-                results.append(response)
-
-                # Call progress callback with live results
-                if progress_callback:
-                    progress_callback(response, count, total_combinations)
-
-                # Small delay to prevent overwhelming the server
-                import time
-
-                time.sleep(0.001)  # 1ms delay
-
-            except Exception as e:
-                # Create error response for failed scan attempt
-                error_response = ConbusResponse(
-                    success=False,
-                    request=ConbusRequest(
-                        serial_number=serial_number,
-                        function_code=function_code,
-                        data=data,
-                    ),
-                    error=f"Scan failed for F{function_code}D{data}: {e}",
-                )
-                results.append(error_response)
-
-                # Call progress callback with error response
-                if progress_callback:
-                    progress_callback(error_response, count, total_combinations)
-
-        return results
-
-    def scan_module_background(
-        self,
-        serial_number: str,
-        function_code: str,
-        progress_callback: Optional[Callable[[ConbusResponse, int, int], Any]] = None,
-    ) -> threading.Thread:
-        """Scan module in background with immediate output via callback"""
-        import threading
-
-        def background_scan() -> List[ConbusResponse]:
-            return self.scan_module(serial_number, function_code, progress_callback)
-
-        # Start background thread
-        scan_thread = threading.Thread(target=background_scan, daemon=True)
-        scan_thread.start()
+        progress_callback: Callable[[str], None],
+        finish_callback: Callable[[ConbusResponse], None],
+        timeout_seconds: Optional[float] = None,
+    ) -> None:
+        """
+        Query a specific datapoint from a module.
 
-        return scan_thread
+        Args:
+            serial_number: 10-digit module serial number
+            function_code: the function code to scan
+            progress_callback: callback to handle progress
+            finish_callback: callback function to call when the datapoint is received
+            timeout_seconds: timeout in seconds
+
+        Returns:
+            ConbusDatapointResponse with operation result and datapoint value
+        """
 
-    def __enter__(self) -> "ConbusScanService":
-        return self
+        self.logger.info("Starting query_datapoint")
+        if timeout_seconds:
+            self.timeout_seconds = timeout_seconds
 
-    def __exit__(
-        self,
-        _exc_type: Optional[type],
-        _exc_val: Optional[BaseException],
-        _exc_tb: Optional[Any],
-    ) -> None:
-        # Cleanup logic if needed
-        pass
+        self.serial_number = serial_number
+        self.function_code = function_code
+        self.progress_callback = progress_callback
+        self.finish_callback = finish_callback
+        self.start_reactor()

xp/services/protocol/conbus_protocol.py

@@ -75,7 +75,7 @@ class ConbusProtocol(protocol.Protocol, protocol.ClientFactory):
                 )
 
             self.logger.debug(
-                f"frameReceived payload: {payload.decode()}, checksum: {checksum}"
+                f"frameReceived payload: {payload.decode('latin-1')}, checksum: {checksum}"
             )
 
             # Reset timeout on activity
@@ -83,9 +83,9 @@ class ConbusProtocol(protocol.Protocol, protocol.ClientFactory):
 
             telegram_received = TelegramReceivedEvent(
                 protocol=self,
-                frame=frame.decode(),
-                telegram=telegram.decode(),
-                payload=payload.decode(),
+                frame=frame.decode("latin-1"),
+                telegram=telegram.decode("latin-1"),
+                payload=payload.decode("latin-1"),
                 telegram_type=telegram_type,
                 serial_number=serial_number,
                 checksum=checksum,
@@ -112,6 +112,7 @@ class ConbusProtocol(protocol.Protocol, protocol.ClientFactory):
         self.logger.debug(f"Sending frame: {frame.decode()}")
         self.transport.write(frame)  # type: ignore
         self.telegram_sent(frame.decode())
+        self._reset_timeout()
 
     def send_telegram(
         self,
@@ -145,6 +146,7 @@ class ConbusProtocol(protocol.Protocol, protocol.ClientFactory):
         self._stop_reactor()
 
     def timeout(self) -> bool:
+        """Timeout callback, return True to continue waiting for next timeout, False to stop"""
         self.logger.info("Timeout after: %ss", self.timeout_seconds)
         self.failed(f"Timeout after: {self.timeout_seconds}s")
         return False

xp/utils/dependencies.py

@@ -25,10 +25,6 @@ from xp.services.conbus.conbus_autoreport_get_service import ConbusAutoreportGet
 from xp.services.conbus.conbus_autoreport_set_service import ConbusAutoreportSetService
 from xp.services.conbus.conbus_blink_all_service import ConbusBlinkAllService
 from xp.services.conbus.conbus_blink_service import ConbusBlinkService
-from xp.services.conbus.conbus_connection_pool import (
-    ConbusConnectionPool,
-    ConbusSocketConnectionManager,
-)
 from xp.services.conbus.conbus_custom_service import ConbusCustomService
 from xp.services.conbus.conbus_datapoint_queryall_service import (
     ConbusDatapointQueryAllService,
@@ -38,12 +34,12 @@ from xp.services.conbus.conbus_datapoint_service import (
 )
 from xp.services.conbus.conbus_discover_service import ConbusDiscoverService
 from xp.services.conbus.conbus_lightlevel_set_service import ConbusLightlevelSetService
-from xp.services.conbus.conbus_linknumber_service import ConbusLinknumberService
+from xp.services.conbus.conbus_linknumber_get_service import ConbusLinknumberGetService
+from xp.services.conbus.conbus_linknumber_set_service import ConbusLinknumberSetService
 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.conbus_service import ConbusService
 from xp.services.homekit.homekit_cache_service import HomeKitCacheService
 from xp.services.homekit.homekit_conbus_service import HomeKitConbusService
 from xp.services.homekit.homekit_dimminglight_service import HomeKitDimmingLightService
@@ -106,30 +102,13 @@ class ServiceContainer:
     def _register_services(self) -> None:
         """Register all services in the container based on dependency graph."""
 
-        # ConbusClientConfig (needed by ConbusConnectionPool)
+        # ConbusClientConfig
         self.container.register(
             ConbusClientConfig,
             factory=lambda: ConbusClientConfig.from_yaml(self._config_path),
             scope=punq.Scope.singleton,
         )
 
-        # Core infrastructure layer - ConbusConnectionPool (singleton)
-        self.container.register(
-            ConbusSocketConnectionManager,
-            factory=lambda: ConbusSocketConnectionManager(
-                cli_config=self.container.resolve(ConbusClientConfig)
-            ),
-            scope=punq.Scope.singleton,
-        )
-
-        self.container.register(
-            ConbusConnectionPool,
-            factory=lambda: ConbusConnectionPool(
-                connection_manager=self.container.resolve(ConbusSocketConnectionManager)
-            ),
-            scope=punq.Scope.singleton,
-        )
-
         # Telegram services layer
         self.container.register(TelegramService, scope=punq.Scope.singleton)
         self.container.register(
@@ -143,16 +122,6 @@ class ServiceContainer:
         self.container.register(TelegramBlinkService, scope=punq.Scope.singleton)
         self.container.register(LinkNumberService, scope=punq.Scope.singleton)
 
-        # ConbusService - depends on ConbusConnectionPool
-        self.container.register(
-            ConbusService,
-            factory=lambda: ConbusService(
-                client_config=self.container.resolve(ConbusClientConfig),
-                connection_pool=self.container.resolve(ConbusConnectionPool),
-            ),
-            scope=punq.Scope.singleton,
-        )
-
         # Conbus services layer
         self.container.register(
             ConbusDatapointService,
@@ -177,8 +146,8 @@ class ServiceContainer:
         self.container.register(
             ConbusScanService,
             factory=lambda: ConbusScanService(
-                telegram_service=self.container.resolve(TelegramService),
-                conbus_service=self.container.resolve(ConbusService),
+                cli_config=self.container.resolve(ConbusClientConfig),
+                reactor=self.container.resolve(PosixReactorBase),
             ),
             scope=punq.Scope.singleton,
         )
@@ -215,10 +184,9 @@ class ServiceContainer:
         self.container.register(
             ConbusOutputService,
             factory=lambda: ConbusOutputService(
-                telegram_service=self.container.resolve(TelegramService),
                 telegram_output_service=self.container.resolve(TelegramOutputService),
-                datapoint_service=self.container.resolve(ConbusDatapointService),
-                conbus_service=self.container.resolve(ConbusService),
+                cli_config=self.container.resolve(ConbusClientConfig),
+                reactor=self.container.resolve(PosixReactorBase),
             ),
             scope=punq.Scope.singleton,
         )
@@ -300,12 +268,21 @@ class ServiceContainer:
         )
 
         self.container.register(
-            ConbusLinknumberService,
-            factory=lambda: ConbusLinknumberService(
-                conbus_service=self.container.resolve(ConbusService),
-                datapoint_service=self.container.resolve(ConbusDatapointService),
-                link_number_service=self.container.resolve(LinkNumberService),
+            ConbusLinknumberGetService,
+            factory=lambda: ConbusLinknumberGetService(
+                telegram_service=self.container.resolve(TelegramService),
+                cli_config=self.container.resolve(ConbusClientConfig),
+                reactor=self.container.resolve(PosixReactorBase),
+            ),
+            scope=punq.Scope.singleton,
+        )
+
+        self.container.register(
+            ConbusLinknumberSetService,
+            factory=lambda: ConbusLinknumberSetService(
                 telegram_service=self.container.resolve(TelegramService),
+                cli_config=self.container.resolve(ConbusClientConfig),
+                reactor=self.container.resolve(PosixReactorBase),
             ),
             scope=punq.Scope.singleton,
         )