conson-xp 1.15.0__tar.gz → 1.17.0__tar.gz

{conson_xp-1.15.0 → conson_xp-1.17.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: conson-xp
-Version: 1.15.0
+Version: 1.17.0
 Summary: XP Protocol Communication Tools
 Author-Email: ldvchosal <ldvchosal@github.com>
 License: MIT License
@@ -47,6 +47,7 @@ Requires-Dist: HAP-python[QRCode]>=5.0.0
 Requires-Dist: punq>=0.7.0
 Requires-Dist: twisted>=25.5.0
 Requires-Dist: bubus>=1.5.6
+Requires-Dist: psygnal>=0.15.0
 Description-Content-Type: text/markdown
 
 # 🔌 XP Protocol Communication Tool
@@ -304,6 +305,10 @@ xp conbus datapoint query
 
 xp conbus discover
 
+xp conbus event
+xp conbus event raw
+
+
 xp conbus lightlevel
 xp conbus lightlevel get
 xp conbus lightlevel off

{conson_xp-1.15.0 → conson_xp-1.17.0}/README.md

@@ -253,6 +253,10 @@ xp conbus datapoint query
 
 xp conbus discover
 
+xp conbus event
+xp conbus event raw
+
+
 xp conbus lightlevel
 xp conbus lightlevel get
 xp conbus lightlevel off

{conson_xp-1.15.0 → conson_xp-1.17.0}/pyproject.toml

@@ -17,10 +17,11 @@ dependencies = [
     "punq>=0.7.0",
     "twisted>=25.5.0",
     "bubus>=1.5.6",
+    "psygnal>=0.15.0",
 ]
 requires-python = ">=3.11"
 readme = "README.md"
-version = "1.15.0"
+version = "1.17.0"
 
 [project.license]
 file = "LICENSE"

{conson_xp-1.15.0 → conson_xp-1.17.0}/src/xp/__init__.py

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

{conson_xp-1.15.0 → conson_xp-1.17.0}/src/xp/cli/commands/__init__.py

@@ -37,6 +37,7 @@ from xp.cli.commands.conbus.conbus_datapoint_commands import (
     query_datapoint,
 )
 from xp.cli.commands.conbus.conbus_discover_commands import send_discover_telegram
+from xp.cli.commands.conbus.conbus_event_commands import conbus_event, send_event_raw
 from xp.cli.commands.conbus.conbus_lightlevel_commands import (
     xp_lightlevel_get,
     xp_lightlevel_off,
@@ -97,6 +98,7 @@ __all__ = [
     "conbus_lightlevel",
     "conbus_msactiontable",
     "conbus_actiontable",
+    "conbus_event",
     "file",
     "module",
     "reverse_proxy",
@@ -118,6 +120,7 @@ __all__ = [
     "show_config",
     "send_custom_telegram",
     "send_discover_telegram",
+    "send_event_raw",
     "xp_output_on",
     "xp_output_off",
     "xp_output_status",

{conson_xp-1.15.0 → conson_xp-1.17.0}/src/xp/cli/commands/conbus/conbus_discover_commands.py

@@ -9,6 +9,7 @@ from xp.cli.utils.decorators import (
     connection_command,
 )
 from xp.models import ConbusDiscoverResponse
+from xp.models.conbus.conbus_discover import DiscoveredDevice
 from xp.services.conbus.conbus_discover_service import (
     ConbusDiscoverService,
 )
@@ -36,6 +37,14 @@ def send_discover_telegram(ctx: click.Context) -> None:
         """
         click.echo(json.dumps(discovered_devices.to_dict(), indent=2))
 
+    def on_device_discovered(discovered_device: DiscoveredDevice) -> None:
+        """Handle discovery of sa single module.
+
+        Args:
+            discovered_device: Discover device.
+        """
+        click.echo(json.dumps(discovered_device, indent=2))
+
     def progress(_serial_number: str) -> None:
         """Handle progress updates during device discovery.
 
@@ -48,5 +57,5 @@ def send_discover_telegram(ctx: click.Context) -> None:
     service: ConbusDiscoverService = (
         ctx.obj.get("container").get_container().resolve(ConbusDiscoverService)
     )
-    with service:
-        service.start(progress, on_finish, 0.5)
+    service.run(progress, on_device_discovered, on_finish, 5)
+    service.start_reactor()

conson_xp-1.17.0/src/xp/cli/commands/conbus/conbus_event_commands.py

@@ -0,0 +1,115 @@
+"""Conbus event operations CLI commands."""
+
+import json
+
+import click
+
+from xp.cli.commands.conbus.conbus import conbus
+from xp.cli.utils.decorators import connection_command
+from xp.models import ConbusEventRawResponse
+from xp.models.telegram.module_type_code import ModuleTypeCode
+from xp.services.conbus.conbus_event_raw_service import ConbusEventRawService
+
+
+@click.group(name="event")
+def conbus_event() -> None:
+    """Send event telegrams to Conbus modules."""
+    pass
+
+
+@conbus_event.command("raw")
+@click.argument("module_type", type=str)
+@click.argument("link_number", type=int)
+@click.argument("input_number", type=int)
+@click.argument("time_ms", type=int, default=1000)
+@click.pass_context
+@connection_command()
+def send_event_raw(
+    ctx: click.Context,
+    module_type: str,
+    link_number: int,
+    input_number: int,
+    time_ms: int,
+) -> None:
+    r"""Send raw event telegrams to simulate button presses.
+
+    Args:
+        ctx: Click context object.
+        module_type: Module type code (e.g., CP20, XP33).
+        link_number: Link number (0-99).
+        input_number: Input number (0-9).
+        time_ms: Delay between MAKE/BREAK events in milliseconds (default: 1000).
+
+    Examples:
+        \b
+        xp conbus event raw CP20 00 00
+        xp conbus event raw XP33 00 00 500
+    """
+    # Validate parameters
+    if link_number < 0 or link_number > 99:
+        click.echo(
+            json.dumps({"error": "Link number must be between 0 and 99"}, indent=2)
+        )
+        return
+
+    if input_number < 0 or input_number > 9:
+        click.echo(
+            json.dumps({"error": "Input number must be between 0 and 9"}, indent=2)
+        )
+        return
+
+    if time_ms <= 0:
+        click.echo(json.dumps({"error": "Time must be greater than 0"}, indent=2))
+        return
+
+    # Resolve module type to numeric code
+    module_type_code: int = 0
+    try:
+        # Try to get the enum value by name
+        module_type_enum = ModuleTypeCode[module_type.upper()]
+        module_type_code = module_type_enum.value
+    except KeyError:
+        # Module type not found
+        click.echo(
+            json.dumps(
+                {
+                    "error": f"Unknown module type: {module_type}. Use module types like CP20, XP33, XP24, etc."
+                },
+                indent=2,
+            )
+        )
+        return
+
+    def on_finish(response: ConbusEventRawResponse) -> None:
+        """Handle successful completion of event raw operation.
+
+        Args:
+            response: Event raw response with sent and received telegrams.
+        """
+        click.echo(json.dumps(response.to_dict(), indent=2))
+
+    def on_progress(telegram: str) -> None:
+        """Handle progress updates during event operation.
+
+        Args:
+            telegram: Received telegram.
+        """
+        click.echo(json.dumps({"telegram": telegram}))
+
+    service: ConbusEventRawService = (
+        ctx.obj.get("container").get_container().resolve(ConbusEventRawService)
+    )
+    service.run(
+        module_type_code=module_type_code,
+        link_number=link_number,
+        input_number=input_number,
+        time_ms=time_ms,
+        progress_callback=on_progress,
+        finish_callback=on_finish,
+        timeout_seconds=5,
+    )
+    service.start_reactor()
+
+
+# Register the event command group with conbus
+conbus.add_command(conbus_event)

{conson_xp-1.15.0 → conson_xp-1.17.0}/src/xp/cli/main.py

@@ -56,7 +56,7 @@ def cli(ctx: click.Context) -> None:
 
     # xp
     logging.getLogger("xp").setLevel(logging.DEBUG)
-    logging.getLogger("xp.services.homekit").setLevel(logging.WARNING)
+    logging.getLogger("xp.services.homekit").setLevel(logging.DEBUG)
 
     # pyhap
     logging.getLogger("pyhap").setLevel(logging.WARNING)

{conson_xp-1.15.0 → conson_xp-1.17.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_raw import ConbusEventRawResponse
 from xp.models.log_entry import LogEntry
 from xp.models.telegram.event_telegram import EventTelegram
 from xp.models.telegram.event_type import EventType
@@ -30,5 +31,6 @@ __all__ = [
     "ConbusResponse",
     "ConbusDatapointResponse",
     "ConbusDiscoverResponse",
+    "ConbusEventRawResponse",
     "ConbusConnectionStatus",
 ]

conson_xp-1.17.0/src/xp/models/conbus/conbus_event_raw.py

@@ -0,0 +1,47 @@
+"""Conbus event raw response model."""
+
+from dataclasses import dataclass
+from datetime import datetime
+from typing import Any, Dict, Optional
+
+
+@dataclass
+class ConbusEventRawResponse:
+    """Represents a response from Conbus event raw operation.
+
+    Attributes:
+        success: Whether the operation was successful.
+        sent_telegrams: List of event telegrams sent (MAKE and BREAK).
+        received_telegrams: List of all telegrams received.
+        error: Error message if operation failed.
+        timestamp: Timestamp of the response.
+    """
+
+    success: bool
+    sent_telegrams: Optional[list[str]] = None
+    received_telegrams: Optional[list[str]] = None
+    error: Optional[str] = None
+    timestamp: Optional[datetime] = None
+
+    def __post_init__(self) -> None:
+        """Initialize timestamp and telegram lists if not provided."""
+        if self.timestamp is None:
+            self.timestamp = datetime.now()
+        if self.sent_telegrams is None:
+            self.sent_telegrams = []
+        if self.received_telegrams is None:
+            self.received_telegrams = []
+
+    def to_dict(self) -> Dict[str, Any]:
+        """Convert to dictionary for JSON serialization.
+
+        Returns:
+            Dictionary representation of the response.
+        """
+        return {
+            "success": self.success,
+            "sent_telegrams": self.sent_telegrams,
+            "received_telegrams": self.received_telegrams,
+            "error": self.error,
+            "timestamp": self.timestamp.isoformat() if self.timestamp else None,
+        }

{conson_xp-1.15.0 → conson_xp-1.17.0}/src/xp/models/protocol/conbus_protocol.py

@@ -12,6 +12,7 @@ from xp.models.homekit.homekit_conson_config import ConsonModuleConfig
 from xp.models.telegram.datapoint_type import DataPointType
 
 if TYPE_CHECKING:
+    from xp.services.protocol.conbus_event_protocol import ConbusEventProtocol
     from xp.services.protocol.conbus_protocol import ConbusProtocol
     from xp.services.protocol.telegram_protocol import TelegramProtocol
 
@@ -249,7 +250,7 @@ class TelegramEvent(BaseEvent):
         checksum_valid: Checksum valid true or false.
     """
 
-    protocol: Union[TelegramProtocol, ConbusProtocol] = Field(
+    protocol: Union[TelegramProtocol, ConbusProtocol, ConbusEventProtocol] = Field(
         description="TelegramProtocol instance"
     )
     frame: str = Field(description="Frame <S0123450001F02D12FK>")

{conson_xp-1.15.0 → conson_xp-1.17.0}/src/xp/services/conbus/conbus_datapoint_service.py

@@ -130,6 +130,7 @@ class ConbusDatapointService(ConbusProtocol):
         self.service_response.data_value = datapoint_telegram.data_value
         if self.datapoint_finished_callback:
             self.datapoint_finished_callback(self.service_response)
+        self._stop_reactor()
 
     def failed(self, message: str) -> None:
         """Handle failed connection event.

{conson_xp-1.15.0 → conson_xp-1.17.0}/src/xp/services/conbus/conbus_discover_service.py

@@ -7,49 +7,57 @@ discover telegrams to find modules on the network.
 import logging
 from typing import Callable, Optional
 
-from twisted.internet.posixbase import PosixReactorBase
-
-from xp.models import ConbusClientConfig, ConbusDiscoverResponse
+from xp.models import ConbusDiscoverResponse
 from xp.models.conbus.conbus_discover import DiscoveredDevice
 from xp.models.protocol.conbus_protocol import TelegramReceivedEvent
 from xp.models.telegram.datapoint_type import DataPointType
 from xp.models.telegram.module_type_code import MODULE_TYPE_REGISTRY
 from xp.models.telegram.system_function import SystemFunction
 from xp.models.telegram.telegram_type import TelegramType
-from xp.services.protocol.conbus_protocol import ConbusProtocol
+from xp.services.protocol.conbus_event_protocol import ConbusEventProtocol
 
 
-class ConbusDiscoverService(ConbusProtocol):
+class ConbusDiscoverService:
     """
     Service for discovering modules on Conbus servers.
 
     Uses ConbusProtocol to provide discovery functionality for finding
     modules connected to the Conbus network.
+
+    Attributes:
+        conbus_protocol: Protocol instance for Conbus communication.
     """
 
-    def __init__(
-        self,
-        cli_config: ConbusClientConfig,
-        reactor: PosixReactorBase,
-    ) -> None:
+    conbus_protocol: ConbusEventProtocol
+
+    def __init__(self, conbus_protocol: ConbusEventProtocol) -> None:
         """Initialize the Conbus discover service.
 
         Args:
-            cli_config: Conbus client configuration.
-            reactor: Twisted reactor instance.
+            conbus_protocol: ConbusProtocol.
         """
-        super().__init__(cli_config, reactor)
         self.progress_callback: Optional[Callable[[str], None]] = None
+        self.device_discover_callback: Optional[Callable[[DiscoveredDevice], None]] = (
+            None
+        )
         self.finish_callback: Optional[Callable[[ConbusDiscoverResponse], None]] = None
 
+        self.conbus_protocol: ConbusEventProtocol = conbus_protocol
+        self.conbus_protocol.on_connection_made.connect(self.connection_made)
+        self.conbus_protocol.on_telegram_sent.connect(self.telegram_sent)
+        self.conbus_protocol.on_telegram_received.connect(self.telegram_received)
+        self.conbus_protocol.on_timeout.connect(self.timeout)
+        self.conbus_protocol.on_failed.connect(self.failed)
+
         self.discovered_device_result = ConbusDiscoverResponse(success=False)
         # Set up logging
         self.logger = logging.getLogger(__name__)
 
-    def connection_established(self) -> None:
+    def connection_made(self) -> None:
         """Handle connection established event."""
-        self.logger.debug("Connection established, sending discover telegram")
-        self.send_telegram(
+        self.logger.debug("Connection established")
+        self.logger.debug("Sending discover telegram")
+        self.conbus_protocol.send_telegram(
             telegram_type=TelegramType.SYSTEM,
             serial_number="0000000000",
             system_function=SystemFunction.DISCOVERY,
@@ -83,7 +91,7 @@ class ConbusDiscoverService(ConbusProtocol):
             and telegram_received.payload[11:16] == "F01D"
             and len(telegram_received.payload) == 15
         ):
-            self.discovered_device(telegram_received.serial_number)
+            self.handle_discovered_device(telegram_received.serial_number)
 
         # Check for module type response (F02D07)
         elif (
@@ -109,7 +117,7 @@ class ConbusDiscoverService(ConbusProtocol):
         else:
             self.logger.debug("Not a discover or module type response")
 
-    def discovered_device(self, serial_number: str) -> None:
+    def handle_discovered_device(self, serial_number: str) -> None:
         """Handle discovered device event.
 
         Args:
@@ -128,22 +136,17 @@ class ConbusDiscoverService(ConbusProtocol):
         }
         self.discovered_device_result.discovered_devices.append(device)
 
+        if self.device_discover_callback:
+            self.device_discover_callback(device)
+
         # Send READ_DATAPOINT telegram to query module type
         self.logger.debug(f"Sending module type query for {serial_number}")
-        self.send_telegram(
+        self.conbus_protocol.send_telegram(
             telegram_type=TelegramType.SYSTEM,
             serial_number=serial_number,
             system_function=SystemFunction.READ_DATAPOINT,
             data_value=DataPointType.MODULE_TYPE.value,
         )
-
-        self.send_telegram(
-            telegram_type=TelegramType.SYSTEM,
-            serial_number=serial_number,
-            system_function=SystemFunction.READ_DATAPOINT,
-            data_value=DataPointType.MODULE_TYPE_CODE.value,
-        )
-
         if self.progress_callback:
             self.progress_callback(serial_number)
 
@@ -190,11 +193,27 @@ class ConbusDiscoverService(ConbusProtocol):
                 if device["serial_number"] == serial_number:
                     device["module_type_code"] = code
                     device["module_type_name"] = module_type_name
+
+                    if self.device_discover_callback:
+                        self.device_discover_callback(device)
+
                     self.logger.debug(
                         f"Updated device {serial_number} with module_type {module_type_name}"
                     )
                     break
 
+        if self.discovered_device_result.discovered_devices:
+            for device in self.discovered_device_result.discovered_devices:
+                if not (
+                    device["serial_number"]
+                    and device["module_type"]
+                    and device["module_type_code"]
+                    and device["module_type_name"]
+                ):
+                    return
+
+        self.succeed()
+
     def handle_module_type_response(self, serial_number: str, module_type: str) -> None:
         """Handle module type response and update discovered device.
 
@@ -212,19 +231,28 @@ class ConbusDiscoverService(ConbusProtocol):
                     self.logger.debug(
                         f"Updated device {serial_number} with module_type {module_type}"
                     )
+                    if self.device_discover_callback:
+                        self.device_discover_callback(device)
+
                     break
 
-    def timeout(self) -> bool:
-        """Handle timeout event to stop discovery.
+        self.conbus_protocol.send_telegram(
+            telegram_type=TelegramType.SYSTEM,
+            serial_number=serial_number,
+            system_function=SystemFunction.READ_DATAPOINT,
+            data_value=DataPointType.MODULE_TYPE_CODE.value,
+        )
 
-        Returns:
-            False to stop the reactor.
-        """
-        self.logger.info("Discovery stopped after: %ss", self.timeout_seconds)
-        self.discovered_device_result.success = True
+    def timeout(self) -> None:
+        """Handle timeout event to stop discovery."""
+        timeout = self.conbus_protocol.timeout_seconds
+        self.logger.info("Discovery stopped after: %ss", timeout)
+        self.discovered_device_result.success = False
+        self.discovered_device_result.error = "Discovered device timeout"
         if self.finish_callback:
             self.finish_callback(self.discovered_device_result)
-        return False
+
+        self.stop_reactor()
 
     def failed(self, message: str) -> None:
         """Handle failed connection event.
@@ -238,9 +266,32 @@ class ConbusDiscoverService(ConbusProtocol):
         if self.finish_callback:
             self.finish_callback(self.discovered_device_result)
 
-    def start(
+        self.stop_reactor()
+
+    def succeed(self) -> None:
+        """Handle discovered device success event."""
+        self.logger.debug("Succeed")
+        self.discovered_device_result.success = True
+        self.discovered_device_result.error = None
+        if self.finish_callback:
+            self.finish_callback(self.discovered_device_result)
+
+        self.stop_reactor()
+
+    def stop_reactor(self) -> None:
+        """Stop reactor."""
+        self.logger.info("Stopping reactor")
+        self.conbus_protocol.stop_reactor()
+
+    def start_reactor(self) -> None:
+        """Start reactor."""
+        self.logger.info("Starting reactor")
+        self.conbus_protocol.start_reactor()
+
+    def run(
         self,
         progress_callback: Callable[[str], None],
+        device_discover_callback: Callable[[DiscoveredDevice], None],
         finish_callback: Callable[[ConbusDiscoverResponse], None],
         timeout_seconds: Optional[float] = None,
     ) -> None:
@@ -248,12 +299,14 @@ class ConbusDiscoverService(ConbusProtocol):
 
         Args:
             progress_callback: Callback for each discovered device.
+            device_discover_callback: Callback for each discovered device.
             finish_callback: Callback when discovery completes.
             timeout_seconds: Optional timeout in seconds.
         """
         self.logger.info("Starting discovery")
+
         if timeout_seconds:
-            self.timeout_seconds = timeout_seconds
+            self.conbus_protocol.timeout_seconds = timeout_seconds
         self.progress_callback = progress_callback
+        self.device_discover_callback = device_discover_callback
         self.finish_callback = finish_callback
-        self.start_reactor()