sp-rtk-base 0.2.0__py3-none-any.whl

sp_rtk_base/__init__.py

@@ -0,0 +1,5 @@
+"""SP-Base: Web UI and API for u-blox GPS RTK base station relay control."""
+
+from __future__ import annotations
+
+__version__ = "0.2.0"

sp_rtk_base/api/__init__.py

@@ -0,0 +1,3 @@
+"""SP-Base REST API endpoints."""
+
+from __future__ import annotations

sp_rtk_base/api/config.py

@@ -0,0 +1,99 @@
+"""Config import/export API endpoints.
+
+Provides YAML-based configuration export (download) and import (upload)
+for backing up and restoring the full application configuration.
+"""
+
+from __future__ import annotations
+
+import logging
+
+import yaml
+from fastapi import APIRouter, Depends, HTTPException, UploadFile
+from fastapi.responses import Response
+
+from sp_rtk_base.models.config_models import AppConfig
+from sp_rtk_base.services import get_config_service
+from sp_rtk_base.services.config_service import ConfigService
+
+logger = logging.getLogger(__name__)
+
+router = APIRouter(prefix="/api/config", tags=["config"])
+
+
+@router.get("/export")
+async def export_config(
+    config_svc: ConfigService = Depends(get_config_service),
+) -> Response:
+    """Export the full application configuration as a YAML file download.
+
+    Returns:
+        YAML file response with Content-Disposition attachment header.
+    """
+    config = config_svc.get_config()
+    data = config.model_dump(mode="json", exclude_none=True)
+    yaml_text = yaml.dump(data, default_flow_style=False, sort_keys=False)
+
+    return Response(
+        content=yaml_text,
+        media_type="application/x-yaml",
+        headers={"Content-Disposition": "attachment; filename=sp-rtk-base-config.yaml"},
+    )
+
+
+@router.post("/import")
+async def import_config(
+    file: UploadFile,
+    config_svc: ConfigService = Depends(get_config_service),
+) -> dict[str, str]:
+    """Import application configuration from a YAML file upload.
+
+    Validates the uploaded YAML against the AppConfig schema before saving.
+
+    Args:
+        file: The uploaded YAML configuration file.
+
+    Returns:
+        Success message with destination/input counts.
+
+    Raises:
+        HTTPException: 400 if the file is not valid YAML or fails schema validation.
+    """
+    try:
+        content = await file.read()
+        text = content.decode("utf-8")
+    except Exception as exc:
+        raise HTTPException(
+            status_code=400, detail=f"Failed to read uploaded file: {exc}"
+        ) from exc
+
+    if not text.strip():
+        raise HTTPException(status_code=400, detail="Uploaded file is empty")
+
+    try:
+        data = yaml.safe_load(text)
+    except yaml.YAMLError as exc:
+        raise HTTPException(status_code=400, detail=f"Invalid YAML: {exc}") from exc
+
+    if not isinstance(data, dict):
+        raise HTTPException(
+            status_code=400, detail="YAML content must be a mapping (object)"
+        )
+
+    try:
+        config = AppConfig.model_validate(data)
+    except Exception as exc:
+        raise HTTPException(
+            status_code=400, detail=f"Invalid configuration schema: {exc}"
+        ) from exc
+
+    config_svc.save_config(config)
+    logger.info("Configuration imported successfully")
+
+    return {
+        "status": "ok",
+        "message": (
+            f"Configuration imported: {len(config.destinations)} destinations, "
+            f"input={'configured' if config.input else 'none'}"
+        ),
+    }

sp_rtk_base/api/destinations.py

@@ -0,0 +1,161 @@
+"""Destination management API endpoints.
+
+Provides CRUD operations for relay destination profiles.
+"""
+
+from __future__ import annotations
+
+import logging
+
+from fastapi import APIRouter, Depends
+from fastapi.responses import JSONResponse
+
+from sp_rtk_base.models.api_models import (
+    DestinationCreateRequest,
+    DestinationListResponse,
+    DestinationResponse,
+    DestinationUpdateRequest,
+    RelayActionResponse,
+)
+from sp_rtk_base.models.config_models import DestinationProfile, FilterProfile
+from sp_rtk_base.services import get_config_service
+from sp_rtk_base.services.config_service import ConfigService
+
+logger = logging.getLogger(__name__)
+
+router = APIRouter(prefix="/api/destinations", tags=["destinations"])
+
+
+def _profile_to_response(profile: DestinationProfile) -> DestinationResponse:
+    """Convert a DestinationProfile to an API response model."""
+    return DestinationResponse(
+        name=profile.name,
+        type=profile.type,
+        enabled=profile.enabled,
+        config=profile.config,
+        filter=profile.filter.model_dump(),
+    )
+
+
+@router.get("", response_model=DestinationListResponse)
+async def list_destinations(
+    config_svc: ConfigService = Depends(get_config_service),
+) -> DestinationListResponse:
+    """List all configured destinations."""
+    destinations = config_svc.get_destinations()
+    items = [_profile_to_response(d) for d in destinations]
+    return DestinationListResponse(destinations=items, count=len(items))
+
+
+@router.get("/{name}", response_model=DestinationResponse)
+async def get_destination(
+    name: str,
+    config_svc: ConfigService = Depends(get_config_service),
+) -> DestinationResponse | JSONResponse:
+    """Get a single destination by name."""
+    dest = config_svc.get_destination(name)
+    if dest is None:
+        return JSONResponse(
+            status_code=404,
+            content={"status": "error", "message": f"Destination '{name}' not found"},
+        )
+    return _profile_to_response(dest)
+
+
+@router.post("", response_model=DestinationResponse, status_code=201)
+async def create_destination(
+    request: DestinationCreateRequest,
+    config_svc: ConfigService = Depends(get_config_service),
+) -> DestinationResponse | JSONResponse:
+    """Create a new destination profile.
+
+    The destination is saved to config but not added to the running
+    relay engine. Restart the relay or use the relay start endpoint
+    to apply changes.
+    """
+    # Check for duplicate name
+    existing = config_svc.get_destination(request.name)
+    if existing is not None:
+        return JSONResponse(
+            status_code=409,
+            content={
+                "status": "error",
+                "message": f"Destination '{request.name}' already exists",
+            },
+        )
+
+    try:
+        profile = DestinationProfile(
+            name=request.name,
+            type=request.type,  # type: ignore[arg-type]
+            enabled=request.enabled,
+            config=request.config,
+            filter=FilterProfile.model_validate(request.filter),
+        )
+        config_svc.save_destination(profile)
+        logger.info("Created destination: %s", request.name)
+        return _profile_to_response(profile)
+    except Exception as exc:
+        return JSONResponse(
+            status_code=400,
+            content={"status": "error", "message": str(exc)},
+        )
+
+
+@router.put("/{name}", response_model=DestinationResponse)
+async def update_destination(
+    name: str,
+    request: DestinationUpdateRequest,
+    config_svc: ConfigService = Depends(get_config_service),
+) -> DestinationResponse | JSONResponse:
+    """Update an existing destination profile.
+
+    Only the provided fields are updated; unset fields retain
+    their current values.
+    """
+    existing = config_svc.get_destination(name)
+    if existing is None:
+        return JSONResponse(
+            status_code=404,
+            content={"status": "error", "message": f"Destination '{name}' not found"},
+        )
+
+    try:
+        updated_data = existing.model_dump()
+        if request.enabled is not None:
+            updated_data["enabled"] = request.enabled
+        if request.config is not None:
+            updated_data["config"] = request.config
+        if request.filter is not None:
+            updated_data["filter"] = request.filter
+
+        updated = DestinationProfile.model_validate(updated_data)
+        config_svc.save_destination(updated)
+        logger.info("Updated destination: %s", name)
+        return _profile_to_response(updated)
+    except Exception as exc:
+        return JSONResponse(
+            status_code=400,
+            content={"status": "error", "message": str(exc)},
+        )
+
+
+@router.delete("/{name}", response_model=RelayActionResponse)
+async def delete_destination(
+    name: str,
+    config_svc: ConfigService = Depends(get_config_service),
+) -> RelayActionResponse | JSONResponse:
+    """Delete a destination profile.
+
+    Removes the destination from saved config. If the relay is
+    running, the destination continues until the relay is restarted.
+    """
+    removed = config_svc.remove_destination(name)
+    if not removed:
+        return JSONResponse(
+            status_code=404,
+            content={"status": "error", "message": f"Destination '{name}' not found"},
+        )
+
+    logger.info("Deleted destination: %s", name)
+    return RelayActionResponse(status="ok", message=f"Destination '{name}' deleted")