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

xp/models/conbus/conbus_output.py

@@ -1,3 +1,5 @@
+"""Conbus output response model."""
+
 from dataclasses import dataclass
 from datetime import datetime
 from typing import Any, Dict, Optional
@@ -9,7 +11,20 @@ from xp.models.telegram.reply_telegram import ReplyTelegram
 
 @dataclass
 class ConbusOutputResponse:
-    """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.
+        output_number: Output number controlled.
+        action_type: Type of action performed.
+        timestamp: Timestamp of the response.
+        output_telegram: Output telegram sent.
+        sent_telegram: Raw telegram sent to device.
+        received_telegrams: List of telegrams received.
+        datapoint_telegram: Datapoint telegram received.
+        error: Error message if operation failed.
+    """
 
     success: bool
     serial_number: str
@@ -23,11 +38,16 @@ class ConbusOutputResponse:
     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,
             "sent_telegram": self.sent_telegram,

xp/models/conbus/conbus_raw.py

@@ -1,3 +1,5 @@
+"""Conbus raw response model."""
+
 from dataclasses import dataclass
 from datetime import datetime
 from typing import Any, Dict, List, Optional
@@ -5,7 +7,15 @@ from typing import Any, Dict, List, Optional
 
 @dataclass
 class ConbusRawResponse:
-    """Represents a response from Conbus raw telegram send operation"""
+    """Represents a response from Conbus raw telegram send operation.
+
+    Attributes:
+        success: Whether the operation was successful.
+        sent_telegrams: Raw telegrams sent.
+        received_telegrams: List of telegrams received.
+        error: Error message if operation failed.
+        timestamp: Timestamp of the response.
+    """
 
     success: bool
     sent_telegrams: Optional[str] = None
@@ -14,13 +24,18 @@ class ConbusRawResponse:
     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_telegrams": self.sent_telegrams,

xp/models/conbus/conbus_receive.py

@@ -1,3 +1,5 @@
+"""Conbus receive response model."""
+
 from dataclasses import dataclass
 from datetime import datetime
 from typing import Any, Dict, List, Optional
@@ -5,7 +7,14 @@ from typing import Any, Dict, List, Optional
 
 @dataclass
 class ConbusReceiveResponse:
-    """Represents a response from Conbus receive operation"""
+    """Represents a response from Conbus receive operation.
+
+    Attributes:
+        success: Whether the operation was successful.
+        received_telegrams: List of telegrams received.
+        error: Error message if operation failed.
+        timestamp: Timestamp of the response.
+    """
 
     success: bool
     received_telegrams: Optional[List[str]] = None
@@ -13,13 +22,18 @@ class ConbusReceiveResponse:
     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,
             "received_telegrams": self.received_telegrams,

xp/models/conbus/conbus_writeconfig.py

@@ -0,0 +1,60 @@
+"""Conbus link number response model."""
+
+from dataclasses import dataclass
+from datetime import datetime
+from typing import Any, Dict, Optional
+
+from xp.models.telegram.datapoint_type import DataPointType
+from xp.models.telegram.system_function import SystemFunction
+
+
+@dataclass
+class ConbusWriteConfigResponse:
+    """Represents a response from Conbus write config operations (set/get).
+
+    Attributes:
+        success: Whether the operation was successful.
+        serial_number: Serial number of the device.
+        datapoint_type: the datapoint to write.
+        system_function: ACK or NAK received.
+        sent_telegram: Telegram sent to device.
+        received_telegrams: List of telegrams received.
+        data_value: written value.
+        error: Error message if operation failed.
+        timestamp: Timestamp of the response.
+    """
+
+    success: bool
+    serial_number: str
+    datapoint_type: Optional[DataPointType] = None
+    system_function: Optional[SystemFunction] = None
+    sent_telegram: Optional[str] = None
+    received_telegrams: Optional[list] = None
+    data_value: Optional[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.
+        """
+        return {
+            "success": self.success,
+            "system_function": self.system_function,
+            "datapoint_type": self.datapoint_type,
+            "data_value": self.data_value,
+            "serial_number": self.serial_number,
+            "sent_telegram": self.sent_telegram,
+            "received_telegrams": self.received_telegrams,
+            "error": self.error,
+            "timestamp": self.timestamp.isoformat() if self.timestamp else None,
+        }

xp/models/homekit/__init__.py

@@ -0,0 +1 @@
+"""HomeKit integration models."""

xp/models/homekit/homekit_accessory.py

@@ -1,3 +1,5 @@
+"""HomeKit configuration models."""
+
 import random
 from typing import Any
 
@@ -6,11 +8,22 @@ from pyhap.const import CATEGORY_SENSOR
 
 
 class TemperatureSensor(Accessory):
-    """Fake Temperature sensor, measuring every 3 seconds."""
+    """Fake Temperature sensor, measuring every 3 seconds.
+
+    Attributes:
+        category: HomeKit category for sensor.
+        char_temp: Temperature characteristic.
+    """
 
     category = CATEGORY_SENSOR
 
     def __init__(self, *args: Any, **kwargs: Any) -> None:
+        """Initialize temperature sensor accessory.
+
+        Args:
+            args: Positional arguments passed to parent Accessory.
+            kwargs: Keyword arguments passed to parent Accessory.
+        """
         super().__init__(*args, **kwargs)
 
         serv_temp = self.add_preload_service("TemperatureSensor")
@@ -18,4 +31,5 @@ class TemperatureSensor(Accessory):
 
     @Accessory.run_at_interval(30)
     async def run(self) -> None:
+        """Update temperature value every 30 seconds."""
         self.char_temp.set_value(random.randint(-25, 25))

xp/models/homekit/homekit_config.py

@@ -1,3 +1,5 @@
+"""HomeKit configuration models."""
+
 import logging
 from ipaddress import IPv4Address, IPv6Address
 from pathlib import Path
@@ -8,21 +10,54 @@ from pydantic import BaseModel, Field, IPvAnyAddress
 
 
 class NetworkConfig(BaseModel):
+    """Network configuration settings.
+
+    Attributes:
+        ip: IP address for the network connection.
+        port: Port number for the network connection.
+    """
+
     ip: Union[IPvAnyAddress, IPv4Address, IPv6Address, str] = "127.0.0.1"
     port: int = 51826
 
 
 class RoomConfig(BaseModel):
+    """Room configuration settings.
+
+    Attributes:
+        name: Name of the room.
+        accessories: List of accessory identifiers in the room.
+    """
+
     name: str
     accessories: List[str]
 
 
 class BridgeConfig(BaseModel):
+    """HomeKit bridge settings.
+
+    Attributes:
+        name: Name of the HomeKit bridge.
+        rooms: List of room configurations.
+    """
+
     name: str = "Conson Bridge"
     rooms: List[RoomConfig] = []
 
 
 class HomekitAccessoryConfig(BaseModel):
+    """HomeKit accessory configuration.
+
+    Attributes:
+        name: Name of the accessory.
+        id: Unique identifier for the accessory.
+        serial_number: Serial number of the accessory.
+        output_number: Output number for the accessory.
+        description: Description of the accessory.
+        service: Service type for the accessory.
+        hap_accessory: Optional HAP accessory identifier.
+    """
+
     name: str
     id: str
     serial_number: str
@@ -33,6 +68,15 @@ class HomekitAccessoryConfig(BaseModel):
 
 
 class HomekitConfig(BaseModel):
+    """HomeKit bridge configuration.
+
+    Attributes:
+        homekit: Network configuration for HomeKit.
+        conson: Network configuration for Conson.
+        bridge: Bridge configuration settings.
+        accessories: List of accessory configurations.
+    """
+
     homekit: NetworkConfig = Field(default_factory=NetworkConfig)
     conson: NetworkConfig = Field(default_factory=NetworkConfig)
     bridge: BridgeConfig = Field(default_factory=BridgeConfig)
@@ -40,6 +84,14 @@ class HomekitConfig(BaseModel):
 
     @classmethod
     def from_yaml(cls, file_path: str) -> "HomekitConfig":
+        """Load configuration from YAML file.
+
+        Args:
+            file_path: Path to the YAML configuration file.
+
+        Returns:
+            HomekitConfig instance loaded from file or default config.
+        """
         if not Path(file_path).exists():
             logger = logging.getLogger(__name__)
             logger.error(f"File {file_path} does not exist, loading default")

xp/models/homekit/homekit_conson_config.py

@@ -1,3 +1,5 @@
+"""HomeKit configuration models."""
+
 import logging
 from pathlib import Path
 from typing import List, Optional
@@ -6,6 +8,22 @@ from pydantic import BaseModel, IPvAnyAddress
 
 
 class ConsonModuleConfig(BaseModel):
+    """Configuration for a Conson module.
+
+    Attributes:
+        name: Name of the module.
+        serial_number: Serial number of the module.
+        module_type: Type of the module.
+        module_type_code: Numeric code for the module type.
+        link_number: Link number for the module.
+        enabled: Whether the module is enabled.
+        module_number: Optional module number.
+        conbus_ip: Optional Conbus IP address.
+        conbus_port: Optional Conbus port number.
+        sw_version: Optional software version.
+        hw_version: Optional hardware version.
+    """
+
     name: str
     serial_number: str
     module_type: str
@@ -20,10 +38,24 @@ class ConsonModuleConfig(BaseModel):
 
 
 class ConsonModuleListConfig(BaseModel):
+    """Configuration list for Conson modules.
+
+    Attributes:
+        root: List of Conson module configurations.
+    """
+
     root: List[ConsonModuleConfig] = []
 
     @classmethod
     def from_yaml(cls, file_path: str) -> "ConsonModuleListConfig":
+        """Load configuration from YAML file.
+
+        Args:
+            file_path: Path to the YAML configuration file.
+
+        Returns:
+            ConsonModuleListConfig instance loaded from file or default config.
+        """
         import yaml
 
         if not Path(file_path).exists():

xp/models/log_entry.py

@@ -11,11 +11,23 @@ from xp.models.telegram.system_telegram import SystemTelegram
 
 @dataclass
 class LogEntry:
-    """
-    Represents a single entry in a console bus log file.
+    """Represents a single entry in a console bus log file.
 
     Format: HH:MM:SS,mmm [TX/RX] <telegram>
     Examples: 22:44:20,352 [TX] <S0012345008F27D00AAFN>
+
+    Attributes:
+        timestamp: Timestamp of the log entry.
+        direction: Direction of telegram ("TX" or "RX").
+        raw_telegram: Raw telegram string.
+        parsed_telegram: Parsed telegram object if successfully parsed.
+        parse_error: Error message if parsing failed.
+        line_number: Line number in the log file.
+        is_transmitted: True if this is a transmitted telegram.
+        is_received: True if this is a received telegram.
+        telegram_type: Telegram type (event, system, reply, unknown).
+        is_valid_parse: True if the telegram was successfully parsed.
+        checksum_validated: Checksum validation status if available.
     """
 
     timestamp: datetime
@@ -29,17 +41,29 @@ class LogEntry:
 
     @property
     def is_transmitted(self) -> bool:
-        """True if this is a transmitted telegram"""
+        """True if this is a transmitted telegram.
+
+        Returns:
+            True if direction is TX, False otherwise.
+        """
         return self.direction == "TX"
 
     @property
     def is_received(self) -> bool:
-        """True if this is a received telegram"""
+        """True if this is a received telegram.
+
+        Returns:
+            True if direction is RX, False otherwise.
+        """
         return self.direction == "RX"
 
     @property
     def telegram_type(self) -> str:
-        """Get the telegram type (event, system, reply, unknown)"""
+        """Get the telegram type (event, system, reply, unknown).
+
+        Returns:
+            Telegram type string.
+        """
         if self.parsed_telegram is None:
             return "unknown"
 
@@ -47,18 +71,30 @@ class LogEntry:
 
     @property
     def is_valid_parse(self) -> bool:
-        """True if the telegram was successfully parsed"""
+        """True if the telegram was successfully parsed.
+
+        Returns:
+            True if parsed without errors, False otherwise.
+        """
         return self.parsed_telegram is not None and self.parse_error is None
 
     @property
     def checksum_validated(self) -> Optional[bool]:
-        """Get checksum validation status if available"""
+        """Get checksum validation status if available.
+
+        Returns:
+            Checksum validation status or None if not available.
+        """
         if self.parsed_telegram and hasattr(self.parsed_telegram, "checksum_validated"):
             return self.parsed_telegram.checksum_validated
         return 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 log entry.
+        """
         result: dict[str, Any] = {
             "line_number": self.line_number,
             "timestamp": self.timestamp.strftime("%H:%M:%S.%f")[
@@ -79,7 +115,11 @@ class LogEntry:
         return result
 
     def __str__(self) -> str:
-        """Human-readable string representation"""
+        """Human-readable string representation.
+
+        Returns:
+            Formatted string representation of the log entry.
+        """
         timestamp_str = self.timestamp.strftime("%H:%M:%S,%f")[:-3]  # HH:MM:SS,mmm
         status = "✓" if self.is_valid_parse else "✗"
         checksum_status = ""

xp/models/protocol/__init__.py

@@ -0,0 +1 @@
+"""Protocol models and interfaces."""