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

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,

xp/services/server/xp24_server_service.py

@@ -13,7 +13,7 @@ from xp.services.server.base_server_service import BaseServerService
 
 
 class XP24ServerError(Exception):
-    """Raised when XP24 server operations fail"""
+    """Raised when XP24 server operations fail."""
 
     pass
 
@@ -27,7 +27,11 @@ class XP24ServerService(BaseServerService):
     """
 
     def __init__(self, serial_number: str):
-        """Initialize XP24 server service"""
+        """Initialize XP24 server service.
+
+        Args:
+            serial_number: The device serial number.
+        """
         super().__init__(serial_number)
         self.device_type = "XP24"
         self.module_type_code = 7  # XP24 module type from registry
@@ -36,7 +40,7 @@ class XP24ServerService(BaseServerService):
     def _handle_device_specific_data_request(
         self, request: SystemTelegram
     ) -> Optional[str]:
-        """Handle XP24-specific data requests"""
+        """Handle XP24-specific data requests."""
         if (
             request.system_function != SystemFunction.READ_DATAPOINT
             or not request.datapoint_type
@@ -49,7 +53,12 @@ class XP24ServerService(BaseServerService):
             DataPointType.MODULE_STATE: "OFF",
             DataPointType.MODULE_OPERATING_HOURS: "00:000[H],01:000[H],02:000[H],03:000[H]",
         }
-        data_part = f"R{self.serial_number}F02{datapoint_type.value}{self.module_type_code}{datapoint_values.get(datapoint_type)}"
+        data_part = (
+            f"R{self.serial_number}"
+            f"F02{datapoint_type.value}"
+            f"{self.module_type_code}"
+            f"{datapoint_values.get(datapoint_type)}"
+        )
         telegram = self._build_response_telegram(data_part)
 
         self.logger.debug(
@@ -60,14 +69,25 @@ class XP24ServerService(BaseServerService):
     def _handle_device_specific_action_request(
         self, request: SystemTelegram
     ) -> Optional[str]:
+        """Handle XP24-specific action requests.
+
+        Args:
+            request: The system telegram request.
 
+        Returns:
+            The response telegram string, or None if request cannot be handled.
+        """
         if request.system_function != SystemFunction.ACTION:
             return None
 
         return self.generate_action_response(request)
 
     def get_device_info(self) -> Dict:
-        """Get XP24 device information"""
+        """Get XP24 device information.
+
+        Returns:
+            Dictionary containing device information.
+        """
         return {
             "serial_number": self.serial_number,
             "device_type": self.device_type,
@@ -77,7 +97,14 @@ class XP24ServerService(BaseServerService):
         }
 
     def generate_action_response(self, request: SystemTelegram) -> Optional[str]:
-        """Generate action response telegram (simulated)"""
+        """Generate action response telegram (simulated).
+
+        Args:
+            request: The system telegram request.
+
+        Returns:
+            The ACK or NAK response telegram string.
+        """
         response = "F19D"  # NAK
         if (
             request.system_function == SystemFunction.ACTION

xp/services/server/xp33_server_service.py

@@ -15,7 +15,7 @@ from xp.utils import calculate_checksum
 
 
 class XP33ServerError(Exception):
-    """Raised when XP33 server operations fail"""
+    """Raised when XP33 server operations fail."""
 
     pass
 
@@ -29,7 +29,12 @@ class XP33ServerService(BaseServerService):
     """
 
     def __init__(self, serial_number: str, variant: str = "XP33LR"):
-        """Initialize XP33 server service"""
+        """Initialize XP33 server service.
+
+        Args:
+            serial_number: The device serial number.
+            variant: Device variant (XP33, XP33LR, or XP33LED).
+        """
         super().__init__(serial_number)
         self.variant = variant  # XP33 or XP33LR or XP33LED
         self.device_type = "XP33"
@@ -69,7 +74,7 @@ class XP33ServerService(BaseServerService):
     def _handle_device_specific_data_request(
         self, request: SystemTelegram
     ) -> Optional[str]:
-        """Handle XP24-specific data requests"""
+        """Handle XP24-specific data requests."""
         if (
             request.system_function != SystemFunction.READ_DATAPOINT
             or not request.datapoint_type
@@ -82,7 +87,12 @@ class XP33ServerService(BaseServerService):
             DataPointType.MODULE_STATE: "OFF",
             DataPointType.MODULE_OPERATING_HOURS: "00:000[H],01:000[H],02:000[H]",
         }
-        data_part = f"R{self.serial_number}F02{datapoint_type.value}{self.module_type_code}{datapoint_values.get(datapoint_type)}"
+        data_part = (
+            f"R{self.serial_number}"
+            f"F02{datapoint_type.value}"
+            f"{self.module_type_code}"
+            f"{datapoint_values.get(datapoint_type)}"
+        )
         checksum = calculate_checksum(data_part)
         telegram = f"<{data_part}{checksum}>"
 
@@ -92,7 +102,15 @@ class XP33ServerService(BaseServerService):
         return telegram
 
     def set_channel_dimming(self, channel: int, level: int) -> bool:
-        """Set individual channel dimming level"""
+        """Set individual channel dimming level.
+
+        Args:
+            channel: Channel number (1-3).
+            level: Dimming level (0-100 percent).
+
+        Returns:
+            True if channel was set successfully, False otherwise.
+        """
         if 1 <= channel <= 3 and 0 <= level <= 100:
             self.channel_states[channel - 1] = level
             self.logger.info(f"XP33 channel {channel} set to {level}%")
@@ -100,7 +118,14 @@ class XP33ServerService(BaseServerService):
         return False
 
     def activate_scene(self, scene: int) -> bool:
-        """Activate a pre-programmed scene"""
+        """Activate a pre-programmed scene.
+
+        Args:
+            scene: Scene number (1-4).
+
+        Returns:
+            True if scene was activated successfully, False otherwise.
+        """
         if scene in self.scenes:
             self.channel_states = self.scenes[scene].copy()
             self.logger.info(f"XP33 scene {scene} activated: {self.channel_states}")
@@ -108,7 +133,11 @@ class XP33ServerService(BaseServerService):
         return False
 
     def get_device_info(self) -> Dict:
-        """Get XP33 device information"""
+        """Get XP33 device information.
+
+        Returns:
+            Dictionary containing device information.
+        """
         return {
             "serial_number": self.serial_number,
             "device_type": self.device_type,
@@ -123,7 +152,11 @@ class XP33ServerService(BaseServerService):
         }
 
     def get_technical_specs(self) -> Dict:
-        """Get technical specifications"""
+        """Get technical specifications.
+
+        Returns:
+            Dictionary containing technical specifications.
+        """
         if self.variant == "XP33LED":
             return {
                 "power_per_channel": "100VA",

xp/services/telegram/__init__.py

@@ -0,0 +1 @@
+"""Telegram parsing and processing services."""