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

xp/services/reverse_proxy_service.py

@@ -16,7 +16,7 @@ from xp.models.response import Response
 
 
 class ReverseProxyError(Exception):
-    """Raised when Conbus reverse proxy operations fail"""
+    """Raised when Conbus reverse proxy operations fail."""
 
     pass
 
@@ -28,6 +28,17 @@ class ReverseProxyService:
     Accepts client connections on port 10001 and forwards all telegrams
     to the target server configured in cli.yml. Monitors and prints all
     bidirectional traffic with timestamps.
+
+    Attributes:
+        logger: Logger instance for the service.
+        listen_port: Port to listen on for client connections.
+        server_socket: Main server socket for accepting connections.
+        is_running: Flag indicating if proxy is running.
+        active_connections: Dictionary of active connection information.
+        connection_counter: Counter for connection IDs.
+        cli_config: Conbus client configuration.
+        target_ip: Target server IP address.
+        target_port: Target server port number.
     """
 
     def __init__(
@@ -35,7 +46,12 @@ class ReverseProxyService:
         cli_config: ConbusClientConfig,
         listen_port: int,
     ):
-        """Initialize the Conbus reverse proxy service"""
+        """Initialize the Conbus reverse proxy service.
+
+        Args:
+            cli_config: Conbus client configuration.
+            listen_port: Port to listen on for client connections.
+        """
         # Set up logging first
         self.logger = logging.getLogger(__name__)
 
@@ -50,16 +66,28 @@ class ReverseProxyService:
 
     @property
     def target_ip(self) -> str:
-        """Get target server IP"""
+        """Get target server IP.
+
+        Returns:
+            Target server IP address.
+        """
         return self.cli_config.conbus.ip
 
     @property
     def target_port(self) -> int:
-        """Get target server port"""
+        """Get target server port.
+
+        Returns:
+            Target server port number.
+        """
         return self.cli_config.conbus.port
 
     def start_proxy(self) -> Response:
-        """Start the reverse proxy server"""
+        """Start the reverse proxy server.
+
+        Returns:
+            Response object with success status and proxy details.
+        """
         if self.is_running:
             return Response(
                 success=False, data=None, error="Reverse proxy is already running"
@@ -111,7 +139,11 @@ class ReverseProxyService:
             )
 
     def stop_proxy(self) -> Response:
-        """Stop the reverse proxy server"""
+        """Stop the reverse proxy server.
+
+        Returns:
+            Response object with success status.
+        """
         if not self.is_running:
             return Response(
                 success=False, data=None, error="Reverse proxy is not running"
@@ -139,7 +171,11 @@ class ReverseProxyService:
         )
 
     def get_status(self) -> Response:
-        """Get current proxy status and active connections"""
+        """Get current proxy status and active connections.
+
+        Returns:
+            Response object with proxy status and connection details.
+        """
         return Response(
             success=True,
             data={
@@ -161,7 +197,7 @@ class ReverseProxyService:
         )
 
     def _accept_connections(self) -> None:
-        """Accept and handle client connections"""
+        """Accept and handle client connections."""
         while self.is_running:
             try:
                 # Accept connection
@@ -194,7 +230,13 @@ class ReverseProxyService:
     def _handle_client(
         self, client_socket: socket.socket, client_address: tuple, conn_id: str
     ) -> None:
-        """Handle individual client connection with server relay"""
+        """Handle individual client connection with server relay.
+
+        Args:
+            client_socket: Client socket connection.
+            client_address: Client address tuple (ip, port).
+            conn_id: Connection identifier.
+        """
         try:
             # Connect to target server
             server_socket = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
@@ -272,7 +314,15 @@ class ReverseProxyService:
         dest_label: str,
         conn_id: str,
     ) -> None:
-        """Relay data between sockets with telegram monitoring"""
+        """Relay data between sockets with telegram monitoring.
+
+        Args:
+            source_socket: Source socket to receive from.
+            dest_socket: Destination socket to send to.
+            source_label: Label for source in logs.
+            dest_label: Label for destination in logs.
+            conn_id: Connection identifier.
+        """
         try:
             while self.is_running:
                 # Receive data from source
@@ -316,7 +366,11 @@ class ReverseProxyService:
                 self.logger.error(f"Error in data relay: {e} [{conn_id}]")
 
     def _close_connection_pair(self, conn_id: str) -> None:
-        """Close both client and server sockets for a connection"""
+        """Close both client and server sockets for a connection.
+
+        Args:
+            conn_id: Connection identifier.
+        """
         if conn_id not in self.active_connections:
             return
 
@@ -344,7 +398,10 @@ class ReverseProxyService:
             f"Client {client_address} disconnected [{conn_id}] - {bytes_relayed} bytes relayed"
         )
         print(
-            f"{self.timestamp()} [DISCONNECTION] Client {client_address} disconnected [{conn_id}] - {bytes_relayed} bytes relayed"
+            f"{self.timestamp()} [DISCONNECTION] "
+            f"Client {client_address} "
+            f"disconnected [{conn_id}] - "
+            f"{bytes_relayed} bytes relayed"
         )
 
         # Remove from active connections
@@ -352,11 +409,19 @@ class ReverseProxyService:
 
     @staticmethod
     def timestamp() -> str:
-        """Generate timestamp string for logging"""
+        """Generate timestamp string for logging.
+
+        Returns:
+            Timestamp string in HH:MM:SS,mmm format.
+        """
         return datetime.now().strftime("%H:%M:%S,%f")[:-3]
 
     def run_blocking(self) -> None:
-        """Run the proxy in blocking mode (for CLI usage)"""
+        """Run the proxy in blocking mode (for CLI usage).
+
+        Raises:
+            ReverseProxyError: If proxy fails to start.
+        """
         result = self.start_proxy()
         if not result.success:
             raise ReverseProxyError(result.error)

xp/services/server/__init__.py

@@ -0,0 +1 @@
+"""Server services for XP protocol variants."""

xp/services/server/base_server_service.py

@@ -23,7 +23,11 @@ class BaseServerService(ABC):
     """
 
     def __init__(self, serial_number: str):
-        """Initialize base server service"""
+        """Initialize base server service.
+
+        Args:
+            serial_number: The device serial number.
+        """
         self.serial_number = serial_number
         self.logger = logging.getLogger(__name__)
 
@@ -40,7 +44,14 @@ class BaseServerService(ABC):
     def generate_datapoint_type_response(
         self, datapoint_type: DataPointType
     ) -> Optional[str]:
-        """Generate datapoint_type response telegram"""
+        """Generate datapoint_type response telegram.
+
+        Args:
+            datapoint_type: The type of datapoint to query.
+
+        Returns:
+            The response telegram string, or None if generation fails.
+        """
         datapoint_values = {
             DataPointType.TEMPERATURE: self.temperature,
             DataPointType.MODULE_TYPE_CODE: f"{self.module_type_code:02X}",
@@ -62,23 +73,46 @@ class BaseServerService(ABC):
         return telegram
 
     def _check_request_for_device(self, request: SystemTelegram) -> bool:
-        """Check if request is for this device (including broadcast)"""
+        """Check if request is for this device (including broadcast).
+
+        Args:
+            request: The system telegram request to check.
+
+        Returns:
+            True if request is for this device or broadcast, False otherwise.
+        """
         return request.serial_number in (self.serial_number, "0000000000")
 
     @staticmethod
     def _build_response_telegram(data_part: str) -> str:
-        """Build a complete response telegram with checksum"""
+        """Build a complete response telegram with checksum.
+
+        Args:
+            data_part: The data part of the telegram without checksum.
+
+        Returns:
+            The complete telegram with checksum enclosed in angle brackets.
+        """
         checksum = calculate_checksum(data_part)
         return f"<{data_part}{checksum}>"
 
     def _log_response(self, response_type: str, telegram: str) -> None:
-        """Log response generation"""
+        """Log response generation.
+
+        Args:
+            response_type: The type of response being generated.
+            telegram: The telegram string being logged.
+        """
         self.logger.debug(
             f"Generated {self.device_type} {response_type} response: {telegram}"
         )
 
     def generate_discover_response(self) -> str:
-        """Generate discover response telegram"""
+        """Generate discover response telegram.
+
+        Returns:
+            The discover response telegram string.
+        """
         data_part = f"R{self.serial_number}F01D"
         telegram = self._build_response_telegram(data_part)
         self._log_response("discover", telegram)
@@ -87,7 +121,15 @@ class BaseServerService(ABC):
     def set_link_number(
         self, request: SystemTelegram, new_link_number: int
     ) -> Optional[str]:
-        """Set link number and generate ACK response"""
+        """Set link number and generate ACK response.
+
+        Args:
+            request: The system telegram request.
+            new_link_number: The new link number to set.
+
+        Returns:
+            The ACK response telegram string, or None if request is invalid.
+        """
         if (
             request.system_function == SystemFunction.WRITE_CONFIG
             and request.datapoint_type == DataPointType.LINK_NUMBER
@@ -105,7 +147,14 @@ class BaseServerService(ABC):
         return None
 
     def process_system_telegram(self, request: SystemTelegram) -> Optional[str]:
-        """Template method for processing system telegrams"""
+        """Template method for processing system telegrams.
+
+        Args:
+            request: The system telegram request to process.
+
+        Returns:
+            The response telegram string, or None if request cannot be handled.
+        """
         # Check if request is for this device
         if not self._check_request_for_device(request):
             return None
@@ -127,7 +176,14 @@ class BaseServerService(ABC):
         return None
 
     def _handle_return_data_request(self, request: SystemTelegram) -> Optional[str]:
-        """Handle RETURN_DATA requests - can be overridden by subclasses"""
+        """Handle RETURN_DATA requests - can be overridden by subclasses.
+
+        Args:
+            request: The system telegram request.
+
+        Returns:
+            The response telegram string, or None if request cannot be handled.
+        """
         self.logger.debug(
             f"_handle_return_data_request {self.device_type} request: {request}"
         )
@@ -140,27 +196,59 @@ class BaseServerService(ABC):
     def _handle_device_specific_data_request(
         self, request: SystemTelegram
     ) -> Optional[str]:
-        """Override in subclasses for device-specific data requests"""
+        """Override in subclasses for device-specific data requests.
+
+        Args:
+            request: The system telegram request.
+
+        Returns:
+            The response telegram string, or None if request cannot be handled.
+        """
         return None
 
     def _handle_write_config_request(self, request: SystemTelegram) -> Optional[str]:
-        """Handle WRITE_CONFIG requests"""
+        """Handle WRITE_CONFIG requests.
+
+        Args:
+            request: The system telegram request.
+
+        Returns:
+            The response telegram string, or None if request cannot be handled.
+        """
         if request.datapoint_type == DataPointType.LINK_NUMBER:
             return self.set_link_number(request, 1)  # Default implementation
 
         return self._handle_device_specific_config_request()
 
     def _handle_action_request(self, request: SystemTelegram) -> Optional[str]:
-        """Handle ACTION requests"""
+        """Handle ACTION requests.
+
+        Args:
+            request: The system telegram request.
+
+        Returns:
+            The response telegram string, or None if request cannot be handled.
+        """
         return self._handle_device_specific_action_request(request)
 
     def _handle_device_specific_action_request(
         self, request: SystemTelegram
     ) -> Optional[str]:
-        """Override in subclasses for device-specific data requests"""
+        """Override in subclasses for device-specific data requests.
+
+        Args:
+            request: The system telegram request.
+
+        Returns:
+            The response telegram string, or None if request cannot be handled.
+        """
         return None
 
     @staticmethod
     def _handle_device_specific_config_request() -> Optional[str]:
-        """Override in subclasses for device-specific config requests"""
+        """Override in subclasses for device-specific config requests.
+
+        Returns:
+            The response telegram string, or None if request cannot be handled.
+        """
         return None

xp/services/server/cp20_server_service.py

@@ -11,7 +11,7 @@ from xp.services.server.base_server_service import BaseServerService
 
 
 class CP20ServerError(Exception):
-    """Raised when CP20 server operations fail"""
+    """Raised when CP20 server operations fail."""
 
     pass
 
@@ -25,7 +25,11 @@ class CP20ServerService(BaseServerService):
     """
 
     def __init__(self, serial_number: str):
-        """Initialize CP20 server service"""
+        """Initialize CP20 server service.
+
+        Args:
+            serial_number: The device serial number.
+        """
         super().__init__(serial_number)
         self.device_type = "CP20"
         self.module_type_code = 2  # CP20 module type from registry
@@ -34,11 +38,15 @@ class CP20ServerService(BaseServerService):
     def _handle_device_specific_data_request(
         self, request: SystemTelegram
     ) -> Optional[str]:
-        """Handle CP20-specific data requests"""
+        """Handle CP20-specific data requests."""
         return None
 
     def get_device_info(self) -> Dict:
-        """Get CP20 device information"""
+        """Get CP20 device information.
+
+        Returns:
+            Dictionary containing device information.
+        """
         return {
             "serial_number": self.serial_number,
             "device_type": self.device_type,

xp/services/server/server_service.py

@@ -26,7 +26,7 @@ from xp.services.telegram.telegram_service import TelegramService
 
 
 class ServerError(Exception):
-    """Raised when Conbus server operations fail"""
+    """Raised when Conbus server operations fail."""
 
     pass
 
@@ -46,7 +46,14 @@ class ServerService:
         config_path: str = "server.yml",
         port: int = 10001,
     ):
-        """Initialize the Conbus server service"""
+        """Initialize the Conbus server service.
+
+        Args:
+            telegram_service: Service for parsing system telegrams.
+            discover_service: Service for handling discover requests.
+            config_path: Path to the server configuration file.
+            port: TCP port to listen on.
+        """
         self.telegram_service = telegram_service
         self.discover_service = discover_service
         self.config_path = config_path
@@ -71,7 +78,7 @@ class ServerService:
         self._load_device_config()
 
     def _load_device_config(self) -> None:
-        """Load device configurations from server.yml"""
+        """Load device configurations from server.yml."""
         try:
             if Path(self.config_path).exists():
                 config = ConsonModuleListConfig.from_yaml(self.config_path)
@@ -90,7 +97,7 @@ class ServerService:
             self.device_services = {}
 
     def _create_device_services(self) -> None:
-        """Create device service instances based on device configuration"""
+        """Create device service instances based on device configuration."""
         self.device_services = {}
 
         for module in self.devices:
@@ -143,7 +150,11 @@ class ServerService:
                 )
 
     def start_server(self) -> None:
-        """Start the TCP server on port 10001"""
+        """Start the TCP server on port 10001.
+
+        Raises:
+            ServerError: If server is already running or fails to start.
+        """
         if self.is_running:
             raise ServerError("Server is already running")
 
@@ -170,7 +181,7 @@ class ServerService:
             raise ServerError(f"Failed to start server: {e}")
 
     def stop_server(self) -> None:
-        """Stop the TCP server"""
+        """Stop the TCP server."""
         if not self.is_running:
             return
 
@@ -184,7 +195,7 @@ class ServerService:
                 self.logger.error(f"Error closing server socket: {e}")
 
     def _accept_connections(self) -> None:
-        """Accept and handle client connections"""
+        """Accept and handle client connections."""
         while self.is_running:
             try:
                 # Accept connection
@@ -208,7 +219,7 @@ class ServerService:
     def _handle_client(
         self, client_socket: socket.socket, client_address: tuple[str, int]
     ) -> None:
-        """Handle individual client connection"""
+        """Handle individual client connection."""
         try:
             # Set timeout for idle connections (30 seconds as per spec)
             client_socket.settimeout(300.0)
@@ -242,7 +253,7 @@ class ServerService:
                 self.logger.error(f"Error closing client socket: {e}")
 
     def _process_request(self, message: str) -> List[str]:
-        """Process incoming request and generate responses"""
+        """Process incoming request and generate responses."""
         responses: list[str] = []
 
         try:
@@ -290,7 +301,11 @@ class ServerService:
         return responses
 
     def get_server_status(self) -> dict:
-        """Get current server status"""
+        """Get current server status.
+
+        Returns:
+            Dictionary containing server status information.
+        """
         return {
             "running": self.is_running,
             "port": self.port,
@@ -299,7 +314,7 @@ class ServerService:
         }
 
     def reload_config(self) -> None:
-        """Reload device configuration from file"""
+        """Reload device configuration from file."""
         self._load_device_config()
         self.logger.info(
             f"Configuration reloaded: {len(self.devices)} devices, {len(self.device_services)} services"

xp/services/server/xp130_server_service.py

@@ -11,7 +11,7 @@ from xp.services.server.base_server_service import BaseServerService
 
 
 class XP130ServerError(Exception):
-    """Raised when XP130 server operations fail"""
+    """Raised when XP130 server operations fail."""
 
     pass
 
@@ -25,7 +25,11 @@ class XP130ServerService(BaseServerService):
     """
 
     def __init__(self, serial_number: str):
-        """Initialize XP130 server service"""
+        """Initialize XP130 server service.
+
+        Args:
+            serial_number: The device serial number.
+        """
         super().__init__(serial_number)
         self.device_type = "XP130"
         self.module_type_code = 13  # XP130 module type from registry
@@ -37,7 +41,11 @@ class XP130ServerService(BaseServerService):
         self.gateway = "192.168.1.1"
 
     def get_device_info(self) -> Dict:
-        """Get XP130 device information"""
+        """Get XP130 device information.
+
+        Returns:
+            Dictionary containing device information.
+        """
         return {
             "serial_number": self.serial_number,
             "device_type": self.device_type,

xp/services/server/xp20_server_service.py

@@ -10,7 +10,7 @@ from xp.services.server.base_server_service import BaseServerService
 
 
 class XP20ServerError(Exception):
-    """Raised when XP20 server operations fail"""
+    """Raised when XP20 server operations fail."""
 
     pass
 
@@ -24,14 +24,22 @@ class XP20ServerService(BaseServerService):
     """
 
     def __init__(self, serial_number: str):
-        """Initialize XP20 server service"""
+        """Initialize XP20 server service.
+
+        Args:
+            serial_number: The device serial number.
+        """
         super().__init__(serial_number)
         self.device_type = "XP20"
         self.module_type_code = 33  # XP20 module type from registry
         self.firmware_version = "XP20_V0.01.05"
 
     def get_device_info(self) -> Dict:
-        """Get XP20 device information"""
+        """Get XP20 device information.
+
+        Returns:
+            Dictionary containing device information.
+        """
         return {
             "serial_number": self.serial_number,
             "device_type": self.device_type,

xp/services/server/xp230_server_service.py

@@ -10,7 +10,7 @@ from xp.services.server.base_server_service import BaseServerService
 
 
 class XP230ServerError(Exception):
-    """Raised when XP230 server operations fail"""
+    """Raised when XP230 server operations fail."""
 
     pass
 
@@ -24,14 +24,22 @@ class XP230ServerService(BaseServerService):
     """
 
     def __init__(self, serial_number: str):
-        """Initialize XP230 server service"""
+        """Initialize XP230 server service.
+
+        Args:
+            serial_number: The device serial number.
+        """
         super().__init__(serial_number)
         self.device_type = "XP230"
         self.module_type_code = 34  # XP230 module type from registry
         self.firmware_version = "XP230_V1.00.04"
 
     def get_device_info(self) -> Dict:
-        """Get XP230 device information"""
+        """Get XP230 device information.
+
+        Returns:
+            Dictionary containing device information.
+        """
         return {
             "serial_number": self.serial_number,
             "device_type": self.device_type,