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

xp/services/telegram/telegram_datapoint_service.py

@@ -0,0 +1,70 @@
+"""Service for processing Telegram protocol datapoint values."""
+
+
+class TelegramDatapointService:
+    """Service for processing Telegram protocol datapoint values.
+
+    Provides methods to parse and extract values from different types of
+    Telegram datapoints including autoreport status, light level outputs,
+    and link number values.
+    """
+
+    def get_autoreport_status(self, data_value: str) -> bool:
+        """Get the autoreport status value.
+
+        Args:
+            data_value: The raw autoreport status data value (PP or AA).
+
+        Returns:
+            The autoreport status: Enable (True) or disable (False).
+        """
+        status_value = True if data_value == "PP" else False
+        return status_value
+
+    def get_autoreport_status_data_value(self, status_value: bool) -> str:
+        """Get the autoreport status data_value.
+
+        Args:
+            status_value: Enable (True) or disable (False).
+
+        Returns:
+            data_value: The raw autoreport status data value (PP or AA).
+        """
+        data_value = "PP" if status_value else "AA"
+        return data_value
+
+    def get_lightlevel(self, data_value: str, output_number: int) -> int:
+        """Extract the light level for a specific output number.
+
+        Parses comma-separated output data in the format "output:level[%]"
+        and returns the level for the requested output number.
+
+        Args:
+            data_value: Comma-separated string of output:level pairs
+                       (e.g., "1:50[%],2:75[%]").
+            output_number: The output number to get the level for.
+
+        Returns:
+            The light level as an integer (0 if output not found).
+        """
+        level = 0
+        for output_data in data_value.split(","):
+            if ":" in output_data:
+                output_str, level_str = output_data.split(":")
+                if int(output_str) == output_number:
+                    level_str = level_str.replace("[%]", "")
+                    level = int(level_str)
+                    break
+        return level
+
+    def get_linknumber(self, data_value: str) -> int:
+        """Parse and return the link number value.
+
+        Args:
+            data_value: The raw link number data value as a string.
+
+        Returns:
+            The link number as an integer.
+        """
+        link_number_value = int(data_value)
+        return link_number_value

xp/utils/dependencies.py

@@ -21,8 +21,6 @@ from xp.services.conbus.actiontable.msactiontable_xp24_serializer import (
 from xp.services.conbus.actiontable.msactiontable_xp33_serializer import (
     Xp33MsActionTableSerializer,
 )
-from xp.services.conbus.conbus_autoreport_get_service import ConbusAutoreportGetService
-from xp.services.conbus.conbus_autoreport_set_service import ConbusAutoreportSetService
 from xp.services.conbus.conbus_blink_all_service import ConbusBlinkAllService
 from xp.services.conbus.conbus_blink_service import ConbusBlinkService
 from xp.services.conbus.conbus_custom_service import ConbusCustomService
@@ -33,13 +31,11 @@ from xp.services.conbus.conbus_datapoint_service import (
     ConbusDatapointService,
 )
 from xp.services.conbus.conbus_discover_service import ConbusDiscoverService
-from xp.services.conbus.conbus_lightlevel_set_service import ConbusLightlevelSetService
-from xp.services.conbus.conbus_linknumber_get_service import ConbusLinknumberGetService
-from xp.services.conbus.conbus_linknumber_set_service import ConbusLinknumberSetService
 from xp.services.conbus.conbus_output_service import ConbusOutputService
 from xp.services.conbus.conbus_raw_service import ConbusRawService
 from xp.services.conbus.conbus_receive_service import ConbusReceiveService
 from xp.services.conbus.conbus_scan_service import ConbusScanService
+from xp.services.conbus.write_config_service import WriteConfigService
 from xp.services.homekit.homekit_cache_service import HomeKitCacheService
 from xp.services.homekit.homekit_conbus_service import HomeKitConbusService
 from xp.services.homekit.homekit_dimminglight_service import HomeKitDimmingLightService
@@ -191,8 +187,9 @@ class ServiceContainer:
         )
 
         self.container.register(
-            ConbusLightlevelSetService,
-            factory=lambda: ConbusLightlevelSetService(
+            WriteConfigService,
+            factory=lambda: WriteConfigService(
+                telegram_service=self.container.resolve(TelegramService),
                 cli_config=self.container.resolve(ConbusClientConfig),
                 reactor=self.container.resolve(PosixReactorBase),
             ),
@@ -247,45 +244,6 @@ class ServiceContainer:
             scope=punq.Scope.singleton,
         )
 
-        self.container.register(
-            ConbusAutoreportSetService,
-            factory=lambda: ConbusAutoreportSetService(
-                cli_config=self.container.resolve(ConbusClientConfig),
-                reactor=self.container.resolve(PosixReactorBase),
-            ),
-            scope=punq.Scope.singleton,
-        )
-
-        self.container.register(
-            ConbusAutoreportGetService,
-            factory=lambda: ConbusAutoreportGetService(
-                telegram_service=self.container.resolve(TelegramService),
-                cli_config=self.container.resolve(ConbusClientConfig),
-                reactor=self.container.resolve(PosixReactorBase),
-            ),
-            scope=punq.Scope.singleton,
-        )
-
-        self.container.register(
-            ConbusLinknumberGetService,
-            factory=lambda: ConbusLinknumberGetService(
-                telegram_service=self.container.resolve(TelegramService),
-                cli_config=self.container.resolve(ConbusClientConfig),
-                reactor=self.container.resolve(PosixReactorBase),
-            ),
-            scope=punq.Scope.singleton,
-        )
-
-        self.container.register(
-            ConbusLinknumberSetService,
-            factory=lambda: ConbusLinknumberSetService(
-                telegram_service=self.container.resolve(TelegramService),
-                cli_config=self.container.resolve(ConbusClientConfig),
-                reactor=self.container.resolve(PosixReactorBase),
-            ),
-            scope=punq.Scope.singleton,
-        )
-
         self.container.register(
             ConbusCustomService,
             factory=lambda: ConbusCustomService(

xp/api/__init__.py

@@ -1 +0,0 @@
-"""API module for FastAPI endpoints and models."""

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",
-    )