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

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 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 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_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

@@ -145,6 +145,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,
         )

xp/services/conbus/conbus_connection_pool.py

@@ -1,148 +0,0 @@
-"""Connection pooling implementation for Conbus TCP connections.
-
-This module provides a singleton connection pool for managing TCP socket connections
-to Conbus servers with automatic lifecycle management, health checking, and reconnection.
-"""
-
-import logging
-import socket
-import threading
-import time
-from typing import Any, Optional
-
-from xp.models import ConbusClientConfig
-
-
-class ConbusSocketConnectionManager:
-    """Connection manager for TCP socket connections to Conbus servers"""
-
-    def __init__(self, cli_config: ConbusClientConfig):
-        self.config = cli_config.conbus
-        self.logger = logging.getLogger(__name__)
-
-    def create(self) -> socket.socket:
-        """Create and configure a new TCP socket connection"""
-        sock = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
-        sock.settimeout(self.config.timeout)
-        sock.connect((self.config.ip, self.config.port))
-        self.logger.info(
-            f"Created new connection to {self.config.ip}:{self.config.port} (timeout: {self.config.timeout})"
-        )
-        return sock
-
-    def dispose(self, connection: socket.socket) -> None:
-        """Close and cleanup socket connection"""
-        try:
-            connection.close()
-            self.logger.info("Disposed socket connection")
-        except Exception as e:
-            self.logger.warning(f"Error disposing connection: {e}")
-
-    @staticmethod
-    def check_aliveness(connection: socket.socket) -> bool:
-        """Verify if connection is still alive"""
-        try:
-            # Use socket error checking rather than sending empty data
-            # to avoid potential protocol issues
-            error = connection.getsockopt(socket.SOL_SOCKET, socket.SO_ERROR)
-            return error == 0
-        except (socket.error, OSError):
-            return False
-
-
-class ConbusConnectionPool:
-    """Singleton connection pool for Conbus TCP connections"""
-
-    _lock = threading.Lock()
-
-    def __init__(self, connection_manager: ConbusSocketConnectionManager) -> None:
-        if hasattr(self, "_initialized"):
-            return
-
-        self._connection_manager = connection_manager
-        self._connection: Optional[socket.socket] = None
-        self._current_connection: Optional[socket.socket] = None
-        self._connection_created_at: Optional[float] = None
-        self._lock = threading.Lock()
-        self.logger = logging.getLogger(__name__)
-
-        # Configuration
-        self.idle_timeout = 21600  # 6 hours
-        self.max_lifetime = 21600  # 6 hours
-        self._initialized = True
-
-    def _is_connection_expired(self) -> bool:
-        """Check if the current connection has expired"""
-        if self._connection_created_at is None:
-            return True
-
-        age = time.time() - self._connection_created_at
-        return age > self.max_lifetime
-
-    def _is_connection_alive(self) -> bool:
-        """Check if connection is still alive"""
-        if self._connection is None or self._connection_manager is None:
-            return False
-
-        return self._connection_manager.check_aliveness(self._connection)
-
-    def acquire_connection(self) -> socket.socket:
-        """Acquire a connection from the pool"""
-        if self._connection_manager is None:
-            raise RuntimeError("Connection pool not initialized")
-
-        with self._lock:
-            # Check if we need a new connection
-            if (
-                self._connection is None
-                or self._is_connection_expired()
-                or not self._is_connection_alive()
-            ):
-
-                # Close existing connection if any
-                if self._connection:
-                    self._connection_manager.dispose(self._connection)
-                    self._connection = None
-
-                # Create new connection
-                self._connection = self._connection_manager.create()
-                self._connection_created_at = time.time()
-                self.logger.debug("Created new connection")
-
-            self.logger.debug("Acquired connection from pool")
-            return self._connection
-
-    # noinspection PyUnusedLocal
-    def release_connection(self, connection: socket.socket) -> None:
-        """Release a connection back to the pool (no-op for single connection pool)"""
-        self.logger.debug("Released connection back to pool")
-        # For single connection pool, we just log but don't actually close the connection
-
-    def __enter__(self) -> socket.socket:
-        """Context manager entry - acquire connection"""
-        self._current_connection = self.acquire_connection()
-        return self._current_connection
-
-    def __exit__(
-        self,
-        _exc_type: Optional[type],
-        _exc_val: Optional[Exception],
-        _exc_tb: Optional[Any],
-    ) -> None:
-        """Context manager exit - release connection"""
-        if hasattr(self, "_current_connection") and self._current_connection:
-            self.release_connection(self._current_connection)
-            self._current_connection = None
-
-    def close(self) -> None:
-        """Close the connection pool and cleanup resources"""
-        with self._lock:
-            if self._connection and self._connection_manager is not None:
-                try:
-                    self._connection_manager.dispose(self._connection)
-                    self.logger.info("Connection pool closed")
-                except Exception as e:
-                    self.logger.error(f"Error closing connection pool: {e}")
-                finally:
-                    self._connection = None
-                    self._connection_created_at = None