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

xp/api/main.py

@@ -1,125 +0,0 @@
-"""FastAPI application for XP Protocol API endpoints."""
-
-import logging
-import os
-from pathlib import Path
-from typing import Any
-
-import yaml
-from fastapi import FastAPI
-from fastapi.middleware.cors import CORSMiddleware
-
-from xp.api.routers import conbus
-from xp.utils.dependencies import ServiceContainer
-
-# Set up logging
-logging.basicConfig(level=logging.INFO)
-logger = logging.getLogger(__name__)
-
-
-def load_api_config() -> dict[str, Any]:
-    """Load API configuration from api.yml or environment variables.
-
-    Returns:
-        Dictionary containing API configuration settings.
-    """
-    config = {
-        "title": "XP Protocol API",
-        "description": "REST API for XP Protocol Conbus operations",
-        "version": "0.2.0",
-        "cors_origins": ["*"],
-        "cors_methods": ["GET", "POST"],
-        "cors_headers": ["*"],
-    }
-
-    # Try to load from api.yml
-    try:
-        if Path("api.yml").exists():
-            with Path("api.yml").open("r") as file:
-                file_config = yaml.safe_load(file)
-                if file_config:
-                    config.update(file_config.get("api", {}))
-                    logger.info("Loaded API configuration from api.yml")
-    except Exception as e:
-        logger.warning(f"Could not load api.yml: {e}")
-
-    # Override with environment variables
-    config["title"] = os.getenv("API_TITLE", config["title"])
-    config["description"] = os.getenv("API_DESCRIPTION", config["description"])
-    config["version"] = os.getenv("API_VERSION", config["version"])
-
-    # CORS configuration from environment
-    cors_origins = os.getenv("CORS_ORIGINS")
-    if cors_origins is not None:
-        config["cors_origins"] = cors_origins.split(",")
-    cors_methods = os.getenv("CORS_METHODS")
-    if cors_methods is not None:
-        config["cors_methods"] = cors_methods.split(",")
-    cors_headers = os.getenv("CORS_HEADERS")
-    if cors_headers is not None:
-        config["cors_headers"] = cors_headers.split(",")
-
-    return config
-
-
-def create_app(container: ServiceContainer) -> FastAPI:
-    """Create and configure the FastAPI application.
-
-    Args:
-        container: Optional ServiceContainer instance. If not provided, a new one will be created.
-
-    Returns:
-        Configured FastAPI application instance.
-    """
-    config = load_api_config()
-
-    fastapi = FastAPI(
-        title=config["title"],
-        description=config["description"],
-        version=config["version"],
-        docs_url="/docs",
-        redoc_url="/redoc",
-    )
-
-    # Add CORS middleware
-    fastapi.add_middleware(
-        CORSMiddleware,
-        allow_origins=config["cors_origins"],
-        allow_credentials=True,
-        allow_methods=config["cors_methods"],
-        allow_headers=config["cors_headers"],
-    )
-
-    # Initialize service container
-    fastapi.state.container = container
-
-    # Include routers
-    fastapi.include_router(conbus.router)
-
-    # Health check endpoint
-    @fastapi.get("/health")
-    async def health_check() -> dict[str, str]:
-        """Return health status of the API.
-
-        Returns:
-            Dictionary containing status and service information.
-        """
-        return {"status": "healthy", "service": "xp-api"}
-
-    # Root endpoint
-    @fastapi.get("/")
-    async def root() -> dict[str, str]:
-        """Return API information and available endpoints.
-
-        Returns:
-            Dictionary containing API metadata and endpoint links.
-        """
-        return {
-            "message": "XP Protocol API",
-            "version": config["version"],
-            "docs": "/docs",
-            "health": "/health",
-        }
-
-    logger.info(f"FastAPI application created: {config['title']} v{config['version']}")
-    return fastapi

xp/api/models/__init__.py

@@ -1 +0,0 @@
-"""API models for request and response validation."""

xp/api/models/api.py

@@ -1,31 +0,0 @@
-"""Pydantic models for Input API endpoints."""
-
-from typing import Optional
-
-from pydantic import BaseModel, Field
-
-
-class ApiResponse(BaseModel):
-    """Response model for successful Input operation.
-
-    Attributes:
-        success: Operation success status.
-        result: Result value.
-        description: Description of the result.
-    """
-
-    success: bool = Field(default=True, description="Operation success status")
-    result: Optional[str] = Field(default=None, description="Result")
-    description: Optional[str] = Field(default=None, description="Description")
-
-
-class ApiErrorResponse(BaseModel):
-    """Response model for failed Input operation.
-
-    Attributes:
-        success: Operation success status (always False).
-        error: Error message describing what went wrong.
-    """
-
-    success: bool = Field(default=False, description="Operation success status")
-    error: str = Field(..., description="Error message")

xp/api/models/discover.py

@@ -1,31 +0,0 @@
-"""Pydantic models for discover API endpoints."""
-
-from typing import List
-
-from pydantic import BaseModel, Field
-
-
-class DiscoverResponse(BaseModel):
-    """Response model for successful discover operation.
-
-    Attributes:
-        success: Operation success status.
-        devices: List of discovered device information strings.
-    """
-
-    success: bool = Field(default=True, description="Operation success status")
-    devices: List[str] = Field(
-        default_factory=list, description="Parsed device information"
-    )
-
-
-class DiscoverErrorResponse(BaseModel):
-    """Response model for failed discover operation.
-
-    Attributes:
-        success: Operation success status (always False).
-        error: Error message describing what went wrong.
-    """
-
-    success: bool = Field(default=False, description="Operation success status")
-    error: str = Field(..., description="Error message")

xp/api/routers/__init__.py

@@ -1,17 +0,0 @@
-"""API routers for FastAPI endpoints."""
-
-from xp.api.routers import (
-    conbus_blink,
-    conbus_custom,
-    conbus_datapoint,
-    conbus_output,
-)
-from xp.api.routers.conbus import router
-
-__all__ = [
-    "router",
-    "conbus_blink",
-    "conbus_custom",
-    "conbus_datapoint",
-    "conbus_output",
-]

xp/api/routers/conbus.py

@@ -1,5 +0,0 @@
-"""FastAPI router for Conbus operations."""
-
-from fastapi import APIRouter
-
-router = APIRouter(prefix="/api/conbus", tags=["conbus"])

xp/api/routers/conbus_blink.py

@@ -1,117 +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.services.conbus.conbus_blink_service import ConbusBlinkService
-
-logger = logging.getLogger(__name__)
-
-
-@router.get(
-    "/blink/on/{serial_number}",
-    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 blink_on(
-    request: Request,
-    serial_number: str = "1702033007",
-) -> Union[ApiResponse, ApiErrorResponse, JSONResponse]:
-    """Turn on device blinking.
-
-    Sends a blink on telegram to make the device blink.
-
-    Args:
-        request: FastAPI request object.
-        serial_number: Serial number of the device.
-
-    Returns:
-        API response with blink result or error.
-    """
-    service = request.app.state.container.get_container().resolve(ConbusBlinkService)
-
-    # SendInput telegram and receive responses
-    with service:
-        response = service.send_blink_telegram(
-            serial_number=serial_number, on_or_off="on"
-        )
-
-    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
-    return ApiResponse(
-        success=True,
-        result=response.system_function.name,
-        description=(
-            response.reply_telegram.system_function.get_description()
-            if response.reply_telegram and response.reply_telegram.system_function
-            else None
-        ),
-        # raw_telegram = response.output_telegram.raw_telegram,
-    )
-
-
-@router.get(
-    "/blink/off/{serial_number}",
-    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 blink_off(
-    request: Request,
-    serial_number: str = "1702033007",
-) -> Union[ApiResponse, ApiErrorResponse, JSONResponse]:
-    """Turn off device blinking.
-
-    Sends a blink off telegram to stop the device from blinking.
-
-    Args:
-        request: FastAPI request object.
-        serial_number: Serial number of the device.
-
-    Returns:
-        API response with blink result or error.
-    """
-    service = request.app.state.container.get_container().resolve(ConbusBlinkService)
-
-    # SendInput telegram and receive responses
-    with service:
-        response = service.send_blink_telegram(
-            serial_number=serial_number, on_or_off="off"
-        )
-
-    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
-    return ApiResponse(
-        success=True,
-        result=response.system_function.name,
-        description=(
-            response.reply_telegram.system_function.get_description()
-            if response.reply_telegram and response.reply_telegram.system_function
-            else None
-        ),
-        # raw_telegram = response.output_telegram.raw_telegram,
-    )

xp/api/routers/conbus_custom.py

@@ -1,71 +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]:
-    """Execute a custom function on a device.
-
-    Sends a custom telegram with specified function code and data.
-
-    Args:
-        request: FastAPI request object.
-        serial_number: Serial number of the device.
-        function_code: Function code to execute.
-        data: Data to send with the function.
-
-    Returns:
-        API response with custom function result or error.
-    """
-    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,74 +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]:
-    """Query a datapoint value from a device.
-
-    Sends a datapoint query telegram and retrieves the requested datapoint value.
-
-    Args:
-        request: FastAPI request object.
-        datapoint: Type of datapoint to query (default: SW_VERSION).
-        serial_number: Serial number of the device.
-
-    Returns:
-        API response with datapoint value or error.
-    """
-    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,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(),
-    )