conson-xp 1.2.0__py3-none-any.whl → 1.3.0__py3-none-any.whl

xp/api/routers/conbus_output.py

@@ -1,167 +0,0 @@
-"""FastAPI router for Conbus operations."""
-
-import json
-import logging
-from typing import Union
-
-from fastapi import Request
-from fastapi.responses import JSONResponse
-
-from xp.api.models.api import ApiErrorResponse, ApiResponse
-from xp.api.routers.conbus import router
-from xp.api.routers.errors import handle_service_error
-from xp.models.telegram.action_type import ActionType
-from xp.services.conbus.conbus_output_service import ConbusOutputService
-
-logger = logging.getLogger(__name__)
-
-
-@router.get(
-    "/output/{action}/{serial}/{device_input}",
-    response_model=Union[ApiResponse, ApiErrorResponse],
-    responses={
-        200: {"model": ApiResponse, "description": "Input completed successfully"},
-        400: {"model": ApiErrorResponse, "description": "Connection or request error"},
-        408: {"model": ApiErrorResponse, "description": "Request timeout"},
-        500: {"model": ApiErrorResponse, "description": "Internal server error"},
-    },
-)
-async def input_action(
-    request: Request,
-    action: ActionType = ActionType.OFF_PRESS,
-    serial: str = "1702033007",
-    device_input: int = 0,
-) -> Union[ApiResponse, ApiErrorResponse, JSONResponse]:
-    """Initiate Input operation to find devices on the network.
-
-    Sends a broadcast Input telegram and collects responses from all connected devices.
-
-    Args:
-        request: FastAPI request object.
-        action: Action type to perform (default: OFF_PRESS).
-        serial: Serial number of the device.
-        device_input: Device input number.
-
-    Returns:
-        API response with operation result or error.
-    """
-    service = request.app.state.container.get_container().resolve(ConbusOutputService)
-
-    # SendInput telegram and receive responses
-    with service:
-        response = service.send_action(serial, device_input, action)
-
-    if not response.success:
-        return handle_service_error(response.error or "Unknown error")
-
-    logger.debug(json.dumps(response.to_dict(), indent=2))
-
-    # Build successful response
-    if response.output_telegram and response.output_telegram.system_function:
-        return ApiResponse(
-            success=True,
-            result=response.output_telegram.system_function.name,
-            description=response.output_telegram.system_function.get_description(),
-            # raw_telegram = response.output_telegram.raw_telegram,
-        )
-    return ApiResponse(
-        success=True,
-        result="Output command sent",
-        description="Output command was sent successfully",
-    )
-
-
-@router.get(
-    "/output/status/{serial_number}",
-    response_model=Union[ApiResponse, ApiErrorResponse],
-    responses={
-        200: {"model": ApiResponse, "description": "Query completed successfully"},
-        400: {"model": ApiErrorResponse, "description": "Connection or request error"},
-        408: {"model": ApiErrorResponse, "description": "Request timeout"},
-        500: {"model": ApiErrorResponse, "description": "Internal server error"},
-    },
-)
-async def output_status(
-    request: Request,
-    serial_number: str,
-) -> Union[ApiResponse, ApiErrorResponse, JSONResponse]:
-    """Query output status from a device.
-
-    Sends a status query telegram and retrieves the output state.
-
-    Args:
-        request: FastAPI request object.
-        serial_number: Serial number of the device to query.
-
-    Returns:
-        API response with output status or error.
-    """
-    service = request.app.state.container.get_container().resolve(ConbusOutputService)
-
-    # SendInput telegram and receive responses
-    with service:
-        response = service.get_output_state(serial_number)
-
-    if not response.success:
-        return handle_service_error(response.error or "Unknown error")
-
-    # Build successful response
-    if response.datapoint_telegram and response.datapoint_telegram.datapoint_type:
-        return ApiResponse(
-            success=True,
-            result=response.datapoint_telegram.data_value,
-            description=response.datapoint_telegram.datapoint_type.name,
-        )
-    return ApiResponse(
-        success=True,
-        result="No data available",
-        description="Output status retrieved but no data available",
-    )
-
-
-@router.get(
-    "/output/state/{serial_number}",
-    response_model=Union[ApiResponse, ApiErrorResponse],
-    responses={
-        200: {"model": ApiResponse, "description": "Query completed successfully"},
-        400: {"model": ApiErrorResponse, "description": "Connection or request error"},
-        408: {"model": ApiErrorResponse, "description": "Request timeout"},
-        500: {"model": ApiErrorResponse, "description": "Internal server error"},
-    },
-)
-async def output_state(
-    request: Request,
-    serial_number: str,
-) -> Union[ApiResponse, ApiErrorResponse, JSONResponse]:
-    """Query module state from a device.
-
-    Sends a state query telegram and retrieves the module state.
-
-    Args:
-        request: FastAPI request object.
-        serial_number: Serial number of the device to query.
-
-    Returns:
-        API response with module state or error.
-    """
-    service = request.app.state.container.get_container().resolve(ConbusOutputService)
-
-    # SendInput telegram and receive responses
-    with service:
-        response = service.get_module_state(serial_number)
-
-    if not response.success:
-        return handle_service_error(response.error or "Unknown error")
-
-    # Build successful response
-    if response.datapoint_telegram and response.datapoint_telegram.datapoint_type:
-        return ApiResponse(
-            success=True,
-            result=response.datapoint_telegram.data_value,
-            description=response.datapoint_telegram.datapoint_type.name,
-        )
-    return ApiResponse(
-        success=True,
-        result="No data available",
-        description="Module state retrieved but no data available",
-    )

xp/api/routers/errors.py

@@ -1,38 +0,0 @@
-"""Error handling utilities for API endpoints."""
-
-from starlette import status
-from starlette.responses import JSONResponse
-
-from xp.api.models.discover import DiscoverErrorResponse
-
-
-def handle_service_error(
-    error: str, default_status_code: int = status.HTTP_500_INTERNAL_SERVER_ERROR
-) -> JSONResponse:
-    """Handle service errors by creating a standardized JSON error response.
-
-    Args:
-        error: Service response object with success and error attributes.
-        default_status_code: HTTP status code to use (defaults to 500).
-
-    Returns:
-        JSONResponse with error details.
-    """
-    error_msg = error or "Unknown service error"
-
-    # Map specific error patterns to appropriate HTTP status codes
-    if "Not connected to server" in error_msg:
-        status_code = status.HTTP_400_BAD_REQUEST
-    elif "Failed to generate telegram" in error_msg:
-        status_code = status.HTTP_400_BAD_REQUEST
-    elif "Response timeout" in error_msg:
-        status_code = status.HTTP_408_REQUEST_TIMEOUT
-    elif "Failed to send telegram" in error_msg:
-        status_code = status.HTTP_500_INTERNAL_SERVER_ERROR
-    else:
-        status_code = default_status_code
-
-    return JSONResponse(
-        status_code=status_code,
-        content=DiscoverErrorResponse(error=error_msg).model_dump(),
-    )

xp/cli/commands/api.py

@@ -1,12 +0,0 @@
-"""API server management CLI commands."""
-
-import click
-from click_help_colors import HelpColorsGroup
-
-
-@click.group(
-    cls=HelpColorsGroup, help_headers_color="yellow", help_options_color="green"
-)
-def api() -> None:
-    """Manage the FastAPI server for XP Protocol operations."""
-    pass

xp/cli/commands/api_start_commands.py

@@ -1,132 +0,0 @@
-"""API server start command."""
-
-import sys
-
-import click
-import uvicorn
-
-from xp.api.main import create_app
-from xp.cli.commands.api import api
-
-
-@api.command("start")
-@click.option(
-    "--host",
-    default="127.0.0.1",
-    help="Host to bind the server to (default: 127.0.0.1)",
-    show_default=True,
-)
-@click.option(
-    "--port",
-    default=8000,
-    type=int,
-    help="Port to bind the server to (default: 8000)",
-    show_default=True,
-)
-@click.option(
-    "--reload",
-    is_flag=True,
-    default=True,
-    help="Enable auto-reload for development",
-)
-@click.option(
-    "--workers",
-    default=1,
-    type=int,
-    help="Number of worker processes (default: 1)",
-    show_default=True,
-)
-@click.option(
-    "--log-level",
-    default="info",
-    type=click.Choice(["critical", "error", "warning", "info", "debug", "trace"]),
-    help="Log level (default: info)",
-    show_default=True,
-)
-@click.option(
-    "--access-log/--no-access-log",
-    default=True,
-    help="Enable/disable access log (default: enabled)",
-)
-@click.pass_context
-def start_api_server(
-    context: click.Context,
-    host: str,
-    port: int,
-    reload: bool,
-    workers: int,
-    log_level: str,
-    access_log: bool,
-) -> None:
-    r"""Start the FastAPI server.
-
-    This command starts the XP Protocol FastAPI server using uvicorn.
-    The server provides REST API endpoints for Conbus operations.
-
-    Args:
-        context: Click context object.
-        host: Host to bind the server to.
-        port: Port to bind the server to.
-        reload: Enable auto-reload for development.
-        workers: Number of worker processes.
-        log_level: Log level for the server.
-        access_log: Enable/disable access log.
-
-    Examples:
-        \b
-        # Start server on default host and port
-        xp api start
-
-        \b
-        # Start server on specific host and port
-        xp api start --host 0.0.0.0 --port 8080
-
-        \b
-        # Start development server with auto-reload
-        xp api start --reload
-
-        \b
-        # Start production server with multiple workers
-        xp api start --host 0.0.0.0 --workers 4 --no-access-log
-    """
-    # Validate workers and reload options
-    if reload and workers > 1:
-        click.echo(
-            click.style(
-                "Warning: Auto-reload is enabled. Setting workers to 1.",
-                fg="yellow",
-            )
-        )
-        workers = 1
-
-    click.echo("Starting XP Protocol API server...")
-    click.echo(f"Server will be available at: https://{host}:{port}")
-    click.echo(f"API documentation at: https://{host}:{port}/docs")
-    click.echo(f"Health check at: https://{host}:{port}/health")
-
-    if reload:
-        click.echo(click.style("Development mode: Auto-reload enabled", fg="green"))
-
-    # Get container from CLI context or create new one
-    container = context.obj.get("container")
-
-    try:
-        # For production mode, create app instance with container
-        app = create_app(container)
-        uvicorn.run(
-            app,
-            host=host,
-            port=port,
-            reload=reload,
-            workers=workers,
-            log_level=log_level,
-            access_log=access_log,
-        )
-    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)

xp/services/conbus/conbus_autoreport_get_service.py

@@ -1,94 +0,0 @@
-"""Conbus Auto Report Service for getting and setting module auto report status.
-
-This service handles auto report status operations for modules through Conbus telegrams.
-"""
-
-import logging
-from typing import Callable, Optional
-
-from twisted.internet.posixbase import PosixReactorBase
-
-from xp.models import ConbusClientConfig, ConbusDatapointResponse
-from xp.models.conbus.conbus_autoreport import ConbusAutoreportResponse
-from xp.models.telegram.datapoint_type import DataPointType
-from xp.services.conbus.conbus_datapoint_service import ConbusDatapointService
-from xp.services.telegram.telegram_service import TelegramService
-
-
-class ConbusAutoreportGetService(ConbusDatapointService):
-    """
-    Service for getting auto report status from Conbus modules.
-
-    Uses ConbusProtocol to provide auto report status query functionality
-    for reading the current auto report configuration from modules.
-    """
-
-    def __init__(
-        self,
-        telegram_service: TelegramService,
-        cli_config: ConbusClientConfig,
-        reactor: PosixReactorBase,
-    ) -> None:
-        """Initialize the Conbus autoreport get service.
-
-        Args:
-            telegram_service: Telegram service for parsing.
-            cli_config: Conbus client configuration.
-            reactor: Twisted reactor instance.
-        """
-        super().__init__(telegram_service, cli_config, reactor)
-        self.service_callback: Optional[Callable[[ConbusAutoreportResponse], None]] = (
-            None
-        )
-
-        # Set up logging
-        self.logger = logging.getLogger(__name__)
-
-    def finish_service_callback(
-        self, datapoint_response: ConbusDatapointResponse
-    ) -> None:
-        """Handle finished service callback.
-
-        Args:
-            datapoint_response: Datapoint response from service.
-        """
-        self.logger.debug("Parsing datapoint response")
-        autoreport_status = ""
-        if datapoint_response.success and datapoint_response.datapoint_telegram:
-            autoreport_status = datapoint_response.datapoint_telegram.data_value
-
-        service_response = ConbusAutoreportResponse(
-            success=datapoint_response.success,
-            serial_number=self.serial_number,
-            auto_report_status=autoreport_status,
-            error=datapoint_response.error,
-            sent_telegram=datapoint_response.sent_telegram,
-            received_telegrams=datapoint_response.received_telegrams,
-            timestamp=datapoint_response.timestamp,
-        )
-
-        if self.service_callback:
-            self.service_callback(service_response)
-
-    def get_autoreport_status(
-        self,
-        serial_number: str,
-        finish_callback: Callable[[ConbusAutoreportResponse], None],
-        timeout_seconds: Optional[float] = None,
-    ) -> None:
-        """
-        Get the current auto report status for a specific module.
-
-        Args:
-            serial_number: 10-digit module serial number
-            finish_callback: callback function to call when the auto report status is received
-            timeout_seconds: timeout in seconds
-        """
-        self.logger.info("Starting get_autoreport_status")
-        if timeout_seconds:
-            self.timeout_seconds = timeout_seconds
-        self.serial_number = serial_number
-        self.datapoint_type = DataPointType.AUTO_REPORT_STATUS
-        self.finish_callback = self.finish_service_callback
-        self.service_callback = finish_callback
-        self.start_reactor()

xp/services/conbus/conbus_autoreport_set_service.py

@@ -1,141 +0,0 @@
-"""Conbus Auto Report Service for getting and setting module auto report status.
-
-This service handles auto report status operations for modules through Conbus telegrams.
-"""
-
-import logging
-from datetime import datetime
-from typing import Callable, Optional
-
-from twisted.internet.posixbase import PosixReactorBase
-
-from xp.models import ConbusClientConfig
-from xp.models.conbus.conbus_autoreport import ConbusAutoreportResponse
-from xp.models.protocol.conbus_protocol import TelegramReceivedEvent
-from xp.models.telegram.datapoint_type import DataPointType
-from xp.models.telegram.system_function import SystemFunction
-from xp.models.telegram.telegram_type import TelegramType
-from xp.services.protocol import ConbusProtocol
-
-
-class ConbusAutoreportSetService(ConbusProtocol):
-    """
-    Service for setting auto report status on Conbus modules.
-
-    Uses ConbusProtocol to provide auto report configuration functionality
-    for enabling/disabling automatic reporting on modules.
-    """
-
-    def __init__(
-        self,
-        cli_config: ConbusClientConfig,
-        reactor: PosixReactorBase,
-    ) -> None:
-        """Initialize the Conbus autoreport set service.
-
-        Args:
-            cli_config: Conbus client configuration.
-            reactor: Twisted reactor instance.
-        """
-        super().__init__(cli_config, reactor)
-        self.serial_number: str = ""
-        self.status: bool = False
-        self.finish_callback: Optional[Callable[[ConbusAutoreportResponse], None]] = (
-            None
-        )
-        self.service_response: ConbusAutoreportResponse = ConbusAutoreportResponse(
-            success=False,
-            serial_number=self.serial_number,
-        )
-
-        # Set up logging
-        self.logger = logging.getLogger(__name__)
-
-    def connection_established(self) -> None:
-        """Handle connection established event."""
-        # Convert boolean to appropriate value
-        status_value = "PP" if self.status else "AA"
-        status_text = "on" if self.status else "off"
-
-        self.logger.debug("Connection established, set autoreport to %s", status_text)
-        self.send_telegram(
-            telegram_type=TelegramType.SYSTEM,
-            serial_number=self.serial_number,
-            system_function=SystemFunction.WRITE_CONFIG,
-            data_value=f"{DataPointType.AUTO_REPORT_STATUS.value}{status_value}",
-        )
-
-    def telegram_sent(self, telegram_sent: str) -> None:
-        """Handle telegram sent event.
-
-        Args:
-            telegram_sent: The telegram that was sent.
-        """
-        self.logger.debug("Autoreport reply telegram sent %s", telegram_sent)
-        self.service_response.sent_telegram = 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}")
-        if not self.service_response.received_telegrams:
-            self.service_response.received_telegrams = []
-        self.service_response.received_telegrams.append(telegram_received.frame)
-
-        if not (
-            telegram_received.checksum_valid
-            and telegram_received.telegram_type == TelegramType.REPLY
-            and telegram_received.serial_number == self.serial_number
-            and telegram_received.system_function
-            in (SystemFunction.ACK, SystemFunction.NAK)
-        ):
-            self.logger.debug(f"Not a reply telegram received: {telegram_received}")
-            return
-
-        self.service_response.success = True
-        self.service_response.timestamp = datetime.now()
-        self.service_response.result = telegram_received.system_function.name
-        self.service_response.auto_report_status = "on" if self.status else "off"
-
-        self.logger.debug("Received autoreport reply telegram")
-        if self.finish_callback:
-            self.finish_callback(self.service_response)
-
-    def failed(self, message: str) -> None:
-        """Handle failed connection event.
-
-        Args:
-            message: Failure message.
-        """
-        self.logger.debug(f"Failed with message: {message}")
-        self.service_response.success = False
-        self.service_response.error = message
-        self.service_response.timestamp = datetime.now()
-        if self.finish_callback:
-            self.finish_callback(self.service_response)
-
-    def set_autoreport_status(
-        self,
-        serial_number: str,
-        status: bool,
-        finish_callback: Callable[[ConbusAutoreportResponse], None],
-        timeout_seconds: Optional[float] = None,
-    ) -> None:
-        """Set the auto report status for a specific module.
-
-        Args:
-            serial_number: 10-digit module serial number.
-            status: True for ON, False for OFF.
-            finish_callback: Callback function to call when operation completes.
-            timeout_seconds: Timeout in seconds.
-        """
-        self.logger.info("Starting set_autoreport_status")
-        if timeout_seconds:
-            self.timeout_seconds = timeout_seconds
-        self.finish_callback = finish_callback
-        self.serial_number = serial_number
-        self.status = status
-        self.start_reactor()

xp/services/conbus/conbus_lightlevel_get_service.py

@@ -1,109 +0,0 @@
-"""Conbus Lightlevel Get Service for getting module light levels.
-
-This service handles light level query operations for modules through Conbus telegrams.
-"""
-
-import logging
-from datetime import datetime
-from typing import Callable, Optional
-
-from twisted.internet.posixbase import PosixReactorBase
-
-from xp.models import ConbusClientConfig, ConbusDatapointResponse
-from xp.models.conbus.conbus_lightlevel import ConbusLightlevelResponse
-from xp.models.telegram.datapoint_type import DataPointType
-from xp.services.conbus.conbus_datapoint_service import ConbusDatapointService
-from xp.services.telegram.telegram_service import TelegramService
-
-
-class ConbusLightlevelGetService(ConbusDatapointService):
-    """
-    Service for getting light levels from Conbus modules.
-
-    Uses ConbusProtocol to provide light level query functionality
-    for reading the current light level configuration from module outputs.
-    """
-
-    def __init__(
-        self,
-        telegram_service: TelegramService,
-        cli_config: ConbusClientConfig,
-        reactor: PosixReactorBase,
-    ) -> None:
-        """Initialize the Conbus lightlevel get service.
-
-        Args:
-            telegram_service: Service for parsing telegrams.
-            cli_config: Configuration for Conbus client connection.
-            reactor: Twisted reactor for event loop.
-        """
-        super().__init__(telegram_service, cli_config, reactor)
-        self.output_number: int = 0
-        self.service_callback: Optional[Callable[[ConbusLightlevelResponse], None]] = (
-            None
-        )
-
-        # Set up logging
-        self.logger = logging.getLogger(__name__)
-
-    def finish_service_callback(
-        self, datapoint_response: ConbusDatapointResponse
-    ) -> None:
-        """Process datapoint response and extract light level.
-
-        Args:
-            datapoint_response: The datapoint response from the module.
-        """
-        self.logger.debug("Parsing datapoint response")
-
-        level = 0
-        if datapoint_response.success and datapoint_response.datapoint_telegram:
-            for output_data in datapoint_response.datapoint_telegram.data_value.split(
-                ","
-            ):
-                if ":" in output_data:
-                    output_str, level_str = output_data.split(":")
-                    if int(output_str) == self.output_number:
-                        level_str = level_str.replace("[%]", "")
-                        level = int(level_str)
-                        break
-
-        service_response = ConbusLightlevelResponse(
-            success=datapoint_response.success,
-            serial_number=self.serial_number,
-            output_number=self.output_number,
-            level=level,
-            error=datapoint_response.error,
-            sent_telegram=datapoint_response.sent_telegram,
-            received_telegrams=datapoint_response.received_telegrams,
-            timestamp=datetime.now(),
-        )
-
-        if self.service_callback:
-            self.service_callback(service_response)
-
-    def get_light_level(
-        self,
-        serial_number: str,
-        output_number: int,
-        finish_callback: Callable[[ConbusLightlevelResponse], None],
-        timeout_seconds: Optional[float] = None,
-    ) -> None:
-        """Get the current light level for a specific module output.
-
-        Args:
-            serial_number: 10-digit module serial number.
-            output_number: Output module number.
-            finish_callback: Callback function to call when the light level is received.
-            timeout_seconds: Timeout in seconds.
-        """
-        self.logger.info("Starting get_light_level")
-        if timeout_seconds:
-            self.timeout_seconds = timeout_seconds
-        self.serial_number = serial_number
-        self.output_number = output_number
-        self.datapoint_type = DataPointType.MODULE_LIGHT_LEVEL
-
-        self.finish_callback = self.finish_service_callback
-        self.service_callback = finish_callback
-        self.start_reactor()