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

xp/services/term/homekit_service.py

@@ -18,6 +18,7 @@ from xp.models.term.connection_state import ConnectionState
 from xp.services.protocol.conbus_event_protocol import ConbusEventProtocol
 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
 
 
 class HomekitService:
@@ -50,6 +51,7 @@ class HomekitService:
         homekit_config: HomekitConfig,
         conson_config: ConsonModuleListConfig,
         telegram_service: TelegramService,
+        accessory_driver: HomekitAccessoryDriver,
     ) -> None:
         """
         Initialize the HomeKit service.
@@ -59,12 +61,14 @@ class HomekitService:
             homekit_config: HomekitConfig for accessory configuration.
             conson_config: ConsonModuleListConfig for module configuration.
             telegram_service: TelegramService for parsing telegrams.
+            accessory_driver: HomekitAccessoryDriver for pyhap integration.
         """
         self.logger = logging.getLogger(__name__)
         self._conbus_protocol = conbus_protocol
         self._homekit_config = homekit_config
         self._conson_config = conson_config
         self._telegram_service = telegram_service
+        self._accessory_driver = accessory_driver
         self._connection_state = ConnectionState.DISCONNECTED
         self._state_machine = ConnectionState.create_state_machine()
 
@@ -74,6 +78,9 @@ class HomekitService:
         # Action key to accessory ID mapping
         self._action_map: Dict[str, str] = {}
 
+        # Set up HomeKit callback
+        self._accessory_driver.set_callback(self._on_homekit_set)
+
         # Connect to protocol signals
         self._connect_signals()
 
@@ -82,7 +89,7 @@ class HomekitService:
 
     def _initialize_accessory_states(self) -> None:
         """Initialize accessory states from HomekitConfig and ConsonModuleListConfig."""
-        action_keys = "abcdefghijklmnopqrstuvwxyz0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZ"
+        action_keys = "abcdefghijklmnopqrstuvwxyz0123456789"
         action_index = 0
         sort_order = 0
 
@@ -152,6 +159,44 @@ class HomekitService:
                 return accessory
         return None
 
+    def _find_accessory_config_by_output(
+        self, serial_number: str, output: int
+    ) -> Optional[HomekitAccessoryConfig]:
+        """
+        Find accessory config by serial number and output.
+
+        Args:
+            serial_number: Module serial number.
+            output: Output number (1-based).
+
+        Returns:
+            HomekitAccessoryConfig if found, None otherwise.
+        """
+        for accessory in self._homekit_config.accessories:
+            if (
+                accessory.serial_number == serial_number
+                and accessory.output_number == output - 1
+            ):
+                return accessory
+        return None
+
+    def _find_accessory_config_by_id(
+        self, accessory_id: str
+    ) -> Optional[HomekitAccessoryConfig]:
+        """
+        Find accessory config by accessory ID.
+
+        Args:
+            accessory_id: Accessory ID (e.g., "A12_1").
+
+        Returns:
+            HomekitAccessoryConfig if found, None otherwise.
+        """
+        state = self._accessory_states.get(accessory_id)
+        if not state:
+            return None
+        return self._find_accessory_config_by_output(state.serial_number, state.output)
+
     def _connect_signals(self) -> None:
         """Connect to protocol signals."""
         self._conbus_protocol.on_connection_made.connect(self._on_connection_made)
@@ -242,6 +287,44 @@ class HomekitService:
             self.on_connection_state_changed.emit(self._connection_state)
             self.on_status_message.emit("Disconnected")
 
+    async def start(self) -> None:
+        """Start the service and AccessoryDriver."""
+        self.connect()
+        await self._accessory_driver.start()
+
+    async def stop(self) -> None:
+        """Stop the AccessoryDriver and cleanup."""
+        await self._accessory_driver.stop()
+        self.cleanup()
+
+    def _on_homekit_set(self, accessory_name: str, is_on: bool) -> None:
+        """
+        Handle HomeKit app toggle request.
+
+        Args:
+            accessory_name: Accessory name from HomeKit.
+            is_on: True for on, False for off.
+        """
+        config = self._find_accessory_config(accessory_name)
+        if config:
+            action = config.on_action if is_on else config.off_action
+            self.send_action(action)
+            self.on_status_message.emit(
+                f"HomeKit: {accessory_name} {'ON' if is_on else 'OFF'}"
+            )
+        else:
+            self.logger.warning(f"No config found for accessory: {accessory_name}")
+
+    def send_action(self, action: str) -> None:
+        """
+        Send an action telegram to the conbus protocol.
+
+        Args:
+            action: The action string to send (e.g., "E00L00I00").
+        """
+        self._conbus_protocol.send_raw_telegram(f"{action}M")
+        self._conbus_protocol.send_raw_telegram(f"{action}B")
+
     def toggle_connection(self) -> None:
         """
         Toggle connection state between connected and disconnected.
@@ -257,31 +340,111 @@ class HomekitService:
         else:
             self.connect()
 
-    def toggle_accessory(self, action_key: str) -> bool:
+    def select_accessory(self, action_key: str) -> Optional[str]:
         """
-        Toggle accessory by action key.
+        Get accessory ID for action key.
 
-        Sends the toggle_action telegram for the accessory mapped to the given key.
+        Args:
+            action_key: Action key (a-z0-9).
+
+        Returns:
+            Accessory ID if found, None otherwise.
+        """
+        return self._action_map.get(action_key)
+
+    def toggle_selected(self, accessory_id: str) -> bool:
+        """
+        Toggle accessory by ID.
 
         Args:
-            action_key: Action key (a-z).
+            accessory_id: Accessory ID (e.g., "A12_1").
 
         Returns:
             True if toggle was sent, False otherwise.
         """
-        accessory_id = self._action_map.get(action_key)
-        if not accessory_id:
-            return False
-
         state = self._accessory_states.get(accessory_id)
         if not state or not state.toggle_action:
             self.logger.warning(f"No toggle_action for accessory {accessory_id}")
             return False
 
-        self._conbus_protocol.send_raw_telegram(state.toggle_action)
+        self.send_action(state.toggle_action)
         self.on_status_message.emit(f"Toggling {state.accessory_name}")
         return True
 
+    def turn_on_selected(self, accessory_id: str) -> bool:
+        """
+        Turn on accessory by ID.
+
+        Args:
+            accessory_id: Accessory ID (e.g., "A12_1").
+
+        Returns:
+            True if on command was sent, False otherwise.
+        """
+        config = self._find_accessory_config_by_id(accessory_id)
+        state = self._accessory_states.get(accessory_id)
+        if not config or not state:
+            self.logger.warning(f"No config for accessory {accessory_id}")
+            return False
+
+        self.send_action(config.on_action)
+        self.on_status_message.emit(f"Turning ON {state.accessory_name}")
+        return True
+
+    def turn_off_selected(self, accessory_id: str) -> bool:
+        """
+        Turn off accessory by ID.
+
+        Args:
+            accessory_id: Accessory ID (e.g., "A12_1").
+
+        Returns:
+            True if off command was sent, False otherwise.
+        """
+        config = self._find_accessory_config_by_id(accessory_id)
+        state = self._accessory_states.get(accessory_id)
+        if not config or not state:
+            self.logger.warning(f"No config for accessory {accessory_id}")
+            return False
+
+        self.send_action(config.off_action)
+        self.on_status_message.emit(f"Turning OFF {state.accessory_name}")
+        return True
+
+    def increase_dimmer(self, accessory_id: str) -> bool:
+        """
+        Increase dimmer level for accessory.
+
+        Args:
+            accessory_id: Accessory ID (e.g., "A12_1").
+
+        Returns:
+            True if command was sent, False otherwise.
+        """
+        state = self._accessory_states.get(accessory_id)
+        if not state:
+            return False
+        # TODO: Implement dimmer control
+        self.on_status_message.emit(f"Dimmer+ {state.accessory_name} (not implemented)")
+        return False
+
+    def decrease_dimmer(self, accessory_id: str) -> bool:
+        """
+        Decrease dimmer level for accessory.
+
+        Args:
+            accessory_id: Accessory ID (e.g., "A12_1").
+
+        Returns:
+            True if command was sent, False otherwise.
+        """
+        state = self._accessory_states.get(accessory_id)
+        if not state:
+            return False
+        # TODO: Implement dimmer control
+        self.on_status_message.emit(f"Dimmer- {state.accessory_name} (not implemented)")
+        return False
+
     def refresh_all(self) -> None:
         """
         Refresh all module states.
@@ -406,6 +569,13 @@ class HomekitService:
                     # Update dimming state for dimmable modules
                     if state.is_dimmable():
                         state.dimming_state = "-" if not is_on else ""
+
+                    # Sync to HomeKit
+                    config = self._find_accessory_config_by_output(
+                        serial_number, state.output
+                    )
+                    if config:
+                        self._accessory_driver.update_state(config.name, is_on)
                 else:
                     state.output_state = "?"
 
@@ -463,6 +633,13 @@ class HomekitService:
                 if state.is_dimmable():
                     state.dimming_state = "-" if not is_on else ""
 
+                # Sync to HomeKit
+                config = self._find_accessory_config_by_output(
+                    state.serial_number, state.output
+                )
+                if config:
+                    self._accessory_driver.update_state(config.name, is_on)
+
                 state.last_update = datetime.now()
                 self.on_module_state_changed.emit(state)
 

xp/term/homekit.py

@@ -4,6 +4,7 @@ from pathlib import Path
 from typing import Any, Optional
 
 from textual.app import App, ComposeResult
+from textual.widgets import DataTable
 
 from xp.services.term.homekit_service import HomekitService
 from xp.term.widgets.room_list import RoomListWidget
@@ -14,11 +15,13 @@ 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.
+    Displays rooms and accessories with real-time state updates.
+    Select accessory with action key, then perform action on selection.
 
     Attributes:
         homekit_service: HomekitService for accessory state operations.
+        selected_accessory_id: Currently selected accessory ID.
+        _last_cursor_row: Last cursor row for direction detection.
         CSS_PATH: Path to CSS stylesheet file.
         BINDINGS: Keyboard bindings for app actions.
         TITLE: Application title displayed in header.
@@ -32,7 +35,12 @@ class HomekitApp(App[None]):
     BINDINGS = [
         ("Q", "quit", "Quit"),
         ("C", "toggle_connection", "Connect"),
-        ("r", "refresh_all", "Refresh"),
+        ("R", "refresh_all", "Refresh"),
+        ("space", "toggle_selected", "Toggle"),
+        ("full_stop", "turn_on_selected", "On"),
+        ("minus", "turn_off_selected", "Off"),
+        ("plus", "dim_up", "Dim+"),
+        ("quotation_mark", "dim_down", "Dim-"),
     ]
 
     def __init__(self, homekit_service: HomekitService) -> None:
@@ -44,6 +52,8 @@ class HomekitApp(App[None]):
         """
         super().__init__()
         self.homekit_service: HomekitService = homekit_service
+        self.selected_accessory_id: Optional[str] = None
+        self._last_cursor_row: int = 0
         self.room_list_widget: Optional[RoomListWidget] = None
         self.footer_widget: Optional[StatusFooterWidget] = None
 
@@ -68,14 +78,14 @@ class HomekitApp(App[None]):
         """
         Initialize app after UI is mounted.
 
-        Delays connection by 0.5s to let UI render first. Sets up automatic screen
-        refresh every second to update elapsed times.
+        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)
-        self.homekit_service.connect()
+        await self.homekit_service.start()
 
         # Set up periodic refresh to update elapsed times
         self.set_interval(1.0, self._refresh_last_update_column)
@@ -87,17 +97,114 @@ class HomekitApp(App[None]):
 
     def on_key(self, event: Any) -> None:
         """
-        Handle key press events for action keys.
+        Handle key press events for selection and action keys.
 
-        Intercepts a-z keys to toggle accessories.
+        Selection keys (a-z0-9): Select accessory row.
+        Action keys (on selected accessory):
+        - Space: Toggle
+        - . : Turn ON
+        - - : Turn OFF
+        - + : Dim up
+        - " : Dim down
 
         Args:
             event: Key press event.
         """
-        key = event.key.lower()
-        if len(key) == 1 and "a" <= key <= "z":
-            if self.homekit_service.toggle_accessory(key):
+        key = event.key
+
+        # Selection keys (a-z0-9)
+        if len(key) == 1 and (("a" <= key <= "z") or ("0" <= key <= "9")):
+            accessory_id = self.homekit_service.select_accessory(key)
+            if accessory_id:
+                self.selected_accessory_id = accessory_id
+                self._select_row(key)
                 event.prevent_default()
+            return
+
+        # Action keys (require selection)
+        if not self.selected_accessory_id:
+            return
+
+        if key == "space":
+            self.homekit_service.toggle_selected(self.selected_accessory_id)
+            event.prevent_default()
+        elif key in ("full_stop", "."):
+            self.homekit_service.turn_on_selected(self.selected_accessory_id)
+            event.prevent_default()
+        elif key in ("minus", "-"):
+            self.homekit_service.turn_off_selected(self.selected_accessory_id)
+            event.prevent_default()
+        elif key in ("plus", "+"):
+            self.homekit_service.increase_dimmer(self.selected_accessory_id)
+            event.prevent_default()
+        elif key in ("quotation_mark", '"'):
+            self.homekit_service.decrease_dimmer(self.selected_accessory_id)
+            event.prevent_default()
+
+    def _select_row(self, action_key: str) -> None:
+        """
+        Select row in RoomListWidget by action key.
+
+        Args:
+            action_key: Action key to select.
+        """
+        if self.room_list_widget:
+            self.room_list_widget.select_by_action_key(action_key)
+
+    def on_data_table_row_highlighted(self, event: DataTable.RowHighlighted) -> None:
+        """
+        Handle row highlight changes from arrow key navigation.
+
+        Updates selected_accessory_id when cursor moves via arrow keys.
+        Skips non-accessory rows (layout rows) automatically.
+
+        Args:
+            event: Row highlighted event from DataTable.
+        """
+        if not self.room_list_widget or not event.row_key:
+            return
+
+        accessory_id = self.room_list_widget.get_accessory_id_for_row(event.row_key)
+        if accessory_id:
+            self.selected_accessory_id = accessory_id
+            self._last_cursor_row = event.cursor_row
+        else:
+            # Non-accessory row (layout), skip to next valid row
+            self._skip_to_accessory_row(event.cursor_row)
+
+    def _skip_to_accessory_row(self, current_row: int) -> None:
+        """
+        Skip cursor to the nearest accessory row.
+
+        Args:
+            current_row: Current cursor row index.
+        """
+        if not self.room_list_widget or not self.room_list_widget.table:
+            return
+
+        table = self.room_list_widget.table
+        row_count = table.row_count
+
+        # Determine direction based on last position
+        direction = 1 if current_row >= self._last_cursor_row else -1
+
+        # Search for next accessory row in direction
+        next_row = current_row + direction
+        while 0 <= next_row < row_count:
+            row_key = self.room_list_widget.get_row_key_at_index(next_row)
+            if row_key and self.room_list_widget.get_accessory_id_for_row(row_key):
+                table.move_cursor(row=next_row)
+                return
+            next_row += direction
+
+        # If not found in direction, try opposite direction
+        next_row = current_row - direction
+        while 0 <= next_row < row_count:
+            row_key = self.room_list_widget.get_row_key_at_index(next_row)
+            if row_key and self.room_list_widget.get_accessory_id_for_row(row_key):
+                table.move_cursor(row=next_row)
+                return
+            next_row -= direction
 
     def action_toggle_connection(self) -> None:
         """
@@ -111,6 +218,31 @@ class HomekitApp(App[None]):
         """Refresh all module data on 'r' key press."""
         self.homekit_service.refresh_all()
 
-    def on_unmount(self) -> None:
-        """Clean up service when app unmounts."""
-        self.homekit_service.cleanup()
+    def action_toggle_selected(self) -> None:
+        """Toggle selected accessory."""
+        if self.selected_accessory_id:
+            self.homekit_service.toggle_selected(self.selected_accessory_id)
+
+    def action_turn_on_selected(self) -> None:
+        """Turn on selected accessory."""
+        if self.selected_accessory_id:
+            self.homekit_service.turn_on_selected(self.selected_accessory_id)
+
+    def action_turn_off_selected(self) -> None:
+        """Turn off selected accessory."""
+        if self.selected_accessory_id:
+            self.homekit_service.turn_off_selected(self.selected_accessory_id)
+
+    def action_dim_up(self) -> None:
+        """Increase dimmer on selected accessory."""
+        if self.selected_accessory_id:
+            self.homekit_service.increase_dimmer(self.selected_accessory_id)
+
+    def action_dim_down(self) -> None:
+        """Decrease dimmer on selected accessory."""
+        if self.selected_accessory_id:
+            self.homekit_service.decrease_dimmer(self.selected_accessory_id)
+
+    async def on_unmount(self) -> None:
+        """Stop AccessoryDriver and clean up service when app unmounts."""
+        await self.homekit_service.stop()

xp/term/homekit.tcss

@@ -45,13 +45,13 @@ DataTable > .datatable--header {
 }
 
 DataTable > .datatable--cursor {
-    background: $background;
-    color: $success;
+    background: $success;
+    color: $background;
 }
 
 DataTable:focus > .datatable--cursor {
-    background: $background;
-    color: $success;
+    background: $success;
+    color: $background;
 }
 
 /* Footer styling */

xp/term/widgets/room_list.py

@@ -41,6 +41,9 @@ class RoomListWidget(Static):
         self.service = service
         self.table: Optional[DataTable] = None
         self._row_keys: dict[str, Any] = {}  # Map accessory_id to row key
+        self._row_to_accessory: dict[Any, str] = {}  # Map row key to accessory_id
+        self._row_index_to_key: list[Any] = []  # Map row index to row key
+        self._action_to_row: dict[str, Any] = {}  # Map action key to row key
         self._current_room: str = ""
 
     def compose(self) -> ComposeResult:
@@ -93,15 +96,23 @@ class RoomListWidget(Static):
 
         self.table.clear()
         self._row_keys.clear()
+        self._row_to_accessory.clear()
+        self._row_index_to_key.clear()
+        self._action_to_row.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()
+                # Add layout rows (empty and header) - not selectable
+                self._row_index_to_key.extend(
+                    [
+                        self.table.add_row(),
+                        self.table.add_row(Text(state.room_name, style="bold")),
+                        self.table.add_row(),
+                    ]
+                )
 
             self._add_accessory_row(state)
 
@@ -160,6 +171,10 @@ class RoomListWidget(Static):
             Text(self._format_last_update(state.last_update), justify="center"),
         )
         self._row_keys[accessory_id] = row_key
+        self._row_to_accessory[row_key] = accessory_id
+        self._row_index_to_key.append(row_key)
+        if state.action:
+            self._action_to_row[state.action] = row_key
 
     def _format_dim(self, state: AccessoryState) -> str:
         """
@@ -230,3 +245,46 @@ class RoomListWidget(Static):
                         justify="center",
                     ),
                 )
+
+    def select_by_action_key(self, action_key: str) -> None:
+        """
+        Select and highlight row by action key.
+
+        Moves the table cursor to the row corresponding to the action key.
+
+        Args:
+            action_key: Action key (a-z0-9) to select.
+        """
+        if not self.table:
+            return
+
+        row_key = self._action_to_row.get(action_key)
+        if row_key is not None:
+            row_index = self.table.get_row_index(row_key)
+            self.table.move_cursor(row=row_index)
+
+    def get_accessory_id_for_row(self, row_key: Any) -> Optional[str]:
+        """
+        Get accessory ID for a row key.
+
+        Args:
+            row_key: DataTable row key.
+
+        Returns:
+            Accessory ID if found, None otherwise.
+        """
+        return self._row_to_accessory.get(row_key)
+
+    def get_row_key_at_index(self, index: int) -> Optional[Any]:
+        """
+        Get row key at a given index.
+
+        Args:
+            index: Row index.
+
+        Returns:
+            Row key if valid index, None otherwise.
+        """
+        if 0 <= index < len(self._row_index_to_key):
+            return self._row_index_to_key[index]
+        return None