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

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

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,
-        )

xp/services/conbus/conbus_linknumber_service.py

@@ -1,197 +0,0 @@
-"""Conbus Link Number Service for setting module link numbers.
-
-This service handles setting link numbers for modules through Conbus telegrams.
-"""
-
-import logging
-from typing import Any, Optional
-
-from xp.models.conbus.conbus_linknumber import ConbusLinknumberResponse
-from xp.models.telegram.datapoint_type import DataPointType
-from xp.models.telegram.reply_telegram import ReplyTelegram
-from xp.services.conbus.conbus_datapoint_service import ConbusDatapointService
-from xp.services.conbus.conbus_service import ConbusService
-from xp.services.telegram.telegram_link_number_service import (
-    LinkNumberError,
-    LinkNumberService,
-)
-from xp.services.telegram.telegram_service import TelegramService
-
-
-class ConbusLinknumberService:
-    """
-    Service for setting and getting module link numbers via Conbus telegrams.
-
-    Handles link number assignment by sending F04D04 telegrams and processing
-    ACK/NAK responses from modules. Also handles link number reading using
-    datapoint queries.
-    """
-
-    def __init__(
-        self,
-        conbus_service: ConbusService,
-        datapoint_service: ConbusDatapointService,
-        link_number_service: LinkNumberService,
-        telegram_service: TelegramService,
-    ):
-        """Initialize the Conbus link number service"""
-
-        # Service dependencies
-        self.conbus_service = conbus_service
-        self.datapoint_service = datapoint_service
-        self.link_number_service = link_number_service
-        self.telegram_service = telegram_service
-
-        # Set up logging
-        self.logger = logging.getLogger(__name__)
-
-    def __enter__(self) -> "ConbusLinknumberService":
-        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_linknumber(
-        self, serial_number: str, link_number: int
-    ) -> ConbusLinknumberResponse:
-        """
-        Set the link number for a specific module.
-
-        Args:
-            serial_number: 10-digit module serial number
-            link_number: Link number to set (0-99)
-
-        Returns:
-            ConbusLinknumberResponse with operation result
-
-        Raises:
-            LinkNumberError: If parameters are invalid
-        """
-        try:
-            # Generate the link number setting telegram
-            telegram = self.link_number_service.generate_set_link_number_telegram(
-                serial_number, link_number
-            )
-
-            # Send telegram using ConbusService
-            with self.conbus_service:
-                response = self.conbus_service.send_raw_telegram(telegram)
-
-                # Determine result based on response
-                result = "NAK"  # Default to NAK
-                if response.success and response.received_telegrams:
-                    # Try to parse the first received telegram
-                    if len(response.received_telegrams) > 0:
-                        received_telegram = response.received_telegrams[0]
-                        try:
-                            parsed_telegram = self.telegram_service.parse_telegram(
-                                received_telegram
-                            )
-                            if isinstance(parsed_telegram, ReplyTelegram):
-                                if self.link_number_service.is_ack_response(
-                                    parsed_telegram
-                                ):
-                                    result = "ACK"
-                                elif self.link_number_service.is_nak_response(
-                                    parsed_telegram
-                                ):
-                                    result = "NAK"
-                        except Exception as e:
-                            self.logger.warning(f"Failed to parse reply telegram: {e}")
-
-                return ConbusLinknumberResponse(
-                    success=response.success and result == "ACK",
-                    result=result,
-                    link_number=link_number,
-                    serial_number=serial_number,
-                    sent_telegram=telegram,
-                    received_telegrams=response.received_telegrams,
-                    error=response.error,
-                    timestamp=response.timestamp,
-                )
-
-        except LinkNumberError as e:
-            return ConbusLinknumberResponse(
-                success=False,
-                result="NAK",
-                serial_number=serial_number,
-                error=str(e),
-            )
-        except Exception as e:
-            return ConbusLinknumberResponse(
-                success=False,
-                result="NAK",
-                serial_number=serial_number,
-                error=f"Unexpected error: {e}",
-            )
-
-    def get_linknumber(self, serial_number: str) -> ConbusLinknumberResponse:
-        """
-        Get the current link number for a specific module.
-
-        Args:
-            serial_number: 10-digit module serial number
-
-        Returns:
-            ConbusLinknumberResponse with operation result and link number
-
-        Raises:
-            Exception: If datapoint query fails
-        """
-        try:
-            # TODO: Migrate to new ConbusDatapointService callback-based API
-            # Query the LINK_NUMBER datapoint
-            datapoint_response = self.datapoint_service.query_datapoint(  # type: ignore[call-arg,func-returns-value]
-                serial_number=serial_number,
-                datapoint_type=DataPointType.LINK_NUMBER,
-            )
-
-            if datapoint_response.success and datapoint_response.datapoint_telegram:
-                # Extract link number from datapoint response
-                try:
-                    link_number_value = int(
-                        datapoint_response.datapoint_telegram.data_value
-                    )
-                    return ConbusLinknumberResponse(
-                        success=True,
-                        result="SUCCESS",
-                        serial_number=serial_number,
-                        link_number=link_number_value,
-                        sent_telegram=datapoint_response.sent_telegram,
-                        received_telegrams=datapoint_response.received_telegrams,
-                        timestamp=datapoint_response.timestamp,
-                    )
-                except (ValueError, TypeError) as e:
-                    return ConbusLinknumberResponse(
-                        success=False,
-                        result="PARSE_ERROR",
-                        serial_number=serial_number,
-                        sent_telegram=datapoint_response.sent_telegram,
-                        received_telegrams=datapoint_response.received_telegrams,
-                        error=f"Failed to parse link number: {e}",
-                        timestamp=datapoint_response.timestamp,
-                    )
-            else:
-                return ConbusLinknumberResponse(
-                    success=False,
-                    result="QUERY_FAILED",
-                    serial_number=serial_number,
-                    sent_telegram=datapoint_response.sent_telegram,
-                    received_telegrams=datapoint_response.received_telegrams,
-                    error=datapoint_response.error or "Failed to query link number",
-                    timestamp=datapoint_response.timestamp,
-                )
-
-        except Exception as e:
-            return ConbusLinknumberResponse(
-                success=False,
-                result="ERROR",
-                serial_number=serial_number,
-                error=f"Unexpected error: {e}",
-            )