conson-xp 1.35.0__tar.gz → 1.36.0__tar.gz

{conson_xp-1.35.0 → conson_xp-1.36.0}/PKG-INFO

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

{conson_xp-1.35.0 → conson_xp-1.36.0}/pyproject.toml

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

{conson_xp-1.35.0 → conson_xp-1.36.0}/src/xp/__init__.py

@@ -3,7 +3,7 @@
 conson-xp package.
 """
 
-__version__ = "1.35.0"
+__version__ = "1.36.0"
 __manufacturer__ = "salchichon"
 __model__ = "xp.cli"
 __serial__ = "2025.09.23.000"

{conson_xp-1.35.0 → conson_xp-1.36.0}/src/xp/services/term/state_monitor_service.py

@@ -321,7 +321,7 @@ class StateMonitorService:
 
         Args:
             module_state: Module state to update.
-            output_number: Output number (0-3 for XP24).
+            output_number: Output number (0-3 for XP24, 0-2 for XP33 modules).
             output_state: True for ON, False for OFF.
         """
         # Parse existing outputs string "0 1 0 0" → [0, 1, 0, 0]
@@ -340,8 +340,9 @@ class StateMonitorService:
     def _handle_event_telegram(self, event: TelegramReceivedEvent) -> None:
         """Handle event telegram for output state changes.
 
-        Processes XP24 output event telegrams to update module state in real-time.
-        Output events use input_number field with values 80-83 to represent outputs 0-3.
+        Processes XP24 and XP33 output event telegrams to update module state in real-time.
+        - XP24 output events use input_number 80-83 to represent outputs 0-3.
+        - XP33 output events use input_number 0-2 to represent channels 0-2.
 
         Args:
             event: Telegram received event containing event telegram.
@@ -352,17 +353,37 @@ class StateMonitorService:
             self.logger.debug("Failed to parse event telegram")
             return
 
-        # Only process XP24 output events
-        if event_telegram.module_type != ModuleTypeCode.XP24.value:
-            self.logger.debug(
-                f"Ignoring event from module type {event_telegram.module_type}"
-            )
-            return
+        # Determine output number based on module type
+        output_number = None
+
+        if event_telegram.module_type == ModuleTypeCode.XP24.value:
+            # XP24 uses input_number 80-83 for outputs 0-3
+            if 80 <= event_telegram.input_number <= 83:
+                output_number = event_telegram.input_number - 80
+            else:
+                self.logger.debug(
+                    f"Ignoring XP24 input event I{event_telegram.input_number:02d}"
+                )
+                return
 
-        # Validate output number range (80-83 for XP24 outputs 0-3)
-        if not (80 <= event_telegram.input_number <= 83):
+        elif event_telegram.module_type in (
+            ModuleTypeCode.XP33.value,
+            ModuleTypeCode.XP33LR.value,
+            ModuleTypeCode.XP33LED.value,
+        ):
+            # XP33 modules use input_number 0-2 for channels 0-2
+            if 80 <= event_telegram.input_number <= 82:
+                output_number = event_telegram.input_number - 80
+            else:
+                self.logger.debug(
+                    f"Ignoring XP33 input event I{event_telegram.input_number:02d}"
+                )
+                return
+
+        else:
+            # Ignore events from other module types
             self.logger.debug(
-                f"Ignoring input event I{event_telegram.input_number:02d}"
+                f"Ignoring event from module type {event_telegram.module_type}"
             )
             return
 
@@ -374,9 +395,8 @@ class StateMonitorService:
             )
             return
 
-        # Convert input_number to output_number (80→0, 81→1, 82→2, 83→3)
-        output_number = event_telegram.input_number - 80
-        output_state = event_telegram.is_button_press  # M=True, B=False
+        # Determine output state (M=True/ON, B=False/OFF)
+        output_state = event_telegram.is_button_press
 
         # Update output state
         self._update_output_bit(module_state, output_number, output_state)

{conson_xp-1.35.0 → conson_xp-1.36.0}/src/xp/term/widgets/modules_list.py

@@ -111,7 +111,9 @@ class ModulesListWidget(Static):
             # Update existing row
             row_key = self._row_keys[serial_number]
             self.table.update_cell(
-                row_key, "outputs", self._format_outputs(module_state.outputs)
+                row_key,
+                "outputs",
+                Text(self._format_outputs(module_state.outputs), justify="right"),
             )
             self.table.update_cell(
                 row_key,
@@ -144,7 +146,7 @@ class ModulesListWidget(Static):
             Text(str(module_state.link_number), justify="right"),
             module_state.serial_number,
             module_state.module_type,
-            self._format_outputs(module_state.outputs),
+            Text(self._format_outputs(module_state.outputs), justify="right"),
             Text(self._format_report(module_state.auto_report), justify="center"),
             module_state.error_status,
             Text(self._format_last_update(module_state.last_update), justify="center"),

{conson_xp-1.35.0 → conson_xp-1.36.0}/tests/unit/test_services/test_state_monitor_service.py

@@ -84,6 +84,22 @@ class TestStateMonitorService:
                     link_number=5,
                     auto_report_status="NN",
                 ),
+                ConsonModuleConfig(
+                    name="A03",
+                    serial_number="1111111111",
+                    module_type="XP33LR",
+                    module_type_code=30,
+                    link_number=3,
+                    auto_report_status="PP",
+                ),
+                ConsonModuleConfig(
+                    name="A04",
+                    serial_number="2222222222",
+                    module_type="XP33LED",
+                    module_type_code=35,
+                    link_number=4,
+                    auto_report_status="PP",
+                ),
             ]
         )
 
@@ -107,7 +123,7 @@ class TestStateMonitorService:
 
     def test_initialization(self, service):
         """Test service initializes module states from config."""
-        assert len(service.module_states) == 2
+        assert len(service.module_states) == 4
 
         # Check first module (XP24)
         xp24_state = next(m for m in service.module_states if m.name == "A01")
@@ -123,6 +139,20 @@ class TestStateMonitorService:
         assert xp130_state.link_number == 5
         assert xp130_state.auto_report is False
 
+        # Check third module (XP33LR)
+        xp33lr_state = next(m for m in service.module_states if m.name == "A03")
+        assert xp33lr_state.serial_number == "1111111111"
+        assert xp33lr_state.module_type == "XP33LR"
+        assert xp33lr_state.link_number == 3
+        assert xp33lr_state.auto_report is True
+
+        # Check fourth module (XP33LED)
+        xp33led_state = next(m for m in service.module_states if m.name == "A04")
+        assert xp33led_state.serial_number == "2222222222"
+        assert xp33led_state.module_type == "XP33LED"
+        assert xp33led_state.link_number == 4
+        assert xp33led_state.auto_report is True
+
     def test_find_module_by_link_found(self, service):
         """Test _find_module_by_link returns module when found."""
         module = service._find_module_by_link(9)
@@ -362,3 +392,122 @@ class TestStateMonitorService:
 
         # Verify parse_reply_telegram was called
         mock_telegram_service.parse_reply_telegram.assert_called_once()
+
+    def test_handle_event_telegram_xp33lr_channel_on(
+        self, service, mock_telegram_service, mock_protocol
+    ):
+        """Test _handle_event_telegram processes XP33LR channel ON event."""
+        # Mock event telegram for XP33LR L03 channel 0 ON
+        event_telegram = EventTelegram(
+            raw_telegram="<E30L03I80MAE>",
+            checksum="AE",
+            checksum_validated=True,
+            event_telegram_type="E",
+            module_type=30,  # XP33LR
+            link_number=3,
+            input_number=80,  # Channel 0 (I80)
+            event_type=EventType.BUTTON_PRESS,
+        )
+        mock_telegram_service.parse_event_telegram.return_value = event_telegram
+
+        # Setup module initial state
+        module = service._find_module_by_link(3)
+        module.outputs = "0 0 0"
+
+        # Mock signal to verify emission
+        signal_handler = Mock()
+        service.on_module_state_changed.connect(signal_handler)
+
+        # Create event
+        event = self._make_event(mock_protocol, "<E30L03I80MAE>", "E")
+
+        # Process event
+        service._handle_event_telegram(event)
+
+        # Verify output updated
+        assert module.outputs == "1 0 0"
+        assert module.last_update is not None
+        signal_handler.assert_called_once()
+
+    def test_handle_event_telegram_xp33lr_channel_off(
+        self, service, mock_telegram_service, mock_protocol
+    ):
+        """Test _handle_event_telegram processes XP33LR channel OFF event."""
+        # Mock event telegram for XP33LR L03 channel 1 OFF
+        event_telegram = EventTelegram(
+            raw_telegram="<E30L03I81BAE>",
+            checksum="AE",
+            checksum_validated=True,
+            event_telegram_type="E",
+            module_type=30,  # XP33LR
+            link_number=3,
+            input_number=81,  # Channel 1 (I81)
+            event_type=EventType.BUTTON_RELEASE,
+        )
+        mock_telegram_service.parse_event_telegram.return_value = event_telegram
+
+        module = service._find_module_by_link(3)
+        module.outputs = "1 1 1"
+
+        event = self._make_event(mock_protocol, "<E30L03I81BAE>", "E")
+
+        service._handle_event_telegram(event)
+        assert module.outputs == "1 0 1"
+
+    def test_handle_event_telegram_xp33led_channel_on(
+        self, service, mock_telegram_service, mock_protocol
+    ):
+        """Test _handle_event_telegram processes XP33LED channel ON event."""
+        # Mock event telegram for XP33LED L04 channel 2 ON
+        event_telegram = EventTelegram(
+            raw_telegram="<E35L04I82MAE>",
+            checksum="AE",
+            checksum_validated=True,
+            event_telegram_type="E",
+            module_type=35,  # XP33LED
+            link_number=4,
+            input_number=82,  # Channel 2 (I82)
+            event_type=EventType.BUTTON_PRESS,
+        )
+        mock_telegram_service.parse_event_telegram.return_value = event_telegram
+
+        # Setup module initial state
+        module = service._find_module_by_link(4)
+        module.outputs = "0 0 0"
+
+        # Create event
+        event = self._make_event(mock_protocol, "<E35L04I82MAE>", "E")
+
+        # Process event
+        service._handle_event_telegram(event)
+
+        # Verify output updated
+        assert module.outputs == "0 0 1"
+        assert module.last_update is not None
+
+    def test_handle_event_telegram_xp33_ignores_invalid_channel(
+        self, service, mock_telegram_service, mock_protocol
+    ):
+        """Test _handle_event_telegram ignores XP33 events for invalid channels."""
+        # Mock event telegram for XP33LR with invalid channel number
+        event_telegram = EventTelegram(
+            raw_telegram="<E30L03I05MAE>",
+            checksum="AE",
+            checksum_validated=True,
+            event_telegram_type="E",
+            module_type=30,  # XP33LR
+            link_number=3,
+            input_number=5,  # Invalid channel (only 0-2 valid)
+            event_type=EventType.BUTTON_PRESS,
+        )
+        mock_telegram_service.parse_event_telegram.return_value = event_telegram
+
+        module = service._find_module_by_link(3)
+        module.outputs = "0 0 0"
+
+        event = self._make_event(mock_protocol, "<E30L03I05MAE>", "E")
+
+        service._handle_event_telegram(event)
+
+        # Output should not change
+        assert module.outputs == "0 0 0"