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

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: conson-xp
-Version: 1.16.0
+Version: 1.17.0
 Summary: XP Protocol Communication Tools
 Author-Email: ldvchosal <ldvchosal@github.com>
 License: MIT License
@@ -305,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.16.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.16.0 → conson_xp-1.17.0}/pyproject.toml

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

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

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

{conson_xp-1.16.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.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.16.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.17.0/src/xp/services/conbus/conbus_event_raw_service.py

@@ -0,0 +1,185 @@
+"""Conbus Event Raw Service for sending raw event telegrams.
+
+This service implements a TCP client that connects to Conbus servers and sends
+raw event telegrams to simulate button presses on Conbus modules.
+"""
+
+import logging
+from typing import Callable, Optional
+
+from twisted.internet.base import DelayedCall
+
+from xp.models import ConbusEventRawResponse
+from xp.models.protocol.conbus_protocol import TelegramReceivedEvent
+from xp.services.protocol.conbus_event_protocol import ConbusEventProtocol
+
+
+class ConbusEventRawService:
+    """Service for sending raw event telegrams to Conbus servers.
+
+    Uses ConbusEventProtocol to send MAKE/BREAK event sequences to
+    simulate button presses on Conbus modules.
+
+    Attributes:
+        conbus_protocol: Protocol instance for Conbus communication.
+    """
+
+    conbus_protocol: ConbusEventProtocol
+
+    def __init__(self, conbus_protocol: ConbusEventProtocol) -> None:
+        """Initialize the Conbus event raw service.
+
+        Args:
+            conbus_protocol: ConbusEventProtocol instance.
+        """
+        self.progress_callback: Optional[Callable[[str], None]] = None
+        self.finish_callback: Optional[Callable[[ConbusEventRawResponse], 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.event_result = ConbusEventRawResponse(success=False)
+        self.logger = logging.getLogger(__name__)
+
+        # Event parameters
+        self.module_type_code: int = 0
+        self.link_number: int = 0
+        self.input_number: int = 0
+        self.time_ms: int = 1000
+        self.break_event_call: Optional[DelayedCall] = None
+
+    def connection_made(self) -> None:
+        """Handle connection established event."""
+        self.logger.debug("Connection established")
+        self.logger.debug("Sending MAKE event telegram")
+        self._send_make_event()
+
+    def _send_make_event(self) -> None:
+        """Send MAKE event telegram."""
+        payload = f"E{self.module_type_code:02d}L{self.link_number:02d}I{self.input_number:02d}M"
+        self.logger.debug(f"Sending MAKE event: {payload}")
+        self.conbus_protocol.telegram_queue.put_nowait(payload.encode())
+        self.conbus_protocol._reactor.callLater(
+            0.0, self.conbus_protocol.start_queue_manager
+        )
+
+        # Schedule BREAK event after delay
+        delay_seconds = self.time_ms / 1000.0
+        self.break_event_call = self.conbus_protocol._reactor.callLater(
+            delay_seconds, self._send_break_event
+        )
+
+    def _send_break_event(self) -> None:
+        """Send BREAK event telegram."""
+        payload = f"E{self.module_type_code:02d}L{self.link_number:02d}I{self.input_number:02d}B"
+        self.logger.debug(f"Sending BREAK event: {payload}")
+        self.conbus_protocol.telegram_queue.put_nowait(payload.encode())
+        self.conbus_protocol._reactor.callLater(
+            0.0, self.conbus_protocol.start_queue_manager
+        )
+
+    def telegram_sent(self, telegram_sent: str) -> None:
+        """Handle telegram sent event.
+
+        Args:
+            telegram_sent: The telegram that was sent.
+        """
+        self.logger.debug(f"Telegram sent: {telegram_sent}")
+        if self.event_result.sent_telegrams is None:
+            self.event_result.sent_telegrams = []
+        self.event_result.sent_telegrams.append(telegram_sent)
+
+    def telegram_received(self, telegram_received: TelegramReceivedEvent) -> None:
+        """Handle telegram received event.
+
+        Args:
+            telegram_received: The telegram received event.
+        """
+        self.logger.debug(f"Telegram received: {telegram_received.frame}")
+        if self.event_result.received_telegrams is None:
+            self.event_result.received_telegrams = []
+        self.event_result.received_telegrams.append(telegram_received.frame)
+
+        # Display progress - show ALL received telegrams
+        if self.progress_callback:
+            self.progress_callback(telegram_received.frame)
+
+    def timeout(self) -> None:
+        """Handle timeout event.
+
+        Timeout is the normal/expected way to finish this service.
+        """
+        timeout_seconds = self.conbus_protocol.timeout_seconds
+        self.logger.info("Event raw finished after timeout: %ss", timeout_seconds)
+        self.event_result.success = True
+        self.event_result.error = None
+        if self.finish_callback:
+            self.finish_callback(self.event_result)
+
+        self.stop_reactor()
+
+    def failed(self, message: str) -> None:
+        """Handle failed connection event.
+
+        Args:
+            message: Failure message.
+        """
+        self.logger.debug(f"Failed: {message}")
+        self.event_result.success = False
+        self.event_result.error = message
+        if self.finish_callback:
+            self.finish_callback(self.event_result)
+
+        self.stop_reactor()
+
+    def stop_reactor(self) -> None:
+        """Stop reactor."""
+        self.logger.info("Stopping reactor")
+        # Cancel break event call if it's still pending
+        if self.break_event_call and self.break_event_call.active():
+            self.break_event_call.cancel()
+        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,
+        module_type_code: int,
+        link_number: int,
+        input_number: int,
+        time_ms: int,
+        progress_callback: Optional[Callable[[str], None]],
+        finish_callback: Callable[[ConbusEventRawResponse], None],
+        timeout_seconds: int = 5,
+    ) -> None:
+        """Run reactor in dedicated thread with its own event loop.
+
+        Args:
+            module_type_code: Module type code (numeric, e.g., 2 for CP20, 33 for XP33).
+            link_number: Link number (0-99).
+            input_number: Input number (0-9).
+            time_ms: Delay in milliseconds between MAKE and BREAK events.
+            progress_callback: Callback for progress updates (received telegrams).
+            finish_callback: Callback when operation completes.
+            timeout_seconds: Timeout in seconds (default: 5).
+        """
+        self.logger.info(
+            f"Starting event raw: module={module_type_code}, "
+            f"link={link_number}, input={input_number}, time={time_ms}ms"
+        )
+
+        self.module_type_code = module_type_code
+        self.link_number = link_number
+        self.input_number = input_number
+        self.time_ms = time_ms
+
+        self.conbus_protocol.timeout_seconds = timeout_seconds
+        self.progress_callback = progress_callback
+        self.finish_callback = finish_callback

{conson_xp-1.16.0 → conson_xp-1.17.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_raw_service import ConbusEventRawService
 from xp.services.conbus.conbus_output_service import ConbusOutputService
 from xp.services.conbus.conbus_raw_service import ConbusRawService
 from xp.services.conbus.conbus_receive_service import ConbusReceiveService
@@ -180,6 +181,14 @@ class ServiceContainer:
             scope=punq.Scope.singleton,
         )
 
+        self.container.register(
+            ConbusEventRawService,
+            factory=lambda: ConbusEventRawService(
+                conbus_protocol=self.container.resolve(ConbusEventProtocol)
+            ),
+            scope=punq.Scope.singleton,
+        )
+
         self.container.register(
             ConbusBlinkService,
             factory=lambda: ConbusBlinkService(

conson_xp-1.17.0/tests/unit/test_services/test_conbus_event_raw_service.py

@@ -0,0 +1,169 @@
+"""Unit tests for ConbusEventRawService."""
+
+from unittest.mock import Mock
+
+import pytest
+
+from xp.models.protocol.conbus_protocol import TelegramReceivedEvent
+from xp.services.conbus.conbus_event_raw_service import ConbusEventRawService
+from xp.services.protocol.conbus_event_protocol import ConbusEventProtocol
+
+
+class TestConbusEventRawService:
+    """Unit tests for ConbusEventRawService functionality."""
+
+    @pytest.fixture
+    def mock_protocol(self):
+        """Create a mock ConbusEventProtocol."""
+        protocol = Mock(spec=ConbusEventProtocol)
+        protocol.on_connection_made = Mock()
+        protocol.on_telegram_sent = Mock()
+        protocol.on_telegram_received = Mock()
+        protocol.on_timeout = Mock()
+        protocol.on_failed = Mock()
+        protocol.on_connection_made.connect = Mock()
+        protocol.on_telegram_sent.connect = Mock()
+        protocol.on_telegram_received.connect = Mock()
+        protocol.on_timeout.connect = Mock()
+        protocol.on_failed.connect = Mock()
+        protocol._reactor = Mock()
+        protocol.telegram_queue = Mock()
+        protocol.timeout_seconds = 5
+        return protocol
+
+    @pytest.fixture
+    def service(self, mock_protocol):
+        """Create service instance with mock protocol."""
+        return ConbusEventRawService(conbus_protocol=mock_protocol)
+
+    def test_service_initialization(self, service):
+        """Test service can be initialized with required dependencies."""
+        assert service.module_type_code == 0
+        assert service.link_number == 0
+        assert service.input_number == 0
+        assert service.time_ms == 1000
+        assert service.finish_callback is None
+        assert service.progress_callback is None
+        assert service.event_result.success is False
+
+    def test_connection_made_sends_make_event(self, service, mock_protocol):
+        """Test connection_made sends MAKE event telegram."""
+        service.module_type_code = 2  # CP20
+        service.link_number = 10
+        service.input_number = 5
+        service.time_ms = 1000
+
+        service.connection_made()
+
+        # Verify MAKE event was queued
+        mock_protocol.telegram_queue.put_nowait.assert_called()
+        call_args = mock_protocol.telegram_queue.put_nowait.call_args[0][0]
+        assert call_args == b"E02L10I05M"
+
+        # Verify BREAK event was scheduled
+        mock_protocol._reactor.callLater.assert_called()
+
+    def test_telegram_sent(self, service):
+        """Test telegram_sent callback updates service response."""
+        telegram = "<E02L10I05MAK>"
+
+        service.telegram_sent(telegram)
+
+        assert service.event_result.sent_telegrams == [telegram]
+
+    def test_telegram_received(self, service, mock_protocol):
+        """Test telegram_received callback updates service response."""
+        telegram_event = TelegramReceivedEvent(
+            protocol=mock_protocol,
+            frame="<E02L10I05MAK>",
+            telegram="E02L10I05MAK",
+            payload="E02L10I05M",
+            telegram_type="E",
+            serial_number="",
+            checksum="AK",
+            checksum_valid=True,
+        )
+
+        service.telegram_received(telegram_event)
+
+        assert service.event_result.received_telegrams == ["<E02L10I05MAK>"]
+
+    def test_telegram_received_with_progress_callback(self, service, mock_protocol):
+        """Test telegram_received calls progress callback."""
+        progress_mock = Mock()
+        service.progress_callback = progress_mock
+
+        telegram_event = TelegramReceivedEvent(
+            protocol=mock_protocol,
+            frame="<E02L10I05MAK>",
+            telegram="E02L10I05MAK",
+            payload="E02L10I05M",
+            telegram_type="E",
+            serial_number="",
+            checksum="AK",
+            checksum_valid=True,
+        )
+
+        service.telegram_received(telegram_event)
+
+        progress_mock.assert_called_once_with("<E02L10I05MAK>")
+
+    def test_timeout(self, service, mock_protocol):
+        """Test timeout callback marks operation as successful."""
+        finish_mock = Mock()
+        service.finish_callback = finish_mock
+
+        service.timeout()
+
+        assert service.event_result.success is True
+        assert service.event_result.error is None
+        finish_mock.assert_called_once_with(service.event_result)
+        mock_protocol.stop_reactor.assert_called_once()
+
+    def test_failed(self, service, mock_protocol):
+        """Test failed callback updates service response."""
+        finish_mock = Mock()
+        service.finish_callback = finish_mock
+
+        service.failed("Connection timeout")
+
+        assert service.event_result.success is False
+        assert service.event_result.error == "Connection timeout"
+        finish_mock.assert_called_once_with(service.event_result)
+        mock_protocol.stop_reactor.assert_called_once()
+
+    def test_run(self, service, mock_protocol):
+        """Test run method sets up service parameters."""
+        finish_mock = Mock()
+        progress_mock = Mock()
+
+        service.run(
+            module_type_code=33,  # XP33
+            link_number=15,
+            input_number=8,
+            time_ms=500,
+            progress_callback=progress_mock,
+            finish_callback=finish_mock,
+            timeout_seconds=10,
+        )
+
+        assert service.module_type_code == 33
+        assert service.link_number == 15
+        assert service.input_number == 8
+        assert service.time_ms == 500
+        assert service.progress_callback == progress_mock
+        assert service.finish_callback == finish_mock
+        assert mock_protocol.timeout_seconds == 10
+
+    def test_send_break_event(self, service, mock_protocol):
+        """Test _send_break_event sends BREAK event telegram."""
+        service.module_type_code = 2  # CP20
+        service.link_number = 10
+        service.input_number = 5
+
+        service._send_break_event()
+
+        # Verify BREAK event was queued
+        mock_protocol.telegram_queue.put_nowait.assert_called()
+        call_args = mock_protocol.telegram_queue.put_nowait.call_args[0][0]
+        assert call_args == b"E02L10I05B"