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

xp/models/telegram/module_type.py

@@ -1,3 +1,5 @@
+"""Module type models for the XP system."""
+
 from dataclasses import dataclass
 from typing import Dict, List, Optional
 
@@ -6,25 +8,35 @@ from xp.models.telegram.module_type_code import MODULE_TYPE_REGISTRY
 
 @dataclass
 class ModuleType:
-    """
-    Represents a module type in the XP system.
+    """Represents a module type in the XP system.
+
     Contains the module code, name, and description.
+
+    Attributes:
+        code: Numeric module type code.
+        name: Module name.
+        description: Module description.
+        module_category: Module category.
+        is_reserved: True if module type is reserved.
+        is_push_button_panel: True if module is a push button panel.
+        is_ir_capable: True if module has IR capabilities.
+        category: Module category based on its type.
     """
 
     code: int
     name: str
     description: str
+    module_category: str = ""
 
     @classmethod
     def from_code(cls, code: int) -> Optional["ModuleType"]:
-        """
-        Create ModuleType from a numeric code.
+        """Create ModuleType from a numeric code.
 
         Args:
-            code: The numeric module type code
+            code: The numeric module type code.
 
         Returns:
-            ModuleType instance or None if code is invalid
+            ModuleType instance or None if code is invalid.
         """
         module_info = MODULE_TYPE_REGISTRY.get(code)
         if module_info:
@@ -33,14 +45,13 @@ class ModuleType:
 
     @classmethod
     def from_name(cls, name: str) -> Optional["ModuleType"]:
-        """
-        Create ModuleType from a module name.
+        """Create ModuleType from a module name.
 
         Args:
-            name: The module name (case-insensitive)
+            name: The module name (case-insensitive).
 
         Returns:
-            ModuleType instance or None if name is invalid
+            ModuleType instance or None if name is invalid.
         """
         name_upper = name.upper()
         for code, info in MODULE_TYPE_REGISTRY.items():
@@ -50,12 +61,20 @@ class ModuleType:
 
     @property
     def is_reserved(self) -> bool:
-        """Check if this module type is reserved"""
+        """Check if this module type is reserved.
+
+        Returns:
+            True if module type is reserved, False otherwise.
+        """
         return self.name in ("XP26X1", "XP26X2")
 
     @property
     def is_push_button_panel(self) -> bool:
-        """Check if this module type is a push button panel"""
+        """Check if this module type is a push button panel.
+
+        Returns:
+            True if module is a push button panel, False otherwise.
+        """
         return self.name in (
             "XP2606",
             "XP2606A",
@@ -68,7 +87,11 @@ class ModuleType:
 
     @property
     def is_ir_capable(self) -> bool:
-        """Check if this module type has IR capabilities"""
+        """Check if this module type has IR capabilities.
+
+        Returns:
+            True if module has IR capabilities, False otherwise.
+        """
         return any(ir_type in self.name for ir_type in ("38kHz", "B&O")) or any(
             ir_code in self.name
             for ir_code in (
@@ -83,7 +106,11 @@ class ModuleType:
 
     @property
     def category(self) -> str:
-        """Get the module category based on its type"""
+        """Get the module category based on its type.
+
+        Returns:
+            Module category string.
+        """
         if self.code <= 1:
             return "System"
         elif 2 <= self.code <= 6:
@@ -95,7 +122,11 @@ class ModuleType:
         return "Unknown"
 
     def to_dict(self) -> Dict:
-        """Convert to dictionary for JSON serialization"""
+        """Convert to dictionary for JSON serialization.
+
+        Returns:
+            Dictionary representation of the module type.
+        """
         return {
             "code": self.code,
             "name": self.name,
@@ -107,12 +138,20 @@ class ModuleType:
         }
 
     def __str__(self) -> str:
-        """Human-readable string representation"""
+        """Return human-readable string representation.
+
+        Returns:
+            Formatted string representation.
+        """
         return f"{self.name} (Code {self.code}): {self.description}"
 
 
 def get_all_module_types() -> List[ModuleType]:
-    """Get all available module types"""
+    """Get all available module types.
+
+    Returns:
+        List of all ModuleType instances.
+    """
     return [
         module_type
         for module_type in [
@@ -123,7 +162,11 @@ def get_all_module_types() -> List[ModuleType]:
 
 
 def get_module_types_by_category() -> Dict[str, List[ModuleType]]:
-    """Get module types grouped by category"""
+    """Get module types grouped by category.
+
+    Returns:
+        Dictionary mapping category names to lists of ModuleType instances.
+    """
     categories: Dict[str, List[ModuleType]] = {}
     for module_type in get_all_module_types():
         category = module_type.category
@@ -134,5 +177,12 @@ def get_module_types_by_category() -> Dict[str, List[ModuleType]]:
 
 
 def is_valid_module_code(code: int) -> bool:
-    """Check if a module code is valid"""
+    """Check if a module code is valid.
+
+    Args:
+        code: Module code to validate.
+
+    Returns:
+        True if code is valid, False otherwise.
+    """
     return code in MODULE_TYPE_REGISTRY

xp/models/telegram/module_type_code.py

@@ -1,9 +1,51 @@
+"""Module type code enumeration for XP system modules."""
+
 from enum import Enum
 from typing import Dict
 
 
 class ModuleTypeCode(Enum):
-    """Enum representing all XP system module type codes"""
+    """Enum representing all XP system module type codes.
+
+    Attributes:
+        NOMOD: No module (code 0).
+        ALLMOD: Matches every module type (code 1).
+        CP20: CP switch link module (code 2).
+        CP70A: CP 38kHz IR link module (code 3).
+        CP70B: CP B&O IR link module (code 4).
+        CP70C: CP UHF link module (code 5).
+        CP70D: CP timer link module (code 6).
+        XP24: XP relay module (code 7).
+        XP31UNI: XP universal load light dimmer (code 8).
+        XP31BCU: XP ballast controller 0-10V (code 9).
+        XP31DD: XP ballast controller DSI/DALI (code 10).
+        XP33: XP 3-channel light dimmer (code 11).
+        CP485: CP RS485 interface module (code 12).
+        XP130: Ethernet/TCP/IP interface module (code 13).
+        XP2606: 5-way push button panel with sesam (code 14).
+        XP2606A: 5-way push button with IR receiver (code 15).
+        XP2606B: 5-way push button with B&O IR (code 16).
+        XP26X1: Reserved (code 17).
+        XP26X2: Reserved (code 18).
+        XP2506: 5-way push button panel with sesam Conson design (code 19).
+        XP2506A: 5-way push button panel with sesam and 38kHz IR Conson design (code 20).
+        XP2506B: 5-way push button panel with sesam and B&O IR Conson design (code 21).
+        XPX1_8: 8-way push button panel interface (code 22).
+        XP134: Junctionbox interlink (code 23).
+        XP24P: XP24P module (code 24).
+        XP28A: XP28A module (code 25).
+        XP28B: XP28B module (code 26).
+        CONTOOL: CONTOOL module (code 27).
+        XP28: XP28 module (code 28).
+        XP31LR: XP 1-channel lightdimmer (code 29).
+        XP33LR: XP 33 3-channel lightdimmer (code 30).
+        XP31CR: XP 31 1-channel dimmer (code 31).
+        XP31BC: XP 31 1-channel dimmer (code 32).
+        XP20: XP switch link module (code 33).
+        XP230: Ethernet/TCPIP interface module (code 34).
+        XP33LED: XP 3-channel LED dimmer (code 35).
+        XP31LED: XP 1-channel LED dimmer (code 36).
+    """
 
     NOMOD = 0  # No module
     ALLMOD = 1  # Code matching every moduletype

xp/models/telegram/output_telegram.py

@@ -17,11 +17,18 @@ from xp.models.telegram.telegram import Telegram
 
 @dataclass
 class OutputTelegram(Telegram):
-    """
-    Represents a parsed XP output telegram from the console bus.
+    """Represent a parsed XP output telegram from the console bus.
 
     Format: <S{serial_number}F27D{input:02d}{action}{checksum}>
     Examples: <S0012345008F27D00AAFN>
+
+    Attributes:
+        serial_number: Serial number of the device.
+        output_number: Output number (0-3 for XP24, 0-2 for XP33, 0 for XP31).
+        action_type: Type of action to perform.
+        system_function: System function code.
+        action_description: Human-readable action description.
+        input_description: Human-readable input description.
     """
 
     serial_number: str = ""
@@ -32,12 +39,17 @@ class OutputTelegram(Telegram):
     system_function: SystemFunction = SystemFunction.ACTION
 
     def __post_init__(self) -> None:
+        """Initialize timestamp if not provided."""
         if self.timestamp is None:
             self.timestamp = datetime.now()
 
     @property
     def action_description(self) -> str:
-        """Get human-readable action description"""
+        """Get human-readable action description.
+
+        Returns:
+            Human-readable description of the action.
+        """
         descriptions = {
             ActionType.OFF_PRESS: "Press (Make)",
             ActionType.ON_RELEASE: "Release (Break)",
@@ -50,11 +62,19 @@ class OutputTelegram(Telegram):
 
     @property
     def input_description(self) -> str:
-        """Get human-readable input description"""
+        """Get human-readable input description.
+
+        Returns:
+            Description of the input/output number.
+        """
         return f"Input {self.output_number}"
 
     def to_dict(self) -> dict:
-        """Convert to dictionary for JSON serialization"""
+        """Convert to dictionary for JSON serialization.
+
+        Returns:
+            Dictionary representation of the output telegram.
+        """
         return {
             "serial_number": self.serial_number,
             "system_function": self.system_function,
@@ -71,7 +91,11 @@ class OutputTelegram(Telegram):
         }
 
     def __str__(self) -> str:
-        """Human-readable string representation"""
+        """Return human-readable string representation.
+
+        Returns:
+            Formatted string representation.
+        """
         return (
             f"XP Output: {self.action_description} "
             f"on {self.input_description} "

xp/models/telegram/reply_telegram.py

@@ -16,11 +16,11 @@ from xp.models.telegram.telegram_type import TelegramType
 
 @dataclass
 class ReplyTelegram(Telegram):
-    """
-    Represents a parsed reply telegram from the console bus.
+    """Represents a parsed reply telegram from the console bus.
 
     Format: <R{serial_number}F{function_code}D{data}{checksum}>
     Format: <R{serial_number}F{function_code}D{datapoint_type}{data_value}{checksum}>
+
     Examples:
         - raw_telegram: <R0020012521F02D18+26,0§CIL>
         - telegram_type : ReplyTelegram (R)
@@ -30,6 +30,14 @@ class ReplyTelegram(Telegram):
         - datapoint_type: 18
         - data_value: +26,0§C
         - checksum: IL
+
+    Attributes:
+        serial_number: Serial number of the device.
+        system_function: System function code.
+        data: Raw data payload.
+        datapoint_type: Type of datapoint.
+        data_value: Parsed data value.
+        parse_datapoint_value: Parsed value based on datapoint type.
     """
 
     serial_number: str = ""
@@ -39,13 +47,18 @@ class ReplyTelegram(Telegram):
     data_value: str = ""
 
     def __post_init__(self) -> None:
+        """Initialize timestamp and telegram type."""
         if self.timestamp is None:
             self.timestamp = datetime.now()
         self.telegram_type = TelegramType.REPLY
 
     @property
     def parse_datapoint_value(self) -> dict[str, Any]:
-        """Parse the data value based on data point type"""
+        """Parse the data value based on data point type.
+
+        Returns:
+            Dictionary containing parsed value and metadata.
+        """
         if self.datapoint_type == DataPointType.TEMPERATURE:
             return self._parse_temperature_value()
         elif self.datapoint_type == DataPointType.SW_TOP_VERSION:
@@ -61,7 +74,11 @@ class ReplyTelegram(Telegram):
         return {"raw_value": self.data_value, "parsed": False}
 
     def _parse_temperature_value(self) -> dict:
-        """Parse temperature value like '+26,0§C'"""
+        """Parse temperature value like '+26,0§C'.
+
+        Returns:
+            Dictionary containing parsed temperature value and metadata.
+        """
         try:
             # Remove unit indicator (§C)
             value_part = self.data_value.replace("§C", "")
@@ -84,7 +101,11 @@ class ReplyTelegram(Telegram):
             }
 
     def _parse_humidity_value(self) -> dict:
-        """Parse humidity value like '+65,5§H'"""
+        """Parse humidity value like '+65,5§H'.
+
+        Returns:
+            Dictionary containing parsed humidity value and metadata.
+        """
         try:
             # Remove unit indicator (§H)
             value_part = self.data_value.replace("§RH", "")
@@ -107,7 +128,11 @@ class ReplyTelegram(Telegram):
             }
 
     def _parse_voltage_value(self) -> dict:
-        """Parse voltage value like '+12,5§V'"""
+        """Parse voltage value like '+12,5§V'.
+
+        Returns:
+            Dictionary containing parsed voltage value and metadata.
+        """
         try:
             # Remove unit indicator (§V)
             value_part = self.data_value.replace("§V", "")
@@ -130,7 +155,11 @@ class ReplyTelegram(Telegram):
             }
 
     def _parse_current_value(self) -> dict:
-        """Parse current value like '+0,25§A'"""
+        """Parse current value like '+0,25§A'.
+
+        Returns:
+            Dictionary containing parsed current value and metadata.
+        """
         try:
             # Remove unit indicator (§A)
             value_part = self.data_value.replace("§A", "")
@@ -153,7 +182,11 @@ class ReplyTelegram(Telegram):
             }
 
     def _parse_module_type_value(self) -> dict:
-        """Parse status value"""
+        """Parse status value.
+
+        Returns:
+            Dictionary containing parsed module type value.
+        """
         # Status values are typically alphanumeric codes
         return {
             "module_type": self.data_value,
@@ -162,7 +195,11 @@ class ReplyTelegram(Telegram):
         }
 
     def _parse_sw_version_value(self) -> dict:
-        """Parse version value like 'XP230_V1.00.04'"""
+        """Parse version value like 'XP230_V1.00.04'.
+
+        Returns:
+            Dictionary containing parsed version information.
+        """
         try:
             # Version format: {PRODUCT}_{VERSION}
             # Examples: XP230_V1.00.04, XP20_V0.01.05, XP33LR_V0.04.02, XP24_V0.34.03
@@ -198,7 +235,11 @@ class ReplyTelegram(Telegram):
             }
 
     def to_dict(self) -> dict[str, Any]:
-        """Convert to dictionary for JSON serialization"""
+        """Convert to dictionary for JSON serialization.
+
+        Returns:
+            Dictionary representation of the reply telegram.
+        """
         parsed_data = self.parse_datapoint_value
 
         return {
@@ -234,7 +275,11 @@ class ReplyTelegram(Telegram):
         }
 
     def __str__(self) -> str:
-        """Human-readable string representation"""
+        """Human-readable string representation.
+
+        Returns:
+            Formatted string representation.
+        """
         parsed = self.parse_datapoint_value
         if parsed.get("parsed", False) and "formatted" in parsed:
             value_display = parsed["formatted"]

xp/models/telegram/system_function.py

@@ -1,9 +1,30 @@
+"""System function enumeration for system telegrams."""
+
 from enum import Enum
 from typing import Optional
 
 
 class SystemFunction(str, Enum):
-    """System function codes for system telegrams"""
+    """System function codes for system telegrams.
+
+    Attributes:
+        NONE: Undefined function.
+        DISCOVERY: Discover function.
+        READ_DATAPOINT: Read datapoint.
+        READ_CONFIG: Read configuration.
+        WRITE_CONFIG: Write configuration.
+        BLINK: Blink LED function.
+        UNBLINK: Unblink LED function.
+        DOWNLOAD_MSACTIONTABLE: Download module specific action table.
+        DOWNLOAD_ACTIONTABLE: Download ActionTable.
+        EOF: End of msactiontable response.
+        MSACTIONTABLE: Module specific action table response.
+        ACTIONTABLE: Module specific action table response.
+        ACK: Acknowledge response.
+        NAK: Not acknowledge response.
+        UNKNOWN_26: Used after discover, unknown purpose.
+        ACTION: Action function.
+    """
 
     NONE = "00"  # Undefined
     DISCOVERY = "01"  # Discover function
@@ -25,7 +46,11 @@ class SystemFunction(str, Enum):
     ACTION = "27"  # Action function
 
     def get_description(self) -> str:
-        """Get the description of the SystemFunction"""
+        """Get the description of the SystemFunction.
+
+        Returns:
+            Human-readable description of the function.
+        """
         return (
             {
                 self.DISCOVERY: "Discover function",
@@ -47,7 +72,14 @@ class SystemFunction(str, Enum):
 
     @classmethod
     def from_code(cls, code: str) -> Optional["SystemFunction"]:
-        """Get SystemFunction from code string"""
+        """Get SystemFunction from code string.
+
+        Args:
+            code: Function code string.
+
+        Returns:
+            SystemFunction instance if found, None otherwise.
+        """
         for func in cls:
             if func.value.lower() == code.lower():
                 return func

xp/models/telegram/system_telegram.py

@@ -16,11 +16,16 @@ from xp.models.telegram.telegram_type import TelegramType
 
 @dataclass
 class SystemTelegram(Telegram):
-    """
-    Represents a parsed system telegram from the console bus.
+    """Represents a parsed system telegram from the console bus.
 
     Format: <S{serial_number}F{function_code}D{datapoint_type}{checksum}>
     Examples: <S0020012521F02D18FN>
+
+    Attributes:
+        serial_number: Serial number of the device.
+        system_function: System function code.
+        data: Data payload.
+        datapoint_type: Type of datapoint.
     """
 
     serial_number: str = ""
@@ -29,12 +34,17 @@ class SystemTelegram(Telegram):
     datapoint_type: Optional[DataPointType] = None
 
     def __post_init__(self) -> None:
+        """Initialize timestamp and telegram type."""
         if self.timestamp is None:
             self.timestamp = datetime.now()
         self.telegram_type = TelegramType.SYSTEM
 
     def to_dict(self) -> dict[str, Any]:
-        """Convert to dictionary for JSON serialization"""
+        """Convert to dictionary for JSON serialization.
+
+        Returns:
+            Dictionary representation of the system telegram.
+        """
         return {
             "serial_number": self.serial_number,
             "system_function": (
@@ -67,7 +77,11 @@ class SystemTelegram(Telegram):
         }
 
     def __str__(self) -> str:
-        """Human-readable string representation"""
+        """Human-readable string representation.
+
+        Returns:
+            Formatted string representation.
+        """
         system_func_name = (
             self.system_function.name if self.system_function else "Unknown"
         )

xp/models/telegram/telegram.py

@@ -1,3 +1,5 @@
+"""Base telegram model for console bus communication."""
+
 from dataclasses import dataclass
 from datetime import datetime
 from typing import Optional
@@ -7,9 +9,16 @@ from xp.models.telegram.telegram_type import TelegramType
 
 @dataclass
 class Telegram:
-    """
-    Represents an abstract telegram from the console bus.
-    Can be an EventTelegram, SystemTelegram or ReplyTelegram
+    """Represents an abstract telegram from the console bus.
+
+    Can be an EventTelegram, SystemTelegram or ReplyTelegram.
+
+    Attributes:
+        checksum: Telegram checksum value.
+        raw_telegram: Raw telegram string.
+        checksum_validated: Whether checksum validation passed.
+        timestamp: Timestamp when telegram was received.
+        telegram_type: Type of telegram (EVENT, SYSTEM, or REPLY).
     """
 
     checksum: str

xp/models/telegram/telegram_type.py

@@ -4,7 +4,14 @@ from enum import Enum
 
 
 class TelegramType(str, Enum):
-    """Enumeration of telegram types in the console bus system."""
+    """Enumeration of telegram types in the console bus system.
+
+    Attributes:
+        EVENT: Event telegram (E).
+        REPLY: Reply telegram (R).
+        SYSTEM: System telegram (S).
+        CPEVENT: CP event telegram (O).
+    """
 
     EVENT = "E"
     REPLY = "R"

xp/models/telegram/timeparam_type.py

@@ -1,7 +1,34 @@
+"""Time parameter enumeration for telegram actions."""
+
 from enum import IntEnum
 
 
 class TimeParam(IntEnum):
+    """Time parameter values for action timing.
+
+    Attributes:
+        NONE: No time parameter.
+        T05SEC: 0.5 second delay.
+        T1SEC: 1 second delay.
+        T2SEC: 2 second delay.
+        T5SEC: 5 second delay.
+        T10SEC: 10 second delay.
+        T15SEC: 15 second delay.
+        T20SEC: 20 second delay.
+        T30SEC: 30 second delay.
+        T45SEC: 45 second delay.
+        T1MIN: 1 minute delay.
+        T2MIN: 2 minute delay.
+        T5MIN: 5 minute delay.
+        T10MIN: 10 minute delay.
+        T15MIN: 15 minute delay.
+        T20MIN: 20 minute delay.
+        T30MIN: 30 minute delay.
+        T45MIN: 45 minute delay.
+        T60MIN: 60 minute delay.
+        T120MIN: 120 minute delay.
+    """
+
     NONE = 0
     T05SEC = 1
     T1SEC = 2

xp/models/write_config_type.py

@@ -1,9 +1,17 @@
+"""Write config type enumeration."""
+
 from enum import Enum
 from typing import Optional
 
 
 class WriteConfigType(str, Enum):
-    """Write Config types for system telegrams"""
+    """Write Config types for system telegrams.
+
+    Attributes:
+        LINK_NUMBER: Link number configuration (code 04).
+        MODULE_NUMBER: Module number configuration (code 05).
+        SYSTEM_TYPE: System type configuration (code 06).
+    """
 
     LINK_NUMBER = "04"
     MODULE_NUMBER = "05"
@@ -11,7 +19,14 @@ class WriteConfigType(str, Enum):
 
     @classmethod
     def from_code(cls, code: str) -> Optional["WriteConfigType"]:
-        """Get DataPointType from code string"""
+        """Get WriteConfigType from code string.
+
+        Args:
+            code: Configuration type code string.
+
+        Returns:
+            WriteConfigType instance if found, None otherwise.
+        """
         for dp_type in cls:
             if dp_type.value == code:
                 return dp_type

xp/services/__init__.py

@@ -1,4 +1,4 @@
-"""Service layer for XP CLI tool"""
+"""Service layer for XP CLI tool."""
 
 from xp.services.log_file_service import LogFileParsingError, LogFileService
 from xp.services.module_type_service import ModuleTypeNotFoundError, ModuleTypeService

xp/services/conbus/__init__.py

@@ -0,0 +1 @@
+"""Conbus service layer."""