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

xp/api/routers/conbus_custom.py

@@ -1,63 +0,0 @@
-"""FastAPI router for Conbus operations."""
-
-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.services.conbus.conbus_custom_service import ConbusCustomService
-
-logger = logging.getLogger(__name__)
-
-
-@router.get(
-    "/custom/{serial_number}/{function_code}/{data}",
-    response_model=Union[ApiResponse, ApiErrorResponse],
-    responses={
-        200: {"model": ApiResponse, "description": "Datapoint 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 custom_function(
-    request: Request,
-    serial_number: str = "1702033007",
-    function_code: str = "02",
-    data: str = "00",
-) -> Union[ApiResponse, ApiErrorResponse, JSONResponse]:
-    """
-    Initiate a Datapoint operation to find devices on the network.
-
-    Sends a broadcastDatapoint telegram and collects responses from all connected devices.
-    """
-    service = request.app.state.container.get_container().resolve(ConbusCustomService)
-    # SendDatapoint telegram and receive responses
-    with service:
-        response = service.send_custom_telegram(serial_number, function_code, data)
-
-    if not response.success:
-        return handle_service_error(response.error or "Unknown error")
-
-    if response.reply_telegram is None:
-        return ApiErrorResponse(
-            success=False,
-            error=response.error or "Unknown error",
-        )
-
-    # Build successful response
-    if response.reply_telegram and response.reply_telegram.datapoint_type:
-        return ApiResponse(
-            success=True,
-            result=response.reply_telegram.data_value,
-            description=response.reply_telegram.datapoint_type.name,
-        )
-    return ApiResponse(
-        success=True,
-        result=response.reply_telegram.data_value,
-        description="Custom command executed successfully",
-    )

xp/api/routers/conbus_datapoint.py

@@ -1,67 +0,0 @@
-"""FastAPI router for Conbus operations."""
-
-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.datapoint_type import DataPointType
-from xp.services.conbus.conbus_datapoint_service import ConbusDatapointService
-
-logger = logging.getLogger(__name__)
-
-
-@router.get(
-    "/datapoint/{datapoint}/{serial_number}",
-    response_model=Union[ApiResponse, ApiErrorResponse],
-    responses={
-        200: {"model": ApiResponse, "description": "Datapoint 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 datapoint_devices(
-    request: Request,
-    datapoint: DataPointType = DataPointType.SW_VERSION,
-    serial_number: str = "1702033007",
-) -> Union[ApiResponse, ApiErrorResponse, JSONResponse]:
-    """
-    Initiate a Datapoint operation to find devices on the network.
-
-    Sends a broadcastDatapoint telegram and collects responses from all connected devices.
-    """
-    service = request.app.state.container.get_container().resolve(
-        ConbusDatapointService
-    )
-    # SendDatapoint telegram and receive responses
-    with service:
-        response = service.query_datapoint(
-            datapoint_type=datapoint, serial_number=serial_number
-        )
-
-    if not response.success:
-        return handle_service_error(response.error or "Unknown error")
-
-    if response.datapoint_telegram is None:
-        return ApiErrorResponse(
-            success=False,
-            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=response.datapoint_telegram.data_value,
-        description="Datapoint value retrieved",
-    )

xp/api/routers/conbus_output.py

@@ -1,147 +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 broadcastInput telegram and collects responses from all connected devices.
-    """
-    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]:
-    """
-    Initiate Input operation to find devices on the network.
-
-    Sends a broadcastInput telegram and collects responses from all connected devices.
-    """
-    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]:
-    """
-    Initiate Input operation to find devices on the network.
-
-    Sends a broadcastInput telegram and collects responses from all connected devices.
-    """
-    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,37 +0,0 @@
-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,16 +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:
-    """
-    API server management commands.
-
-    Manage the FastAPI server for XP Protocol operations.
-    """
-    pass

xp/cli/commands/api_start_commands.py

@@ -1,126 +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:
-    """
-    Start the FastAPI server.
-
-    This command starts the XP Protocol FastAPI server using uvicorn.
-    The server provides REST API endpoints for Conbus operations.
-
-    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,85 +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 receiving telegrams from Conbus servers.
-
-    Uses composition with ConbusService to provide receive-only functionality
-    for collecting waiting event telegrams from the server.
-    """
-
-    def __init__(
-        self,
-        telegram_service: TelegramService,
-        cli_config: ConbusClientConfig,
-        reactor: PosixReactorBase,
-    ) -> None:
-        """Initialize the Conbus client send service"""
-        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:
-
-        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:
-            :param  serial_number: 10-digit module serial number
-            :param  finish_callback: callback function to call when the linknumber status is
-            :param  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,128 +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 receiving telegrams from Conbus servers.
-
-    Uses composition with ConbusService to provide receive-only functionality
-    for collecting waiting event telegrams from the server.
-    """
-
-    def __init__(
-        self,
-        cli_config: ConbusClientConfig,
-        reactor: PosixReactorBase,
-    ) -> None:
-        """Initialize the Conbus client send service"""
-        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:
-        # 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:
-        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:
-
-        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:
-        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 the autoreport status is
-            timeout_seconds: timeout in seconds
-
-        Returns:
-            ConbusAutoreportResponse with operation result
-
-        Raises:
-            ConbusAutoreportError: If parameters are invalid
-        """
-        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()