conson-xp 1.18.0__py3-none-any.whl

xp/models/log_entry.py

@@ -0,0 +1,130 @@
+"""Log entry model for console bus communication logs."""
+
+from dataclasses import dataclass
+from datetime import datetime
+from typing import Any, Optional, Union
+
+from xp.models.telegram.event_telegram import EventTelegram
+from xp.models.telegram.reply_telegram import ReplyTelegram
+from xp.models.telegram.system_telegram import SystemTelegram
+
+
+@dataclass
+class LogEntry:
+    """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
+    direction: str  # "TX" or "RX"
+    raw_telegram: str
+    parsed_telegram: Optional[Union[EventTelegram, SystemTelegram, ReplyTelegram]] = (
+        None
+    )
+    parse_error: Optional[str] = None
+    line_number: int = 0
+
+    @property
+    def is_transmitted(self) -> bool:
+        """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.
+
+        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).
+
+        Returns:
+            Telegram type string.
+        """
+        if self.parsed_telegram is None:
+            return "unknown"
+
+        return self.parsed_telegram.telegram_type.value.lower()
+
+    @property
+    def is_valid_parse(self) -> bool:
+        """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.
+
+        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.
+
+        Returns:
+            Dictionary representation of the log entry.
+        """
+        result: dict[str, Any] = {
+            "line_number": self.line_number,
+            "timestamp": self.timestamp.strftime("%H:%M:%S.%f")[
+                :-3
+            ],  # HH:MM:SS,mmm format
+            "direction": self.direction,
+            "raw_telegram": self.raw_telegram,
+            "telegram_type": self.telegram_type,
+            "is_valid_parse": self.is_valid_parse,
+            "parse_error": self.parse_error,
+        }
+
+        # Add parsed telegram data if available
+        if self.parsed_telegram:
+            result["parsed"] = self.parsed_telegram.to_dict()
+            result["checksum_validated"] = self.checksum_validated
+
+        return result
+
+    def __str__(self) -> str:
+        """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 = ""
+
+        if self.checksum_validated is not None:
+            checksum_status = f" ({('✓' if self.checksum_validated else '✗')})"
+
+        return f"[{self.line_number:3d}] {timestamp_str} [{self.direction}] {self.raw_telegram} {status}{checksum_status}"

xp/models/protocol/__init__.py

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

xp/models/protocol/conbus_protocol.py

@@ -0,0 +1,312 @@
+"""Conbus protocol event models."""
+
+from __future__ import annotations
+
+from typing import TYPE_CHECKING, Union
+
+from bubus import BaseEvent
+from pydantic import Field
+
+from xp.models.homekit.homekit_config import HomekitAccessoryConfig
+from xp.models.homekit.homekit_conson_config import ConsonModuleConfig
+from xp.models.telegram.datapoint_type import DataPointType
+
+if TYPE_CHECKING:
+    from xp.services.protocol.conbus_event_protocol import ConbusEventProtocol
+    from xp.services.protocol.conbus_protocol import ConbusProtocol
+    from xp.services.protocol.telegram_protocol import TelegramProtocol
+
+
+class ConnectionMadeEvent(BaseEvent):
+    """Event dispatched when TCP connection is established.
+
+    Attributes:
+        protocol: Reference to the TelegramProtocol instance.
+    """
+
+    protocol: TelegramProtocol = Field(
+        description="Reference to the TelegramProtocol instance"
+    )
+
+
+class ConnectionFailedEvent(BaseEvent):
+    """Event dispatched when TCP connection fails.
+
+    Attributes:
+        reason: Failure reason.
+    """
+
+    reason: str = Field(description="Failure reason")
+
+
+class SendWriteConfigEvent(BaseEvent):
+    """Event for sending write config commands.
+
+    Attributes:
+        serial_number: Serial number.
+        output_number: Output number.
+        datapoint_type: Datapoint type.
+        value: Set brightness value.
+    """
+
+    serial_number: str = Field(description="Serial number")
+    output_number: int = Field(description="Output number")
+    datapoint_type: DataPointType = Field(description="Datapoint type")
+    value: int = Field(description="Set brightness value")
+
+
+class SendActionEvent(BaseEvent):
+    """Event for sending action commands.
+
+    Attributes:
+        serial_number: Serial number of the light bulb set.
+        output_number: Output number of the light bulb set.
+        value: Set light bulb On or Off (True/False).
+        on_action: On action E00L00I00.
+        off_action: On action E00L00I04.
+    """
+
+    serial_number: str = Field(description="Serial number of the light bulb set")
+    output_number: int = Field(description="Output number of the light bulb set")
+    value: bool = Field(description="Set light bulb On or Off (True/False)")
+    on_action: str = Field(description="on action")
+    off_action: str = Field(description="off action")
+
+
+class DatapointEvent(BaseEvent):
+    """Base event for datapoint operations.
+
+    Attributes:
+        serial_number: Serial number of the light bulb set.
+        datapoint_type: Datapoint type.
+    """
+
+    serial_number: str = Field(description="Serial number of the light bulb set")
+    datapoint_type: DataPointType = Field(description="Datapoint type")
+
+
+class OutputStateReceivedEvent(DatapointEvent):
+    """Event when output state is received.
+
+    Attributes:
+        data_value: Data value.
+    """
+
+    data_value: str = Field(description="Data value")
+
+
+class LightLevelReceivedEvent(DatapointEvent):
+    """Event when light level is received.
+
+    Attributes:
+        data_value: Data value.
+    """
+
+    data_value: str = Field(description="Data value")
+
+
+class ReadDatapointEvent(DatapointEvent):
+    """Event to read datapoint.
+
+    Attributes:
+        refresh_cache: If True, force cache invalidation and fresh protocol query.
+    """
+
+    refresh_cache: bool = Field(
+        default=False,
+        description="If True, force cache invalidation and fresh protocol query",
+    )
+
+
+class ReadDatapointFromProtocolEvent(DatapointEvent):
+    """Internal event for cache service to forward to protocol when cache misses."""
+
+    pass
+
+
+class ModuleEvent(BaseEvent):
+    """Event dispatched when light bulb set is on.
+
+    Attributes:
+        serial_number: Serial number of the light bulb set.
+        output_number: Output number of the light bulb set.
+        module: ConsonModuleConfig of the light bulb set.
+        accessory: HomekitAccessoryConfig of the light bulb set.
+    """
+
+    serial_number: str = Field(description="Serial number of the light bulb set")
+    output_number: int = Field(description="Output number of the light bulb set")
+    module: ConsonModuleConfig = Field(
+        description="ConsonModuleConfig of the light bulb set"
+    )
+    accessory: HomekitAccessoryConfig = Field(
+        description="HomekitAccessoryConfig of the light bulb set"
+    )
+
+
+class LightBulbSetOnEvent(ModuleEvent):
+    """Event dispatched when light bulb set is on.
+
+    Attributes:
+        value: On or Off the light bulb set.
+    """
+
+    value: bool = Field(description="On or Off the light bulb set")
+
+
+class LightBulbGetOnEvent(ModuleEvent, BaseEvent[bool]):
+    """Event dispatched when getting light bulb on state."""
+
+    pass
+
+
+class OutletSetOnEvent(ModuleEvent):
+    """Event dispatched when outlet set is on.
+
+    Attributes:
+        value: On or Off the light bulb set.
+    """
+
+    value: bool = Field(description="On or Off the light bulb set")
+
+
+class OutletGetOnEvent(ModuleEvent):
+    """Event dispatched when getting outlet on state."""
+
+    pass
+
+
+class OutletGetInUseEvent(ModuleEvent):
+    """Event dispatched when getting outlet in-use state."""
+
+    pass
+
+
+class OutletSetInUseEvent(ModuleEvent, BaseEvent[bool]):
+    """Event dispatched when outlet set is on.
+
+    Attributes:
+        value: On or Off the light bulb set.
+    """
+
+    value: bool = Field(description="On or Off the light bulb set")
+
+
+class DimmingLightSetOnEvent(ModuleEvent):
+    """Event dispatched when dimming light set is on.
+
+    Attributes:
+        value: On or Off the light bulb set.
+        brightness: Brightness of the light bulb set.
+    """
+
+    value: bool = Field(description="On or Off the light bulb set")
+    brightness: int = Field(description="Brightness of the light bulb set")
+
+
+class DimmingLightGetOnEvent(ModuleEvent):
+    """Event dispatched when getting dimming light on state."""
+
+    pass
+
+
+class DimmingLightSetBrightnessEvent(ModuleEvent):
+    """Event dispatched when dimming light set is on.
+
+    Attributes:
+        brightness: Level of brightness of the dimming light.
+    """
+
+    brightness: int = Field(description="Level of brightness of the dimming light")
+
+
+class DimmingLightGetBrightnessEvent(ModuleEvent):
+    """Event dispatched when getting dimming light brightness."""
+
+    pass
+
+
+class ConnectionLostEvent(BaseEvent):
+    """Event dispatched when TCP connection is lost.
+
+    Attributes:
+        reason: Disconnection reason.
+    """
+
+    reason: str = Field(description="Disconnection reason")
+
+
+class TelegramEvent(BaseEvent):
+    """Event for telegram operations.
+
+    Attributes:
+        protocol: TelegramProtocol instance.
+        frame: Frame <S0123450001F02D12FK>.
+        telegram: Telegram S0123450001F02D12FK.
+        payload: Payload S0123450001F02D12.
+        telegram_type: Telegram type S.
+        serial_number: Serial number 0123450001 or empty.
+        checksum: Checksum FK.
+        checksum_valid: Checksum valid true or false.
+    """
+
+    protocol: Union[TelegramProtocol, ConbusProtocol, ConbusEventProtocol] = Field(
+        description="TelegramProtocol instance"
+    )
+    frame: str = Field(description="Frame <S0123450001F02D12FK>")
+    telegram: str = Field(description="Telegram: S0123450001F02D12FK")
+    payload: str = Field(description="Payload: S0123450001F02D12")
+    telegram_type: str = Field(description="Telegram type: S")
+    serial_number: str = Field(description="Serial number: 0123450001 or empty")
+    checksum: str = Field(description="Checksum: FK")
+    checksum_valid: bool = Field(
+        default=True, description="Checksum valid: true, or false"
+    )
+
+
+class ModuleStateChangedEvent(BaseEvent):
+    """Event dispatched when a module's state changes (from event telegram).
+
+    Attributes:
+        module_type_code: Module type code from event telegram.
+        link_number: Link number from event telegram.
+        input_number: Input number that triggered the event.
+        telegram_event_type: Event type (M=press, B=release).
+    """
+
+    module_type_code: int = Field(description="Module type code from event telegram")
+    link_number: int = Field(description="Link number from event telegram")
+    input_number: int = Field(description="Input number that triggered the event")
+    telegram_event_type: str = Field(description="Event type (M=press, B=release)")
+
+
+class EventTelegramReceivedEvent(TelegramEvent):
+    """Event telegram received."""
+
+    pass
+
+
+class ModuleDiscoveredEvent(TelegramEvent):
+    """Event dispatched when module is discovered."""
+
+    pass
+
+
+class TelegramReceivedEvent(TelegramEvent):
+    """Event dispatched when a telegram frame is received."""
+
+    pass
+
+
+class InvalidTelegramReceivedEvent(BaseEvent):
+    """Event dispatched when an invalid telegram frame is received.
+
+    Attributes:
+        protocol: TelegramProtocol instance.
+        frame: Frame <S0123450001F02D12FK>.
+        error: Error with the received telegram.
+    """
+
+    protocol: TelegramProtocol = Field(description="TelegramProtocol instance")
+    frame: str = Field(description="Frame <S0123450001F02D12FK>")
+    error: str = Field(description="Error with the received telegram")

xp/models/response.py

@@ -0,0 +1,42 @@
+"""Response model for structured service responses.
+
+This module provides the Response class used throughout the application
+for consistent service response formatting.
+"""
+
+from datetime import datetime
+from typing import Any, Optional
+
+
+class Response:
+    """Standard response model for service operations.
+
+    Provides consistent structure for all service responses including
+    success status, data payload, error messages, and timestamp.
+    """
+
+    def __init__(self, success: bool, data: Any, error: Optional[str] = None):
+        """Initialize response.
+
+        Args:
+            success: Whether the operation was successful
+            data: Response data payload
+            error: Error message if operation failed
+        """
+        self.success = success
+        self.data = data
+        self.error = error
+        self.timestamp = datetime.now()
+
+    def to_dict(self) -> dict:
+        """Convert response to dictionary for JSON serialization.
+
+        Returns:
+            Dictionary representation of the response
+        """
+        return {
+            "success": self.success,
+            "data": self.data,
+            "error": self.error,
+            "timestamp": self.timestamp.isoformat(),
+        }

xp/models/telegram/__init__.py

@@ -0,0 +1 @@
+"""Telegram models for console bus communication."""

xp/models/telegram/action_type.py

@@ -0,0 +1,31 @@
+"""Action type enumeration for XP24 telegrams."""
+
+from enum import Enum
+from typing import Optional
+
+
+class ActionType(Enum):
+    """Action types for XP24 telegrams.
+
+    Attributes:
+        OFF_PRESS: Make action (activate relay).
+        ON_RELEASE: Break action (deactivate relay).
+    """
+
+    OFF_PRESS = "AA"  # Make action (activate relay)
+    ON_RELEASE = "AB"  # Break action (deactivate relay)
+
+    @classmethod
+    def from_code(cls, code: str) -> Optional["ActionType"]:
+        """Get ActionType from code string.
+
+        Args:
+            code: Action code string.
+
+        Returns:
+            ActionType instance if found, None otherwise.
+        """
+        for action in cls:
+            if action.value == code:
+                return action
+        return None

xp/models/telegram/datapoint_type.py

@@ -0,0 +1,82 @@
+"""Datapoint type enumeration for system telegrams."""
+
+from enum import Enum
+from typing import Optional
+
+
+class DataPointType(str, Enum):
+    """Data point types for system telegrams.
+
+    Attributes:
+        MODULE_TYPE: Module type (XP24, XP33, etc).
+        HW_VERSION: Hardware version information.
+        SW_VERSION: Software version information.
+        SERIAL_NUMBER: Serial number.
+        LINK_NUMBER: Link number.
+        MODULE_NUMBER: Module number.
+        SYSTEM_TYPE: System type.
+        MODULE_TYPE_CODE: Module type code.
+        MODULE_TYPE_ID: Module type ID.
+        MODULE_STATE: Module state.
+        MODULE_ERROR_CODE: Status query data point.
+        MODULE_INPUT_STATE: Module input state.
+        MODULE_OUTPUT_STATE: Channel states (XP33).
+        MODULE_FW_CRC: Module firmware CRC.
+        MODULE_ACTION_TABLE_CRC: Module action table CRC.
+        MODULE_LIGHT_LEVEL: Module light level.
+        MODULE_OPERATING_HOURS: Module operating hours.
+        MODULE_ENERGY_LEVEL: Current data point.
+        TEMPERATURE: Temperature data point.
+        SW_TOP_VERSION: Software top version.
+        VOLTAGE: Voltage data point.
+        AUTO_REPORT_STATUS: Auto report status.
+    """
+
+    MODULE_TYPE = "00"  # Module type (XP24, XP33, ..)
+    HW_VERSION = "01"  # Hardware version information
+    SW_VERSION = "02"  # Software version information
+    SERIAL_NUMBER = "03"  # Serial number
+    LINK_NUMBER = "04"  # Link number
+    MODULE_NUMBER = "05"  # Module number
+    SYSTEM_TYPE = "06"  # System type
+    MODULE_TYPE_CODE = "07"  # Module type code
+    MODULE_TYPE_ID = "08"  # Module type id
+    MODULE_STATE = "09"  # Module state
+    MODULE_ERROR_CODE = "10"  # Status query data point
+    MODULE_INPUT_STATE = "11"  # Module input state
+    MODULE_OUTPUT_STATE = "12"  # Channel states (XP33)
+    MODULE_FW_CRC = "13"  # Module Firmware CRC
+    MODULE_ACTION_TABLE_CRC = "14"  # Module Action Table CRC
+
+    # XP24 00:000[%],01:000[%],02:000[%],03:000[%]
+    # XP33 00:000[%],01:000[%],02:000[%]
+    MODULE_LIGHT_LEVEL = "15"  # Module Light Level
+
+    # XP24 00:000[H],01:000[H],02:000[H],03:000[H]
+    MODULE_OPERATING_HOURS = "16"  # Module Operating Hours
+
+    # XP24 00:00000[NA],01:00000[NA],02:00000[NA],03:00000[NA]
+    MODULE_ENERGY_LEVEL = "17"  # Current data point
+
+    # XP24 +34,0C
+    # XP33 -20,0C
+    TEMPERATURE = "18"  # Temperature data point
+
+    SW_TOP_VERSION = "19"  # Software Top Version
+    VOLTAGE = "20"  # VOLTAGE data point
+    AUTO_REPORT_STATUS = "21"  # Auto Report Status
+
+    @classmethod
+    def from_code(cls, code: str) -> Optional["DataPointType"]:
+        """Get DataPointType from code string.
+
+        Args:
+            code: Datapoint type code string.
+
+        Returns:
+            DataPointType instance if found, None otherwise.
+        """
+        for dp_type in cls:
+            if dp_type.value == code:
+                return dp_type
+        return None