conson-xp 1.18.0__py3-none-any.whl

xp/cli/commands/telegram/telegram_checksum_commands.py

@@ -0,0 +1,112 @@
+"""Checksum calculation and validation CLI commands."""
+
+import json
+
+import click
+
+from xp.cli.commands.telegram.telegram import checksum
+from xp.cli.utils.decorators import handle_service_errors
+from xp.cli.utils.error_handlers import CLIErrorHandler
+from xp.cli.utils.formatters import OutputFormatter
+from xp.services.telegram.telegram_checksum_service import TelegramChecksumService
+
+
+@checksum.command("calculate")
+@click.argument("data")
+@click.option(
+    "--algorithm",
+    "-a",
+    type=click.Choice(["simple", "crc32"]),
+    default="simple",
+    help="Checksum algorithm to use",
+)
+@handle_service_errors(Exception)
+def calculate_checksum(data: str, algorithm: str) -> None:
+    r"""Calculate checksum for given data string.
+
+    Args:
+        data: Data string to calculate checksum for.
+        algorithm: Checksum algorithm to use.
+
+    Examples:
+        \b
+        xp checksum calculate "E14L00I02M"
+        xp checksum calculate "E14L00I02M" --algorithm crc32
+
+    Raises:
+        SystemExit: If checksum calculation fails.
+    """
+    service = TelegramChecksumService()
+    formatter = OutputFormatter(True)
+
+    try:
+        if algorithm == "simple":
+            result = service.calculate_simple_checksum(data)
+        else:  # crc32
+            result = service.calculate_crc32_checksum(data)
+
+        if not result.success:
+            error_response = formatter.error_response(
+                result.error or "Unknown error", {"input": data}
+            )
+            click.echo(error_response)
+            raise SystemExit(1)
+
+        click.echo(json.dumps(result.to_dict(), indent=2))
+
+    except Exception as e:
+        CLIErrorHandler.handle_service_error(e, "checksum calculation", {"input": data})
+
+
+@checksum.command("validate")
+@click.argument("data")
+@click.argument("expected_checksum")
+@click.option(
+    "--algorithm",
+    "-a",
+    type=click.Choice(["simple", "crc32"]),
+    default="simple",
+    help="Checksum algorithm to use",
+)
+@handle_service_errors(Exception)
+def validate_checksum(data: str, expected_checksum: str, algorithm: str) -> None:
+    r"""Validate data against expected checksum.
+
+    Args:
+        data: Data string to validate.
+        expected_checksum: Expected checksum value.
+        algorithm: Checksum algorithm to use.
+
+    Examples:
+        \b
+        xp checksum validate "E14L00I02M" "AK"
+        xp checksum validate "E14L00I02M" "ABCDABCD" --algorithm crc32
+
+    Raises:
+        SystemExit: If checksum validation fails.
+    """
+    service = TelegramChecksumService()
+    formatter = OutputFormatter(True)
+
+    try:
+        if algorithm == "simple":
+            result = service.validate_checksum(data, expected_checksum)
+        else:  # crc32
+            result = service.validate_crc32_checksum(data, expected_checksum)
+
+        if not result.success:
+            error_response = formatter.error_response(
+                result.error or "Unknown error",
+                {"input": data, "expected_checksum": expected_checksum},
+            )
+            click.echo(error_response)
+            raise SystemExit(1)
+
+        click.echo(json.dumps(result.to_dict(), indent=2))
+
+    except Exception as e:
+        CLIErrorHandler.handle_service_error(
+            e,
+            "checksum validation",
+            {"input": data, "expected_checksum": expected_checksum},
+        )

xp/cli/commands/telegram/telegram_discover_commands.py

@@ -0,0 +1,41 @@
+"""Device discover operations CLI commands."""
+
+import json
+
+import click
+
+from xp.cli.commands.telegram.telegram import telegram
+from xp.cli.utils.decorators import handle_service_errors
+from xp.cli.utils.error_handlers import CLIErrorHandler
+from xp.cli.utils.formatters import OutputFormatter
+from xp.services.telegram.telegram_discover_service import (
+    DiscoverError,
+    TelegramDiscoverService,
+)
+
+
+@telegram.command("discover")
+@handle_service_errors(DiscoverError)
+def generate_discover() -> None:
+    r"""Generate a discover telegram for device enumeration.
+
+    Examples:
+        \b
+        xp telegram discover
+    """
+    service = TelegramDiscoverService()
+    OutputFormatter(True)
+
+    try:
+        discover = service.generate_discover_telegram()
+
+        output = {
+            "success": True,
+            "telegram": discover,
+            "operation": "discover_broadcast",
+            "broadcast_address": "0000000000",
+        }
+        click.echo(json.dumps(output, indent=2))
+
+    except DiscoverError as e:
+        CLIErrorHandler.handle_service_error(e, "discover telegram generation")

xp/cli/commands/telegram/telegram_linknumber_commands.py

@@ -0,0 +1,86 @@
+"""Link number operations CLI commands."""
+
+import json
+
+import click
+
+from xp.cli.commands.telegram.telegram import linknumber
+from xp.cli.utils.decorators import handle_service_errors
+from xp.cli.utils.error_handlers import CLIErrorHandler
+from xp.cli.utils.formatters import OutputFormatter
+from xp.cli.utils.serial_number_type import SERIAL
+from xp.services.telegram.telegram_link_number_service import (
+    LinkNumberError,
+    LinkNumberService,
+)
+
+
+@linknumber.command("write")
+@click.argument("serial_number", type=SERIAL)
+@click.argument("link_number", type=int)
+@handle_service_errors(LinkNumberError)
+def generate_set_link_number(serial_number: str, link_number: int) -> None:
+    r"""Generate a telegram to set module link number.
+
+    Args:
+        serial_number: 10-digit module serial number.
+        link_number: Link number to set.
+
+    Examples:
+        \b
+        xp telegram linknumber write 0012345005 25
+    """
+    service = LinkNumberService()
+    OutputFormatter(True)
+
+    try:
+        telegram = service.generate_set_link_number_telegram(serial_number, link_number)
+
+        output = {
+            "success": True,
+            "telegram": telegram,
+            "serial_number": serial_number,
+            "link_number": link_number,
+            "operation": "set_link_number",
+        }
+        click.echo(json.dumps(output, indent=2))
+
+    except LinkNumberError as e:
+        CLIErrorHandler.handle_service_error(
+            e,
+            "link number telegram generation",
+            {"serial_number": serial_number, "link_number": link_number},
+        )
+
+
+@linknumber.command("read")
+@click.argument("serial_number", type=SERIAL)
+@handle_service_errors(LinkNumberError)
+def generate_read_link_number(serial_number: str) -> None:
+    r"""Generate a telegram to read module link number.
+
+    Args:
+        serial_number: 10-digit module serial number.
+
+    Examples:
+        \b
+        xp telegram linknumber read 0012345005
+    """
+    service = LinkNumberService()
+    OutputFormatter(True)
+
+    try:
+        telegram = service.generate_read_link_number_telegram(serial_number)
+
+        output = {
+            "success": True,
+            "telegram": telegram,
+            "serial_number": serial_number,
+            "operation": "read_link_number",
+        }
+        click.echo(json.dumps(output, indent=2))
+
+    except LinkNumberError as e:
+        CLIErrorHandler.handle_service_error(
+            e, "read telegram generation", {"serial_number": serial_number}
+        )

xp/cli/commands/telegram/telegram_parse_commands.py

@@ -0,0 +1,75 @@
+"""Telegram-related CLI commands."""
+
+import json
+
+import click
+
+from xp.cli.commands.telegram.telegram import telegram
+from xp.cli.utils.decorators import (
+    handle_service_errors,
+)
+from xp.cli.utils.error_handlers import CLIErrorHandler
+from xp.cli.utils.formatters import TelegramFormatter
+from xp.services.telegram.telegram_service import TelegramParsingError, TelegramService
+
+
+@telegram.command("parse")
+@click.argument("telegram_string")
+@handle_service_errors(TelegramParsingError)
+def parse_any_telegram(telegram_string: str) -> None:
+    r"""Auto-detect and parse any type of telegram (event, system, reply, or discover).
+
+    Args:
+        telegram_string: Telegram string to parse.
+
+    Examples:
+        \b
+        xp telegram parse "<E14L00I02MAK>"
+        xp telegram parse "<S0020012521F02D18FN>"
+        xp telegram parse "<R0020012521F02D18+26,0§CIL>"
+        xp telegram parse "<S0000000000F01D00FA>"
+        xp telegram parse "<R0012345011F01DFM>"
+        xp telegram parse "<R0012345003F18DFF>"
+    """
+    service = TelegramService()
+    TelegramFormatter(True)
+
+    try:
+        parsed = service.parse_telegram(telegram_string)
+        output = parsed.to_dict()
+        click.echo(json.dumps(output, indent=2))
+
+    except TelegramParsingError as e:
+        CLIErrorHandler.handle_parsing_error(e, telegram_string)
+
+
+@telegram.command("validate")
+@click.argument("telegram_string")
+@handle_service_errors(TelegramParsingError)
+def validate_telegram(telegram_string: str) -> None:
+    r"""Validate the format of an event telegram.
+
+    Args:
+        telegram_string: Telegram string to validate.
+
+    Examples:
+        \b
+        xp telegram validate "<E14L00I02MAK>"
+    """
+    service = TelegramService()
+    TelegramFormatter(True)
+
+    try:
+        parsed = service.parse_event_telegram(telegram_string)
+        checksum_valid = service.validate_checksum(parsed)
+
+        output = {
+            "success": True,
+            "valid_format": True,
+            "valid_checksum": checksum_valid,
+            "telegram": parsed.to_dict(),
+        }
+        click.echo(json.dumps(output, indent=2))
+
+    except TelegramParsingError as e:
+        CLIErrorHandler.handle_validation_error(e, telegram_string)

xp/cli/commands/telegram/telegram_version_commands.py

@@ -0,0 +1,52 @@
+"""Version information operations CLI commands."""
+
+import json
+
+import click
+
+from xp.cli.commands.telegram.telegram import telegram
+from xp.cli.utils.decorators import handle_service_errors
+from xp.cli.utils.error_handlers import CLIErrorHandler
+from xp.cli.utils.formatters import OutputFormatter
+from xp.cli.utils.serial_number_type import SERIAL
+from xp.services.telegram.telegram_version_service import (
+    VersionParsingError,
+    VersionService,
+)
+
+
+@telegram.command("version")
+@click.argument("serial_number", type=SERIAL)
+@handle_service_errors(VersionParsingError)
+def generate_version_request(serial_number: str) -> None:
+    r"""Generate a telegram to request version information from a device.
+
+    Args:
+        serial_number: 10-digit module serial number.
+
+    Examples:
+        \b
+        xp telegram version 0012345011
+
+    Raises:
+        SystemExit: If request cannot be generated.
+    """
+    service = VersionService()
+    formatter = OutputFormatter(True)
+
+    try:
+        result = service.generate_version_request_telegram(serial_number)
+
+        if not result.success:
+            error_response = formatter.error_response(
+                result.error or "Unknown error", {"serial_number": serial_number}
+            )
+            click.echo(error_response)
+            raise SystemExit(1)
+
+        click.echo(json.dumps(result.to_dict(), indent=2))
+
+    except VersionParsingError as e:
+        CLIErrorHandler.handle_service_error(
+            e, "version request generation", {"serial_number": serial_number}
+        )

xp/cli/main.py

@@ -0,0 +1,87 @@
+"""XP CLI tool entry point with modular command structure."""
+
+import logging
+
+import click
+from click_help_colors import HelpColorsGroup
+
+from xp.cli.commands import homekit
+from xp.cli.commands.conbus.conbus import conbus
+from xp.cli.commands.file_commands import file
+from xp.cli.commands.module_commands import module
+
+# Import all conbus command modules to register their commands
+from xp.cli.commands.reverse_proxy_commands import reverse_proxy
+from xp.cli.commands.server.server_commands import server
+
+# Import command groups from modular structure
+from xp.cli.commands.telegram.telegram_parse_commands import telegram
+from xp.cli.utils.click_tree import add_tree_command
+from xp.utils.dependencies import ServiceContainer
+
+
+@click.group(
+    cls=HelpColorsGroup, help_headers_color="yellow", help_options_color="green"
+)
+@click.version_option()
+@click.pass_context
+def cli(ctx: click.Context) -> None:
+    """XP CLI tool for remote console bus operations.
+
+    Args:
+        ctx: Click context object for passing state between commands.
+    """
+    # Configure logging with thread information
+    log_format = "%(asctime)s - [%(threadName)s-%(thread)d] - %(levelname)s - %(name)s - %(message)s"
+    date_format = "%H:%M:%S"
+
+    # Force format on root logger and all handlers
+    formatter = logging.Formatter(log_format, datefmt=date_format)
+    root_logger = logging.getLogger()
+    root_logger.setLevel(logging.DEBUG)
+
+    # Update all existing handlers or create new one
+    if root_logger.handlers:
+        for handler in root_logger.handlers:
+            handler.setFormatter(formatter)
+    else:
+        handler = logging.StreamHandler()
+        handler.setFormatter(formatter)
+        root_logger.addHandler(handler)
+
+    # Suppress pyhap.hap_protocol logs
+
+    # bubus
+    logging.getLogger("bubus").setLevel(logging.WARNING)
+
+    # xp
+    logging.getLogger("xp").setLevel(logging.DEBUG)
+    logging.getLogger("xp.services.homekit").setLevel(logging.DEBUG)
+
+    # pyhap
+    logging.getLogger("pyhap").setLevel(logging.WARNING)
+    logging.getLogger("pyhap.hap_handler").setLevel(logging.WARNING)
+    logging.getLogger("pyhap.hap_protocol").setLevel(logging.WARNING)
+    # logging.getLogger('pyhap.accessory_driver').setLevel(logging.WARNING)
+
+    # Initialize the service container and store it in the context
+    ctx.ensure_object(dict)
+    # Only create a new container if one wasn't provided (e.g., for testing)
+    if "container" not in ctx.obj:
+        ctx.obj["container"] = ServiceContainer()
+
+
+# Register all command groups
+cli.add_command(conbus)
+cli.add_command(homekit)
+cli.add_command(telegram)
+cli.add_command(module)
+cli.add_command(file)
+cli.add_command(server)
+cli.add_command(reverse_proxy)
+
+# Add the tree command
+add_tree_command(cli)
+
+if __name__ == "__main__":
+    cli()

xp/cli/utils/__init__.py

@@ -0,0 +1 @@
+"""CLI utilities for common functionality."""

xp/cli/utils/click_tree.py

@@ -0,0 +1,57 @@
+"""Utilities for displaying Click command trees."""
+
+from typing import Any
+
+import click
+
+
+def add_tree_command(cli_group: click.Group, command_name: str = "help") -> Any:
+    """Add a tree command to any Click group.
+
+    Args:
+        cli_group: The Click group to add the tree command to.
+        command_name: Name of the tree command (default: "help").
+
+    Returns:
+        The tree command function.
+    """
+
+    def print_command_tree(group: click.Group, ctx: click.Context, suffix: str) -> None:
+        """Print command tree recursively.
+
+        Args:
+            group: The Click group to print.
+            ctx: The Click context.
+            suffix: Prefix string for tree display.
+        """
+        for name in sorted(group.list_commands(ctx)):
+            cmd = group.get_command(ctx, name)
+
+            if isinstance(cmd, click.Group):
+                # print(f"")
+                print()
+                print(f"{suffix} {name}")
+                print_command_tree(cmd, ctx, f"{suffix} {name}")
+                print()
+            else:
+                print(f"{suffix} {name}")
+
+    @cli_group.command(command_name)
+    @click.pass_context
+    def tree_command(ctx: click.Context) -> None:
+        """Show complete command tree.
+
+        Args:
+            ctx: The Click context.
+        """
+        root = ctx.find_root().command
+        root_ctx = ctx.find_root()
+        root_name = root_ctx.info_name or "cli"
+        print()
+        print(root_name)
+        if root.short_help:
+            print(str(root.short_help))
+        if isinstance(root, click.Group):
+            print_command_tree(root, root_ctx, root_name)
+
+    return tree_command

xp/cli/utils/datapoint_type_choice.py

@@ -0,0 +1,57 @@
+"""Click parameter type for DataPointType enum validation."""
+
+from typing import Any, Optional
+
+import click
+
+from xp.models.telegram.datapoint_type import DataPointType
+
+
+# noinspection DuplicatedCode
+class DatapointTypeChoice(click.ParamType):
+    """Click parameter type for validating DataPointType enum values.
+
+    Attributes:
+        name: The parameter type name.
+        choices: List of valid choice strings.
+    """
+
+    name = "telegram_type"
+
+    def __init__(self) -> None:
+        """Initialize the DatapointTypeChoice parameter type."""
+        self.choices = [key.lower() for key in DataPointType.__members__.keys()]
+
+    def convert(
+        self, value: Any, param: Optional[click.Parameter], ctx: Optional[click.Context]
+    ) -> Any:
+        """Convert and validate input to DataPointType enum.
+
+        Args:
+            value: The input value to convert.
+            param: The Click parameter.
+            ctx: The Click context.
+
+        Returns:
+            DataPointType enum member if valid, None if input is None.
+        """
+        if value is None:
+            return value
+
+        # Convert to lower for comparison
+        normalized_value = value.lower()
+
+        if normalized_value in self.choices:
+            # Return the actual enum member
+            return DataPointType[normalized_value.upper()]
+
+        # If not found, show error with available choices
+        choices_list = "\n".join(f" - {choice}" for choice in sorted(self.choices))
+        self.fail(
+            f"{value!r} is not a valid choice. " f"Choose from:\n{choices_list}",
+            param,
+            ctx,
+        )
+
+
+DATAPOINT = DatapointTypeChoice()