conson-xp 1.18.0__py3-none-any.whl

xp/models/actiontable/msactiontable_xp20.py

@@ -0,0 +1,53 @@
+"""XP20 Action Table models for input actions and settings."""
+
+from dataclasses import dataclass, field
+
+
+@dataclass
+class InputChannel:
+    """Configuration for a single input channel in XP20 action table.
+
+    Attributes:
+        invert: Input inversion flag
+        short_long: Short/long press detection flag
+        group_on_off: Group on/off function flag
+        and_functions: 8-bit AND function configuration array
+        sa_function: SA function flag
+        ta_function: TA function flag
+    """
+
+    invert: bool = False
+    short_long: bool = False
+    group_on_off: bool = False
+    and_functions: list[bool] = field(default_factory=lambda: [False] * 8)
+    sa_function: bool = False
+    ta_function: bool = False
+
+
+@dataclass
+class Xp20MsActionTable:
+    """XP20 Action Table for managing 8 input channels.
+
+    Contains configuration for 8 input channels (input1 through input8),
+    each with flags for inversion, short/long press detection, group functions,
+    AND functions, SA functions, and TA functions.
+
+    Attributes:
+        input1: Configuration for input channel 1.
+        input2: Configuration for input channel 2.
+        input3: Configuration for input channel 3.
+        input4: Configuration for input channel 4.
+        input5: Configuration for input channel 5.
+        input6: Configuration for input channel 6.
+        input7: Configuration for input channel 7.
+        input8: Configuration for input channel 8.
+    """
+
+    input1: InputChannel = field(default_factory=InputChannel)
+    input2: InputChannel = field(default_factory=InputChannel)
+    input3: InputChannel = field(default_factory=InputChannel)
+    input4: InputChannel = field(default_factory=InputChannel)
+    input5: InputChannel = field(default_factory=InputChannel)
+    input6: InputChannel = field(default_factory=InputChannel)
+    input7: InputChannel = field(default_factory=InputChannel)
+    input8: InputChannel = field(default_factory=InputChannel)

xp/models/actiontable/msactiontable_xp24.py

@@ -0,0 +1,58 @@
+"""XP24 Action Table models for input actions and settings."""
+
+from dataclasses import dataclass, field
+
+from xp.models.telegram.input_action_type import InputActionType
+from xp.models.telegram.timeparam_type import TimeParam
+
+
+@dataclass
+class InputAction:
+    """Represents an input action with type and parameter.
+
+    Attributes:
+        type: The input action type.
+        param: Time parameter for the action.
+    """
+
+    type: InputActionType = InputActionType.TOGGLE
+    param: TimeParam = TimeParam.NONE
+
+
+@dataclass
+class Xp24MsActionTable:
+    """XP24 Action Table for managing input actions and settings.
+
+    Each input has an action type (TOGGLE, ON, LEVELSET, etc.)
+    with an optional parameter string.
+
+    Attributes:
+        MS300: Timing constant for 300ms.
+        MS500: Timing constant for 500ms.
+        input1_action: Action configuration for input 1.
+        input2_action: Action configuration for input 2.
+        input3_action: Action configuration for input 3.
+        input4_action: Action configuration for input 4.
+        mutex12: Mutual exclusion between inputs 1-2.
+        mutex34: Mutual exclusion between inputs 3-4.
+        curtain12: Curtain setting for inputs 1-2.
+        curtain34: Curtain setting for inputs 3-4.
+        mutual_deadtime: Master timing (MS300=12 or MS500=20).
+    """
+
+    # MS timing constants
+    MS300 = 12
+    MS500 = 20
+
+    # Input actions for each input (default to TOGGLE with None parameter)
+    input1_action: InputAction = field(default_factory=InputAction)
+    input2_action: InputAction = field(default_factory=InputAction)
+    input3_action: InputAction = field(default_factory=InputAction)
+    input4_action: InputAction = field(default_factory=InputAction)
+
+    # Boolean settings
+    mutex12: bool = False  # Mutual exclusion between inputs 1-2
+    mutex34: bool = False  # Mutual exclusion between inputs 3-4
+    curtain12: bool = False  # Curtain setting for inputs 1-2
+    curtain34: bool = False  # Curtain setting for inputs 3-4
+    mutual_deadtime: int = MS300  # Master timing (MS300=12 or MS500=20)

xp/models/actiontable/msactiontable_xp33.py

@@ -0,0 +1,65 @@
+"""XP33 Action Table models for output and scene configuration."""
+
+from dataclasses import dataclass, field
+
+from xp.models.telegram.timeparam_type import TimeParam
+
+
+@dataclass
+class Xp33Output:
+    """Represents an XP33 output configuration.
+
+    Attributes:
+        min_level: Minimum output level (0-100).
+        max_level: Maximum output level (0-100).
+        scene_outputs: Enable scene outputs.
+        start_at_full: Start at full brightness.
+        leading_edge: Use leading edge dimming.
+    """
+
+    min_level: int = 0
+    max_level: int = 100
+    scene_outputs: bool = False
+    start_at_full: bool = False
+    leading_edge: bool = False
+
+
+@dataclass
+class Xp33Scene:
+    """Represents a scene configuration.
+
+    Attributes:
+        output1_level: Output level for output 1 (0-100).
+        output2_level: Output level for output 2 (0-100).
+        output3_level: Output level for output 3 (0-100).
+        time: Time parameter for scene transition.
+    """
+
+    output1_level: int = 0
+    output2_level: int = 0
+    output3_level: int = 0
+    time: TimeParam = TimeParam.NONE
+
+
+@dataclass
+class Xp33MsActionTable:
+    """XP33 Action Table for managing outputs and scenes.
+
+    Attributes:
+        output1: Configuration for output 1.
+        output2: Configuration for output 2.
+        output3: Configuration for output 3.
+        scene1: Configuration for scene 1.
+        scene2: Configuration for scene 2.
+        scene3: Configuration for scene 3.
+        scene4: Configuration for scene 4.
+    """
+
+    output1: Xp33Output = field(default_factory=Xp33Output)
+    output2: Xp33Output = field(default_factory=Xp33Output)
+    output3: Xp33Output = field(default_factory=Xp33Output)
+
+    scene1: Xp33Scene = field(default_factory=Xp33Scene)
+    scene2: Xp33Scene = field(default_factory=Xp33Scene)
+    scene3: Xp33Scene = field(default_factory=Xp33Scene)
+    scene4: Xp33Scene = field(default_factory=Xp33Scene)

xp/models/conbus/__init__.py

@@ -0,0 +1 @@
+"""Conbus communication models."""

xp/models/conbus/conbus.py

@@ -0,0 +1,87 @@
+"""Conbus request and response models."""
+
+from dataclasses import dataclass
+from datetime import datetime
+from typing import Any, Dict, Optional
+
+
+@dataclass
+class ConbusRequest:
+    """Represents a Conbus send request.
+
+    Attributes:
+        serial_number: Serial number of the target device.
+        function_code: Function code for the operation.
+        data: Data payload for the request.
+        telegram: Raw telegram string.
+        timestamp: Timestamp of the request.
+    """
+
+    serial_number: Optional[str] = None
+    function_code: Optional[str] = None
+    data: Optional[str] = None
+    telegram: Optional[str] = None
+    timestamp: Optional[datetime] = None
+
+    def __post_init__(self) -> None:
+        """Initialize timestamp if not provided."""
+        if self.timestamp is None:
+            self.timestamp = datetime.now()
+
+    def to_dict(self) -> Dict[str, Any]:
+        """Convert to dictionary for JSON serialization.
+
+        Returns:
+            Dictionary representation of the request.
+        """
+        return {
+            "serial_number": self.serial_number,
+            "function_code": self.function_code,
+            "data": self.data,
+            "timestamp": self.timestamp.isoformat() if self.timestamp else None,
+        }
+
+
+@dataclass
+class ConbusResponse:
+    """Represents a response from Conbus send operation.
+
+    Attributes:
+        success: Whether the operation was successful.
+        sent_telegrams: List of telegrams sent.
+        received_telegrams: List of telegrams received.
+        timestamp: Timestamp of the response.
+        error: Error message if operation failed.
+        serial_number: Serial number of the device.
+        function_code: Function code used.
+    """
+
+    success: bool
+    sent_telegrams: list[str]
+    received_telegrams: list[str]
+    timestamp: datetime
+    error: str = ""
+    serial_number: str = ""
+    function_code: str = ""
+
+    def __post_init__(self) -> None:
+        """Initialize timestamp and telegram lists."""
+        self.timestamp = datetime.now()
+        self.sent_telegrams = []
+        self.received_telegrams = []
+
+    def to_dict(self) -> Dict[str, Any]:
+        """Convert to dictionary for JSON serialization.
+
+        Returns:
+            Dictionary representation of the response.
+        """
+        return {
+            "success": self.success,
+            "serial_number": self.serial_number,
+            "function_code": self.function_code,
+            "sent_telegrams": self.sent_telegrams,
+            "received_telegrams": self.received_telegrams,
+            "error": self.error,
+            "timestamp": self.timestamp.isoformat() if self.timestamp else None,
+        }

xp/models/conbus/conbus_autoreport.py

@@ -0,0 +1,67 @@
+"""Conbus auto report response model."""
+
+from dataclasses import dataclass
+from datetime import datetime
+from typing import Any, Dict, Optional
+
+
+@dataclass
+class ConbusAutoreportResponse:
+    """Represents a response from Conbus auto report operations (get/set).
+
+    Attributes:
+        success: Whether the operation was successful.
+        serial_number: Serial number of the device.
+        auto_report_status: Current auto report status.
+        result: Result message from set operation.
+        sent_telegram: Telegram sent to device.
+        received_telegrams: List of telegrams received.
+        error: Error message if operation failed.
+        timestamp: Timestamp of the response.
+    """
+
+    success: bool
+    serial_number: str
+    auto_report_status: Optional[str] = None
+    result: Optional[str] = None
+    sent_telegram: Optional[str] = None
+    received_telegrams: Optional[list[str]] = None
+    error: Optional[str] = None
+    timestamp: Optional[datetime] = None
+
+    def __post_init__(self) -> None:
+        """Initialize timestamp and received_telegrams if not provided."""
+        if self.timestamp is None:
+            self.timestamp = datetime.now()
+        if self.received_telegrams is None:
+            self.received_telegrams = []
+
+    def to_dict(self) -> Dict[str, Any]:
+        """Convert to dictionary for JSON serialization.
+
+        Returns:
+            Dictionary representation of the response.
+        """
+        result_dict: Dict[str, Any] = {
+            "success": self.success,
+            "serial_number": self.serial_number,
+            "error": self.error,
+            "timestamp": self.timestamp.isoformat() if self.timestamp else None,
+        }
+
+        # Include auto_report_status if available
+        if self.auto_report_status is not None:
+            result_dict["auto_report_status"] = self.auto_report_status
+
+        # Include result for set operations
+        if self.result is not None:
+            result_dict["result"] = self.result
+
+        # Include telegram details
+        if self.sent_telegram is not None:
+            result_dict["sent_telegram"] = self.sent_telegram
+
+        if self.received_telegrams is not None:
+            result_dict["received_telegrams"] = self.received_telegrams
+
+        return result_dict

xp/models/conbus/conbus_blink.py

@@ -0,0 +1,80 @@
+"""Conbus blink response model."""
+
+from dataclasses import dataclass
+from datetime import datetime
+from typing import Any, Dict, Optional
+
+from xp.models import ConbusResponse
+from xp.models.telegram.reply_telegram import ReplyTelegram
+from xp.models.telegram.system_function import SystemFunction
+from xp.models.telegram.system_telegram import SystemTelegram
+
+
+@dataclass
+class ConbusBlinkResponse:
+    """Represents a response from Conbus send operation.
+
+    Attributes:
+        success: Whether the operation was successful.
+        serial_number: Serial number of the device.
+        operation: Operation type (get or set).
+        system_function: System function used.
+        response: Response from Conbus operation.
+        reply_telegram: Reply telegram received.
+        sent_telegram: System telegram sent.
+        received_telegrams: List of telegrams received.
+        error: Error message if operation failed.
+        timestamp: Timestamp of the response.
+    """
+
+    success: bool
+    serial_number: str
+    operation: str
+    system_function: SystemFunction
+    response: Optional[ConbusResponse] = None
+    reply_telegram: Optional[ReplyTelegram] = None
+    sent_telegram: Optional[SystemTelegram] = None
+    received_telegrams: Optional[list] = None
+    error: Optional[str] = None
+    timestamp: Optional[datetime] = None
+
+    def __post_init__(self) -> None:
+        """Initialize timestamp and received_telegrams if not provided."""
+        if self.timestamp is None:
+            self.timestamp = datetime.now()
+        if self.received_telegrams is None:
+            self.received_telegrams = []
+
+    def to_dict(self) -> Dict[str, Any]:
+        """Convert to dictionary for JSON serialization.
+
+        Returns:
+            Dictionary representation of the response.
+        """
+        result = {
+            "success": self.success,
+            "serial_number": self.serial_number,
+            "operation": self.operation,
+            "system_function": (
+                self.system_function.name if self.system_function else None
+            ),
+            "sent_telegram": (
+                self.sent_telegram.to_dict()
+                if self.sent_telegram and hasattr(self.sent_telegram, "to_dict")
+                else str(self.sent_telegram) if self.sent_telegram else None
+            ),
+            "reply_telegram": (
+                self.reply_telegram.to_dict()
+                if self.reply_telegram and hasattr(self.reply_telegram, "to_dict")
+                else str(self.reply_telegram) if self.reply_telegram else None
+            ),
+            "timestamp": self.timestamp.isoformat() if self.timestamp else None,
+        }
+
+        # Only include these if they have values
+        if self.received_telegrams:
+            result["received_telegrams"] = self.received_telegrams
+        if self.error:
+            result["error"] = self.error
+
+        return result

xp/models/conbus/conbus_client_config.py

@@ -0,0 +1,55 @@
+"""Conbus client configuration models."""
+
+import logging
+from pathlib import Path
+
+import yaml
+from pydantic import BaseModel, Field
+
+
+class ClientConfig(BaseModel):
+    """Client connection configuration.
+
+    Attributes:
+        ip: IP address of the Conbus server.
+        port: Port number for the connection.
+        timeout: Connection timeout in seconds.
+    """
+
+    ip: str = "192.168.1.100"
+    port: int = 10001
+    timeout: float = 0.1
+
+
+class ConbusClientConfig(BaseModel):
+    """Configuration for Conbus client connection.
+
+    Attributes:
+        conbus: Client configuration settings.
+    """
+
+    conbus: ClientConfig = Field(default_factory=ClientConfig)
+
+    @classmethod
+    def from_yaml(cls, file_path: str) -> "ConbusClientConfig":
+        """Load configuration from YAML file.
+
+        Args:
+            file_path: Path to the YAML configuration file.
+
+        Returns:
+            ConbusClientConfig instance loaded from file or default config.
+        """
+        logger = logging.getLogger(__name__)
+        try:
+            with Path(file_path).open("r") as file:
+                data = yaml.safe_load(file)
+                return cls(**data)
+
+        except FileNotFoundError:
+            logger.error(f"File {file_path} does not exist, loading default")
+            return cls()
+        except yaml.YAMLError:
+            logger.error(f"File {file_path} is not valid")
+            # Return default config if YAML parsing fails
+            return cls()

xp/models/conbus/conbus_connection_status.py

@@ -0,0 +1,40 @@
+"""Conbus connection status model."""
+
+from dataclasses import dataclass
+from datetime import datetime
+from typing import Any, Dict, Optional
+
+
+@dataclass
+class ConbusConnectionStatus:
+    """Represents the current connection status.
+
+    Attributes:
+        connected: Whether currently connected.
+        ip: IP address of the connection.
+        port: Port number of the connection.
+        last_activity: Timestamp of last activity.
+        error: Error message if connection failed.
+    """
+
+    connected: bool
+    ip: str
+    port: int
+    last_activity: Optional[datetime] = None
+    error: Optional[str] = None
+
+    def to_dict(self) -> Dict[str, Any]:
+        """Convert to dictionary for JSON serialization.
+
+        Returns:
+            Dictionary representation of the connection status.
+        """
+        return {
+            "connected": self.connected,
+            "ip": self.ip,
+            "port": self.port,
+            "last_activity": (
+                self.last_activity.isoformat() if self.last_activity else None
+            ),
+            "error": self.error,
+        }

xp/models/conbus/conbus_custom.py

@@ -0,0 +1,58 @@
+"""Conbus custom response model."""
+
+from dataclasses import dataclass
+from datetime import datetime
+from typing import Any, Dict, Optional
+
+from xp.models.telegram.reply_telegram import ReplyTelegram
+
+
+@dataclass
+class ConbusCustomResponse:
+    """Represents a response from Conbus send operation.
+
+    Attributes:
+        success: Whether the operation was successful.
+        serial_number: Serial number of the device.
+        function_code: Function code used.
+        data: Data payload.
+        sent_telegram: Telegram sent to device.
+        received_telegrams: List of telegrams received.
+        reply_telegram: Parsed reply telegram.
+        error: Error message if operation failed.
+        timestamp: Timestamp of the response.
+    """
+
+    success: bool
+    serial_number: Optional[str] = None
+    function_code: Optional[str] = None
+    data: Optional[str] = None
+    sent_telegram: Optional[str] = None
+    received_telegrams: Optional[list] = None
+    reply_telegram: Optional[ReplyTelegram] = None
+    error: Optional[str] = None
+    timestamp: Optional[datetime] = None
+
+    def __post_init__(self) -> None:
+        """Initialize timestamp and received_telegrams if not provided."""
+        if self.timestamp is None:
+            self.timestamp = datetime.now()
+        if self.received_telegrams is None:
+            self.received_telegrams = []
+
+    def to_dict(self) -> Dict[str, Any]:
+        """Convert to dictionary for JSON serialization.
+
+        Returns:
+            Dictionary representation of the response.
+        """
+        return {
+            "success": self.success,
+            "serial_number": self.serial_number,
+            "function_code": self.function_code,
+            "data": self.data,
+            "sent_telegram": self.sent_telegram,
+            "received_telegrams": self.received_telegrams,
+            "error": self.error,
+            "timestamp": self.timestamp.isoformat() if self.timestamp else None,
+        }

xp/models/conbus/conbus_datapoint.py

@@ -0,0 +1,89 @@
+"""Conbus datapoint response model."""
+
+from dataclasses import dataclass
+from datetime import datetime
+from typing import Any, Dict, List, Optional
+
+from xp.models.telegram.datapoint_type import DataPointType
+from xp.models.telegram.reply_telegram import ReplyTelegram
+from xp.models.telegram.system_function import SystemFunction
+
+
+@dataclass
+class ConbusDatapointResponse:
+    """Represents a response from Conbus send operation.
+
+    Attributes:
+        success: Whether the operation was successful.
+        serial_number: Serial number of the device.
+        system_function: System function used for query.
+        datapoint_type: Type of datapoint queried.
+        sent_telegram: Telegram sent to device.
+        received_telegrams: List of telegrams received.
+        datapoint_telegram: Parsed datapoint telegram.
+        data_value: Value of the datapoint telegram.
+        datapoints: List of datapoint values.
+        error: Error message if operation failed.
+        timestamp: Timestamp of the response.
+    """
+
+    success: bool
+    serial_number: Optional[str] = None
+    system_function: Optional[SystemFunction] = None
+    datapoint_type: Optional[DataPointType] = None
+    sent_telegram: Optional[str] = None
+    received_telegrams: Optional[list] = None
+    datapoint_telegram: Optional[ReplyTelegram] = None
+    data_value: str = ""
+    datapoints: Optional[List[Dict[str, str]]] = None
+    error: Optional[str] = None
+    timestamp: Optional[datetime] = None
+
+    def __post_init__(self) -> None:
+        """Initialize timestamp, received_telegrams, and datapoints if not provided."""
+        if self.timestamp is None:
+            self.timestamp = datetime.now()
+        if self.received_telegrams is None:
+            self.received_telegrams = []
+        if self.datapoints is None:
+            self.datapoints = []
+
+    def to_dict(self) -> Dict[str, Any]:
+        """Convert to dictionary for JSON serialization.
+
+        Returns:
+            Dictionary representation of the response.
+        """
+        result: Dict[str, Any] = {
+            "success": self.success,
+            "serial_number": self.serial_number,
+            "data_value": self.data_value,
+            "error": self.error,
+            "timestamp": self.timestamp.isoformat() if self.timestamp else None,
+        }
+
+        # Include system_function for single datapoint queries
+        if self.system_function is not None:
+            result["system_function"] = str(self.system_function)
+
+        # Include datapoint_type for single datapoint queries
+        if self.datapoint_type is not None:
+            result["datapoint_type"] = str(self.datapoint_type)
+
+        # Include sent_telegram for single datapoint queries
+        if self.sent_telegram is not None:
+            result["sent_telegram"] = self.sent_telegram
+
+        # Include received_telegrams for single datapoint queries
+        if self.received_telegrams is not None:
+            result["received_telegrams"] = self.received_telegrams
+
+        # Include datapoint_telegram for single datapoint queries
+        if self.datapoint_telegram is not None:
+            result["datapoint_telegram"] = self.datapoint_telegram.to_dict()
+
+        # Include datapoints for all datapoints queries
+        if self.datapoints is not None and len(self.datapoints) > 0:
+            result["datapoints"] = self.datapoints
+
+        return result