conson-xp 1.18.0__py3-none-any.whl

xp/cli/commands/module_commands.py

@@ -0,0 +1,187 @@
+"""Module type operations CLI commands."""
+
+import json
+from typing import Any, Dict, Union
+
+import click
+from click import Context
+from click_help_colors import HelpColorsGroup
+
+from xp.cli.utils.decorators import list_command
+from xp.cli.utils.error_handlers import CLIErrorHandler
+from xp.cli.utils.formatters import ListFormatter, OutputFormatter
+from xp.services.module_type_service import ModuleTypeNotFoundError, ModuleTypeService
+
+
+@click.group(
+    cls=HelpColorsGroup, help_headers_color="yellow", help_options_color="green"
+)
+def module() -> None:
+    """Perform module type operations."""
+    pass
+
+
+@module.command("info")
+@click.argument("identifier")
+@click.pass_context
+@list_command(ModuleTypeNotFoundError)
+def module_info(ctx: Context, identifier: str) -> None:
+    r"""Get information about a module type by code or name.
+
+    Args:
+        ctx: Click context object.
+        identifier: Module code or name.
+
+    Examples:
+        \b
+        xp module info 14
+        xp module info XP2606
+    """
+    service: ModuleTypeService = (
+        ctx.obj.get("container").get_container().resolve(ModuleTypeService)
+    )
+    OutputFormatter(True)
+
+    try:
+        # Try to parse as integer first, then as string
+        module_id: Union[int, str]
+        try:
+            module_id = int(identifier)
+        except ValueError:
+            module_id = identifier
+
+        module_type = service.get_module_type(module_id)
+        click.echo(json.dumps(module_type.to_dict(), indent=2))
+
+    except ModuleTypeNotFoundError as e:
+        CLIErrorHandler.handle_not_found_error(e, "module type", identifier)
+
+
+@module.command("list")
+@click.option("--category", "-c", help="Filter by category")
+@click.option(
+    "--group-by-category", "-g", is_flag=True, help="Group modules by category"
+)
+@click.pass_context
+@list_command(Exception)
+def module_list(ctx: Context, category: str, group_by_category: bool) -> None:
+    r"""List module types, optionally filtered by category.
+
+    Args:
+        ctx: Click context object.
+        category: Filter by category.
+        group_by_category: Group modules by category.
+
+    Examples:
+        \b
+        xp module list
+        xp module list --category "Interface Panels"
+        xp module list --group-by-category
+    """
+    service: ModuleTypeService = (
+        ctx.obj.get("container").get_container().resolve(ModuleTypeService)
+    )
+    ListFormatter(True)
+
+    try:
+        if category:
+            modules = service.get_modules_by_category(category)
+            if not modules:
+                click.echo(json.dumps({"modules": [], "category": category}))
+                return
+        else:
+            modules = service.list_all_modules()
+
+        if group_by_category:
+            categories = service.list_modules_by_category()
+            output: Dict[str, Any] = {
+                "modules_by_category": {
+                    cat: [mod.to_dict() for mod in mods]
+                    for cat, mods in categories.items()
+                }
+            }
+        else:
+            output = {
+                "modules": [_module.to_dict() for _module in modules],
+                "count": len(modules),
+            }
+        click.echo(json.dumps(output, indent=2))
+
+    except Exception as e:
+        CLIErrorHandler.handle_service_error(e, "module listing")
+
+
+@module.command("search")
+@click.argument("query")
+@click.option(
+    "--field",
+    multiple=True,
+    type=click.Choice(["name", "description"]),
+    help="Fields to search in (default: both)",
+)
+@click.pass_context
+@list_command(Exception)
+def module_search(ctx: Context, query: str, field: tuple) -> None:
+    r"""Search for module types by name or description.
+
+    Args:
+        ctx: Click context object.
+        query: Search query.
+        field: Fields to search in.
+
+    Examples:
+        \b
+        xp module search "push button"
+        xp module search --field name "XP"
+    """
+    service: ModuleTypeService = (
+        ctx.obj.get("container").get_container().resolve(ModuleTypeService)
+    )
+    ListFormatter(True)
+
+    try:
+        search_fields = list(field) if field else ["name", "description"]
+        matching_modules = service.search_modules(query, search_fields)
+
+        output = {
+            "query": query,
+            "search_fields": search_fields,
+            "matches": [_module.to_dict() for _module in matching_modules],
+            "count": len(matching_modules),
+        }
+        click.echo(json.dumps(output, indent=2))
+
+    except Exception as e:
+        CLIErrorHandler.handle_service_error(e, "module search", {"query": query})
+
+
+@module.command("categories")
+@click.pass_context
+@list_command(Exception)
+def module_categories(ctx: Context) -> None:
+    r"""List all available module categories.
+
+    Args:
+        ctx: Click context object.
+
+    Examples:
+        \b
+        xp module categories
+    """
+    service: ModuleTypeService = (
+        ctx.obj.get("container").get_container().resolve(ModuleTypeService)
+    )
+    OutputFormatter(True)
+
+    try:
+        categories = service.list_modules_by_category()
+
+        output = {
+            "categories": {
+                category: len(modules) for category, modules in categories.items()
+            }
+        }
+        click.echo(json.dumps(output, indent=2))
+
+    except Exception as e:
+        CLIErrorHandler.handle_service_error(e, "category listing")

xp/cli/commands/reverse_proxy_commands.py

@@ -0,0 +1,178 @@
+"""Conbus reverse proxy operations CLI commands."""
+
+import json
+import signal
+import sys
+from types import FrameType
+from typing import Any, Dict, Optional
+
+import click
+from click import Context
+from click_help_colors import HelpColorsGroup
+
+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.reverse_proxy_service import (
+    ReverseProxyError,
+    ReverseProxyService,
+)
+
+# Global proxy instance
+global_proxy_instance: Optional[ReverseProxyService] = None
+
+
+@click.group(
+    name="rp",
+    cls=HelpColorsGroup,
+    help_headers_color="yellow",
+    help_options_color="green",
+)
+def reverse_proxy() -> None:
+    """Perform Conbus reverse proxy operations."""
+    pass
+
+
+@reverse_proxy.command("start")
+@click.option(
+    "--port", "-p", default=10001, type=int, help="Port to listen on (default: 10001)"
+)
+@click.option("--config", "-c", default="rp.yml", help="Configuration file path")
+@handle_service_errors(ReverseProxyError)
+@click.pass_context
+def start_proxy(ctx: Context, port: int, config: str) -> None:
+    r"""Start the Conbus reverse proxy server.
+
+    The proxy listens on the specified port and forwards all telegrams
+    to the target server configured in cli.yml. All traffic is monitored
+    and printed with timestamps.
+
+    Args:
+        ctx: Click context object.
+        port: Port to listen on.
+        config: Configuration file path.
+
+    Examples:
+        \b
+        xp rp start
+        xp rp start --port 10002 --config my_cli.yml
+
+    Raises:
+        SystemExit: If proxy is already running.
+    """
+    global global_proxy_instance
+
+    try:
+        # Check if proxy is already running
+        if global_proxy_instance and global_proxy_instance.is_running:
+            error_response = {
+                "success": False,
+                "error": "Reverse proxy is already running",
+            }
+            click.echo(json.dumps(error_response, indent=2))
+            raise SystemExit(1)
+
+        # Load configuration and create proxy instance
+        service: ReverseProxyService = (
+            ctx.obj.get("container").get_container().resolve(ReverseProxyService)
+        )
+        global_proxy_instance = service
+
+        # Handle graceful shutdown on SIGINT
+        def signal_handler(signum: int, frame: Optional[FrameType]) -> None:
+            """Handle shutdown signals for graceful proxy termination.
+
+            Args:
+                signum: Signal number received.
+                frame: Current stack frame (may be None).
+            """
+            if global_proxy_instance and global_proxy_instance.is_running:
+                timestamp = global_proxy_instance.timestamp()
+                print(f"\n{timestamp} [SHUTDOWN] Received interrupt signal ({signum})")
+                print(f"\n{timestamp} [SHUTDOWN] Frame is ({frame})")
+                global_proxy_instance.stop_proxy()
+            sys.exit(0)
+
+        signal.signal(signal.SIGINT, signal_handler)
+
+        # Start proxy (this will block)
+        result = global_proxy_instance.start_proxy()
+        click.echo(json.dumps(result.to_dict(), indent=2))
+        if result.success:
+            global_proxy_instance.run_blocking()
+
+    except ReverseProxyError as e:
+        CLIErrorHandler.handle_service_error(
+            e, "reverse proxy startup", {"port": port, "config": config}
+        )
+    except KeyboardInterrupt:
+        shutdown_response = {
+            "success": True,
+            "message": "Reverse proxy shutdown by user",
+        }
+        click.echo(json.dumps(shutdown_response, indent=2))
+
+
+@reverse_proxy.command("stop")
+@handle_service_errors(ReverseProxyError)
+def stop_proxy() -> None:
+    r"""Stop the running Conbus reverse proxy server.
+
+    Examples:
+        \b
+        xp rp stop
+
+    Raises:
+        SystemExit: If proxy is not running.
+    """
+    try:
+        if global_proxy_instance is None or not global_proxy_instance.is_running:
+            error_response = {
+                "success": False,
+                "error": "Reverse proxy is not running",
+            }
+            click.echo(json.dumps(error_response, indent=2))
+            raise SystemExit(1)
+
+        # Stop the proxy
+        result = global_proxy_instance.stop_proxy()
+
+        click.echo(json.dumps(result.to_dict(), indent=2))
+
+    except ReverseProxyError as e:
+        CLIErrorHandler.handle_service_error(e, "reverse proxy stop")
+
+
+@reverse_proxy.command("status")
+@handle_service_errors(Exception)
+def proxy_status() -> None:
+    r"""Get status of the Conbus reverse proxy server.
+
+    Shows current running state, listen port, target server,
+    and active connection details.
+
+    Examples:
+        \b
+        xp rp status
+    """
+    OutputFormatter(True)
+
+    try:
+        status_data: Dict[str, Any]
+        if global_proxy_instance is None:
+            status_data = {
+                "running": False,
+                "listen_port": None,
+                "target_ip": None,
+                "target_port": None,
+                "active_connections": 0,
+                "connections": {},
+            }
+        else:
+            result = global_proxy_instance.get_status()
+            status_data = result.data if result.success else {}
+
+        click.echo(json.dumps(status_data, indent=2))
+
+    except Exception as e:
+        CLIErrorHandler.handle_service_error(e, "reverse proxy status check")

xp/cli/commands/server/__init__.py

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

xp/cli/commands/server/server_commands.py

@@ -0,0 +1,135 @@
+"""Conbus emulator server operations CLI commands."""
+
+import json
+from typing import Any, Dict, Optional
+
+import click
+from click import Context
+from click_help_colors import HelpColorsGroup
+
+from xp.cli.utils.decorators import handle_service_errors
+from xp.cli.utils.error_handlers import ServerErrorHandler
+from xp.cli.utils.formatters import OutputFormatter
+from xp.services.server.server_service import ServerError, ServerService
+
+# Global server instance
+_server_instance: Optional[ServerService] = None
+
+
+@click.group(
+    cls=HelpColorsGroup, help_headers_color="yellow", help_options_color="green"
+)
+def server() -> None:
+    """Perform Conbus emulator server operations."""
+    pass
+
+
+@server.command("start")
+@click.option(
+    "--port", "-p", default=10001, type=int, help="Port to listen on (default: 10001)"
+)
+@click.option("--config", "-c", default="server.yml", help="Configuration file path")
+@click.pass_context
+@handle_service_errors(ServerError)
+def start_server(ctx: Context, port: int, config: str) -> None:
+    r"""Start the Conbus emulator server.
+
+    Args:
+        ctx: Click context object.
+        port: Port to listen on.
+        config: Configuration file path.
+
+    Examples:
+        \b
+        xp server start
+        xp server start --port 1001 --config my_config.yml
+
+    Raises:
+        SystemExit: If server is already running.
+    """
+    global _server_instance
+
+    try:
+        # Check if server is already running
+        if _server_instance and _server_instance.is_running:
+            error_response = {
+                "success": False,
+                "error": "Server is already running",
+            }
+            click.echo(json.dumps(error_response, indent=2))
+            raise SystemExit(1)
+
+        # Get dependencies from container
+        _server_instance = (
+            ctx.obj.get("container").get_container().resolve(ServerService)
+        )
+
+        status = _server_instance.get_server_status()
+        click.echo(json.dumps(status, indent=2))
+
+        # This will block until server is stopped
+        _server_instance.start_server()
+
+    except ServerError as e:
+        ServerErrorHandler.handle_server_startup_error(e, port, config)
+    except KeyboardInterrupt:
+        shutdown_response = {"success": True, "message": "Server shutdown by user"}
+        click.echo(json.dumps(shutdown_response, indent=2))
+
+
+@server.command("stop")
+@handle_service_errors(ServerError)
+def stop_server() -> None:
+    r"""Stop the running Conbus emulator server.
+
+    Examples:
+        \b
+        xp server stop
+    """
+    try:
+        if _server_instance is None or not _server_instance.is_running:
+            ServerErrorHandler.handle_server_not_running_error()
+
+        # Stop the server
+        if _server_instance is not None:
+            _server_instance.stop_server()
+
+        response = {"success": True, "message": "Server stopped successfully"}
+        click.echo(json.dumps(response, indent=2))
+
+    except ServerError as e:
+        ServerErrorHandler.handle_server_startup_error(e, 0, "")
+
+
+@server.command("status")
+@handle_service_errors(Exception)
+def server_status() -> None:
+    r"""Get status of the Conbus emulator server.
+
+    Examples:
+        \b
+        xp server status
+
+    Raises:
+        SystemExit: If status cannot be retrieved.
+    """
+    formatter = OutputFormatter(True)
+
+    try:
+        status: Dict[str, Any]
+        if _server_instance is None:
+            status = {
+                "running": False,
+                "port": None,
+                "devices_configured": 0,
+                "device_list": [],
+            }
+        else:
+            status = _server_instance.get_server_status()
+
+        click.echo(json.dumps(status, indent=2))
+
+    except Exception as e:
+        error_response = formatter.error_response(str(e))
+        click.echo(error_response)
+        raise SystemExit(1)

xp/cli/commands/telegram/__init__.py

@@ -0,0 +1,5 @@
+"""Telegram CLI commands package."""
+
+from xp.cli.commands.telegram.telegram import blink, checksum, linknumber, telegram
+
+__all__ = ["telegram", "linknumber", "blink", "checksum"]

xp/cli/commands/telegram/telegram.py

@@ -0,0 +1,41 @@
+"""Shared conbus CLI group definition."""
+
+import click
+from click_help_colors import HelpColorsGroup
+
+
+@click.group(
+    cls=HelpColorsGroup, help_headers_color="yellow", help_options_color="green"
+)
+def telegram() -> None:
+    """Perform event telegram operations."""
+    pass
+
+
+@click.group(
+    cls=HelpColorsGroup, help_headers_color="yellow", help_options_color="green"
+)
+def linknumber() -> None:
+    """Perform link number operations for module configuration."""
+    pass
+
+
+@click.group(
+    cls=HelpColorsGroup, help_headers_color="yellow", help_options_color="green"
+)
+def blink() -> None:
+    """Perform blink operations for module LED control."""
+    pass
+
+
+@click.group(
+    cls=HelpColorsGroup, help_headers_color="yellow", help_options_color="green"
+)
+def checksum() -> None:
+    """Perform checksum calculation and validation operations."""
+    pass
+
+
+telegram.add_command(linknumber)
+telegram.add_command(blink)
+telegram.add_command(checksum)

xp/cli/commands/telegram/telegram_blink_commands.py

@@ -0,0 +1,79 @@
+"""Blink operations CLI commands."""
+
+import json
+
+import click
+
+from xp.cli.commands.telegram.telegram import blink
+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_blink_service import BlinkError, TelegramBlinkService
+
+
+@blink.command("on")
+@click.argument("serial_number", type=SERIAL)
+@handle_service_errors(BlinkError)
+def blink_on(serial_number: str) -> None:
+    r"""Generate a telegram to start blinking module LED.
+
+    Args:
+        serial_number: 10-digit module serial number.
+
+    Examples:
+        \b
+        xp blink on 0012345008
+        xp blink on 0012345008
+    """
+    service = TelegramBlinkService()
+    OutputFormatter(True)
+
+    try:
+        telegram = service.generate_blink_telegram(serial_number, "on")
+
+        output = {
+            "success": True,
+            "telegram": telegram,
+            "serial_number": serial_number,
+            "operation": "blink_on",
+        }
+        click.echo(json.dumps(output, indent=2))
+
+    except BlinkError as e:
+        CLIErrorHandler.handle_service_error(
+            e, "blink telegram generation", {"serial_number": serial_number}
+        )
+
+
+@blink.command("off")
+@click.argument("serial_number", type=SERIAL)
+@handle_service_errors(BlinkError)
+def blink_off(serial_number: str) -> None:
+    r"""Generate a telegram to stop blinking module LED.
+
+    Args:
+        serial_number: 10-digit module serial number.
+
+    Examples:
+        \b
+        xp blink off 0012345011
+    """
+    service = TelegramBlinkService()
+    OutputFormatter(True)
+
+    try:
+        telegram = service.generate_blink_telegram(serial_number, "off")
+
+        output = {
+            "success": True,
+            "telegram": telegram,
+            "serial_number": serial_number,
+            "operation": "blink_off",
+        }
+        click.echo(json.dumps(output, indent=2))
+
+    except BlinkError as e:
+        CLIErrorHandler.handle_service_error(
+            e, "unblink telegram generation", {"serial_number": serial_number}
+        )