conson-xp 1.18.0__py3-none-any.whl

xp/models/conbus/conbus_discover.py

@@ -0,0 +1,64 @@
+"""Conbus discover response model."""
+
+from dataclasses import dataclass
+from datetime import datetime
+from typing import Any, Dict, Optional, TypedDict
+
+
+class DiscoveredDevice(TypedDict):
+    """Discovered device information.
+
+    Attributes:
+        serial_number: Serial number of the device.
+        module_type: Module type name (e.g., "XP24", "XP230"), None if not yet retrieved.
+        module_type_code: Module type code (e.g., "13", "10"), None if not yet retrieved.
+        module_type_name: Module type name converted from module_type_code, None if not yet retrieved.
+    """
+
+    serial_number: str
+    module_type: Optional[str]
+    module_type_code: Optional[int]
+    module_type_name: Optional[str]
+
+
+@dataclass
+class ConbusDiscoverResponse:
+    """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 devices with their module types.
+        error: Error message if operation failed.
+        timestamp: Timestamp of the response.
+    """
+
+    success: bool
+    sent_telegram: Optional[str] = None
+    received_telegrams: Optional[list[str]] = None
+    discovered_devices: Optional[list[DiscoveredDevice]] = 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,
+            "sent_telegram": self.sent_telegram,
+            "received_telegrams": self.received_telegrams,
+            "discovered_devices": self.discovered_devices,
+            "error": self.error,
+            "timestamp": self.timestamp.isoformat() if self.timestamp else None,
+        }

xp/models/conbus/conbus_event_raw.py

@@ -0,0 +1,47 @@
+"""Conbus event raw response model."""
+
+from dataclasses import dataclass
+from datetime import datetime
+from typing import Any, Dict, Optional
+
+
+@dataclass
+class ConbusEventRawResponse:
+    """Represents a response from Conbus event raw operation.
+
+    Attributes:
+        success: Whether the operation was successful.
+        sent_telegrams: List of event telegrams sent (MAKE and BREAK).
+        received_telegrams: List of all telegrams received.
+        error: Error message if operation failed.
+        timestamp: Timestamp of the response.
+    """
+
+    success: bool
+    sent_telegrams: Optional[list[str]] = None
+    received_telegrams: Optional[list[str]] = None
+    error: Optional[str] = None
+    timestamp: Optional[datetime] = None
+
+    def __post_init__(self) -> None:
+        """Initialize timestamp and telegram lists if not provided."""
+        if self.timestamp is None:
+            self.timestamp = datetime.now()
+        if self.sent_telegrams is None:
+            self.sent_telegrams = []
+        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,
+            "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_lightlevel.py

@@ -0,0 +1,52 @@
+"""Conbus light level response model."""
+
+from dataclasses import dataclass
+from datetime import datetime
+from typing import Any, Dict, Optional
+
+
+@dataclass
+class ConbusLightlevelResponse:
+    """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
+    output_number: int
+    level: Optional[int]
+    timestamp: datetime
+    sent_telegram: Optional[str] = None
+    received_telegrams: Optional[list[str]] = None
+    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.
+
+        Returns:
+            Dictionary representation of the response.
+        """
+        return {
+            "success": self.success,
+            "serial_number": self.serial_number,
+            "output_number": self.output_number,
+            "level": self.level,
+            "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_linknumber.py

@@ -0,0 +1,54 @@
+"""Conbus link number response model."""
+
+from dataclasses import dataclass
+from datetime import datetime
+from typing import Any, Dict, Optional
+
+
+@dataclass
+class ConbusLinknumberResponse:
+    """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
+    result: str
+    sent_telegram: Optional[str] = None
+    received_telegrams: Optional[list] = None
+    link_number: Optional[int] = 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,
+            "result": self.result,
+            "link_number": self.link_number,
+            "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/conbus/conbus_output.py

@@ -0,0 +1,57 @@
+"""Conbus output response model."""
+
+from dataclasses import dataclass
+from datetime import datetime
+from typing import Any, Dict, Optional
+
+from xp.models.telegram.action_type import ActionType
+from xp.models.telegram.output_telegram import OutputTelegram
+from xp.models.telegram.reply_telegram import ReplyTelegram
+
+
+@dataclass
+class ConbusOutputResponse:
+    """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
+    output_number: int
+    action_type: ActionType
+    timestamp: datetime
+    output_telegram: Optional[OutputTelegram] = None
+    sent_telegram: Optional[str] = None
+    received_telegrams: Optional[list[str]] = None
+    datapoint_telegram: Optional[ReplyTelegram] = None
+    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.
+
+        Returns:
+            Dictionary representation of the response.
+        """
+        return {
+            "success": self.success,
+            "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_raw.py

@@ -0,0 +1,45 @@
+"""Conbus raw response model."""
+
+from dataclasses import dataclass
+from datetime import datetime
+from typing import Any, Dict, List, Optional
+
+
+@dataclass
+class ConbusRawResponse:
+    """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
+    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.
+        """
+        return {
+            "success": self.success,
+            "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_receive.py

@@ -0,0 +1,42 @@
+"""Conbus receive response model."""
+
+from dataclasses import dataclass
+from datetime import datetime
+from typing import Any, Dict, List, Optional
+
+
+@dataclass
+class ConbusReceiveResponse:
+    """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
+    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,
+            "received_telegrams": self.received_telegrams,
+            "error": self.error,
+            "timestamp": self.timestamp.isoformat() if self.timestamp else None,
+        }

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

@@ -0,0 +1,35 @@
+"""HomeKit configuration models."""
+
+import random
+from typing import Any
+
+from pyhap.accessory import Accessory
+from pyhap.const import CATEGORY_SENSOR
+
+
+class TemperatureSensor(Accessory):
+    """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")
+        self.char_temp = serv_temp.configure_char("CurrentTemperature")
+
+    @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

@@ -0,0 +1,106 @@
+"""HomeKit configuration models."""
+
+import logging
+from ipaddress import IPv4Address, IPv6Address
+from pathlib import Path
+from typing import List, Optional, Union
+
+import yaml
+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.
+        on_action: on code for the accessory.
+        off_action: off code for the accessory.
+        hap_accessory: Optional HAP accessory identifier.
+    """
+
+    name: str
+    id: str
+    serial_number: str
+    output_number: int
+    description: str
+    service: str
+    on_action: str
+    off_action: str
+    hap_accessory: Optional[int] = None
+
+
+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)
+    accessories: List[HomekitAccessoryConfig] = []
+
+    @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")
+            return cls()
+
+        with Path(file_path).open("r") as file:
+            data = yaml.safe_load(file)
+        return cls(**data)

xp/models/homekit/homekit_conson_config.py

@@ -0,0 +1,86 @@
+"""HomeKit configuration models."""
+
+import logging
+from pathlib import Path
+from typing import List, Optional
+
+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.
+        action_table: Optional action table configuration.
+        auto_report_status: Optional auto report status.
+    """
+
+    name: str
+    serial_number: str
+    module_type: str
+    module_type_code: int
+    link_number: int
+    enabled: bool = True
+    module_number: Optional[int] = None
+    conbus_ip: Optional[IPvAnyAddress] = None
+    conbus_port: Optional[int] = None
+    sw_version: Optional[str] = None
+    hw_version: Optional[str] = None
+    action_table: Optional[List[str]] = None
+    auto_report_status: Optional[str] = None
+
+
+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():
+            logger = logging.getLogger(__name__)
+            logger.error(f"File {file_path} does not exist, loading default")
+            return cls()
+
+        with Path(file_path).open("r") as file:
+            data = yaml.safe_load(file)
+        return cls(root=data)
+
+    def find_module(self, serial_number: str) -> Optional[ConsonModuleConfig]:
+        """Find a module by serial number.
+
+        Args:
+            serial_number: Module serial number to search for.
+
+        Returns:
+            ConsonModuleConfig if found, None otherwise.
+        """
+        for module in self.root:
+            if module.serial_number == serial_number:
+                return module
+        return None