conson-xp 2.0.2__tar.gz → 2.0.4__tar.gz

{conson_xp-2.0.2 → conson_xp-2.0.4}/PKG-INFO

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

{conson_xp-2.0.2 → conson_xp-2.0.4}/pyproject.toml

@@ -22,7 +22,7 @@ dependencies = [
 ]
 requires-python = ">=3.11"
 readme = "README.md"
-version = "2.0.2"
+version = "2.0.4"
 
 [project.license]
 file = "LICENSE"

{conson_xp-2.0.2 → conson_xp-2.0.4}/src/xp/__init__.py

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

{conson_xp-2.0.2 → conson_xp-2.0.4}/src/xp/cli/commands/conbus/conbus_raw_commands.py

@@ -14,25 +14,24 @@ from xp.services.conbus.conbus_raw_service import ConbusRawService
 
 
 @conbus.command("raw")
-@click.argument("raw_telegrams")
+@click.argument("telegrams", nargs=-1, required=True)
 @click.pass_context
 @connection_command()
-def send_raw_telegrams(ctx: Context, raw_telegrams: str) -> None:
+def send_raw_telegrams(ctx: Context, telegrams: tuple[str, ...]) -> None:
     r"""
     Send raw telegram sequence to Conbus server.
 
-    Accepts a string containing one or more telegrams in format <...>.
-    Multiple telegrams should be concatenated without separators.
+    Accepts one or more telegrams in format S2113010000F02D (without <> nor CHECKSUM) as separate arguments.
 
     Args:
         ctx: Click context object.
-        raw_telegrams: Raw telegram string(s).
+        telegrams: Raw telegram string(s).
 
     Examples:
         \b
-        xp conbus raw '<S2113010000F02D12>'
-        xp conbus raw '<S2113010000F02D12><S2113010001F02D12><S2113010002F02D12>'
-        xp conbus raw '<S0012345003F02D12FM>...<S0012345009F02D12FF>'
+        xp conbus raw 'S2113010000F02D'
+        xp conbus raw 'S2113010000F02D' 'S2113010001F02D'
+        xp conbus raw 'S0012345003F02D12F' 'S0012345009F02D12'
     """
     service: ConbusRawService = (
         ctx.obj.get("container").get_container().resolve(ConbusRawService)
@@ -62,8 +61,8 @@ def send_raw_telegrams(ctx: Context, raw_telegrams: str) -> None:
         service.on_progress.connect(on_progress)
         service.on_finish.connect(on_finish)
         # Setup
-        service.send_raw_telegram(
-            raw_input=raw_telegrams,
+        service.send_raw_telegrams(
+            telegrams=list(telegrams),
             timeout_seconds=5.0,
         )
         # Start (blocks until completion)

{conson_xp-2.0.2 → conson_xp-2.0.4}/src/xp/services/conbus/conbus_raw_service.py

@@ -51,7 +51,7 @@ class ConbusRawService:
         self.conbus_protocol.on_timeout.connect(self.timeout)
         self.conbus_protocol.on_failed.connect(self.failed)
 
-        self.raw_input: str = ""
+        self.telegrams: list[str] = []
         self.service_response: ConbusRawResponse = ConbusRawResponse(
             success=False,
         )
@@ -60,8 +60,11 @@ class ConbusRawService:
 
     def connection_made(self) -> None:
         """Handle connection established event."""
-        self.logger.debug(f"Connection established, sending {self.raw_input}")
-        self.conbus_protocol.send_raw_telegram(self.raw_input)
+        self.logger.debug(
+            f"Connection established, sending {len(self.telegrams)} telegrams"
+        )
+        for telegram in self.telegrams:
+            self.conbus_protocol.send_raw_telegram(telegram)
 
     def telegram_sent(self, telegram_sent: str) -> None:
         """
@@ -108,22 +111,22 @@ class ConbusRawService:
         self.service_response.error = message
         self.on_finish.emit(self.service_response)
 
-    def send_raw_telegram(
+    def send_raw_telegrams(
         self,
-        raw_input: str,
+        telegrams: list[str],
         timeout_seconds: Optional[float] = None,
     ) -> None:
         """
-        Send a raw telegram string to the Conbus server.
+        Send raw telegrams to the Conbus server.
 
         Args:
-            raw_input: Raw telegram string to send.
+            telegrams: List of raw telegram strings to send.
             timeout_seconds: Timeout in seconds.
         """
-        self.logger.info("Starting send_raw_telegram")
+        self.logger.info(f"Starting send_raw_telegrams with {len(telegrams)} telegrams")
         if timeout_seconds:
             self.conbus_protocol.timeout_seconds = timeout_seconds
-        self.raw_input = raw_input
+        self.telegrams = telegrams
 
     def set_timeout(self, timeout_seconds: float) -> None:
         """
@@ -151,7 +154,7 @@ class ConbusRawService:
         """
         # Reset state for singleton reuse
         self.service_response = ConbusRawResponse(success=False)
-        self.raw_input = ""
+        self.telegrams = []
         return self
 
     def __exit__(

{conson_xp-2.0.2 → conson_xp-2.0.4}/src/xp/services/term/homekit_accessory_driver.py

@@ -10,9 +10,18 @@ from pyhap.const import CATEGORY_LIGHTBULB, CATEGORY_OUTLET
 
 from xp.models.homekit.homekit_config import HomekitConfig
 
+# Callback type: (accessory_name, is_on, brightness_or_none)
+OnSetCallback = Callable[[str, bool, Optional[int]], None]
+
 
 class XPAccessory(Accessory):
-    """Single accessory wrapping a Conbus output."""
+    """
+    Single accessory wrapping a Conbus output.
+
+    Attributes:
+        logger: Logger instance for this accessory.
+        current_brightness: Current brightness value 0-100.
+    """
 
     def __init__(
         self,
@@ -35,12 +44,19 @@ class XPAccessory(Accessory):
         super().__init__(driver._driver, display_name, aid=aid)
         self._hk_driver = driver
         self._accessory_id = name
+        self._is_dimmable = service_type == "dimminglight"
+        self._char_brightness: Optional[object] = None
+        self._current_brightness: int = 100
         self.logger = logging.getLogger(__name__)
 
-        if service_type == "dimminglight":
+        if self._is_dimmable:
             self.category = CATEGORY_LIGHTBULB
             serv = self.add_preload_service("Lightbulb", chars=["On", "Brightness"])
-            # Note: Brightness setter_callback deferred to future update
+            self._char_brightness = serv.configure_char(
+                "Brightness",
+                setter_callback=self._set_brightness,
+                value=self._current_brightness,
+            )
         elif service_type == "outlet":
             self.category = CATEGORY_OUTLET
             serv = self.add_preload_service("Outlet")
@@ -58,16 +74,36 @@ class XPAccessory(Accessory):
             value: True for on, False for off.
         """
         if self._hk_driver._on_set:
-            self._hk_driver._on_set(self._accessory_id, value)
+            self._hk_driver._on_set(self._accessory_id, value, None)
+
+    def _set_brightness(self, value: int) -> None:
+        """
+        Handle HomeKit set brightness request.
+
+        Args:
+            value: Brightness value 0-100.
+        """
+        if self._hk_driver._on_set:
+            self._hk_driver._on_set(self._accessory_id, True, value)
+        self._current_brightness = value
 
-    def update_state(self, is_on: bool) -> None:
+    def update_state(self, is_on: bool, brightness: Optional[int] = None) -> None:
         """
         Update accessory state from Conbus event.
 
         Args:
             is_on: True if accessory is on, False otherwise.
+            brightness: Optional brightness value 0-100.
         """
         self._char_on.set_value(is_on)
+        if brightness is not None and self._char_brightness:
+            self._char_brightness.set_value(brightness)  # type: ignore[attr-defined]
+            self._current_brightness = brightness
+
+    @property
+    def current_brightness(self) -> int:
+        """Get current brightness value."""
+        return self._current_brightness
 
 
 class HomekitAccessoryDriver:
@@ -84,14 +120,15 @@ class HomekitAccessoryDriver:
         self._homekit_config = homekit_config
         self._driver: Optional[AccessoryDriver] = None
         self._accessories: Dict[str, XPAccessory] = {}
-        self._on_set: Optional[Callable[[str, bool], None]] = None
+        self._on_set: Optional[OnSetCallback] = None
 
-    def set_callback(self, on_set: Callable[[str, bool], None]) -> None:
+    def set_callback(self, on_set: OnSetCallback) -> None:
         """
         Set callback for HomeKit set events.
 
         Args:
-            on_set: Callback(accessory_name, is_on) called when HomeKit app toggles.
+            on_set: Callback(accessory_name, is_on, brightness) called when HomeKit app changes state.
+                    brightness is None for on/off only, or 0-100 for dimming.
         """
         self._on_set = on_set
 
@@ -157,15 +194,34 @@ class HomekitAccessoryDriver:
         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:
+    def update_state(
+        self, accessory_name: str, is_on: bool, brightness: Optional[int] = None
+    ) -> None:
         """
         Update accessory state from Conbus event.
 
         Args:
             accessory_name: Accessory name to update.
             is_on: True if accessory is on, False otherwise.
+            brightness: Optional brightness value 0-100.
         """
-        if acc := self._accessories.get(accessory_name):
-            acc.update_state(is_on)
+        acc = self._accessories.get(accessory_name)
+        if acc:
+            acc.update_state(is_on, brightness)
         else:
             self.logger.warning(f"Unknown accessory name: {accessory_name}")
+
+    def get_brightness(self, accessory_name: str) -> int:
+        """
+        Get current brightness for an accessory.
+
+        Args:
+            accessory_name: Accessory name.
+
+        Returns:
+            Current brightness 0-100, defaults to 100 if not found.
+        """
+        acc = self._accessories.get(accessory_name)
+        if acc:
+            return acc.current_brightness
+        return 100

{conson_xp-2.0.2 → conson_xp-2.0.4}/src/xp/services/term/homekit_service.py

@@ -300,23 +300,82 @@ class HomekitService:
         await self._accessory_driver.stop()
         self.cleanup()
 
-    def _on_homekit_set(self, accessory_name: str, is_on: bool) -> None:
+    def _on_homekit_set(
+        self, accessory_name: str, is_on: bool, brightness: Optional[int]
+    ) -> None:
         """
-        Handle HomeKit app toggle request.
+        Handle HomeKit app set request (on/off or brightness).
 
         Args:
             accessory_name: Accessory name from HomeKit.
             is_on: True for on, False for off.
+            brightness: Brightness value 0-100, or None for on/off only.
         """
         config = self._find_accessory_config(accessory_name)
-        if config:
+        if not config:
+            self.logger.warning(f"No config found for accessory: {accessory_name}")
+            return
+
+        if brightness is not None:
+            # Handle brightness change
+            self._handle_brightness_change(accessory_name, config, brightness)
+        else:
+            # Handle on/off toggle
             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'}"
             )
+
+    def _handle_brightness_change(
+        self,
+        accessory_name: str,
+        config: "HomekitAccessoryConfig",
+        target_brightness: int,
+    ) -> None:
+        """
+        Handle brightness change by sending dimup/dimdown actions.
+
+        Calculates delta from current brightness and sends appropriate
+        number of LEVELINC or LEVELDEC commands (step = 10%).
+
+        Args:
+            accessory_name: Accessory name.
+            config: Accessory configuration.
+            target_brightness: Target brightness 0-100.
+        """
+        current = self._accessory_driver.get_brightness(accessory_name)
+        delta = target_brightness - current
+
+        if delta == 0:
+            return
+
+        # Determine action and steps (10% per step)
+        step_size = 10
+        steps = abs(delta) // step_size
+
+        if delta > 0:
+            # Increase brightness
+            if not config.dimup_action:
+                self.logger.warning(f"No dimup_action for {accessory_name}")
+                return
+            action = config.dimup_action
+            direction = "+"
         else:
-            self.logger.warning(f"No config found for accessory: {accessory_name}")
+            # Decrease brightness
+            if not config.dimdown_action:
+                self.logger.warning(f"No dimdown_action for {accessory_name}")
+                return
+            action = config.dimdown_action
+            direction = "-"
+
+        # Send action for each step
+        for _ in range(steps):
+            self.send_action(action)
+
+        self.on_status_message.emit(
+            f"HomeKit: {accessory_name} {current}% → {target_brightness}% ({direction}{steps * step_size}%)"
+        )
 
     def send_action(self, action: str) -> None:
         """

{conson_xp-2.0.2 → conson_xp-2.0.4}/tests/integration/test_conbus_raw_integration.py

@@ -59,12 +59,12 @@ class TestConbusRawIntegration:
         mock_service.on_progress.connect.side_effect = mock_on_progress_connect
 
         # Make the mock service call the callback immediately
-        def mock_send_raw_telegram(raw_input, timeout_seconds=None):
+        def mock_send_raw_telegrams(telegrams, timeout_seconds=None):
             """
             Test helper function.
 
             Args:
-                raw_input: Raw telegram input.
+                telegrams: List of raw telegram inputs.
                 timeout_seconds: Timeout in seconds.
             """
             # Call the on_finish callback that was connected
@@ -76,7 +76,7 @@ class TestConbusRawIntegration:
             # Do nothing in test
             pass
 
-        mock_service.send_raw_telegram.side_effect = mock_send_raw_telegram
+        mock_service.send_raw_telegrams.side_effect = mock_send_raw_telegrams
         mock_service.start_reactor.side_effect = mock_start_reactor
 
         # Mock the container
@@ -92,7 +92,7 @@ class TestConbusRawIntegration:
         assert result.exit_code == 0
         assert '"success": true' in result.output
         assert '"received_telegrams": [' in result.output
-        mock_service.send_raw_telegram.assert_called_once()
+        mock_service.send_raw_telegrams.assert_called_once()
 
     def test_conbus_raw_multiple_telegrams(self):
         """Test conbus raw command with multiple telegrams."""
@@ -137,12 +137,12 @@ class TestConbusRawIntegration:
         mock_service.on_progress.connect.side_effect = mock_on_progress_connect
 
         # Make the mock service call the callback immediately
-        def mock_send_raw_telegram(raw_input, timeout_seconds=None):
+        def mock_send_raw_telegrams(telegrams, timeout_seconds=None):
             """
             Test helper function.
 
             Args:
-                raw_input: Raw telegram input.
+                telegrams: List of raw telegram inputs.
                 timeout_seconds: Timeout in seconds.
             """
             # Simulate progress callbacks for each received telegram
@@ -159,23 +159,30 @@ class TestConbusRawIntegration:
             # Do nothing in test
             pass
 
-        mock_service.send_raw_telegram.side_effect = mock_send_raw_telegram
+        mock_service.send_raw_telegrams.side_effect = mock_send_raw_telegrams
         mock_service.start_reactor.side_effect = mock_start_reactor
 
         # Mock the container
         mock_container = MagicMock()
         mock_container.get_container().resolve.return_value = mock_service
 
-        raw_input = "<S2113010000F02D12><S2113010001F02D12><S2113010002F02D12>"
         result = self.runner.invoke(
-            cli, ["conbus", "raw", raw_input], obj={"container": mock_container}
+            cli,
+            [
+                "conbus",
+                "raw",
+                "<S2113010000F02D12>",
+                "<S2113010001F02D12>",
+                "<S2113010002F02D12>",
+            ],
+            obj={"container": mock_container},
         )
 
         assert result.exit_code == 0
         assert "<R2113010000F02D12>" in result.output
         assert "<R2113010001F02D12>" in result.output
         assert "<S2113010002F02D12>" in result.output
-        mock_service.send_raw_telegram.assert_called_once()
+        mock_service.send_raw_telegrams.assert_called_once()
 
     def test_conbus_raw_connection_error(self):
         """Test conbus raw command with connection error."""
@@ -212,12 +219,12 @@ class TestConbusRawIntegration:
         mock_service.on_progress.connect.side_effect = mock_on_progress_connect
 
         # Make the mock service call the callback immediately
-        def mock_send_raw_telegram(raw_input, timeout_seconds=None):
+        def mock_send_raw_telegrams(telegrams, timeout_seconds=None):
             """
             Test helper function.
 
             Args:
-                raw_input: Raw telegram input.
+                telegrams: List of raw telegram inputs.
                 timeout_seconds: Timeout in seconds.
             """
             # Call the on_finish callback that was connected
@@ -229,7 +236,7 @@ class TestConbusRawIntegration:
             # Do nothing in test
             pass
 
-        mock_service.send_raw_telegram.side_effect = mock_send_raw_telegram
+        mock_service.send_raw_telegrams.side_effect = mock_send_raw_telegrams
         mock_service.start_reactor.side_effect = mock_start_reactor
 
         # Mock the container
@@ -285,12 +292,12 @@ class TestConbusRawIntegration:
         mock_service.on_progress.connect.side_effect = mock_on_progress_connect
 
         # Make the mock service call the callback immediately
-        def mock_send_raw_telegram(raw_input, timeout_seconds=None):
+        def mock_send_raw_telegrams(telegrams, timeout_seconds=None):
             """
             Test helper function.
 
             Args:
-                raw_input: Raw telegram input.
+                telegrams: List of raw telegram inputs.
                 timeout_seconds: Timeout in seconds.
             """
             # Call the on_finish callback that was connected
@@ -302,7 +309,7 @@ class TestConbusRawIntegration:
             # Do nothing in test
             pass
 
-        mock_service.send_raw_telegram.side_effect = mock_send_raw_telegram
+        mock_service.send_raw_telegrams.side_effect = mock_send_raw_telegrams
         mock_service.start_reactor.side_effect = mock_start_reactor
 
         # Mock the container
@@ -331,14 +338,14 @@ class TestConbusRawIntegration:
         output = result.output
 
         assert "Send raw telegram sequence to Conbus server" in output
-        assert "RAW_TELEGRAMS" in output
+        assert "TELEGRAMS" in output
 
     def test_conbus_raw_missing_arguments(self):
         """Test conbus raw command with missing arguments."""
         result = self.runner.invoke(cli, ["conbus", "raw"])
 
         assert result.exit_code != 0
-        assert "Usage: cli conbus raw [OPTIONS] RAW_TELEGRAMS" in result.output
+        assert "Usage: cli conbus raw [OPTIONS] TELEGRAMS" in result.output
 
     def test_conbus_raw_service_exception(self):
         """Test conbus raw command when service raises exception."""
@@ -347,8 +354,8 @@ class TestConbusRawIntegration:
         mock_service.__enter__.return_value = mock_service
         mock_service.__exit__.return_value = None
 
-        # Make the service raise an exception when send_raw_telegram is called
-        mock_service.send_raw_telegram.side_effect = Exception("Service error")
+        # Make the service raise an exception when send_raw_telegrams is called
+        mock_service.send_raw_telegrams.side_effect = Exception("Service error")
 
         # Mock the container
         mock_container = MagicMock()

{conson_xp-2.0.2 → conson_xp-2.0.4}/tests/unit/test_services/test_conbus_raw_service.py

@@ -37,7 +37,7 @@ class TestConbusRawService:
 
     def test_service_initialization(self, service, mock_conbus_protocol):
         """Test service can be initialized with required dependencies."""
-        assert service.raw_input == ""
+        assert service.telegrams == []
         assert service.service_response.success is False
         # Verify signals were connected
         assert mock_conbus_protocol.on_connection_made.connect.called
@@ -172,7 +172,7 @@ class TestConbusRawService:
     def test_context_manager_enter_resets_state(self, service):
         """Test __enter__ resets state for singleton reuse."""
         # Set some state
-        service.raw_input = "test"
+        service.telegrams = ["test"]
         service.service_response.success = True
 
         # Enter context
@@ -180,7 +180,7 @@ class TestConbusRawService:
 
         # Verify state is reset
         assert result is service
-        assert service.raw_input == ""
+        assert service.telegrams == []
         assert service.service_response.success is False
 
     def test_context_manager_exit_disconnects_signals(
@@ -208,9 +208,9 @@ class TestConbusRawService:
         mock_conbus_protocol.stop_reactor.assert_called_once()
 
     def test_connection_made(self, service, mock_conbus_protocol):
-        """Test connection_made sends raw telegram."""
-        service.raw_input = "<S2113010000F02D12>"
+        """Test connection_made sends raw telegrams."""
+        service.telegrams = ["S2113010000F02D12", "S2113010001F02D12"]
         service.connection_made()
-        mock_conbus_protocol.send_raw_telegram.assert_called_once_with(
-            "<S2113010000F02D12>"
-        )
+        assert mock_conbus_protocol.send_raw_telegram.call_count == 2
+        mock_conbus_protocol.send_raw_telegram.assert_any_call("S2113010000F02D12")
+        mock_conbus_protocol.send_raw_telegram.assert_any_call("S2113010001F02D12")