conson-xp 1.51.1__tar.gz → 1.52.0__tar.gz

{conson_xp-1.51.1 → conson_xp-1.52.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: conson-xp
-Version: 1.51.1
+Version: 1.52.0
 Summary: XP Protocol Communication Tools
 Author-Email: ldvchosal <ldvchosal@github.com>
 License: MIT License

{conson_xp-1.51.1 → conson_xp-1.52.0}/pyproject.toml

@@ -23,7 +23,7 @@ dependencies = [
 ]
 requires-python = ">=3.11"
 readme = "README.md"
-version = "1.51.1"
+version = "1.52.0"
 
 [project.license]
 file = "LICENSE"

{conson_xp-1.51.1 → conson_xp-1.52.0}/src/xp/__init__.py

@@ -4,7 +4,7 @@ XP CLI tool for remote console bus operations.
 conson-xp package.
 """
 
-__version__ = "1.51.1"
+__version__ = "1.52.0"
 __manufacturer__ = "salchichon"
 __model__ = "xp.cli"
 __serial__ = "2025.09.23.000"

{conson_xp-1.51.1 → conson_xp-1.52.0}/src/xp/models/homekit/homekit_config.py

@@ -16,10 +16,14 @@ class NetworkConfig(BaseModel):
     Attributes:
         ip: IP address for the network connection.
         port: Port number for the network connection.
+        pincode: HomeKit pairing code (format: XXX-XX-XXX).
+        accessory_state_file: Path to file for persisting accessory state.
     """
 
     ip: Union[IPvAnyAddress, IPv4Address, IPv6Address, str] = "127.0.0.1"
     port: int = 51826
+    pincode: str = "031-45-154"
+    accessory_state_file: str = "./accessory.state"
 
 
 class RoomConfig(BaseModel):

conson_xp-1.52.0/src/xp/services/term/homekit_accessory_driver.py

@@ -0,0 +1,168 @@
+"""HomeKit Accessory Driver for pyhap integration."""
+
+import asyncio
+import logging
+from typing import Callable, Dict, Optional
+
+from pyhap.accessory import Accessory, Bridge
+from pyhap.accessory_driver import AccessoryDriver
+from pyhap.const import CATEGORY_LIGHTBULB, CATEGORY_OUTLET
+
+from xp.models.homekit.homekit_config import HomekitConfig
+
+
+class XPAccessory(Accessory):
+    """Single accessory wrapping a Conbus output."""
+
+    def __init__(
+        self,
+        driver: "HomekitAccessoryDriver",
+        name: str,
+        service_type: str,
+        aid: int,
+    ) -> None:
+        """
+        Initialize the XP accessory.
+
+        Args:
+            driver: HomekitAccessoryDriver instance.
+            name: Accessory name (unique identifier and display name).
+            service_type: Service type ('light', 'outlet', 'dimminglight').
+            aid: Accessory ID for HomeKit.
+        """
+        super().__init__(driver._driver, name, aid=aid)
+        self._hk_driver = driver
+        self._accessory_id = name
+        self.logger = logging.getLogger(__name__)
+
+        if service_type == "dimminglight":
+            self.category = CATEGORY_LIGHTBULB
+            serv = self.add_preload_service("Lightbulb", chars=["On", "Brightness"])
+            # Note: Brightness setter_callback deferred to future update
+        elif service_type == "outlet":
+            self.category = CATEGORY_OUTLET
+            serv = self.add_preload_service("Outlet")
+        else:
+            self.category = CATEGORY_LIGHTBULB
+            serv = self.add_preload_service("Lightbulb")
+
+        self._char_on = serv.configure_char("On", setter_callback=self._set_on)
+
+    def _set_on(self, value: bool) -> None:
+        """
+        Handle HomeKit set on/off request.
+
+        Args:
+            value: True for on, False for off.
+        """
+        if self._hk_driver._on_set:
+            self._hk_driver._on_set(self._accessory_id, value)
+
+    def update_state(self, is_on: bool) -> None:
+        """
+        Update accessory state from Conbus event.
+
+        Args:
+            is_on: True if accessory is on, False otherwise.
+        """
+        self._char_on.set_value(is_on)
+
+
+class HomekitAccessoryDriver:
+    """Wrapper around pyhap AccessoryDriver."""
+
+    def __init__(self, homekit_config: HomekitConfig) -> None:
+        """
+        Initialize the HomeKit accessory driver.
+
+        Args:
+            homekit_config: HomekitConfig with network and accessory settings.
+        """
+        self.logger = logging.getLogger(__name__)
+        self._homekit_config = homekit_config
+        self._driver: Optional[AccessoryDriver] = None
+        self._accessories: Dict[str, XPAccessory] = {}
+        self._on_set: Optional[Callable[[str, bool], None]] = None
+
+    def set_callback(self, on_set: Callable[[str, bool], None]) -> None:
+        """
+        Set callback for HomeKit set events.
+
+        Args:
+            on_set: Callback(accessory_name, is_on) called when HomeKit app toggles.
+        """
+        self._on_set = on_set
+
+    def _setup_bridge(self, config: HomekitConfig) -> None:
+        """
+        Set up HomeKit bridge with accessories.
+
+        Args:
+            config: HomekitConfig with accessory definitions.
+        """
+        assert self._driver is not None
+        bridge = Bridge(self._driver, config.bridge.name)
+        aid = 2  # Bridge is 1
+
+        for acc_config in config.accessories:
+            accessory = XPAccessory(
+                driver=self,
+                name=acc_config.name,
+                service_type=acc_config.service,
+                aid=aid,
+            )
+            bridge.add_accessory(accessory)
+            self._accessories[acc_config.name] = accessory
+            aid += 1
+
+        self._driver.add_accessory(bridge)
+
+    async def start(self) -> None:
+        """Start the AccessoryDriver (non-blocking)."""
+        try:
+            # Enable pyhap debug logging
+            pyhap_logger = logging.getLogger("pyhap")
+            pyhap_logger.setLevel(logging.DEBUG)
+
+            # Create driver with the running event loop
+            loop = asyncio.get_running_loop()
+            config = self._homekit_config
+            pincode = config.homekit.pincode.encode()
+            self.logger.info(
+                f"Starting HAP driver on {config.homekit.ip}:{config.homekit.port} with pincode {config.homekit.pincode}"
+            )
+            self._driver = AccessoryDriver(
+                loop=loop,
+                address=str(config.homekit.ip),
+                port=config.homekit.port,
+                pincode=pincode,
+                persist_file=config.homekit.accessory_state_file,
+            )
+            self._setup_bridge(config)
+            await self._driver.async_start()
+            self.logger.info("AccessoryDriver started successfully")
+        except Exception as e:
+            self.logger.error(f"Error starting AccessoryDriver: {e}", exc_info=True)
+
+    async def stop(self) -> None:
+        """Stop the AccessoryDriver."""
+        if not self._driver:
+            return
+        try:
+            await self._driver.async_stop()
+            self.logger.info("AccessoryDriver stopped successfully")
+        except Exception as e:
+            self.logger.error(f"Error stopping AccessoryDriver: {e}", exc_info=True)
+
+    def update_state(self, accessory_name: str, is_on: bool) -> None:
+        """
+        Update accessory state from Conbus event.
+
+        Args:
+            accessory_name: Accessory name to update.
+            is_on: True if accessory is on, False otherwise.
+        """
+        if acc := self._accessories.get(accessory_name):
+            acc.update_state(is_on)
+        else:
+            self.logger.warning(f"Unknown accessory name: {accessory_name}")

{conson_xp-1.51.1 → conson_xp-1.52.0}/src/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()
 
@@ -152,6 +159,27 @@ 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 _connect_signals(self) -> None:
         """Connect to protocol signals."""
         self._conbus_protocol.on_connection_made.connect(self._on_connection_made)
@@ -242,6 +270,34 @@ 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._conbus_protocol.send_raw_telegram(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 toggle_connection(self) -> None:
         """
         Toggle connection state between connected and disconnected.
@@ -406,6 +462,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 +526,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)
 

{conson_xp-1.51.1 → conson_xp-1.52.0}/src/xp/term/homekit.py

@@ -68,14 +68,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)
@@ -111,6 +111,6 @@ 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()
+    async def on_unmount(self) -> None:
+        """Stop AccessoryDriver and clean up service when app unmounts."""
+        await self.homekit_service.stop()

{conson_xp-1.51.1 → conson_xp-1.52.0}/src/xp/utils/dependencies.py

@@ -77,6 +77,7 @@ 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
@@ -267,6 +268,14 @@ 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(
@@ -274,6 +283,7 @@ class ServiceContainer:
                 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,
         )

{conson_xp-1.51.1 → conson_xp-1.52.0}/tests/unit/test_models/test_conbus.py

@@ -62,4 +62,4 @@ class TestConbusResponse:
         assert result["sent_telegrams"] == []  # post_init resets these
         assert result["received_telegrams"] == []  # post_init resets these
         assert result["error"] == "test error"
-        assert "2025" in result["timestamp"]
+        assert "T" in result["timestamp"]  # ISO format check

{conson_xp-1.51.1 → conson_xp-1.52.0}/tests/unit/test_services/test_homekit_service.py

@@ -149,9 +149,26 @@ class TestHomekitService:
         service.parse_reply_telegram = Mock()
         return service
 
+    @pytest.fixture
+    def mock_accessory_driver(self):
+        """Create mock HomekitAccessoryDriver."""
+        from xp.services.term.homekit_accessory_driver import HomekitAccessoryDriver
+
+        driver = Mock(spec=HomekitAccessoryDriver)
+        driver.set_callback = Mock()
+        driver.start = Mock()
+        driver.stop = Mock()
+        driver.update_state = Mock()
+        return driver
+
     @pytest.fixture
     def service(
-        self, mock_protocol, homekit_config, conson_config, mock_telegram_service
+        self,
+        mock_protocol,
+        homekit_config,
+        conson_config,
+        mock_telegram_service,
+        mock_accessory_driver,
     ):
         """Create service instance."""
         return HomekitService(
@@ -159,6 +176,7 @@ class TestHomekitService:
             homekit_config=homekit_config,
             conson_config=conson_config,
             telegram_service=mock_telegram_service,
+            accessory_driver=mock_accessory_driver,
         )
 
     def test_initialization(self, service):
@@ -276,7 +294,7 @@ class TestHomekitService:
         mock_protocol.send_raw_telegram.assert_not_called()
 
     def test_toggle_accessory_no_toggle_action(
-        self, mock_protocol, conson_config, mock_telegram_service
+        self, mock_protocol, conson_config, mock_telegram_service, mock_accessory_driver
     ):
         """Test toggle_accessory returns False when no toggle_action."""
         # Create config without toggle_action
@@ -305,6 +323,7 @@ class TestHomekitService:
             homekit_config=homekit_config,
             conson_config=conson_config,
             telegram_service=mock_telegram_service,
+            accessory_driver=mock_accessory_driver,
         ).toggle_accessory("a")
 
         assert result is False
@@ -633,7 +652,7 @@ class TestHomekitService:
         mock_protocol.on_connection_made.disconnect.assert_called_once()
 
     def test_accessory_not_in_config(
-        self, mock_protocol, conson_config, mock_telegram_service
+        self, mock_protocol, conson_config, mock_telegram_service, mock_accessory_driver
     ):
         """Test service handles missing accessory config gracefully."""
         homekit_config = HomekitConfig(
@@ -649,12 +668,15 @@ class TestHomekitService:
             homekit_config=homekit_config,
             conson_config=conson_config,
             telegram_service=mock_telegram_service,
+            accessory_driver=mock_accessory_driver,
         )
 
         # Should handle gracefully with empty states
         assert len(service.accessory_states) == 0
 
-    def test_module_not_in_config(self, mock_protocol, mock_telegram_service):
+    def test_module_not_in_config(
+        self, mock_protocol, mock_telegram_service, mock_accessory_driver
+    ):
         """Test service handles missing module config gracefully."""
         homekit_config = HomekitConfig(
             bridge=BridgeConfig(
@@ -682,6 +704,7 @@ class TestHomekitService:
             homekit_config=homekit_config,
             conson_config=conson_config,
             telegram_service=mock_telegram_service,
+            accessory_driver=mock_accessory_driver,
         )
 
         # Should handle gracefully with empty states

{conson_xp-1.51.1 → conson_xp-1.52.0}/tests/unit/test_tui/test_homekit_app.py

@@ -1,6 +1,6 @@
 """Unit tests for HomekitApp."""
 
-from unittest.mock import Mock
+from unittest.mock import AsyncMock, Mock
 
 import pytest
 
@@ -115,10 +115,12 @@ class TestHomekitApp:
 
         mock_service.toggle_accessory.assert_not_called()
 
-    def test_on_unmount_cleanup(self, app, mock_service):
-        """Test on_unmount calls service cleanup."""
-        app.on_unmount()
-        mock_service.cleanup.assert_called_once()
+    @pytest.mark.asyncio
+    async def test_on_unmount_cleanup(self, app, mock_service):
+        """Test on_unmount calls service stop."""
+        mock_service.stop = AsyncMock()
+        await app.on_unmount()
+        mock_service.stop.assert_called_once()
 
     def test_refresh_last_update_column_with_widget(self, app, mock_service):
         """Test _refresh_last_update_column calls widget method."""