conson-xp 1.18.0__py3-none-any.whl

xp/cli/commands/conbus/conbus_raw_commands.py

@@ -0,0 +1,62 @@
+"""Conbus raw telegram 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.models.conbus.conbus_raw import ConbusRawResponse
+from xp.services.conbus.conbus_raw_service import ConbusRawService
+
+
+@conbus.command("raw")
+@click.argument("raw_telegrams")
+@click.pass_context
+@connection_command()
+def send_raw_telegrams(ctx: Context, raw_telegrams: str) -> None:
+    r"""Send raw telegram sequence to Conbus server.
+
+    Accepts a string containing one or more telegrams in format <...>.
+    Multiple telegrams should be concatenated without separators.
+
+    Args:
+        ctx: Click context object.
+        raw_telegrams: Raw telegram string(s).
+
+    Examples:
+        \b
+        xp conbus raw '<S2113010000F02D12>'
+        xp conbus raw '<S2113010000F02D12><S2113010001F02D12><S2113010002F02D12>'
+        xp conbus raw '<S0012345003F02D12FM>...<S0012345009F02D12FF>'
+    """
+    service: ConbusRawService = (
+        ctx.obj.get("container").get_container().resolve(ConbusRawService)
+    )
+
+    def on_progress(message: str) -> None:
+        """Handle progress updates during raw telegram sending.
+
+        Args:
+            message: Progress message string.
+        """
+        click.echo(message)
+
+    def on_finish(service_response: ConbusRawResponse) -> None:
+        """Handle successful completion of raw telegram sending.
+
+        Args:
+            service_response: Raw response object.
+        """
+        click.echo(json.dumps(service_response.to_dict(), indent=2))
+
+    with service:
+        service.send_raw_telegram(
+            raw_input=raw_telegrams,
+            progress_callback=on_progress,
+            finish_callback=on_finish,
+            timeout_seconds=5.0,
+        )

xp/cli/commands/conbus/conbus_receive_commands.py

@@ -0,0 +1,59 @@
+"""Conbus receive telegrams 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.models.conbus.conbus_receive import ConbusReceiveResponse
+from xp.services.conbus.conbus_receive_service import (
+    ConbusReceiveService,
+)
+
+
+@conbus.command("receive")
+@click.argument("timeout", type=click.FLOAT, default=2.0)
+@connection_command()
+@click.pass_context
+def receive_telegrams(ctx: Context, timeout: float) -> None:
+    r"""Receive waiting event telegrams from Conbus server.
+
+    Connects to the Conbus server and receives any waiting event telegrams
+    without sending any data first. Useful for collecting pending notifications
+    or events from the server.
+
+    Args:
+        ctx: Click context object.
+        timeout: Timeout in seconds for receiving telegrams (default: 2.0).
+
+    Examples:
+        \b
+        xp conbus receive
+        xp conbus receive 5.0
+    """
+
+    def on_finish(response_received: ConbusReceiveResponse) -> None:
+        """Handle successful completion of telegram receive operation.
+
+        Args:
+            response_received: Receive response object with telegrams.
+        """
+        click.echo(json.dumps(response_received.to_dict(), indent=2))
+
+    def progress(telegram_received: str) -> None:
+        """Handle progress updates during telegram receive operation.
+
+        Args:
+            telegram_received: Received telegram string.
+        """
+        click.echo(telegram_received)
+
+    service: ConbusReceiveService = (
+        ctx.obj.get("container").get_container().resolve(ConbusReceiveService)
+    )
+    with service:
+        service.start(progress, on_finish, timeout)

xp/cli/commands/conbus/conbus_scan_commands.py

@@ -0,0 +1,58 @@
+"""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 import ConbusResponse
+from xp.services.conbus.conbus_scan_service import ConbusScanService
+
+
+@conbus.command("scan")
+@click.argument("serial_number", type=SERIAL)
+@click.argument("function_code", type=str)
+@click.pass_context
+@connection_command()
+def scan_module(ctx: Context, serial_number: str, function_code: str) -> None:
+    r"""Scan all datapoints of a function_code for a module.
+
+    Args:
+        ctx: Click context object.
+        serial_number: 10-digit module serial number.
+        function_code: Function code.
+
+    Examples:
+        \b
+        xp conbus scan 0012345011 02 # Scan all datapoints of function Read data points (02)
+    """
+    service: ConbusScanService = (
+        ctx.obj.get("container").get_container().resolve(ConbusScanService)
+    )
+
+    def on_progress(progress: str) -> None:
+        """Handle progress updates during module scan.
+
+        Args:
+            progress: Progress message string.
+        """
+        click.echo(progress)
+
+    def on_finish(service_response: ConbusResponse) -> None:
+        """Handle successful completion of module scan.
+
+        Args:
+            service_response: Scan response object.
+        """
+        click.echo(json.dumps(service_response.to_dict(), indent=2))
+
+    with service:
+        service.scan_module(
+            serial_number=serial_number,
+            function_code=function_code,
+            progress_callback=on_progress,
+            finish_callback=on_finish,
+        )

xp/cli/commands/file_commands.py

@@ -0,0 +1,186 @@
+"""File operations CLI commands for console bus logs."""
+
+import json
+
+import click
+from click import Context
+from click_help_colors import HelpColorsGroup
+
+from xp.cli.utils.decorators import (
+    file_operation_command,
+    handle_service_errors,
+)
+from xp.cli.utils.error_handlers import CLIErrorHandler
+from xp.cli.utils.formatters import OutputFormatter, StatisticsFormatter
+
+
+@click.group(
+    cls=HelpColorsGroup, help_headers_color="yellow", help_options_color="green"
+)
+def file() -> None:
+    """Perform file operations for console bus logs."""
+    pass
+
+
+@file.command("decode")
+@click.argument("log_file_path")
+@click.option("--summary", is_flag=True, help="Show summary statistics only")
+@click.pass_context
+@file_operation_command()
+@handle_service_errors(Exception)
+def decode_log_file(
+    ctx: Context,
+    log_file_path: str,
+    filter_type: str,
+    filter_direction: str,
+    time_range: str,
+    summary: bool,
+) -> None:
+    r"""Decode and parse console bus log file.
+
+    Args:
+        ctx: Click context object.
+        log_file_path: Path to the log file to decode.
+        filter_type: Filter by telegram type.
+        filter_direction: Filter by telegram direction.
+        time_range: Filter by time range.
+        summary: Show summary statistics only.
+
+    Examples:
+        \b
+        xp file decode conbus.log
+
+    Raises:
+        SystemExit: If time range is invalid or log file cannot be parsed.
+    """
+    from xp.services.log_file_service import LogFileService
+    from xp.utils.time_utils import TimeParsingError, parse_time_range
+
+    service: LogFileService = (
+        ctx.obj.get("container").get_container().resolve(LogFileService)
+    )
+    StatisticsFormatter(True)
+
+    try:
+        # Parse the log file
+        entries = service.parse_log_file(log_file_path)
+
+        # Apply filters
+        if filter_type or filter_direction or time_range:
+            start_time = None
+            end_time = None
+
+            if time_range:
+                try:
+                    start_time, end_time = parse_time_range(time_range)
+                except TimeParsingError as e:
+                    error_response = OutputFormatter(True).error_response(
+                        f"Invalid time range: {e}"
+                    )
+                    click.echo(error_response)
+                    raise SystemExit(1)
+
+            entries = service.filter_entries(
+                entries,
+                telegram_type=filter_type,
+                direction=filter_direction,
+                start_time=start_time,
+                end_time=end_time,
+            )
+
+        # Generate statistics
+        stats = service.get_file_statistics(entries)
+
+        if summary:
+            # Show summary only
+            click.echo(
+                json.dumps({"statistics": stats, "entry_count": len(entries)}, indent=2)
+            )
+        else:
+            # Show full results
+            output = {
+                "file_path": log_file_path,
+                "statistics": stats,
+                "entries": [entry.to_dict() for entry in entries],
+            }
+            click.echo(json.dumps(output, indent=2))
+
+    except Exception as e:
+        CLIErrorHandler.handle_file_error(e, log_file_path, "log file parsing")
+
+
+@file.command("analyze")
+@click.argument("log_file_path")
+@click.pass_context
+@handle_service_errors(Exception)
+def analyze_log_file(ctx: Context, log_file_path: str) -> None:
+    r"""Analyze console bus log file for patterns and statistics.
+
+    Args:
+        ctx: Click context object.
+        log_file_path: Path to the log file to analyze.
+
+    Examples:
+        \b
+        xp file analyze conbus.log
+    """
+    from xp.services.log_file_service import LogFileService
+
+    service: LogFileService = (
+        ctx.obj.get("container").get_container().resolve(LogFileService)
+    )
+    StatisticsFormatter(True)
+
+    try:
+        entries = service.parse_log_file(log_file_path)
+        stats = service.get_file_statistics(entries)
+
+        click.echo(
+            json.dumps({"file_path": log_file_path, "analysis": stats}, indent=2)
+        )
+
+    except Exception as e:
+        CLIErrorHandler.handle_file_error(e, log_file_path, "log file analysis")
+
+
+@file.command("validate")
+@click.argument("log_file_path")
+@click.pass_context
+@handle_service_errors(Exception)
+def validate_log_file(ctx: Context, log_file_path: str) -> None:
+    r"""Validate console bus log file format and telegram checksums.
+
+    Args:
+        ctx: Click context object.
+        log_file_path: Path to the log file to validate.
+
+    Examples:
+        \b
+        xp file validate conbus.log
+    """
+    from xp.services.log_file_service import LogFileService
+
+    service: LogFileService = (
+        ctx.obj.get("container").get_container().resolve(LogFileService)
+    )
+    OutputFormatter(True)
+
+    try:
+        entries = service.parse_log_file(log_file_path)
+        stats = service.get_file_statistics(entries)
+
+        is_valid = stats["parse_errors"] == 0
+        checksum_issues = stats["checksum_validation"]["invalid_checksums"]
+
+        result = {
+            "file_path": log_file_path,
+            "valid_format": is_valid,
+            "parse_errors": stats["parse_errors"],
+            "checksum_issues": checksum_issues,
+            "statistics": stats,
+            "success": is_valid and checksum_issues == 0,
+        }
+        click.echo(json.dumps(result, indent=2))
+
+    except Exception as e:
+        CLIErrorHandler.handle_file_error(e, log_file_path, "log file validation")

xp/cli/commands/homekit/__init__.py

@@ -0,0 +1,3 @@
+"""HomeKit CLI commands package."""
+
+__all__ = []

xp/cli/commands/homekit/homekit.py

@@ -0,0 +1,118 @@
+"""HomeKit management CLI commands."""
+
+import click
+from click_help_colors import HelpColorsGroup
+
+from xp.cli.utils.decorators import service_command
+
+
+@click.group(
+    cls=HelpColorsGroup, help_headers_color="yellow", help_options_color="green"
+)
+def homekit() -> None:
+    """Manage the HomeKit server for XP Protocol operations."""
+    pass
+
+
+@homekit.group(
+    cls=HelpColorsGroup, help_headers_color="yellow", help_options_color="green"
+)
+def config() -> None:
+    """Manage HomeKit configuration."""
+    pass
+
+
+@config.command()
+@click.option(
+    "--conson-config",
+    default="conson.yml",
+    help="Path to conson.yml configuration file",
+)
+@click.option(
+    "--homekit-config",
+    default="homekit.yml",
+    help="Path to homekit.yml configuration file",
+)
+@service_command()
+def validate(conson_config: str, homekit_config: str) -> None:
+    """Validate homekit.yml and conson.yml coherence.
+
+    Args:
+        conson_config: Path to conson.yml configuration file.
+        homekit_config: Path to homekit.yml configuration file.
+    """
+    from xp.services.homekit.homekit_config_validator import ConfigValidationService
+
+    try:
+        validator = ConfigValidationService(conson_config, homekit_config)
+        results = validator.validate_all()
+
+        if results["is_valid"]:
+            click.echo(click.style("✓ Configuration validation passed", fg="green"))
+        else:
+            click.echo(
+                click.style(
+                    f"✗ Configuration validation failed with {results['total_errors']} errors",
+                    fg="red",
+                )
+            )
+
+            if results["conson_errors"]:
+                click.echo(
+                    click.style("\nConson Configuration Errors:", fg="red", bold=True)
+                )
+                for error in results["conson_errors"]:
+                    click.echo(f"  - {error}")
+
+            if results["homekit_errors"]:
+                click.echo(
+                    click.style("\nHomeKit Configuration Errors:", fg="red", bold=True)
+                )
+                for error in results["homekit_errors"]:
+                    click.echo(f"  - {error}")
+
+            if results["cross_reference_errors"]:
+                click.echo(
+                    click.style("\nCross-Reference Errors:", fg="red", bold=True)
+                )
+                for error in results["cross_reference_errors"]:
+                    click.echo(f"  - {error}")
+
+            exit(1)
+
+    except Exception as e:
+        click.echo(click.style(f"✗ Validation failed: {e}", fg="red"))
+        exit(1)
+
+
+@config.command("show")
+@click.option(
+    "--conson-config",
+    default="conson.yml",
+    help="Path to conson.yml configuration file",
+)
+@click.option(
+    "--homekit-config",
+    default="homekit.yml",
+    help="Path to homekit.yml configuration file",
+)
+@service_command()
+def show_config(conson_config: str, homekit_config: str) -> None:
+    """Display parsed configuration summary.
+
+    Args:
+        conson_config: Path to conson.yml configuration file.
+        homekit_config: Path to homekit.yml configuration file.
+    """
+    from xp.services.homekit.homekit_config_validator import ConfigValidationService
+
+    try:
+        validator = ConfigValidationService(conson_config, homekit_config)
+        summary = validator.print_config_summary()
+
+        click.echo(click.style("Configuration Summary:", fg="blue", bold=True))
+        click.echo(summary)
+
+    except Exception as e:
+        click.echo(click.style(f"✗ Failed to load configuration: {e}", fg="red"))
+        exit(1)

xp/cli/commands/homekit/homekit_start_commands.py

@@ -0,0 +1,43 @@
+"""API server start command."""
+
+import sys
+
+import click
+from click import Context
+
+from xp.cli.commands.homekit.homekit import homekit
+from xp.services.homekit.homekit_service import HomeKitService
+
+
+@homekit.command("start")
+@click.pass_context
+def homekit_start(ctx: Context) -> None:
+    r"""Start the HomeKit server.
+
+    This command starts the XP Protocol HomeKit server using HAP-python.
+    The server provides HomeKit endpoints for Conbus operations.
+
+    Args:
+        ctx: Click context object.
+
+    Examples:
+        \b
+        # Start server on default host and port
+        xp homekit start
+    """
+    click.echo("Starting XP Protocol HomeKit server...")
+
+    try:
+        service: HomeKitService = (
+            ctx.obj.get("container").get_container().resolve(HomeKitService)
+        )
+        service.start()  # Blocking call - reactor.run() never returns
+
+    except KeyboardInterrupt:
+        click.echo("\nShutting down server...")
+    except Exception as e:
+        click.echo(
+            click.style(f"Error starting server: {e}", fg="red"),
+            err=True,
+        )
+        sys.exit(1)