conson-xp 1.18.0__tar.gz → 1.19.0__tar.gz

{conson_xp-1.18.0 → conson_xp-1.19.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: conson-xp
-Version: 1.18.0
+Version: 1.19.0
 Summary: XP Protocol Communication Tools
 Author-Email: ldvchosal <ldvchosal@github.com>
 License: MIT License
@@ -306,6 +306,7 @@ xp conbus datapoint query
 xp conbus discover
 
 xp conbus event
+xp conbus event list
 xp conbus event raw
 
 

{conson_xp-1.18.0 → conson_xp-1.19.0}/README.md

@@ -254,6 +254,7 @@ xp conbus datapoint query
 xp conbus discover
 
 xp conbus event
+xp conbus event list
 xp conbus event raw
 
 

{conson_xp-1.18.0 → conson_xp-1.19.0}/pyproject.toml

@@ -21,7 +21,7 @@ dependencies = [
 ]
 requires-python = ">=3.11"
 readme = "README.md"
-version = "1.18.0"
+version = "1.19.0"
 
 [project.license]
 file = "LICENSE"

{conson_xp-1.18.0 → conson_xp-1.19.0}/src/xp/__init__.py

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

{conson_xp-1.18.0 → conson_xp-1.19.0}/src/xp/cli/commands/conbus/conbus_event_commands.py

@@ -8,6 +8,7 @@ from xp.cli.commands.conbus.conbus import conbus
 from xp.cli.utils.decorators import connection_command
 from xp.cli.utils.module_type_choice import MODULE_TYPE
 from xp.models import ConbusEventRawResponse
+from xp.services.conbus.conbus_event_list_service import ConbusEventListService
 from xp.services.conbus.conbus_event_raw_service import ConbusEventRawService
 
 
@@ -17,6 +18,30 @@ def conbus_event() -> None:
     pass
 
 
+@conbus_event.command("list")
+@click.pass_context
+def list_events(ctx: click.Context) -> None:
+    r"""List configured event telegrams from module action tables.
+
+    Reads conson.yml configuration, parses action tables, and groups
+    modules by their event keys to show which modules are assigned to
+    each event (button configuration).
+
+    Output is sorted by module count (most frequently used events first).
+
+    Args:
+        ctx: Click context object.
+
+    Examples:
+        \b
+        xp conbus event list
+    """
+    service: ConbusEventListService = (
+        ctx.obj.get("container").get_container().resolve(ConbusEventListService)
+    )
+    click.echo(json.dumps(service.list_events().to_dict(), indent=2))
+
+
 @conbus_event.command("raw")
 @click.argument("module_type", type=MODULE_TYPE)
 @click.argument("link_number", type=click.IntRange(0, 99))

{conson_xp-1.18.0 → conson_xp-1.19.0}/src/xp/models/__init__.py

@@ -5,6 +5,7 @@ from xp.models.conbus.conbus_client_config import ConbusClientConfig
 from xp.models.conbus.conbus_connection_status import ConbusConnectionStatus
 from xp.models.conbus.conbus_datapoint import ConbusDatapointResponse
 from xp.models.conbus.conbus_discover import ConbusDiscoverResponse
+from xp.models.conbus.conbus_event_list import ConbusEventListResponse
 from xp.models.conbus.conbus_event_raw import ConbusEventRawResponse
 from xp.models.log_entry import LogEntry
 from xp.models.telegram.event_telegram import EventTelegram
@@ -31,6 +32,7 @@ __all__ = [
     "ConbusResponse",
     "ConbusDatapointResponse",
     "ConbusDiscoverResponse",
+    "ConbusEventListResponse",
     "ConbusEventRawResponse",
     "ConbusConnectionStatus",
 ]

conson_xp-1.19.0/src/xp/models/conbus/conbus_event_list.py

@@ -0,0 +1,34 @@
+"""Conbus event list response model."""
+
+from dataclasses import dataclass
+from datetime import datetime
+from typing import Any, Dict, Optional
+
+
+@dataclass
+class ConbusEventListResponse:
+    """Represents a response from Conbus event list operation.
+
+    Attributes:
+        events: Dict mapping event keys to list of module names.
+        timestamp: Timestamp of the response.
+    """
+
+    events: Dict[str, list[str]]
+    timestamp: Optional[datetime] = None
+
+    def __post_init__(self) -> None:
+        """Initialize timestamp if not provided."""
+        if self.timestamp is None:
+            self.timestamp = datetime.now()
+
+    def to_dict(self) -> Dict[str, Any]:
+        """Convert to dictionary for JSON serialization.
+
+        Returns:
+            Dictionary representation of the response.
+        """
+        return {
+            "events": self.events,
+            "timestamp": self.timestamp.isoformat() if self.timestamp else None,
+        }

conson_xp-1.19.0/src/xp/services/conbus/conbus_event_list_service.py

@@ -0,0 +1,91 @@
+"""Conbus Event List Service for listing configured event telegrams.
+
+This service parses action tables from conson.yml and groups events
+by button configuration to show which modules are assigned to each event.
+"""
+
+import logging
+from collections import defaultdict
+from typing import Dict, List
+
+from xp.models import ConbusEventListResponse
+from xp.models.homekit.homekit_conson_config import ConsonModuleListConfig
+from xp.services.actiontable.actiontable_serializer import ActionTableSerializer
+
+
+class ConbusEventListService:
+    """Service for listing configured event telegrams from action tables.
+
+    Parses action tables from conson.yml configuration and groups modules
+    by their event keys to identify common button configurations.
+
+    Attributes:
+        conson_config: Configuration containing module action tables.
+        logger: Logger instance for the service.
+    """
+
+    def __init__(self, conson_config: ConsonModuleListConfig) -> None:
+        """Initialize the Conbus event list service.
+
+        Args:
+            conson_config: ConsonModuleListConfig instance with module action tables.
+        """
+        self.conson_config = conson_config
+        self.logger = logging.getLogger(__name__)
+
+    def list_events(self) -> ConbusEventListResponse:
+        """List all configured events from module action tables.
+
+        Parses action tables, extracts event information (module_type, link, input),
+        groups modules by event key, and sorts by usage count.
+
+        Returns:
+            ConbusEventListResponse with events dict mapping event keys to module names.
+        """
+        # Dict to track which modules are assigned to each event
+        # event_key -> set of module names (using set for automatic deduplication)
+        event_modules: Dict[str, set[str]] = defaultdict(set)
+
+        # Process each module's action table
+        for module in self.conson_config.root:
+            # Skip modules without action table
+            if not module.action_table:
+                continue
+
+            # Process each action in the module's action table
+            for action in module.action_table:
+                try:
+                    # Use existing ActionTableSerializer to parse action
+                    entry = ActionTableSerializer.parse_action_string(action)
+
+                    # Extract event data from parsed entry
+                    module_type_name = entry.module_type.name
+                    link = entry.link_number
+                    input_num = entry.module_input
+
+                    # Create event key (space-separated format)
+                    event_key = f"{module_type_name} {link:02d} {input_num:02d}"
+
+                    # Add this module to the event (set automatically deduplicates)
+                    event_modules[event_key].add(
+                        f"{module.serial_number}:{entry.module_output}"
+                    )
+
+                except ValueError as e:
+                    # Invalid action format - log warning and skip
+                    self.logger.warning(
+                        f"Invalid action '{action}' in module '{module.serial_number}': {e}"
+                    )
+                    continue
+
+        # Convert sets to sorted lists and sort events by module count (descending)
+        events_dict: Dict[str, List[str]] = {
+            event_key: sorted(list(modules))
+            for event_key, modules in sorted(
+                event_modules.items(),
+                key=lambda item: len(item[1]),
+                reverse=True,
+            )
+        }
+
+        return ConbusEventListResponse(events=events_dict)

{conson_xp-1.18.0 → conson_xp-1.19.0}/src/xp/utils/dependencies.py

@@ -43,6 +43,7 @@ from xp.services.conbus.conbus_datapoint_service import (
     ConbusDatapointService,
 )
 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_output_service import ConbusOutputService
 from xp.services.conbus.conbus_raw_service import ConbusRawService
@@ -189,6 +190,14 @@ class ServiceContainer:
             scope=punq.Scope.singleton,
         )
 
+        self.container.register(
+            ConbusEventListService,
+            factory=lambda: ConbusEventListService(
+                conson_config=self.container.resolve(ConsonModuleListConfig)
+            ),
+            scope=punq.Scope.singleton,
+        )
+
         self.container.register(
             ConbusBlinkService,
             factory=lambda: ConbusBlinkService(

conson_xp-1.19.0/tests/unit/test_services/test_conbus_event_list_service.py

@@ -0,0 +1,272 @@
+"""Unit tests for ConbusEventListService."""
+
+import pytest
+
+from xp.models.homekit.homekit_conson_config import (
+    ConsonModuleConfig,
+    ConsonModuleListConfig,
+)
+from xp.services.conbus.conbus_event_list_service import ConbusEventListService
+
+
+class TestConbusEventListService:
+    """Unit tests for ConbusEventListService functionality."""
+
+    @pytest.fixture
+    def empty_config(self):
+        """Create empty config with no modules."""
+        return ConsonModuleListConfig(root=[])
+
+    @pytest.fixture
+    def single_module_config(self):
+        """Create config with single module and one action."""
+        module = ConsonModuleConfig(
+            name="A1",
+            serial_number="0012345001",
+            module_type="XP20",
+            module_type_code=33,
+            link_number=0,
+            action_table=["XP20 10 0 > 0 OFF"],
+        )
+        return ConsonModuleListConfig(root=[module])
+
+    @pytest.fixture
+    def multiple_modules_same_event_config(self):
+        """Create config with multiple modules sharing same event."""
+        module1 = ConsonModuleConfig(
+            name="A1",
+            serial_number="0012345001",
+            module_type="XP20",
+            module_type_code=33,
+            link_number=0,
+            action_table=["XP20 10 0 > 0 OFF"],
+        )
+        module2 = ConsonModuleConfig(
+            name="A2",
+            serial_number="0012345002",
+            module_type="XP20",
+            module_type_code=33,
+            link_number=0,
+            action_table=["XP20 10 0 > 1 ON"],
+        )
+        module3 = ConsonModuleConfig(
+            name="A3",
+            serial_number="0012345003",
+            module_type="XP20",
+            module_type_code=33,
+            link_number=0,
+            action_table=["XP20 10 0 > 2 OFF"],
+        )
+        return ConsonModuleListConfig(root=[module1, module2, module3])
+
+    @pytest.fixture
+    def duplicate_actions_config(self):
+        """Create config with duplicate actions in same module."""
+        module = ConsonModuleConfig(
+            name="A1",
+            serial_number="0012345001",
+            module_type="XP20",
+            module_type_code=33,
+            link_number=0,
+            action_table=[
+                "XP20 10 0 > 0 OFF",
+                "XP20 10 0 > 1 OFF",
+                "XP20 10 0 > 2 OFF",
+            ],
+        )
+        return ConsonModuleListConfig(root=[module])
+
+    @pytest.fixture
+    def invalid_action_config(self):
+        """Create config with invalid action format."""
+        module = ConsonModuleConfig(
+            name="A1",
+            serial_number="0012345001",
+            module_type="XP20",
+            module_type_code=33,
+            link_number=0,
+            action_table=[
+                "XP20 10 0 > 0 OFF",  # Valid
+                "INVALID ACTION FORMAT",  # Invalid
+                "XP20 10 8 > 0 ON",  # Valid
+            ],
+        )
+        return ConsonModuleListConfig(root=[module])
+
+    @pytest.fixture
+    def empty_action_table_config(self):
+        """Create config with module having empty action table."""
+        module1 = ConsonModuleConfig(
+            name="A1",
+            serial_number="0012345001",
+            module_type="XP20",
+            module_type_code=33,
+            link_number=0,
+            action_table=[],
+        )
+        module2 = ConsonModuleConfig(
+            name="A2",
+            serial_number="0012345002",
+            module_type="XP20",
+            module_type_code=33,
+            link_number=0,
+            action_table=["XP20 10 0 > 0 OFF"],
+        )
+        return ConsonModuleListConfig(root=[module1, module2])
+
+    @pytest.fixture
+    def sorting_config(self):
+        """Create config for testing sorting by module count."""
+        # Event XP20 10 00 has 3 modules
+        module1 = ConsonModuleConfig(
+            name="A1",
+            serial_number="0012345001",
+            module_type="XP20",
+            module_type_code=33,
+            link_number=0,
+            action_table=["XP20 10 0 > 0 OFF"],
+        )
+        module2 = ConsonModuleConfig(
+            name="A2",
+            serial_number="0012345002",
+            module_type="XP20",
+            module_type_code=33,
+            link_number=0,
+            action_table=["XP20 10 0 > 1 ON"],
+        )
+        module3 = ConsonModuleConfig(
+            name="A3",
+            serial_number="0012345003",
+            module_type="XP20",
+            module_type_code=33,
+            link_number=0,
+            action_table=["XP20 10 0 > 2 OFF"],
+        )
+        # Event XP20 10 08 has 2 modules
+        module4 = ConsonModuleConfig(
+            name="A4",
+            serial_number="0012345004",
+            module_type="XP20",
+            module_type_code=33,
+            link_number=0,
+            action_table=["XP20 10 8 > 0 ON"],
+        )
+        module5 = ConsonModuleConfig(
+            name="A5",
+            serial_number="0012345005",
+            module_type="XP20",
+            module_type_code=33,
+            link_number=0,
+            action_table=["XP20 10 8 > 1 OFF"],
+        )
+        # Event CP20 00 00 has 1 module
+        module6 = ConsonModuleConfig(
+            name="A6",
+            serial_number="0012345006",
+            module_type="CP20",
+            module_type_code=2,
+            link_number=0,
+            action_table=["CP20 0 0 > 0 OFF"],
+        )
+        return ConsonModuleListConfig(
+            root=[module1, module2, module3, module4, module5, module6]
+        )
+
+    def test_empty_config(self, empty_config):
+        """Test with empty configuration (no modules)."""
+        response = ConbusEventListService(conson_config=empty_config).list_events()
+
+        assert response.events == {}
+        assert response.timestamp is not None
+
+    def test_single_module(self, single_module_config):
+        """Test with single module and one action."""
+        response = ConbusEventListService(
+            conson_config=single_module_config
+        ).list_events()
+
+        assert len(response.events) == 1
+        assert "XP20 10 00" in response.events
+        assert response.events["XP20 10 00"] == ["0012345001:0"]
+
+    def test_multiple_modules_same_event(self, multiple_modules_same_event_config):
+        """Test multiple modules sharing same event."""
+        response = ConbusEventListService(
+            conson_config=multiple_modules_same_event_config
+        ).list_events()
+
+        assert len(response.events) == 1
+        assert "XP20 10 00" in response.events
+        assert sorted(response.events["XP20 10 00"]) == [
+            "0012345001:0",
+            "0012345002:1",
+            "0012345003:2",
+        ]
+
+    def test_duplicate_actions_deduplication(self, duplicate_actions_config):
+        """Test that duplicate actions in same module are deduplicated."""
+        response = ConbusEventListService(
+            conson_config=duplicate_actions_config
+        ).list_events()
+
+        assert len(response.events) == 1
+        assert "XP20 10 00" in response.events
+        assert response.events["XP20 10 00"] == [
+            "0012345001:0",
+            "0012345001:1",
+            "0012345001:2",
+        ]  # Only once, not three times
+
+    def test_invalid_action_format(self, invalid_action_config, caplog):
+        """Test that invalid actions are skipped with warning."""
+        response = ConbusEventListService(
+            conson_config=invalid_action_config
+        ).list_events()
+
+        # Should have 2 valid events
+        assert len(response.events) == 2
+        assert "XP20 10 00" in response.events
+        assert "XP20 10 08" in response.events
+
+        # Should have logged warning about invalid action
+        assert "Invalid action" in caplog.text
+        assert "INVALID ACTION FORMAT" in caplog.text
+
+    def test_empty_action_table(self, empty_action_table_config):
+        """Test that modules with empty action table are silently skipped."""
+        response = ConbusEventListService(
+            conson_config=empty_action_table_config
+        ).list_events()
+
+        # Only A2 should be in result (A1 has empty action_table)
+        assert len(response.events) == 1
+        assert "XP20 10 00" in response.events
+        assert response.events["XP20 10 00"] == ["0012345002:0"]
+
+    def test_sorting_by_module_count(self, sorting_config):
+        """Test that events are sorted by module count (descending)."""
+        response = ConbusEventListService(conson_config=sorting_config).list_events()
+
+        # Get events in order
+        event_keys = list(response.events.keys())
+
+        # Should be sorted by count: XP20 10 00 (3), XP20 10 08 (2), CP20 00 00 (1)
+        assert event_keys[0] == "XP20 10 00"
+        assert len(response.events[event_keys[0]]) == 3
+        assert event_keys[1] == "XP20 10 08"
+        assert len(response.events[event_keys[1]]) == 2
+        assert event_keys[2] == "CP20 00 00"
+        assert len(response.events[event_keys[2]]) == 1
+
+    def test_to_dict_serialization(self, single_module_config):
+        """Test that response can be serialized to dict."""
+        result_dict = (
+            ConbusEventListService(conson_config=single_module_config)
+            .list_events()
+            .to_dict()
+        )
+
+        assert "events" in result_dict
+        assert "timestamp" in result_dict
+        assert isinstance(result_dict["events"], dict)
+        assert isinstance(result_dict["timestamp"], str)  # ISO format

{conson_xp-1.18.0 → conson_xp-1.19.0}/tests/unit/test_services/test_telegram_service.py

@@ -383,6 +383,25 @@ class TestReplyTelegramParsing:
         assert "Timestamp:" in summary
         assert "Checksum: IL" in summary
 
+    def test_parse_actiontable_reply_telegram(self):
+        """Test parsing an actiontable reply telegram (F17).
+
+        This tests a real actiontable telegram received from a module.
+        The F17 function code indicates ACTIONTABLE data response.
+        """
+        raw = "<R0020042796F17DAAAADDBAAABAAADDBAAABBAADDBAAABCAADDBAAIAIAADDBAAIAJAA>"
+        result = self.service.parse_reply_telegram(raw)
+
+        assert isinstance(result, ReplyTelegram)
+        assert result.serial_number == "0020042796"
+        assert result.system_function == SystemFunction.ACTIONTABLE
+        assert result.data == "AA"
+        assert result.data_value == "AADDBAAABAAADDBAAABBAADDBAAABCAADDBAAIAIAADDBAAIAJ"
+        assert result.checksum == "AA"
+        assert not result.checksum_validated
+        assert result.raw_telegram == raw
+        assert result.timestamp is not None
+
 
 class TestAutoDetectTelegramParsing:
     """Test cases for auto-detect telegram parsing in TelegramService."""