conson-xp 1.52.0__py3-none-any.whl → 2.0.0__py3-none-any.whl

xp/cli/commands/homekit/homekit_start_commands.py

@@ -1,44 +0,0 @@
-"""API server start command."""
-
-import sys
-
-import click
-from click import Context
-
-from xp.cli.commands.homekit.homekit import homekit
-from xp.services.homekit.homekit_service import HomeKitService
-
-
-@homekit.command("start")
-@click.pass_context
-def homekit_start(ctx: Context) -> None:
-    r"""
-    Start the HomeKit server.
-
-    This command starts the XP Protocol HomeKit server using HAP-python.
-    The server provides HomeKit endpoints for Conbus operations.
-
-    Args:
-        ctx: Click context object.
-
-    Examples:
-        \b
-        # Start server on default host and port
-        xp homekit start
-    """
-    click.echo("Starting XP Protocol HomeKit server...")
-
-    try:
-        service: HomeKitService = (
-            ctx.obj.get("container").get_container().resolve(HomeKitService)
-        )
-        service.start()  # Blocking call - reactor.run() never returns
-
-    except KeyboardInterrupt:
-        click.echo("\nShutting down server...")
-    except Exception as e:
-        click.echo(
-            click.style(f"Error starting server: {e}", fg="red"),
-            err=True,
-        )
-        sys.exit(1)

xp/services/homekit/__init__.py

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

xp/services/homekit/homekit_cache_service.py

@@ -1,313 +0,0 @@
-"""Bubus cache service for caching datapoint responses."""
-
-import json
-import logging
-from datetime import datetime
-from pathlib import Path
-from typing import Any, TypedDict, Union
-
-from bubus import EventBus
-
-from xp.models.protocol.conbus_protocol import (
-    LightLevelReceivedEvent,
-    OutputStateReceivedEvent,
-    ReadDatapointEvent,
-    ReadDatapointFromProtocolEvent,
-)
-from xp.models.telegram.datapoint_type import DataPointType
-
-# Cache file configuration
-CACHE_DIR = Path(".cache")
-CACHE_FILE = CACHE_DIR / "homekit_cache.json"
-
-
-class CacheEntry(TypedDict):
-    """
-    Cache entry type definition.
-
-    Attributes:
-        event: The cached event (OutputStateReceivedEvent or LightLevelReceivedEvent).
-        timestamp: When the event was cached.
-    """
-
-    event: Union[OutputStateReceivedEvent, LightLevelReceivedEvent]
-    timestamp: datetime
-
-
-class HomeKitCacheService:
-    """
-    Cache service that intercepts bubus protocol messages to reduce redundant queries.
-
-    Caches OutputStateReceivedEvent and LightLevelReceivedEvent responses.
-    When a ReadDatapointEvent is received, checks cache and either:
-    - Returns cached response if available (cache hit)
-    - Forwards to protocol via ReadDatapointFromProtocolEvent (cache miss)
-    """
-
-    def __init__(self, event_bus: EventBus, enable_persistence: bool = True):
-        """
-        Initialize the HomeKit cache service.
-
-        Args:
-            event_bus: Event bus for inter-service communication.
-            enable_persistence: Whether to persist cache to disk.
-        """
-        self.logger = logging.getLogger(__name__)
-        self.event_bus = event_bus
-        self.cache: dict[tuple[str, DataPointType], CacheEntry] = {}
-        self.enable_persistence = enable_persistence
-
-        # Load cache from disk
-        if self.enable_persistence:
-            self._load_cache()
-
-        # Register event handlers
-        # Note: These must be registered BEFORE HomeKitConbusService registers its handlers
-        self.event_bus.on(ReadDatapointEvent, self.handle_read_datapoint_event)
-        self.event_bus.on(
-            OutputStateReceivedEvent, self.handle_output_state_received_event
-        )
-        self.event_bus.on(
-            LightLevelReceivedEvent, self.handle_light_level_received_event
-        )
-
-        self.logger.info(
-            f"HomeKitCacheService initialized with {len(self.cache)} cached entries"
-        )
-
-    def _serialize_cache_key(self, key: tuple[str, DataPointType]) -> str:
-        """Serialize cache key to JSON-compatible string."""
-        serial_number, datapoint_type = key
-        return f"{serial_number}.{datapoint_type.value}"
-
-    def _deserialize_cache_key(self, key_str: str) -> tuple[str, DataPointType]:
-        """Deserialize cache key from JSON string."""
-        serial_number, datapoint_type_str = key_str.rsplit(".", 1)
-        return (serial_number, DataPointType(datapoint_type_str))
-
-    def _serialize_cache(self) -> dict[str, Any]:
-        """Serialize cache to JSON-compatible dict."""
-        serialized = {}
-        for key, entry in self.cache.items():
-            key_str = self._serialize_cache_key(key)
-            serialized[key_str] = {
-                "event": entry["event"].model_dump(mode="json"),
-                "timestamp": entry["timestamp"].isoformat(),
-            }
-        return serialized
-
-    def _deserialize_cache(
-        self, data: dict[str, Any]
-    ) -> dict[tuple[str, DataPointType], CacheEntry]:
-        """Deserialize cache from JSON dict."""
-        cache: dict[tuple[str, DataPointType], CacheEntry] = {}
-        for key_str, entry_data in data.items():
-            try:
-                key = self._deserialize_cache_key(key_str)
-                event_data = entry_data["event"]
-
-                # Reconstruct event based on datapoint_type
-                if key[1] == DataPointType.MODULE_OUTPUT_STATE:
-                    event = OutputStateReceivedEvent(**event_data)
-                elif key[1] == DataPointType.MODULE_LIGHT_LEVEL:
-                    event = LightLevelReceivedEvent(**event_data)
-                else:
-                    self.logger.warning(f"Unknown datapoint type in cache: {key[1]}")
-                    continue
-
-                cache[key] = {
-                    "event": event,
-                    "timestamp": datetime.fromisoformat(entry_data["timestamp"]),
-                }
-            except Exception as e:
-                self.logger.warning(f"Failed to deserialize cache entry {key_str}: {e}")
-                continue
-
-        return cache
-
-    def _load_cache(self) -> None:
-        """Load cache from disk."""
-        if not CACHE_FILE.exists():
-            self.logger.debug("No cache file found, starting with empty cache")
-            return
-
-        try:
-            with CACHE_FILE.open("r") as f:
-                data = json.load(f)
-
-            self.cache = self._deserialize_cache(data)
-            self.logger.info(f"Loaded {len(self.cache)} entries from cache file")
-        except Exception as e:
-            self.logger.error(f"Failed to load cache from disk: {e}")
-            self.cache = {}
-
-    def _save_cache(self) -> None:
-        """Save cache to disk atomically."""
-        if not self.enable_persistence:
-            return
-
-        try:
-            # Ensure cache directory exists
-            CACHE_DIR.mkdir(parents=True, exist_ok=True)
-
-            # Atomic write: write to temp file, then rename
-            temp_file = CACHE_FILE.with_suffix(".tmp")
-            with temp_file.open("w") as f:
-                json.dump(self._serialize_cache(), f, indent=2)
-
-            # Atomic rename
-            temp_file.replace(CACHE_FILE)
-
-            self.logger.debug(f"Saved {len(self.cache)} entries to cache file")
-        except Exception as e:
-            self.logger.error(f"Failed to save cache to disk: {e}")
-
-    def _get_cache_key(
-        self, serial_number: str, datapoint_type: DataPointType
-    ) -> tuple[str, DataPointType]:
-        """Generate cache key from serial number and datapoint type."""
-        return (serial_number, datapoint_type)
-
-    def _cache_event(
-        self, event: Union[OutputStateReceivedEvent, LightLevelReceivedEvent]
-    ) -> None:
-        """Store an event in the cache."""
-        cache_key = self._get_cache_key(event.serial_number, event.datapoint_type)
-        cache_entry: CacheEntry = {
-            "event": event,
-            "timestamp": datetime.now(),
-        }
-        self.cache[cache_key] = cache_entry
-        self.logger.debug(
-            f"Cached event: "
-            f"serial={event.serial_number}, "
-            f"type={event.datapoint_type}, "
-            f"value={event.data_value}"
-        )
-
-        # Persist to disk
-        self._save_cache()
-
-    def _get_cached_event(
-        self, serial_number: str, datapoint_type: DataPointType
-    ) -> Union[OutputStateReceivedEvent, LightLevelReceivedEvent, None]:
-        """Retrieve an event from the cache if it exists."""
-        cache_key = self._get_cache_key(serial_number, datapoint_type)
-        cache_entry = self.cache.get(cache_key)
-
-        if cache_entry:
-            self.logger.debug(
-                f"Cache hit: " f"serial={serial_number}, " f"type={datapoint_type}"
-            )
-            return cache_entry["event"]
-
-        self.logger.debug(f"Cache miss: serial={serial_number}, type={datapoint_type}")
-        return None
-
-    def handle_read_datapoint_event(self, event: ReadDatapointEvent) -> None:
-        """
-        Handle ReadDatapointEvent by checking cache or refresh flag.
-
-        On refresh_cache=True: invalidate cache and force protocol query
-        On cache hit: dispatch cached response event
-        On cache miss: forward to protocol via ReadDatapointFromProtocolEvent
-
-        Args:
-            event: Read datapoint event with serial number, datapoint type, and refresh flag.
-        """
-        self.logger.debug(
-            f"Handling ReadDatapointEvent: "
-            f"serial={event.serial_number}, "
-            f"type={event.datapoint_type}, "
-            f"refresh_cache={event.refresh_cache}"
-        )
-
-        # Check if cache refresh requested
-        if event.refresh_cache:
-            self.logger.info(
-                f"Cache refresh requested: "
-                f"serial={event.serial_number}, "
-                f"type={event.datapoint_type}"
-            )
-            # Invalidate cache entry
-            cache_key = self._get_cache_key(event.serial_number, event.datapoint_type)
-            if cache_key in self.cache:
-                del self.cache[cache_key]
-                self.logger.debug(f"Invalidated cache entry: {cache_key}")
-                # Persist invalidation
-                self._save_cache()
-
-        # Normal cache lookup flow
-        cached_event = self._get_cached_event(event.serial_number, event.datapoint_type)
-
-        if cached_event:
-            # Cache hit - dispatch the cached event
-            self.logger.debug(
-                f"Returning cached response: "
-                f"serial={event.serial_number}, "
-                f"type={event.datapoint_type}"
-            )
-            self.event_bus.dispatch(cached_event)
-            return
-
-        # Cache miss - forward to protocol
-        self.logger.debug(
-            f"Forwarding to protocol: "
-            f"serial={event.serial_number}, "
-            f"type={event.datapoint_type}"
-        )
-        self.event_bus.dispatch(
-            ReadDatapointFromProtocolEvent(
-                serial_number=event.serial_number,
-                datapoint_type=event.datapoint_type,
-            )
-        )
-
-    def handle_output_state_received_event(
-        self, event: OutputStateReceivedEvent
-    ) -> None:
-        """
-        Cache OutputStateReceivedEvent for future queries.
-
-        Args:
-            event: Output state received event to cache.
-        """
-        self.logger.debug(
-            f"Caching OutputStateReceivedEvent: "
-            f"serial={event.serial_number}, "
-            f"type={event.datapoint_type}, "
-            f"value={event.data_value}"
-        )
-        self._cache_event(event)
-
-    def handle_light_level_received_event(self, event: LightLevelReceivedEvent) -> None:
-        """
-        Cache LightLevelReceivedEvent for future queries.
-
-        Args:
-            event: Light level received event to cache.
-        """
-        self.logger.debug(
-            f"Caching LightLevelReceivedEvent: "
-            f"serial={event.serial_number}, "
-            f"type={event.datapoint_type}, "
-            f"value={event.data_value}"
-        )
-        self._cache_event(event)
-
-    def clear_cache(self) -> None:
-        """Clear all cached entries."""
-        self.logger.info("Clearing cache")
-        self.cache.clear()
-        self._save_cache()
-
-    def get_cache_stats(self) -> dict[str, int]:
-        """
-        Get cache statistics.
-
-        Returns:
-            Dictionary with cache statistics including total_entries.
-        """
-        return {
-            "total_entries": len(self.cache),
-        }

xp/services/homekit/homekit_conbus_service.py

@@ -1,99 +0,0 @@
-"""
-HomeKit Conbus Service for protocol communication.
-
-This module bridges HomeKit events with the Conbus protocol for device control.
-"""
-
-import logging
-
-from bubus import EventBus
-
-from xp.models.protocol.conbus_protocol import (
-    ReadDatapointFromProtocolEvent,
-    SendActionEvent,
-    SendWriteConfigEvent,
-)
-from xp.models.telegram.datapoint_type import DataPointType
-from xp.models.telegram.system_function import SystemFunction
-from xp.services.protocol.telegram_protocol import TelegramProtocol
-
-
-class HomeKitConbusService:
-    """
-    Service for bridging HomeKit events with Conbus protocol.
-
-    Attributes:
-        event_bus: Event bus for inter-service communication.
-        telegram_protocol: Protocol for sending telegrams.
-        logger: Logger instance.
-    """
-
-    event_bus: EventBus
-
-    def __init__(self, event_bus: EventBus, telegram_protocol: TelegramProtocol):
-        """
-        Initialize the HomeKit Conbus service.
-
-        Args:
-            event_bus: Event bus instance.
-            telegram_protocol: Telegram protocol instance.
-        """
-        self.logger = logging.getLogger(__name__)
-        self.event_bus = event_bus
-        self.telegram_protocol = telegram_protocol
-
-        # Register event handlers
-        self.event_bus.on(
-            ReadDatapointFromProtocolEvent, self.handle_read_datapoint_request
-        )
-        self.event_bus.on(SendActionEvent, self.handle_send_action_event)
-        self.event_bus.on(SendWriteConfigEvent, self.handle_send_write_config_event)
-
-    def handle_read_datapoint_request(
-        self, event: ReadDatapointFromProtocolEvent
-    ) -> None:
-        """
-        Handle request to read datapoint from protocol.
-
-        Args:
-            event: Read datapoint event with serial number and datapoint type.
-        """
-        self.logger.debug(f"read_datapoint_request {event}")
-
-        system_function = SystemFunction.READ_DATAPOINT.value
-        datapoint_value = event.datapoint_type.value
-        telegram = f"S{event.serial_number}F{system_function}D{datapoint_value}"
-        self.telegram_protocol.sendFrame(telegram.encode())
-
-    def handle_send_write_config_event(self, event: SendWriteConfigEvent) -> None:
-        """
-        Handle send write config event.
-
-        Args:
-            event: Write config event with configuration data.
-        """
-        self.logger.debug(f"send_write_config_event {event}")
-
-        # Format data as output_number:level (e.g., "02:050")
-        system_function = SystemFunction.WRITE_CONFIG.value
-        datapoint_type = DataPointType.MODULE_LIGHT_LEVEL.value
-        config_data = f"{event.output_number:02d}:{event.value:03d}"
-        telegram = (
-            f"S{event.serial_number}F{system_function}D{datapoint_type}{config_data}"
-        )
-        self.telegram_protocol.sendFrame(telegram.encode())
-
-    def handle_send_action_event(self, event: SendActionEvent) -> None:
-        """
-        Handle send action event.
-
-        Args:
-            event: Send action event with action data.
-        """
-        self.logger.debug(f"send_action_event {event}")
-
-        telegram = event.on_action if event.value else event.off_action
-        telegram_make = f"{telegram}M"
-        telegram_break = f"{telegram}B"
-        self.telegram_protocol.sendFrame(telegram_make.encode())
-        self.telegram_protocol.sendFrame(telegram_break.encode())