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

xp/term/homekit.py

@@ -0,0 +1,116 @@
+"""HomeKit TUI Application."""
+
+from pathlib import Path
+from typing import Any, Optional
+
+from textual.app import App, ComposeResult
+
+from xp.services.term.homekit_service import HomekitService
+from xp.term.widgets.room_list import RoomListWidget
+from xp.term.widgets.status_footer import StatusFooterWidget
+
+
+class HomekitApp(App[None]):
+    """
+    Textual app for HomeKit accessory monitoring.
+
+    Displays rooms and accessories with real-time state updates
+    and toggle control via action keys.
+
+    Attributes:
+        homekit_service: HomekitService for accessory state operations.
+        CSS_PATH: Path to CSS stylesheet file.
+        BINDINGS: Keyboard bindings for app actions.
+        TITLE: Application title displayed in header.
+        ENABLE_COMMAND_PALETTE: Disable Textual's command palette feature.
+    """
+
+    CSS_PATH = Path(__file__).parent / "homekit.tcss"
+    TITLE = "HomeKit"
+    ENABLE_COMMAND_PALETTE = False
+
+    BINDINGS = [
+        ("Q", "quit", "Quit"),
+        ("C", "toggle_connection", "Connect"),
+        ("r", "refresh_all", "Refresh"),
+    ]
+
+    def __init__(self, homekit_service: HomekitService) -> None:
+        """
+        Initialize the HomeKit app.
+
+        Args:
+            homekit_service: HomekitService for accessory state operations.
+        """
+        super().__init__()
+        self.homekit_service: HomekitService = homekit_service
+        self.room_list_widget: Optional[RoomListWidget] = None
+        self.footer_widget: Optional[StatusFooterWidget] = None
+
+    def compose(self) -> ComposeResult:
+        """
+        Compose the app layout with widgets.
+
+        Yields:
+            RoomListWidget and StatusFooterWidget.
+        """
+        self.room_list_widget = RoomListWidget(
+            service=self.homekit_service, id="room-list"
+        )
+        yield self.room_list_widget
+
+        self.footer_widget = StatusFooterWidget(
+            service=self.homekit_service, id="footer-container"
+        )
+        yield self.footer_widget
+
+    async def on_mount(self) -> None:
+        """
+        Initialize app after UI is mounted.
+
+        Delays connection by 0.5s to let UI render first. Starts the AccessoryDriver and
+        sets up automatic screen refresh every second to update elapsed times.
+        """
+        import asyncio
+
+        # Delay connection to let UI render
+        await asyncio.sleep(0.5)
+        await self.homekit_service.start()
+
+        # Set up periodic refresh to update elapsed times
+        self.set_interval(1.0, self._refresh_last_update_column)
+
+    def _refresh_last_update_column(self) -> None:
+        """Refresh only the last_update column to show elapsed time."""
+        if self.room_list_widget:
+            self.room_list_widget.refresh_last_update_times()
+
+    def on_key(self, event: Any) -> None:
+        """
+        Handle key press events for action keys.
+
+        Intercepts a-z keys to toggle accessories.
+
+        Args:
+            event: Key press event.
+        """
+        key = event.key.lower()
+        if len(key) == 1 and "a" <= key <= "z":
+            if self.homekit_service.toggle_accessory(key):
+                event.prevent_default()
+
+    def action_toggle_connection(self) -> None:
+        """
+        Toggle connection on 'c' key press.
+
+        Connects if disconnected/failed, disconnects if connected/connecting.
+        """
+        self.homekit_service.toggle_connection()
+
+    def action_refresh_all(self) -> None:
+        """Refresh all module data on 'r' key press."""
+        self.homekit_service.refresh_all()
+
+    async def on_unmount(self) -> None:
+        """Stop AccessoryDriver and clean up service when app unmounts."""
+        await self.homekit_service.stop()

xp/term/homekit.tcss

@@ -0,0 +1,86 @@
+/* HomeKit TUI Styling */
+
+/* Color overrides */
+$success: #00ff00;
+
+/* App-level styling */
+Screen {
+    background: $background;
+}
+
+/* Room List Widget */
+RoomListWidget {
+    border: solid $success;
+    border-title-align: left;
+    width: 1fr;
+    height: 1fr;
+    background: $background;
+    padding: 1;
+}
+
+RoomListWidget:focus {
+    background: $background;
+    background-tint: transparent;
+}
+
+#rooms-table {
+    background: $background !important;
+    width: 100%;
+    height: 1fr;
+}
+
+#rooms-table:focus {
+    background: $background !important;
+    background-tint: transparent;
+}
+
+DataTable {
+    background: $background;
+    color: $success;
+}
+
+DataTable > .datatable--header {
+    background: $background;
+    color: $success;
+}
+
+DataTable > .datatable--cursor {
+    background: $background;
+    color: $success;
+}
+
+DataTable:focus > .datatable--cursor {
+    background: $background;
+    color: $success;
+}
+
+/* Footer styling */
+#footer-container {
+    dock: bottom;
+    height: 1;
+    background: $background;
+}
+
+Footer {
+    width: auto;
+    background: $background;
+    color: $text;
+}
+
+#status-text {
+    dock: right;
+    width: auto;
+    padding: 0 3;
+    background: $background;
+    color: $text;
+    text-align: right;
+}
+
+#status-line {
+    dock: right;
+    width: auto;
+    padding: 0 1;
+    background: $background;
+    color: $text;
+    text-align: right;
+}

xp/term/widgets/room_list.py

@@ -0,0 +1,232 @@
+"""Room List Widget for displaying HomeKit accessories table."""
+
+from datetime import datetime
+from typing import Any, List, Optional
+
+from rich.text import Text
+from textual.app import ComposeResult
+from textual.widgets import DataTable, Static
+
+from xp.models.term.accessory_state import AccessoryState
+from xp.services.term.homekit_service import HomekitService
+
+
+class RoomListWidget(Static):
+    """
+    Widget displaying HomeKit accessories in a data table.
+
+    Shows room/accessory hierarchy with real-time state updates from HomekitService.
+    Table displays: room/accessory, action, state, dim, module, serial, type, status, output, updated.
+
+    Attributes:
+        service: HomekitService for accessory state updates.
+        table: DataTable widget displaying accessory information.
+    """
+
+    def __init__(
+        self,
+        service: Optional[HomekitService] = None,
+        *args: Any,
+        **kwargs: Any,
+    ) -> None:
+        """
+        Initialize the Room List widget.
+
+        Args:
+            service: Optional HomekitService for signal subscriptions.
+            args: Additional positional arguments for Static.
+            kwargs: Additional keyword arguments for Static.
+        """
+        super().__init__(*args, **kwargs)
+        self.service = service
+        self.table: Optional[DataTable] = None
+        self._row_keys: dict[str, Any] = {}  # Map accessory_id to row key
+        self._current_room: str = ""
+
+    def compose(self) -> ComposeResult:
+        """
+        Compose the widget layout.
+
+        Yields:
+            DataTable widget.
+        """
+        self.table = DataTable(id="rooms-table", cursor_type="row")
+        yield self.table
+
+    def on_mount(self) -> None:
+        """Initialize table and subscribe to service signals when widget mounts."""
+        self.border_title = "Rooms"
+
+        if self.table:
+            self.table.add_column("room / accessory", key="name", width=35)
+            self.table.add_column("action", key="action", width=8)
+            self.table.add_column("state", key="state", width=7)
+            self.table.add_column("dim", key="dim", width=6)
+            self.table.add_column("module", key="module", width=8)
+            self.table.add_column("serial", key="serial", width=12)
+            self.table.add_column("type", key="type", width=10)
+            self.table.add_column("status", key="status", width=8)
+            self.table.add_column("output", key="output", width=7)
+            self.table.add_column("updated", key="updated", width=10)
+
+        if self.service:
+            self.service.on_room_list_updated.connect(self.update_accessory_list)
+            self.service.on_module_state_changed.connect(self.update_accessory_state)
+
+    def on_unmount(self) -> None:
+        """Unsubscribe from service signals when widget unmounts."""
+        if self.service:
+            self.service.on_room_list_updated.disconnect(self.update_accessory_list)
+            self.service.on_module_state_changed.disconnect(self.update_accessory_state)
+
+    def update_accessory_list(self, accessory_states: List[AccessoryState]) -> None:
+        """
+        Update entire accessory list from service.
+
+        Clears existing table and repopulates with all accessories grouped by room.
+
+        Args:
+            accessory_states: List of all accessory states.
+        """
+        if not self.table:
+            return
+
+        self.table.clear()
+        self._row_keys.clear()
+        self._current_room = ""
+
+        for state in accessory_states:
+            # Add room header row if new room
+            if state.room_name != self._current_room:
+                self._current_room = state.room_name
+                self.table.add_row()
+                self.table.add_row(Text(state.room_name, style="bold"))
+                self.table.add_row()
+
+            self._add_accessory_row(state)
+
+    def update_accessory_state(self, state: AccessoryState) -> None:
+        """
+        Update individual accessory state in table.
+
+        Updates existing row if accessory exists, otherwise adds new row.
+
+        Args:
+            state: Updated accessory state.
+        """
+        if not self.table:
+            return
+
+        accessory_id = f"{state.module_name}_{state.output}"
+
+        if accessory_id in self._row_keys:
+            row_key = self._row_keys[accessory_id]
+            self.table.update_cell(
+                row_key, "state", Text(state.output_state, justify="center")
+            )
+            self.table.update_cell(
+                row_key, "dim", Text(self._format_dim(state), justify="center")
+            )
+            self.table.update_cell(row_key, "status", state.error_status)
+            self.table.update_cell(
+                row_key,
+                "updated",
+                Text(self._format_last_update(state.last_update), justify="center"),
+            )
+        else:
+            self._add_accessory_row(state)
+
+    def _add_accessory_row(self, state: AccessoryState) -> None:
+        """
+        Add an accessory row to the table.
+
+        Args:
+            state: Accessory state to add.
+        """
+        if not self.table:
+            return
+
+        accessory_id = f"{state.module_name}_{state.output}"
+        row_key = self.table.add_row(
+            f"  - {state.accessory_name}",
+            Text(state.action, justify="center"),
+            Text(state.output_state, justify="center"),
+            Text(self._format_dim(state), justify="center"),
+            state.module_name,
+            state.serial_number,
+            state.module_type,
+            state.error_status,
+            Text(str(state.output), justify="right"),
+            Text(self._format_last_update(state.last_update), justify="center"),
+        )
+        self._row_keys[accessory_id] = row_key
+
+    def _format_dim(self, state: AccessoryState) -> str:
+        """
+        Format dimming state for display.
+
+        Shows percentage if dimmable and ON, "-" if dimmable and OFF, empty otherwise.
+
+        Args:
+            state: Accessory state.
+
+        Returns:
+            Formatted dimming string.
+        """
+        if not state.is_dimmable():
+            return ""
+        if state.output_state == "OFF":
+            return "-"
+        return state.dimming_state or ""
+
+    def _format_last_update(self, last_update: Optional[datetime]) -> str:
+        """
+        Format last update timestamp for display.
+
+        Shows elapsed time in HH:MM:SS format or "--:--:--" if never updated.
+
+        Args:
+            last_update: Last update timestamp or None.
+
+        Returns:
+            Formatted time string.
+        """
+        if last_update is None:
+            return "--:--:--"
+
+        elapsed = datetime.now() - last_update
+        total_seconds = int(elapsed.total_seconds())
+
+        hours = total_seconds // 3600
+        minutes = (total_seconds % 3600) // 60
+        seconds = total_seconds % 60
+
+        return f"{hours:02d}:{minutes:02d}:{seconds:02d}"
+
+    def refresh_last_update_times(self) -> None:
+        """
+        Refresh only the last_update column for all accessories.
+
+        Updates the elapsed time display without querying the service.
+        """
+        if not self.table or not self.service:
+            return
+
+        for accessory_id, row_key in self._row_keys.items():
+            state = next(
+                (
+                    s
+                    for s in self.service.accessory_states
+                    if f"{s.module_name}_{s.output}" == accessory_id
+                ),
+                None,
+            )
+            if state:
+                self.table.update_cell(
+                    row_key,
+                    "updated",
+                    Text(
+                        self._format_last_update(state.last_update),
+                        justify="center",
+                    ),
+                )

xp/term/widgets/status_footer.py

@@ -7,6 +7,7 @@ from textual.containers import Horizontal
 from textual.widgets import Footer, Static
 
 from xp.models.term.connection_state import ConnectionState
+from xp.services.term.homekit_service import HomekitService
 from xp.services.term.protocol_monitor_service import ProtocolMonitorService
 from xp.services.term.state_monitor_service import StateMonitorService
 
@@ -19,14 +20,16 @@ class StatusFooterWidget(Horizontal):
     the current connection state. Subscribes directly to service signals.
 
     Attributes:
-        service: ProtocolMonitorService or StateMonitorService for connection state and status updates.
+        service: ProtocolMonitorService, StateMonitorService, or HomekitService for connection state and status updates.
         status_widget: Static widget displaying colored status dot.
         status_text_widget: Static widget displaying status messages.
     """
 
     def __init__(
         self,
-        service: Optional[Union[ProtocolMonitorService, StateMonitorService]] = None,
+        service: Optional[
+            Union[ProtocolMonitorService, StateMonitorService, HomekitService]
+        ] = None,
         *args: Any,
         **kwargs: Any,
     ) -> None:
@@ -34,7 +37,7 @@ class StatusFooterWidget(Horizontal):
         Initialize the Status Footer widget.
 
         Args:
-            service: Optional ProtocolMonitorService or StateMonitorService for signal subscriptions.
+            service: Optional ProtocolMonitorService, StateMonitorService, or HomekitService for signal subscriptions.
             args: Additional positional arguments for Horizontal.
             kwargs: Additional keyword arguments for Horizontal.
         """

xp/utils/dependencies.py

@@ -77,8 +77,11 @@ from xp.services.telegram.telegram_discover_service import TelegramDiscoverServi
 from xp.services.telegram.telegram_link_number_service import LinkNumberService
 from xp.services.telegram.telegram_output_service import TelegramOutputService
 from xp.services.telegram.telegram_service import TelegramService
+from xp.services.term.homekit_accessory_driver import HomekitAccessoryDriver
+from xp.services.term.homekit_service import HomekitService
 from xp.services.term.protocol_monitor_service import ProtocolMonitorService
 from xp.services.term.state_monitor_service import StateMonitorService
+from xp.term.homekit import HomekitApp
 from xp.term.protocol import ProtocolMonitorApp
 from xp.term.state import StateMonitorApp
 from xp.utils.logging import LoggerService
@@ -265,6 +268,34 @@ class ServiceContainer:
             scope=punq.Scope.singleton,
         )
 
+        self.container.register(
+            HomekitAccessoryDriver,
+            factory=lambda: HomekitAccessoryDriver(
+                homekit_config=self.container.resolve(HomekitConfig),
+            ),
+            scope=punq.Scope.singleton,
+        )
+
+        self.container.register(
+            HomekitService,
+            factory=lambda: HomekitService(
+                conbus_protocol=self.container.resolve(ConbusEventProtocol),
+                homekit_config=self.container.resolve(HomekitConfig),
+                conson_config=self.container.resolve(ConsonModuleListConfig),
+                telegram_service=self.container.resolve(TelegramService),
+                accessory_driver=self.container.resolve(HomekitAccessoryDriver),
+            ),
+            scope=punq.Scope.singleton,
+        )
+
+        self.container.register(
+            HomekitApp,
+            factory=lambda: HomekitApp(
+                homekit_service=self.container.resolve(HomekitService)
+            ),
+            scope=punq.Scope.singleton,
+        )
+
         self.container.register(
             ConbusEventRawService,
             factory=lambda: ConbusEventRawService(