conson-xp 1.50.1__py3-none-any.whl → 1.51.1__py3-none-any.whl

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

@@ -46,6 +46,9 @@ from xp.services.conbus.conbus_datapoint_service import (
 from xp.services.conbus.conbus_discover_service import ConbusDiscoverService
 from xp.services.conbus.conbus_event_list_service import ConbusEventListService
 from xp.services.conbus.conbus_event_raw_service import ConbusEventRawService
+from xp.services.conbus.conbus_export_actiontable_service import (
+    ConbusActiontableExportService,
+)
 from xp.services.conbus.conbus_export_service import ConbusExportService
 from xp.services.conbus.conbus_output_service import ConbusOutputService
 from xp.services.conbus.conbus_raw_service import ConbusRawService
@@ -74,8 +77,10 @@ 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_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
@@ -217,6 +222,15 @@ class ServiceContainer:
             scope=punq.Scope.singleton,
         )
 
+        self.container.register(
+            ConbusActiontableExportService,
+            factory=lambda: ConbusActiontableExportService(
+                download_service=self.container.resolve(ActionTableDownloadService),
+                module_list=self.container.resolve(ConsonModuleListConfig),
+            ),
+            scope=punq.Scope.singleton,
+        )
+
         # Terminal UI
         self.container.register(
             ProtocolMonitorService,
@@ -253,6 +267,25 @@ class ServiceContainer:
             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),
+            ),
+            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(