conson-xp 1.18.0__py3-none-any.whl

xp/cli/commands/conbus/conbus_blink_commands.py

@@ -0,0 +1,163 @@
+"""Conbus client operations CLI commands."""
+
+import json
+
+import click
+from click import Context
+
+from xp.cli.commands.conbus.conbus import conbus_blink
+from xp.cli.utils.decorators import (
+    connection_command,
+    handle_service_errors,
+)
+from xp.cli.utils.serial_number_type import SERIAL
+from xp.models.conbus.conbus_blink import ConbusBlinkResponse
+from xp.services.conbus.conbus_blink_all_service import ConbusBlinkAllService
+from xp.services.conbus.conbus_blink_service import ConbusBlinkService
+from xp.services.telegram.telegram_blink_service import BlinkError
+
+
+@conbus_blink.command("on", short_help="Blink on remote service")
+@click.argument("serial_number", type=SERIAL)
+@click.pass_context
+@connection_command()
+@handle_service_errors(BlinkError)
+def send_blink_on_telegram(ctx: Context, serial_number: str) -> None:
+    r"""Send blink command to start blinking module LED.
+
+    Args:
+        ctx: Click context object.
+        serial_number: 10-digit module serial number.
+
+    Examples:
+        \b
+        xp conbus blink on 0012345008
+    """
+
+    def on_finish(service_response: ConbusBlinkResponse) -> None:
+        """Handle successful completion of blink on command.
+
+        Args:
+            service_response: Blink response object.
+        """
+        click.echo(json.dumps(service_response.to_dict(), indent=2))
+
+    service: ConbusBlinkService = (
+        ctx.obj.get("container").get_container().resolve(ConbusBlinkService)
+    )
+    with service:
+        service.send_blink_telegram(serial_number, "on", on_finish, 0.5)
+
+
+@conbus_blink.command("off")
+@click.argument("serial_number", type=SERIAL)
+@click.pass_context
+@connection_command()
+@handle_service_errors(BlinkError)
+def send_blink_off_telegram(ctx: Context, serial_number: str) -> None:
+    r"""Send blink command to stop blinking module LED.
+
+    Args:
+        ctx: Click context object.
+        serial_number: 10-digit module serial number.
+
+    Examples:
+        \b
+        xp conbus blink off 0012345008
+    """
+
+    def on_finish(service_response: ConbusBlinkResponse) -> None:
+        """Handle successful completion of blink off command.
+
+        Args:
+            service_response: Blink response object.
+        """
+        click.echo(json.dumps(service_response.to_dict(), indent=2))
+
+    service: ConbusBlinkService = (
+        ctx.obj.get("container").get_container().resolve(ConbusBlinkService)
+    )
+    with service:
+        service.send_blink_telegram(serial_number, "off", on_finish, 0.5)
+
+
+@conbus_blink.group("all", short_help="Control blink state for all devices")
+def conbus_blink_all() -> None:
+    """Control blink state for all discovered devices."""
+    pass
+
+
+@conbus_blink_all.command("off", short_help="Turn off blinking for all devices")
+@click.pass_context
+@connection_command()
+@handle_service_errors(BlinkError)
+def blink_all_off(ctx: Context) -> None:
+    r"""Turn off blinking for all discovered devices.
+
+    Args:
+        ctx: Click context object.
+
+    Examples:
+        \b
+        xp conbus blink all off
+    """
+
+    def on_finish(discovered_devices: ConbusBlinkResponse) -> None:
+        """Handle successful completion of blink all off command.
+
+        Args:
+            discovered_devices: Blink response with all devices.
+        """
+        click.echo(json.dumps(discovered_devices.to_dict(), indent=2))
+
+    def progress(message: str) -> None:
+        """Handle progress updates during blink all off operation.
+
+        Args:
+            message: Progress message string.
+        """
+        click.echo(message)
+
+    service: ConbusBlinkAllService = (
+        ctx.obj.get("container").get_container().resolve(ConbusBlinkAllService)
+    )
+    with service:
+        service.send_blink_all_telegram("off", progress, on_finish, 0.5)
+
+
+@conbus_blink_all.command("on", short_help="Turn on blinking for all devices")
+@click.pass_context
+@connection_command()
+@handle_service_errors(BlinkError)
+def blink_all_on(ctx: Context) -> None:
+    r"""Turn on blinking for all discovered devices.
+
+    Args:
+        ctx: Click context object.
+
+    Examples:
+        \b
+        xp conbus blink all on
+    """
+
+    def on_finish(discovered_devices: ConbusBlinkResponse) -> None:
+        """Handle successful completion of blink all on command.
+
+        Args:
+            discovered_devices: Blink response with all devices.
+        """
+        click.echo(json.dumps(discovered_devices.to_dict(), indent=2))
+
+    def progress(message: str) -> None:
+        """Handle progress updates during blink all on operation.
+
+        Args:
+            message: Progress message string.
+        """
+        click.echo(message)
+
+    service: ConbusBlinkAllService = (
+        ctx.obj.get("container").get_container().resolve(ConbusBlinkAllService)
+    )
+    with service:
+        service.send_blink_all_telegram("on", progress, on_finish, 0.5)

xp/cli/commands/conbus/conbus_config_commands.py

@@ -0,0 +1,29 @@
+"""Conbus configuration CLI commands."""
+
+import json
+
+import click
+from click import Context
+
+from xp.cli.commands.conbus.conbus import conbus
+from xp.cli.utils.decorators import handle_service_errors
+from xp.models import ConbusClientConfig
+
+
+@conbus.command("config")
+@click.pass_context
+@handle_service_errors(Exception)
+def show_config(ctx: Context) -> None:
+    r"""Display current Conbus client configuration.
+
+    Args:
+        ctx: Click context object.
+
+    Examples:
+        \b
+        xp conbus config
+    """
+    config: ConbusClientConfig = (
+        ctx.obj.get("container").get_container().resolve(ConbusClientConfig)
+    )
+    click.echo(json.dumps(config.conbus.model_dump(mode="json"), indent=2))

xp/cli/commands/conbus/conbus_custom_commands.py

@@ -0,0 +1,57 @@
+"""Conbus client operations CLI commands."""
+
+import json
+
+import click
+from click import Context
+
+from xp.cli.commands.conbus.conbus import conbus
+from xp.cli.utils.decorators import (
+    connection_command,
+)
+from xp.cli.utils.serial_number_type import SERIAL
+from xp.models.conbus.conbus_custom import ConbusCustomResponse
+from xp.services.conbus.conbus_custom_service import ConbusCustomService
+
+
+@conbus.command("custom")
+@click.argument("serial_number", type=SERIAL)
+@click.argument("function_code")
+@click.argument("datapoint_code")
+@click.pass_context
+@connection_command()
+def send_custom_telegram(
+    ctx: Context, serial_number: str, function_code: str, datapoint_code: str
+) -> None:
+    r"""Send custom telegram with specified function and data point codes.
+
+    Args:
+        ctx: Click context object.
+        serial_number: 10-digit module serial number.
+        function_code: Function code.
+        datapoint_code: Data point code.
+
+    Examples:
+        \b
+        xp conbus custom 0012345011 02 E2
+        xp conbus custom 0012345011 17 AA
+    """
+    service: ConbusCustomService = (
+        ctx.obj.get("container").get_container().resolve(ConbusCustomService)
+    )
+
+    def on_finish(service_response: "ConbusCustomResponse") -> None:
+        """Handle successful completion of custom telegram.
+
+        Args:
+            service_response: Custom response object.
+        """
+        click.echo(json.dumps(service_response.to_dict(), indent=2))
+
+    with service:
+        service.send_custom_telegram(
+            serial_number=serial_number,
+            function_code=function_code,
+            data=datapoint_code,
+            finish_callback=on_finish,
+        )

xp/cli/commands/conbus/conbus_datapoint_commands.py

@@ -0,0 +1,113 @@
+"""Conbus client operations CLI commands."""
+
+import json
+
+import click
+from click import Context
+
+from xp.cli.commands.conbus.conbus import conbus_datapoint
+
+# Import will be handled by conbus.py registration
+from xp.cli.utils.datapoint_type_choice import DATAPOINT
+from xp.cli.utils.decorators import (
+    connection_command,
+)
+from xp.cli.utils.serial_number_type import SERIAL
+from xp.models.conbus.conbus_datapoint import ConbusDatapointResponse
+from xp.models.telegram.datapoint_type import DataPointType
+from xp.models.telegram.reply_telegram import ReplyTelegram
+from xp.services.conbus.conbus_datapoint_queryall_service import (
+    ConbusDatapointQueryAllService,
+)
+from xp.services.conbus.conbus_datapoint_service import (
+    ConbusDatapointService,
+)
+
+
+@click.command("query")
+@click.argument("datapoint", type=DATAPOINT)
+@click.argument("serial_number", type=SERIAL)
+@click.pass_context
+@connection_command()
+def query_datapoint(ctx: Context, serial_number: str, datapoint: DataPointType) -> None:
+    r"""Query a specific datapoint from Conbus server.
+
+    Args:
+        ctx: Click context object.
+        serial_number: 10-digit module serial number.
+        datapoint: Datapoint type to query.
+
+    Examples:
+        \b
+        xp conbus datapoint query version 0012345011
+        xp conbus datapoint query voltage 0012345011
+        xp conbus datapoint query temperature 0012345011
+        xp conbus datapoint query current 0012345011
+        xp conbus datapoint query humidity 0012345011
+    """
+    service: ConbusDatapointService = (
+        ctx.obj.get("container").get_container().resolve(ConbusDatapointService)
+    )
+
+    def on_finish(service_response: ConbusDatapointResponse) -> None:
+        """Handle successful completion of datapoint query.
+
+        Args:
+            service_response: Datapoint response object.
+        """
+        click.echo(json.dumps(service_response.to_dict(), indent=2))
+
+    # Send telegram
+    with service:
+        service.query_datapoint(
+            serial_number=serial_number,
+            datapoint_type=datapoint,
+            finish_callback=on_finish,
+        )
+
+
+# Add the single datapoint query command to the group
+conbus_datapoint.add_command(query_datapoint)
+
+
+@conbus_datapoint.command("all", short_help="Query all datapoints from a module")
+@click.argument("serial_number", type=SERIAL)
+@click.pass_context
+@connection_command()
+def query_all_datapoints(ctx: Context, serial_number: str) -> None:
+    r"""Query all datapoints from a specific module.
+
+    Args:
+        ctx: Click context object.
+        serial_number: 10-digit module serial number.
+
+    Examples:
+        \b
+        xp conbus datapoint all 0123450001
+    """
+    service: ConbusDatapointQueryAllService = (
+        ctx.obj.get("container").get_container().resolve(ConbusDatapointQueryAllService)
+    )
+
+    def on_finish(service_response: ConbusDatapointResponse) -> None:
+        """Handle successful completion of all datapoints query.
+
+        Args:
+            service_response: Datapoint response object with all datapoints.
+        """
+        click.echo(json.dumps(service_response.to_dict(), indent=2))
+
+    def on_progress(reply_telegram: ReplyTelegram) -> None:
+        """Handle progress updates during all datapoints query.
+
+        Args:
+            reply_telegram: Reply telegram object with progress data.
+        """
+        click.echo(json.dumps(reply_telegram.to_dict(), indent=2))
+
+    with service:
+        service.query_all_datapoints(
+            serial_number=serial_number,
+            finish_callback=on_finish,
+            progress_callback=on_progress,
+        )

xp/cli/commands/conbus/conbus_discover_commands.py

@@ -0,0 +1,61 @@
+"""Conbus client 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 ConbusDiscoverResponse
+from xp.models.conbus.conbus_discover import DiscoveredDevice
+from xp.services.conbus.conbus_discover_service import (
+    ConbusDiscoverService,
+)
+
+
+@conbus.command("discover")
+@click.pass_context
+@connection_command()
+def send_discover_telegram(ctx: click.Context) -> None:
+    r"""Send discover telegram to Conbus server.
+
+    Args:
+        ctx: Click context object.
+
+    Examples:
+        \b
+        xp conbus discover
+    """
+
+    def on_finish(discovered_devices: ConbusDiscoverResponse) -> None:
+        """Handle successful completion of device discovery.
+
+        Args:
+            discovered_devices: Discover response with all found devices.
+        """
+        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.
+
+        Args:
+            _serial_number: Serial number of discovered device (unused).
+        """
+        # click.echo(f"Discovered : {serial_number}")
+        pass
+
+    service: ConbusDiscoverService = (
+        ctx.obj.get("container").get_container().resolve(ConbusDiscoverService)
+    )
+    service.run(progress, on_device_discovered, on_finish, 5)
+    service.start_reactor()

xp/cli/commands/conbus/conbus_event_commands.py

@@ -0,0 +1,81 @@
+"""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.cli.utils.module_type_choice import MODULE_TYPE
+from xp.models import ConbusEventRawResponse
+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=MODULE_TYPE)
+@click.argument("link_number", type=click.IntRange(0, 99))
+@click.argument("input_number", type=click.IntRange(0, 9))
+@click.argument("time_ms", type=click.IntRange(min=1), default=1000)
+@click.pass_context
+@connection_command()
+def send_event_raw(
+    ctx: click.Context,
+    module_type: int,
+    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
+    """
+
+    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,
+        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)