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

xp/services/conbus/conbus_raw_service.py

@@ -4,76 +4,99 @@ This service handles sending raw telegram strings without prior validation.
 """
 
 import logging
-from typing import Any, Optional
-
-from xp.models.conbus.conbus_raw import ConbusRawResponse
-from xp.services.conbus.conbus_service import ConbusService
+from datetime import datetime
+from typing import Callable, Optional
 
+from twisted.internet.posixbase import PosixReactorBase
 
-class ConbusRawError(Exception):
-    """Raised when Conbus raw operations fail"""
-
-    pass
+from xp.models import ConbusClientConfig
+from xp.models.conbus.conbus_raw import ConbusRawResponse
+from xp.models.protocol.conbus_protocol import TelegramReceivedEvent
+from xp.services.protocol import ConbusProtocol
 
 
-class ConbusRawService:
+class ConbusRawService(ConbusProtocol):
     """
-    Service for sending raw telegram sequences to Conbus servers.
+    Service for querying datapoints from Conbus modules.
 
-    Handles parsing and sending of raw telegram strings without validation.
+    Uses ConbusProtocol to provide datapoint query functionality
+    for reading sensor data and module information.
     """
 
     def __init__(
         self,
-        conbus_service: ConbusService,
-    ):
-        """Initialize the Conbus raw service"""
-        self.conbus_service = conbus_service
+        cli_config: ConbusClientConfig,
+        reactor: PosixReactorBase,
+    ) -> None:
+        """Initialize the Conbus datapoint service"""
+        super().__init__(cli_config, reactor)
+        self.raw_input: str = ""
+        self.progress_callback: Optional[Callable[[str], None]] = None
+        self.finish_callback: Optional[Callable[[ConbusRawResponse], None]] = None
+        self.service_response: ConbusRawResponse = ConbusRawResponse(
+            success=False,
+        )
+        # Set up logging
         self.logger = logging.getLogger(__name__)
 
-    def send_raw_telegrams(self, raw_input: str) -> ConbusRawResponse:
+    def connection_established(self) -> None:
+        self.logger.debug(f"Connection established, sending {self.raw_input}")
+        self.sendFrame(self.raw_input.encode())
+
+    def telegram_sent(self, telegram_sent: str) -> None:
+        self.service_response.success = True
+        self.service_response.sent_telegrams = telegram_sent
+        self.service_response.timestamp = datetime.now()
+        self.service_response.received_telegrams = []
+        pass
+
+    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")
+        if self.finish_callback:
+            self.finish_callback(self.service_response)
+        return False
+
+    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 send_raw_telegram(
+        self,
+        raw_input: str,
+        progress_callback: Callable[[str], None],
+        finish_callback: Callable[[ConbusRawResponse], None],
+        timeout_seconds: Optional[float] = None,
+    ) -> None:
         """
-        Send raw telegram sequence to Conbus server.
+        Query a specific datapoint from a module.
 
         Args:
-            raw_input: Raw string containing one or more telegrams
+            serial_number: 10-digit module serial number
+            datapoint_type: Type of datapoint to query
+            finish_callback: callback function to call when the datapoint is received
+            timeout_seconds: timeout in seconds
 
         Returns:
-            ConbusRawResponse containing results
+            ConbusDatapointResponse with operation result and datapoint value
         """
-        try:
-
-            self.logger.info(f"Sending raw telegram: {raw_input}")
 
-            response = self.conbus_service.send_raw_telegram(raw_input)
-
-            if not response.success:
-                return ConbusRawResponse(
-                    success=False,
-                    sent_telegrams=raw_input,
-                    error=f"Failed to send telegram {raw_input}: {response.error}",
-                )
-
-            return ConbusRawResponse(
-                success=True,
-                sent_telegrams=raw_input,
-                received_telegrams=response.received_telegrams,
-            )
-
-        except Exception as e:
-            error_msg = f"Failed to send raw telegrams: {e}"
-            self.logger.error(error_msg)
-            return ConbusRawResponse(success=False, error=error_msg)
-
-    def __enter__(self) -> "ConbusRawService":
-        """Context manager entry"""
-        return self
-
-    def __exit__(
-        self,
-        _exc_type: Optional[type],
-        _exc_val: Optional[BaseException],
-        _exc_tb: Optional[Any],
-    ) -> None:
-        """Context manager exit - ensure connection is closed"""
-        self.conbus_service.disconnect()
+        self.logger.info("Starting query_datapoint")
+        if timeout_seconds:
+            self.timeout_seconds = timeout_seconds
+        self.progress_callback = progress_callback
+        self.finish_callback = finish_callback
+        self.raw_input = raw_input
+        self.start_reactor()

xp/utils/dependencies.py

@@ -23,6 +23,7 @@ from xp.services.conbus.actiontable.msactiontable_xp33_serializer import (
 )
 from xp.services.conbus.conbus_autoreport_get_service import ConbusAutoreportGetService
 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,
@@ -36,7 +37,7 @@ from xp.services.conbus.conbus_datapoint_service import (
     ConbusDatapointService,
 )
 from xp.services.conbus.conbus_discover_service import ConbusDiscoverService
-from xp.services.conbus.conbus_lightlevel_service import ConbusLightlevelService
+from xp.services.conbus.conbus_lightlevel_set_service import ConbusLightlevelSetService
 from xp.services.conbus.conbus_linknumber_service import ConbusLinknumberService
 from xp.services.conbus.conbus_output_service import ConbusOutputService
 from xp.services.conbus.conbus_raw_service import ConbusRawService
@@ -194,11 +195,18 @@ class ServiceContainer:
         self.container.register(
             ConbusBlinkService,
             factory=lambda: ConbusBlinkService(
-                conbus_service=self.container.resolve(ConbusService),
-                telegram_discover_service=self.container.resolve(
-                    TelegramDiscoverService
-                ),
-                telegram_blink_service=self.container.resolve(TelegramBlinkService),
+                cli_config=self.container.resolve(ConbusClientConfig),
+                reactor=self.container.resolve(PosixReactorBase),
+                telegram_service=self.container.resolve(TelegramService),
+            ),
+            scope=punq.Scope.singleton,
+        )
+
+        self.container.register(
+            ConbusBlinkAllService,
+            factory=lambda: ConbusBlinkAllService(
+                cli_config=self.container.resolve(ConbusClientConfig),
+                reactor=self.container.resolve(PosixReactorBase),
                 telegram_service=self.container.resolve(TelegramService),
             ),
             scope=punq.Scope.singleton,
@@ -216,11 +224,10 @@ class ServiceContainer:
         )
 
         self.container.register(
-            ConbusLightlevelService,
-            factory=lambda: ConbusLightlevelService(
-                telegram_service=self.container.resolve(TelegramService),
-                conbus_service=self.container.resolve(ConbusService),
-                datapoint_service=self.container.resolve(ConbusDatapointService),
+            ConbusLightlevelSetService,
+            factory=lambda: ConbusLightlevelSetService(
+                cli_config=self.container.resolve(ConbusClientConfig),
+                reactor=self.container.resolve(PosixReactorBase),
             ),
             scope=punq.Scope.singleton,
         )
@@ -316,7 +323,8 @@ class ServiceContainer:
         self.container.register(
             ConbusRawService,
             factory=lambda: ConbusRawService(
-                conbus_service=self.container.resolve(ConbusService),
+                cli_config=self.container.resolve(ConbusClientConfig),
+                reactor=self.container.resolve(PosixReactorBase),
             ),
             scope=punq.Scope.singleton,
         )

xp/services/conbus/conbus_lightlevel_service.py

@@ -1,205 +0,0 @@
-"""Conbus Lightlevel Service for controlling light levels on Conbus modules.
-
-This service implements lightlevel control operations for XP modules,
-including setting specific light levels, turning lights on/off, and
-querying current light levels.
-"""
-
-import logging
-from datetime import datetime
-from typing import Any, Optional
-
-from xp.models.conbus.conbus_lightlevel import ConbusLightlevelResponse
-from xp.models.telegram.datapoint_type import DataPointType
-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_service import TelegramService
-
-
-class ConbusLightlevelError(Exception):
-    """Raised when Conbus lightlevel operations fail"""
-
-    pass
-
-
-class ConbusLightlevelService:
-    """
-    Service for controlling light levels on Conbus modules.
-
-    Manages lightlevel operations including setting specific levels,
-    turning lights on/off, and querying current states.
-    """
-
-    def __init__(
-        self,
-        telegram_service: TelegramService,
-        conbus_service: ConbusService,
-        datapoint_service: ConbusDatapointService,
-    ):
-        """Initialize the Conbus lightlevel service"""
-
-        # Service dependencies
-        self.telegram_service = telegram_service
-        self.conbus_service = conbus_service
-        self.datapoint_service = datapoint_service
-
-        # Set up logging
-        self.logger = logging.getLogger(__name__)
-
-    def __enter__(self) -> "ConbusLightlevelService":
-        return self
-
-    def __exit__(
-        self,
-        _exc_type: Optional[type],
-        _exc_val: Optional[Exception],
-        _exc_tb: Optional[Any],
-    ) -> None:
-        # Cleanup logic if needed
-        pass
-
-    def set_lightlevel(
-        self, serial_number: str, output_number: int, level: int
-    ) -> ConbusLightlevelResponse:
-        """Set light level for a specific output on a module.
-
-        Args:
-            serial_number: Module serial number
-            output_number: Output number (0-based)
-            level: Light level percentage (0-100)
-
-        Returns:
-            ConbusLightlevelResponse with operation result
-        """
-
-        # Validate output_number range (0-8)
-        if not 0 <= output_number <= 8:
-            return ConbusLightlevelResponse(
-                success=False,
-                serial_number=serial_number,
-                output_number=output_number,
-                level=level,
-                timestamp=datetime.now(),
-                error=f"Output number must be between 0 and 8, got {output_number}",
-            )
-
-        # Validate level range
-        if not 0 <= level <= 100:
-            return ConbusLightlevelResponse(
-                success=False,
-                serial_number=serial_number,
-                output_number=output_number,
-                level=level,
-                timestamp=datetime.now(),
-                error=f"Light level must be between 0 and 100, got {level}",
-            )
-
-        # Format data as output_number:level (e.g., "02:050")
-        data = f"{output_number:02d}:{level:03d}"
-
-        # Send telegram using WRITE_CONFIG function with MODULE_LIGHT_LEVEL datapoint
-        response = self.conbus_service.send_telegram(
-            serial_number,
-            SystemFunction.WRITE_CONFIG,  # "04"
-            f"{DataPointType.MODULE_LIGHT_LEVEL.value}{data}",  # "15" + "02:050"
-        )
-
-        return ConbusLightlevelResponse(
-            success=response.success,
-            serial_number=serial_number,
-            output_number=output_number,
-            level=level,
-            timestamp=response.timestamp or datetime.now(),
-            sent_telegram=response.sent_telegram,
-            received_telegrams=response.received_telegrams,
-            error=response.error,
-        )
-
-    def turn_off(
-        self, serial_number: str, output_number: int
-    ) -> ConbusLightlevelResponse:
-        """Turn off light (set level to 0) for a specific output.
-
-        Args:
-            serial_number: Module serial number
-            output_number: Output number (0-8)
-
-        Returns:
-            ConbusLightlevelResponse with operation result
-        """
-        return self.set_lightlevel(serial_number, output_number, 0)
-
-    def turn_on(
-        self, serial_number: str, output_number: int
-    ) -> ConbusLightlevelResponse:
-        """Turn on light (set level to 80%) for a specific output.
-
-        Args:
-            serial_number: Module serial number
-            output_number: Output number (0-8)
-
-        Returns:
-            ConbusLightlevelResponse with operation result
-        """
-        return self.set_lightlevel(serial_number, output_number, 80)
-
-    def get_lightlevel(
-        self, serial_number: str, output_number: int
-    ) -> ConbusLightlevelResponse:
-        """Query current light level for a specific output.
-
-        Args:
-            serial_number: Module serial number
-            output_number: Output number (0-8)
-
-        Returns:
-            ConbusLightlevelResponse with current light level
-        """
-
-        # TODO: Migrate to new ConbusDatapointService callback-based API
-        # Query MODULE_LIGHT_LEVEL datapoint
-        datapoint_response = self.datapoint_service.query_datapoint(  # type: ignore[call-arg,func-returns-value]
-            serial_number=serial_number,
-            datapoint_type=DataPointType.MODULE_LIGHT_LEVEL,
-        )
-
-        if not datapoint_response.success:
-            return ConbusLightlevelResponse(
-                success=False,
-                serial_number=serial_number,
-                output_number=output_number,
-                level=None,
-                timestamp=datetime.now(),
-                error=datapoint_response.error or "Failed to query light level",
-            )
-
-        # Parse the response to extract level for specific output
-        level = None
-        if (
-            datapoint_response.datapoint_telegram
-            and datapoint_response.datapoint_telegram.data_value
-        ):
-            try:
-                # Parse response format like "00:050,01:025,02:100"
-                data_value = str(datapoint_response.datapoint_telegram.data_value)
-                for output_data in data_value.split(","):
-                    if ":" in output_data:
-                        output_str, level_str = output_data.split(":")
-                        if int(output_str) == output_number:
-                            level_str = level_str.replace("[%]", "")
-                            level = int(level_str)
-                            break
-            except (ValueError, AttributeError) as e:
-                self.logger.debug(f"Failed to parse light level data: {e}")
-
-        return ConbusLightlevelResponse(
-            success=datapoint_response.success,
-            serial_number=serial_number,
-            output_number=output_number,
-            level=level,
-            timestamp=datetime.now(),
-            sent_telegram=datapoint_response.sent_telegram,
-            received_telegrams=datapoint_response.received_telegrams,
-            error=datapoint_response.error if level is None else None,
-        )