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

xp/connection/exceptions.py

@@ -1,22 +1,22 @@
-"""
-Connection-related exceptions for XP CLI tool.
+"""Connection-related exceptions for XP CLI tool.
+
 Following the architecture requirement for structured error handling.
 """
 
 
 class XPError(Exception):
-    """Base exception for XP CLI tool"""
+    """Base exception for XP CLI tool."""
 
     pass
 
 
 class ProtocolError(XPError):
-    """Console bus protocol errors"""
+    """Console bus protocol errors."""
 
     pass
 
 
 class ValidationError(XPError):
-    """Input validation errors"""
+    """Input validation errors."""
 
     pass

xp/models/__init__.py

@@ -1,4 +1,4 @@
-"""Data models for XP CLI tool"""
+"""Data models for XP CLI tool."""
 
 from xp.models.conbus.conbus import ConbusRequest, ConbusResponse
 from xp.models.conbus.conbus_client_config import ConbusClientConfig

xp/models/actiontable/__init__.py

@@ -0,0 +1 @@
+"""Action table models for XP protocol."""

xp/models/actiontable/actiontable.py

@@ -11,6 +11,18 @@ from xp.models.telegram.timeparam_type import TimeParam
 # CP20 0 0 > 1 ~ON;
 @dataclass
 class ActionTableEntry:
+    """Entry in an action table mapping input events to output actions.
+
+    Attributes:
+        module_type: Type code of the module.
+        link_number: Link number for the action.
+        module_input: Input number on the module.
+        module_output: Output number on the module.
+        command: Action type to perform.
+        parameter: Time parameter for the action.
+        inverted: Whether the action is inverted.
+    """
+
     module_type: ModuleTypeCode = ModuleTypeCode.CP20
     link_number: int = 0
     module_input: int = 0
@@ -22,6 +34,10 @@ class ActionTableEntry:
 
 @dataclass
 class ActionTable:
-    """Action Table for managing action on events."""
+    """Action Table for managing action on events.
+
+    Attributes:
+        entries: List of action table entries.
+    """
 
     entries: list[ActionTableEntry] = field(default_factory=list)

xp/models/actiontable/msactiontable_xp20.py

@@ -31,6 +31,16 @@ class Xp20MsActionTable:
     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)

xp/models/actiontable/msactiontable_xp24.py

@@ -8,7 +8,12 @@ from xp.models.telegram.timeparam_type import TimeParam
 
 @dataclass
 class InputAction:
-    """Represents an input action with type and parameter"""
+    """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
@@ -16,11 +21,23 @@ class InputAction:
 
 @dataclass
 class Xp24MsActionTable:
-    """
-    XP24 Action Table for managing input actions and settings.
+    """XP24 Action Table for managing input actions and settings.
 
     Each input has an action type (TOGGLE, TURNON, 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

xp/models/actiontable/msactiontable_xp33.py

@@ -7,7 +7,15 @@ from xp.models.telegram.timeparam_type import TimeParam
 
 @dataclass
 class Xp33Output:
-    """Represents an XP33 output configuration"""
+    """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
@@ -18,7 +26,14 @@ class Xp33Output:
 
 @dataclass
 class Xp33Scene:
-    """Represents a scene configuration"""
+    """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
@@ -28,8 +43,16 @@ class Xp33Scene:
 
 @dataclass
 class Xp33MsActionTable:
-    """
-    XP33 Action Table for managing outputs and scenes
+    """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)

xp/models/conbus/__init__.py

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

xp/models/conbus/conbus.py

@@ -1,3 +1,5 @@
+"""Conbus request and response models."""
+
 from dataclasses import dataclass
 from datetime import datetime
 from typing import Any, Dict, Optional
@@ -5,7 +7,15 @@ from typing import Any, Dict, Optional
 
 @dataclass
 class ConbusRequest:
-    """Represents a Conbus send request"""
+    """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
@@ -14,11 +24,16 @@ class ConbusRequest:
     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"""
+        """Convert to dictionary for JSON serialization.
+
+        Returns:
+            Dictionary representation of the request.
+        """
         return {
             "serial_number": self.serial_number,
             "function_code": self.function_code,
@@ -29,7 +44,17 @@ class ConbusRequest:
 
 @dataclass
 class ConbusResponse:
-    """Represents a response from Conbus send operation"""
+    """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]
@@ -40,12 +65,17 @@ class ConbusResponse:
     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"""
+        """Convert to dictionary for JSON serialization.
+
+        Returns:
+            Dictionary representation of the response.
+        """
         return {
             "success": self.success,
             "serial_number": self.serial_number,

xp/models/conbus/conbus_autoreport.py

@@ -1,3 +1,5 @@
+"""Conbus auto report response model."""
+
 from dataclasses import dataclass
 from datetime import datetime
 from typing import Any, Dict, Optional
@@ -5,7 +7,18 @@ from typing import Any, Dict, Optional
 
 @dataclass
 class ConbusAutoreportResponse:
-    """Represents a response from Conbus auto report operations (get/set)"""
+    """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
@@ -17,13 +30,18 @@ class ConbusAutoreportResponse:
     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"""
+        """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,

xp/models/conbus/conbus_blink.py

@@ -1,3 +1,5 @@
+"""Conbus blink response model."""
+
 from dataclasses import dataclass
 from datetime import datetime
 from typing import Any, Dict, Optional
@@ -10,7 +12,20 @@ from xp.models.telegram.system_telegram import SystemTelegram
 
 @dataclass
 class ConbusBlinkResponse:
-    """Represents a response from Conbus send operation"""
+    """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
@@ -24,13 +39,18 @@ class ConbusBlinkResponse:
     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"""
+        """Convert to dictionary for JSON serialization.
+
+        Returns:
+            Dictionary representation of the response.
+        """
         result = {
             "success": self.success,
             "serial_number": self.serial_number,

xp/models/conbus/conbus_client_config.py

@@ -1,3 +1,5 @@
+"""Conbus client configuration models."""
+
 import logging
 from pathlib import Path
 
@@ -6,19 +8,38 @@ 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"""
+    """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:

xp/models/conbus/conbus_connection_status.py

@@ -1,3 +1,5 @@
+"""Conbus connection status model."""
+
 from dataclasses import dataclass
 from datetime import datetime
 from typing import Any, Dict, Optional
@@ -5,7 +7,15 @@ from typing import Any, Dict, Optional
 
 @dataclass
 class ConbusConnectionStatus:
-    """Represents the current connection status"""
+    """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
@@ -14,7 +24,11 @@ class ConbusConnectionStatus:
     error: Optional[str] = None
 
     def to_dict(self) -> Dict[str, Any]:
-        """Convert to dictionary for JSON serialization"""
+        """Convert to dictionary for JSON serialization.
+
+        Returns:
+            Dictionary representation of the connection status.
+        """
         return {
             "connected": self.connected,
             "ip": self.ip,

xp/models/conbus/conbus_custom.py

@@ -1,3 +1,5 @@
+"""Conbus custom response model."""
+
 from dataclasses import dataclass
 from datetime import datetime
 from typing import Any, Dict, Optional
@@ -7,7 +9,19 @@ from xp.models.telegram.reply_telegram import ReplyTelegram
 
 @dataclass
 class ConbusCustomResponse:
-    """Represents a response from Conbus send operation"""
+    """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
@@ -20,13 +34,18 @@ class ConbusCustomResponse:
     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"""
+        """Convert to dictionary for JSON serialization.
+
+        Returns:
+            Dictionary representation of the response.
+        """
         return {
             "success": self.success,
             "serial_number": self.serial_number,

xp/models/conbus/conbus_datapoint.py

@@ -1,3 +1,5 @@
+"""Conbus datapoint response model."""
+
 from dataclasses import dataclass
 from datetime import datetime
 from typing import Any, Dict, List, Optional
@@ -9,7 +11,20 @@ from xp.models.telegram.system_function import SystemFunction
 
 @dataclass
 class ConbusDatapointResponse:
-    """Represents a response from Conbus send operation"""
+    """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.
+        datapoints: List of datapoint values.
+        error: Error message if operation failed.
+        timestamp: Timestamp of the response.
+    """
 
     success: bool
     serial_number: Optional[str] = None
@@ -23,6 +38,7 @@ class ConbusDatapointResponse:
     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:
@@ -31,7 +47,11 @@ class ConbusDatapointResponse:
             self.datapoints = []
 
     def to_dict(self) -> Dict[str, Any]:
-        """Convert to dictionary for JSON serialization"""
+        """Convert to dictionary for JSON serialization.
+
+        Returns:
+            Dictionary representation of the response.
+        """
         result: Dict[str, Any] = {
             "success": self.success,
             "serial_number": self.serial_number,

xp/models/conbus/conbus_discover.py

@@ -1,3 +1,5 @@
+"""Conbus discover response model."""
+
 from dataclasses import dataclass
 from datetime import datetime
 from typing import Any, Dict, Optional
@@ -5,7 +7,16 @@ from typing import Any, Dict, Optional
 
 @dataclass
 class ConbusDiscoverResponse:
-    """Represents a response from Conbus send operation"""
+    """Represents a response from Conbus send operation.
+
+    Attributes:
+        success: Whether the operation was successful.
+        sent_telegram: Telegram sent to discover devices.
+        received_telegrams: List of telegrams received.
+        discovered_devices: List of discovered device serial numbers.
+        error: Error message if operation failed.
+        timestamp: Timestamp of the response.
+    """
 
     success: bool
     sent_telegram: Optional[str] = None
@@ -15,13 +26,18 @@ class ConbusDiscoverResponse:
     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"""
+        """Convert to dictionary for JSON serialization.
+
+        Returns:
+            Dictionary representation of the response.
+        """
         return {
             "success": self.success,
             "sent_telegram": self.sent_telegram,

xp/models/conbus/conbus_lightlevel.py

@@ -1,3 +1,5 @@
+"""Conbus light level response model."""
+
 from dataclasses import dataclass
 from datetime import datetime
 from typing import Any, Dict, Optional
@@ -5,7 +7,18 @@ from typing import Any, Dict, Optional
 
 @dataclass
 class ConbusLightlevelResponse:
-    """Represents a response from Conbus lightlevel operation"""
+    """Represents a response from Conbus lightlevel operation.
+
+    Attributes:
+        success: Whether the operation was successful.
+        serial_number: Serial number of the device.
+        output_number: Output number queried.
+        level: Light level value (0-100).
+        timestamp: Timestamp of the response.
+        sent_telegram: Telegram sent to device.
+        received_telegrams: List of telegrams received.
+        error: Error message if operation failed.
+    """
 
     success: bool
     serial_number: str
@@ -17,11 +30,16 @@ class ConbusLightlevelResponse:
     error: Optional[str] = None
 
     def __post_init__(self) -> None:
+        """Initialize received_telegrams if not provided."""
         if self.received_telegrams is None:
             self.received_telegrams = []
 
     def to_dict(self) -> Dict[str, Any]:
-        """Convert to dictionary for JSON serialization"""
+        """Convert to dictionary for JSON serialization.
+
+        Returns:
+            Dictionary representation of the response.
+        """
         return {
             "success": self.success,
             "serial_number": self.serial_number,

xp/models/conbus/conbus_linknumber.py

@@ -1,3 +1,5 @@
+"""Conbus link number response model."""
+
 from dataclasses import dataclass
 from datetime import datetime
 from typing import Any, Dict, Optional
@@ -5,7 +7,18 @@ from typing import Any, Dict, Optional
 
 @dataclass
 class ConbusLinknumberResponse:
-    """Represents a response from Conbus link number operations (set/get)"""
+    """Represents a response from Conbus link number operations (set/get).
+
+    Attributes:
+        success: Whether the operation was successful.
+        serial_number: Serial number of the device.
+        result: Result message from operation.
+        sent_telegram: Telegram sent to device.
+        received_telegrams: List of telegrams received.
+        link_number: Link number value.
+        error: Error message if operation failed.
+        timestamp: Timestamp of the response.
+    """
 
     success: bool
     serial_number: str
@@ -17,13 +30,18 @@ class ConbusLinknumberResponse:
     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"""
+        """Convert to dictionary for JSON serialization.
+
+        Returns:
+            Dictionary representation of the response.
+        """
         return {
             "success": self.success,
             "result": self.result,