conson-xp 1.5.0__tar.gz → 1.6.0__tar.gz

{conson_xp-1.5.0 → conson_xp-1.6.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: conson-xp
-Version: 1.5.0
+Version: 1.6.0
 Summary: XP Protocol Communication Tools
 Author-Email: ldvchosal <ldvchosal@github.com>
 License: MIT License

{conson_xp-1.5.0 → conson_xp-1.6.0}/pyproject.toml

@@ -20,7 +20,7 @@ dependencies = [
 ]
 requires-python = ">=3.11"
 readme = "README.md"
-version = "1.5.0"
+version = "1.6.0"
 
 [project.license]
 file = "LICENSE"

{conson_xp-1.5.0 → conson_xp-1.6.0}/src/xp/__init__.py

@@ -3,7 +3,7 @@
 conson-xp package.
 """
 
-__version__ = "1.5.0"
+__version__ = "1.6.0"
 __manufacturer__ = "salchichon"
 __model__ = "xp.cli"
 __serial__ = "2025.09.23.000"

conson_xp-1.6.0/src/xp/services/actiontable/__init__.py

@@ -0,0 +1 @@
+"""Action table utils."""

conson_xp-1.6.0/src/xp/services/actiontable/msactiontable_serializer.py

@@ -0,0 +1,7 @@
+"""Generic MsActionTable serializer base class for type hints."""
+
+
+class MsActionTableSerializer:
+    """Serializer for ActionTable telegram encoding/decoding."""
+
+    pass

{conson_xp-1.5.0 → conson_xp-1.6.0}/src/xp/services/conbus/actiontable/actiontable_service.py

@@ -10,7 +10,7 @@ from xp.models.actiontable.actiontable import ActionTable
 from xp.models.protocol.conbus_protocol import TelegramReceivedEvent
 from xp.models.telegram.system_function import SystemFunction
 from xp.models.telegram.telegram_type import TelegramType
-from xp.services.conbus.actiontable.actiontable_serializer import ActionTableSerializer
+from xp.services.actiontable.actiontable_serializer import ActionTableSerializer
 from xp.services.protocol import ConbusProtocol
 from xp.services.telegram.telegram_service import TelegramService
 

{conson_xp-1.5.0 → conson_xp-1.6.0}/src/xp/services/conbus/actiontable/msactiontable_service.py

@@ -12,13 +12,13 @@ from xp.models.actiontable.msactiontable_xp33 import Xp33MsActionTable
 from xp.models.protocol.conbus_protocol import TelegramReceivedEvent
 from xp.models.telegram.system_function import SystemFunction
 from xp.models.telegram.telegram_type import TelegramType
-from xp.services.conbus.actiontable.msactiontable_xp20_serializer import (
+from xp.services.actiontable.msactiontable_xp20_serializer import (
     Xp20MsActionTableSerializer,
 )
-from xp.services.conbus.actiontable.msactiontable_xp24_serializer import (
+from xp.services.actiontable.msactiontable_xp24_serializer import (
     Xp24MsActionTableSerializer,
 )
-from xp.services.conbus.actiontable.msactiontable_xp33_serializer import (
+from xp.services.actiontable.msactiontable_xp33_serializer import (
     Xp33MsActionTableSerializer,
 )
 from xp.services.protocol import ConbusProtocol

{conson_xp-1.5.0 → conson_xp-1.6.0}/src/xp/services/server/base_server_service.py

@@ -7,7 +7,7 @@ containing common functionality like module type response generation.
 import logging
 import threading
 from abc import ABC
-from typing import Optional
+from typing import Any, Optional
 
 from xp.models import ModuleTypeCode
 from xp.models.telegram.datapoint_type import DataPointType
@@ -46,6 +46,9 @@ class BaseServerService(ABC):
         self.telegram_buffer: list[str] = []
         self.telegram_buffer_lock = threading.Lock()  # Lock for socket set
 
+        # MsActionTable download state (None, "ack_sent", "data_sent")
+        self.msactiontable_download_state: Optional[str] = None
+
     def generate_datapoint_type_response(
         self, datapoint_type: DataPointType
     ) -> Optional[str]:
@@ -151,6 +154,83 @@ class BaseServerService(ABC):
 
         return None
 
+    def _get_msactiontable_serializer(self) -> Optional[Any]:
+        """Get the MsActionTable serializer for this device.
+
+        Subclasses should override this to return their specific serializer.
+
+        Returns:
+            The serializer instance, or None if not supported.
+        """
+        return None
+
+    def _get_msactiontable(self) -> Optional[Any]:
+        """Get the MsActionTable for this device.
+
+        Subclasses should override this to return their msactiontable instance.
+
+        Returns:
+            The msactiontable instance, or None if not supported.
+        """
+        return None
+
+    def _handle_download_msactiontable_request(
+        self, request: SystemTelegram
+    ) -> Optional[str]:
+        """Handle F13D - DOWNLOAD_MSACTIONTABLE request.
+
+        Args:
+            request: The system telegram request to process.
+
+        Returns:
+            ACK telegram if request is valid, NAK otherwise.
+        """
+        if (
+            request.system_function == SystemFunction.DOWNLOAD_MSACTIONTABLE
+            and self.msactiontable_download_state is None
+        ):
+            self.msactiontable_download_state = "ack_sent"
+            # Send ACK and queue data telegram
+            return self._build_response_telegram(f"R{self.serial_number}F18D")  # ACK
+
+        return self._build_response_telegram(f"R{self.serial_number}F19D")  # NAK
+
+    def _handle_download_msactiontable_ack_request(
+        self, _request: SystemTelegram
+    ) -> Optional[str]:
+        """Handle MsActionTable download ACK protocol.
+
+        Args:
+            _request: The system telegram request (unused, kept for signature consistency).
+
+        Returns:
+            Data telegram, EOF telegram, or NAK if state is invalid.
+        """
+        serializer = self._get_msactiontable_serializer()
+        msactiontable = self._get_msactiontable()
+
+        # Only handle if serializer and msactiontable are available
+        if not serializer or msactiontable is None:
+            return None
+
+        # Handle F18D - CONTINUE (after ACK or data)
+        if self.msactiontable_download_state == "ack_sent":
+            # Send MsActionTable data
+            encoded_data = serializer.to_data(msactiontable)
+            data_telegram = self._build_response_telegram(
+                f"R{self.serial_number}F17D{encoded_data}"
+            )
+            self.msactiontable_download_state = "data_sent"
+            return data_telegram
+
+        elif self.msactiontable_download_state == "data_sent":
+            # Send EOF
+            eof_telegram = self._build_response_telegram(f"R{self.serial_number}F16D")
+            self.msactiontable_download_state = None
+            return eof_telegram
+
+        return self._build_response_telegram(f"R{self.serial_number}F19D")  # NAK
+
     def process_system_telegram(self, request: SystemTelegram) -> Optional[str]:
         """Template method for processing system telegrams.
 
@@ -177,6 +257,15 @@ class BaseServerService(ABC):
         elif request.system_function == SystemFunction.ACTION:
             return self._handle_action_request(request)
 
+        elif request.system_function == SystemFunction.DOWNLOAD_MSACTIONTABLE:
+            return self._handle_download_msactiontable_request(request)
+
+        elif (
+            request.system_function == SystemFunction.ACK
+            and self.msactiontable_download_state
+        ):
+            return self._handle_download_msactiontable_ack_request(request)
+
         self.logger.warning(f"Unhandled {self.device_type} request: {request}")
         return None
 

{conson_xp-1.5.0 → conson_xp-1.6.0}/src/xp/services/server/cp20_server_service.py

@@ -8,6 +8,7 @@ from typing import Dict, Optional
 
 from xp.models import ModuleTypeCode
 from xp.models.telegram.system_telegram import SystemTelegram
+from xp.services.actiontable.msactiontable_serializer import MsActionTableSerializer
 from xp.services.server.base_server_service import BaseServerService
 
 
@@ -25,11 +26,18 @@ class CP20ServerService(BaseServerService):
     and implements CP20 telegram format.
     """
 
-    def __init__(self, serial_number: str):
+    def __init__(
+        self,
+        serial_number: str,
+        _variant: str = "",
+        _msactiontable_serializer: Optional[MsActionTableSerializer] = None,
+    ):
         """Initialize CP20 server service.
 
         Args:
             serial_number: The device serial number.
+            _variant: Reserved parameter for consistency (unused).
+            _msactiontable_serializer: Generic MsActionTable serializer (unused).
         """
         super().__init__(serial_number)
         self.device_type = "CP20"

conson_xp-1.6.0/src/xp/services/server/device_service_factory.py

@@ -0,0 +1,94 @@
+"""Device Service Factory for creating device instances.
+
+This module provides a factory for creating device service instances
+with proper dependency injection of serializers.
+"""
+
+from xp.services.actiontable.msactiontable_serializer import MsActionTableSerializer
+from xp.services.actiontable.msactiontable_xp20_serializer import (
+    Xp20MsActionTableSerializer,
+)
+from xp.services.actiontable.msactiontable_xp24_serializer import (
+    Xp24MsActionTableSerializer,
+)
+from xp.services.actiontable.msactiontable_xp33_serializer import (
+    Xp33MsActionTableSerializer,
+)
+from xp.services.server.base_server_service import BaseServerService
+from xp.services.server.cp20_server_service import CP20ServerService
+from xp.services.server.xp20_server_service import XP20ServerService
+from xp.services.server.xp24_server_service import XP24ServerService
+from xp.services.server.xp33_server_service import XP33ServerService
+from xp.services.server.xp130_server_service import XP130ServerService
+from xp.services.server.xp230_server_service import XP230ServerService
+
+
+class DeviceServiceFactory:
+    """Factory for creating device service instances.
+
+    Encapsulates device creation logic and handles serializer injection
+    for different device types.
+    """
+
+    def __init__(
+        self,
+        xp20ms_serializer: Xp20MsActionTableSerializer,
+        xp24ms_serializer: Xp24MsActionTableSerializer,
+        xp33ms_serializer: Xp33MsActionTableSerializer,
+        ms_serializer: MsActionTableSerializer,
+    ):
+        """Initialize device service factory.
+
+        Args:
+            xp20ms_serializer: XP20 MsActionTable serializer (injected via DI).
+            xp24ms_serializer: XP24 MsActionTable serializer (injected via DI).
+            xp33ms_serializer: XP33 MsActionTable serializer (injected via DI).
+            ms_serializer: Generic MsActionTable serializer (injected via DI).
+        """
+        self.xp20ms_serializer = xp20ms_serializer
+        self.xp24ms_serializer = xp24ms_serializer
+        self.xp33ms_serializer = xp33ms_serializer
+        self.ms_serializer = ms_serializer
+
+    def create_device(self, module_type: str, serial_number: str) -> BaseServerService:
+        """Create device instance for given module type.
+
+        Args:
+            module_type: Module type code (e.g., "XP20", "XP33LR").
+            serial_number: Device serial number.
+
+        Returns:
+            Device service instance configured with appropriate serializer.
+
+        Raises:
+            ValueError: If module_type is unknown or unsupported.
+        """
+        # Map module types to their constructors and parameters
+        if module_type == "CP20":
+            return CP20ServerService(serial_number, "CP20", self.ms_serializer)
+
+        elif module_type == "XP24":
+            return XP24ServerService(serial_number, "XP24", self.xp24ms_serializer)
+
+        elif module_type == "XP33":
+            return XP33ServerService(serial_number, "XP33", self.xp33ms_serializer)
+
+        elif module_type == "XP33LR":
+            return XP33ServerService(serial_number, "XP33LR", self.xp33ms_serializer)
+
+        elif module_type == "XP33LED":
+            return XP33ServerService(serial_number, "XP33LED", self.xp33ms_serializer)
+
+        elif module_type == "XP20":
+            return XP20ServerService(serial_number, "XP20", self.xp20ms_serializer)
+
+        elif module_type == "XP130":
+            return XP130ServerService(serial_number, "XP130", self.ms_serializer)
+
+        elif module_type == "XP230":
+            return XP230ServerService(serial_number, "XP230", self.ms_serializer)
+
+        else:
+            raise ValueError(
+                f"Unknown device type '{module_type}' for serial {serial_number}"
+            )

{conson_xp-1.5.0 → conson_xp-1.6.0}/src/xp/services/server/server_service.py

@@ -8,19 +8,14 @@ import logging
 import socket
 import threading
 from pathlib import Path
-from typing import Dict, List, Optional, Union
+from typing import Dict, List, Optional
 
 from xp.models.homekit.homekit_conson_config import (
     ConsonModuleConfig,
     ConsonModuleListConfig,
 )
 from xp.services.server.base_server_service import BaseServerService
-from xp.services.server.cp20_server_service import CP20ServerService
-from xp.services.server.xp20_server_service import XP20ServerService
-from xp.services.server.xp24_server_service import XP24ServerService
-from xp.services.server.xp33_server_service import XP33ServerService
-from xp.services.server.xp130_server_service import XP130ServerService
-from xp.services.server.xp230_server_service import XP230ServerService
+from xp.services.server.device_service_factory import DeviceServiceFactory
 from xp.services.telegram.telegram_discover_service import TelegramDiscoverService
 from xp.services.telegram.telegram_service import TelegramService
 
@@ -43,6 +38,7 @@ class ServerService:
         self,
         telegram_service: TelegramService,
         discover_service: TelegramDiscoverService,
+        device_factory: DeviceServiceFactory,
         config_path: str = "server.yml",
         port: int = 10001,
     ):
@@ -51,25 +47,21 @@ class ServerService:
         Args:
             telegram_service: Service for parsing system telegrams.
             discover_service: Service for handling discover requests.
+            device_factory: Factory for creating device service instances (injected via DI).
             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.device_factory = device_factory
         self.config_path = config_path
         self.port = port
         self.server_socket: Optional[socket.socket] = None
         self.is_running = False
         self.devices: List[ConsonModuleConfig] = []
-        self.device_services: Dict[
-            str,
-            Union[
-                BaseServerService,
-                XP33ServerService,
-                XP20ServerService,
-                XP130ServerService,
-            ],
-        ] = {}  # serial -> device service instance
+        self.device_services: Dict[str, BaseServerService] = (
+            {}
+        )  # serial -> device service instance
 
         # Collect device buffer to broadcast to client
         self.collector_thread: Optional[threading.Thread] = (
@@ -112,44 +104,14 @@ class ServerService:
             serial_number = module.serial_number
 
             try:
+                # Use factory to create device instance
+                self.device_services[serial_number] = self.device_factory.create_device(
+                    module_type, serial_number
+                )
 
-                # Serial number is already a string from config
-                if module_type == "CP20":
-                    self.device_services[serial_number] = CP20ServerService(
-                        serial_number
-                    )
-                if module_type == "XP24":
-                    self.device_services[serial_number] = XP24ServerService(
-                        serial_number
-                    )
-                elif module_type == "XP33":
-                    self.device_services[serial_number] = XP33ServerService(
-                        serial_number, "XP33"
-                    )
-                elif module_type == "XP33LR":
-                    self.device_services[serial_number] = XP33ServerService(
-                        serial_number, "XP33LR"
-                    )
-                elif module_type == "XP33LED":
-                    self.device_services[serial_number] = XP33ServerService(
-                        serial_number, "XP33LED"
-                    )
-                elif module_type == "XP20":
-                    self.device_services[serial_number] = XP20ServerService(
-                        serial_number
-                    )
-                elif module_type == "XP130":
-                    self.device_services[serial_number] = XP130ServerService(
-                        serial_number
-                    )
-                elif module_type == "XP230":
-                    self.device_services[serial_number] = XP230ServerService(
-                        serial_number
-                    )
-                else:
-                    self.logger.warning(
-                        f"Unknown device type '{module_type}' for serial {serial_number}"
-                    )
+            except ValueError as e:
+                # Factory raises ValueError for unknown device types
+                self.logger.warning(str(e))
 
             except Exception as e:
                 self.logger.error(

{conson_xp-1.5.0 → conson_xp-1.6.0}/src/xp/services/server/xp130_server_service.py

@@ -5,9 +5,10 @@ including response generation and device configuration handling.
 XP130 is an Ethernet/TCPIP interface module.
 """
 
-from typing import Dict
+from typing import Dict, Optional
 
 from xp.models import ModuleTypeCode
+from xp.services.actiontable.msactiontable_serializer import MsActionTableSerializer
 from xp.services.server.base_server_service import BaseServerService
 
 
@@ -25,11 +26,18 @@ class XP130ServerService(BaseServerService):
     and implements XP130 telegram format for Ethernet/TCPIP interface module.
     """
 
-    def __init__(self, serial_number: str):
+    def __init__(
+        self,
+        serial_number: str,
+        _variant: str = "",
+        _msactiontable_serializer: Optional[MsActionTableSerializer] = None,
+    ):
         """Initialize XP130 server service.
 
         Args:
             serial_number: The device serial number.
+            _variant: Reserved parameter for consistency (unused).
+            _msactiontable_serializer: Generic MsActionTable serializer (unused).
         """
         super().__init__(serial_number)
         self.device_type = "XP130"

conson_xp-1.6.0/src/xp/services/server/xp20_server_service.py

@@ -0,0 +1,92 @@
+"""XP20 Server Service for device emulation.
+
+This service provides XP20-specific device emulation functionality,
+including response generation and device configuration handling.
+"""
+
+from typing import Dict, Optional
+
+from xp.models import ModuleTypeCode
+from xp.models.actiontable.msactiontable_xp20 import Xp20MsActionTable
+from xp.services.actiontable.msactiontable_xp20_serializer import (
+    Xp20MsActionTableSerializer,
+)
+from xp.services.server.base_server_service import BaseServerService
+
+
+class XP20ServerError(Exception):
+    """Raised when XP20 server operations fail."""
+
+    pass
+
+
+class XP20ServerService(BaseServerService):
+    """
+    XP20 device emulation service.
+
+    Generates XP20-specific responses, handles XP20 device configuration,
+    and implements XP20 telegram format.
+    """
+
+    def __init__(
+        self,
+        serial_number: str,
+        _variant: str = "",
+        msactiontable_serializer: Optional[Xp20MsActionTableSerializer] = None,
+    ):
+        """Initialize XP20 server service.
+
+        Args:
+            serial_number: The device serial number.
+            _variant: Reserved parameter for consistency (unused).
+            msactiontable_serializer: MsActionTable serializer (injected via DI).
+        """
+        super().__init__(serial_number)
+        self.device_type = "XP20"
+        self.module_type_code = ModuleTypeCode.XP20  # XP20 module type from registry
+        self.firmware_version = "XP20_V0.01.05"
+
+        # MsActionTable support
+        self.msactiontable_serializer = (
+            msactiontable_serializer or Xp20MsActionTableSerializer()
+        )
+        self.msactiontable = self._get_default_msactiontable()
+
+    def _get_msactiontable_serializer(self) -> Optional[Xp20MsActionTableSerializer]:
+        """Get the MsActionTable serializer for XP20.
+
+        Returns:
+            The XP20 MsActionTable serializer instance.
+        """
+        return self.msactiontable_serializer
+
+    def _get_msactiontable(self) -> Optional[Xp20MsActionTable]:
+        """Get the MsActionTable for XP20.
+
+        Returns:
+            The XP20 MsActionTable instance.
+        """
+        return self.msactiontable
+
+    def _get_default_msactiontable(self) -> Xp20MsActionTable:
+        """Generate default MsActionTable configuration.
+
+        Returns:
+            Default XP20 MsActionTable with all inputs unconfigured.
+        """
+        # All inputs unconfigured (all flags False, AND functions empty)
+        return Xp20MsActionTable()
+
+    def get_device_info(self) -> Dict:
+        """Get XP20 device information.
+
+        Returns:
+            Dictionary containing device information.
+        """
+        return {
+            "serial_number": self.serial_number,
+            "device_type": self.device_type,
+            "firmware_version": self.firmware_version,
+            "status": self.device_status,
+            "link_number": self.link_number,
+        }

{conson_xp-1.5.0 → conson_xp-1.6.0}/src/xp/services/server/xp230_server_service.py

@@ -4,9 +4,10 @@ This service provides XP230-specific device emulation functionality,
 including response generation and device configuration handling.
 """
 
-from typing import Dict
+from typing import Dict, Optional
 
 from xp.models import ModuleTypeCode
+from xp.services.actiontable.msactiontable_serializer import MsActionTableSerializer
 from xp.services.server.base_server_service import BaseServerService
 
 
@@ -24,11 +25,18 @@ class XP230ServerService(BaseServerService):
     and implements XP230 telegram format.
     """
 
-    def __init__(self, serial_number: str):
+    def __init__(
+        self,
+        serial_number: str,
+        _variant: str = "",
+        _msactiontable_serializer: Optional[MsActionTableSerializer] = None,
+    ):
         """Initialize XP230 server service.
 
         Args:
             serial_number: The device serial number.
+            _variant: Reserved parameter for consistency (unused).
+            _msactiontable_serializer: Generic MsActionTable serializer (unused).
         """
         super().__init__(serial_number)
         self.device_type = "XP230"

{conson_xp-1.5.0 → conson_xp-1.6.0}/src/xp/services/server/xp24_server_service.py

@@ -7,9 +7,15 @@ including response generation and device configuration handling.
 from typing import Dict, Optional
 
 from xp.models import ModuleTypeCode
+from xp.models.actiontable.msactiontable_xp24 import InputAction, Xp24MsActionTable
 from xp.models.telegram.datapoint_type import DataPointType
+from xp.models.telegram.input_action_type import InputActionType
 from xp.models.telegram.system_function import SystemFunction
 from xp.models.telegram.system_telegram import SystemTelegram
+from xp.models.telegram.timeparam_type import TimeParam
+from xp.services.actiontable.msactiontable_xp24_serializer import (
+    Xp24MsActionTableSerializer,
+)
 from xp.services.server.base_server_service import BaseServerService
 
 
@@ -37,11 +43,18 @@ class XP24ServerService(BaseServerService):
     and implements XP24 telegram format.
     """
 
-    def __init__(self, serial_number: str):
+    def __init__(
+        self,
+        serial_number: str,
+        _variant: str = "",
+        msactiontable_serializer: Optional[Xp24MsActionTableSerializer] = None,
+    ):
         """Initialize XP24 server service.
 
         Args:
             serial_number: The device serial number.
+            _variant: Reserved parameter for consistency (unused).
+            msactiontable_serializer: MsActionTable serializer (injected via DI).
         """
         super().__init__(serial_number)
         self.device_type = "XP24"
@@ -53,6 +66,12 @@ class XP24ServerService(BaseServerService):
         self.output_2: XP24Output = XP24Output()
         self.output_3: XP24Output = XP24Output()
 
+        # MsActionTable support
+        self.msactiontable_serializer = (
+            msactiontable_serializer or Xp24MsActionTableSerializer()
+        )
+        self.msactiontable = self._get_default_msactiontable()
+
     def _handle_device_specific_action_request(
         self, request: SystemTelegram
     ) -> Optional[str]:
@@ -175,6 +194,40 @@ class XP24ServerService(BaseServerService):
             f"{1 if self.output_3.state else 0}"
         )
 
+    def _get_msactiontable_serializer(self) -> Optional[Xp24MsActionTableSerializer]:
+        """Get the MsActionTable serializer for XP24.
+
+        Returns:
+            The XP24 MsActionTable serializer instance.
+        """
+        return self.msactiontable_serializer
+
+    def _get_msactiontable(self) -> Optional[Xp24MsActionTable]:
+        """Get the MsActionTable for XP24.
+
+        Returns:
+            The XP24 MsActionTable instance.
+        """
+        return self.msactiontable
+
+    def _get_default_msactiontable(self) -> Xp24MsActionTable:
+        """Generate default MsActionTable configuration.
+
+        Returns:
+            Default XP24 MsActionTable with all inputs set to VOID.
+        """
+        return Xp24MsActionTable(
+            input1_action=InputAction(type=InputActionType.VOID, param=TimeParam.NONE),
+            input2_action=InputAction(type=InputActionType.VOID, param=TimeParam.NONE),
+            input3_action=InputAction(type=InputActionType.VOID, param=TimeParam.NONE),
+            input4_action=InputAction(type=InputActionType.VOID, param=TimeParam.NONE),
+            mutex12=False,
+            mutex34=False,
+            curtain12=False,
+            curtain34=False,
+            mutual_deadtime=12,  # MS300
+        )
+
     def get_device_info(self) -> Dict:
         """Get XP24 device information.