lumen-app 0.4.2__py3-none-any.whl

lumen_app/web/api/config.py

@@ -0,0 +1,229 @@
+"""Configuration API endpoints."""
+
+from __future__ import annotations
+
+from pathlib import Path
+from typing import Literal
+
+import yaml
+from fastapi import APIRouter, HTTPException
+
+from lumen_app.core.config import Config
+from lumen_app.core.installer import CoreInstaller
+from lumen_app.utils.logger import get_logger
+from lumen_app.utils.preset_registry import PresetRegistry
+from lumen_app.web.core.state import app_state
+from lumen_app.web.models.config import (
+    ConfigRequest,
+    ConfigResponse,
+)
+
+logger = get_logger("lumen.web.api.config")
+router = APIRouter()
+
+
+@router.post("/generate", response_model=ConfigResponse)
+async def generate_config(request: ConfigRequest):
+    """Generate a Lumen configuration from preset and options."""
+    logger.info(f"Generating config for preset: {request.preset}")
+
+    # Validate preset
+    if not PresetRegistry.preset_exists(request.preset):
+        return ConfigResponse(
+            success=False,
+            preset=request.preset,
+            message=f"Unknown preset: {request.preset}",
+        )
+
+    try:
+        # Create device config from preset
+        device_config = PresetRegistry.create_config(request.preset)
+
+        # Create Config instance
+        config = Config(
+            cache_dir=request.cache_dir,
+            device_config=device_config,
+            region=request.region,
+            service_name=request.service_name,
+            port=request.port,
+        )
+
+        # Generate config based on config_type
+        if request.config_type == "minimal":
+            lumen_config = config.minimal()
+        elif request.config_type == "light_weight":
+            # Ensure clip_model is one of the valid types for light_weight
+            light_clip_model: Literal["MobileCLIP2-S2", "CN-CLIP_ViT-B-16"] = (
+                request.clip_model  # type: ignore
+                if request.clip_model in ["MobileCLIP2-S2", "CN-CLIP_ViT-B-16"]
+                else "MobileCLIP2-S2"
+            )
+            lumen_config = config.light_weight(clip_model=light_clip_model)
+        elif request.config_type == "basic":
+            # Ensure clip_model is one of the valid types for basic
+            basic_clip_model: Literal["MobileCLIP2-S4", "CN-CLIP_ViT-L-14"] = (
+                request.clip_model  # type: ignore
+                if request.clip_model in ["MobileCLIP2-S4", "CN-CLIP_ViT-L-14"]
+                else "MobileCLIP2-S4"
+            )
+            lumen_config = config.basic(clip_model=basic_clip_model)
+        elif request.config_type == "brave":
+            lumen_config = config.brave()
+        else:
+            raise ValueError(f"Unknown config_type: {request.config_type}")
+
+        # Save config to file
+        config_dict = lumen_config.model_dump(mode="json")
+        installer = CoreInstaller(cache_dir=request.cache_dir)
+        success, message = installer.save_config(lumen_config)
+
+        if not success:
+            raise ValueError(message)
+
+        config_path = str(Path(request.cache_dir).expanduser() / "lumen-config.yaml")
+
+        # Update app state
+        app_state.set_config(config, device_config)
+
+        return ConfigResponse(
+            success=True,
+            preset=request.preset,
+            config_path=str(config_path),
+            config_content=config_dict,
+            message=f"Configuration generated successfully at {config_path}",
+        )
+
+    except Exception as e:
+        logger.error(f"Failed to generate config: {e}", exc_info=True)
+        return ConfigResponse(
+            success=False,
+            preset=request.preset,
+            message=f"Failed to generate configuration: {str(e)}",
+        )
+
+
+@router.get("/current")
+async def get_current_config():
+    """Get the currently loaded configuration."""
+    config, device_config = app_state.get_config()
+
+    if not config or not device_config:
+        return {"loaded": False, "message": "No configuration loaded"}
+
+    return {
+        "loaded": True,
+        "cache_dir": config.cache_dir,
+        "region": config.region,
+        "port": config.port,
+        "service_name": config.service_name,
+        "device": {
+            "runtime": device_config.runtime.value,
+            "batch_size": device_config.batch_size,
+            "precision": device_config.precision,
+            "rknn_device": device_config.rknn_device,
+            "onnx_providers": [
+                p if isinstance(p, str) else p[0]
+                for p in (device_config.onnx_providers or [])
+            ],
+        },
+    }
+
+
+@router.post("/validate")
+async def validate_config(config: dict):
+    """Validate a configuration."""
+    # TODO: Implement validation logic
+    return {"valid": True, "errors": [], "warnings": []}
+
+
+@router.post("/validate-path")
+async def validate_path(request: dict):
+    """Validate installation path for permissions and disk space."""
+    path_str = request.get("path", "")
+
+    if not path_str:
+        return {
+            "valid": False,
+            "exists": False,
+            "writable": False,
+            "error": "路径不能为空",
+        }
+
+    try:
+        import os
+        import shutil
+
+        # Expand user home directory
+        path = Path(path_str).expanduser()
+
+        # Check if path exists
+        exists = path.exists()
+
+        # Check if writable
+        writable = False
+        error = None
+
+        if exists:
+            # Check if we can write to existing directory
+            writable = os.access(path, os.W_OK)
+            if not writable:
+                error = f"没有写入权限: {path}"
+        else:
+            # Check if we can create the directory
+            parent = path.parent
+            if parent.exists():
+                writable = os.access(parent, os.W_OK)
+                if not writable:
+                    error = f"没有创建目录的权限: {parent}"
+            else:
+                error = f"父目录不存在: {parent}"
+
+        # Check disk space (only if writable)
+        free_space_gb = 0
+        if writable:
+            stat = shutil.disk_usage(path if exists else path.parent)
+            free_space_gb = stat.free / (1024**3)  # Convert to GB
+
+        return {
+            "valid": writable and free_space_gb >= 10,
+            "exists": exists,
+            "writable": writable,
+            "free_space_gb": round(free_space_gb, 2),
+            "error": error,
+            "warning": "磁盘空间不足 (建议至少 10GB)"
+            if writable and free_space_gb < 10
+            else None,
+        }
+
+    except Exception as e:
+        logger.error(f"Failed to validate path: {e}")
+        return {
+            "valid": False,
+            "exists": False,
+            "writable": False,
+            "error": f"路径验证失败: {str(e)}",
+        }
+
+
+@router.post("/load")
+async def load_config(config_path: str):
+    """Load a configuration from file."""
+    try:
+        path = Path(config_path).expanduser()
+        if not path.exists():
+            raise HTTPException(
+                status_code=404, detail=f"Config file not found: {config_path}"
+            )
+
+        with open(path) as f:
+            config_content = yaml.safe_load(f)
+
+        # TODO: Parse and validate the config, then set app_state
+
+        return {"loaded": True, "config_path": str(path), "config": config_content}
+
+    except HTTPException:
+        raise
+    except Exception as e:
+        logger.error(f"Failed to load config: {e}")
+        raise HTTPException(status_code=500, detail=f"Failed to load config: {str(e)}")

lumen_app/web/api/hardware.py

@@ -0,0 +1,201 @@
+"""Hardware detection and driver API endpoints."""
+
+from __future__ import annotations
+
+import platform
+from typing import Literal
+
+from fastapi import APIRouter, HTTPException
+
+from lumen_app.utils.env_checker import EnvironmentChecker
+from lumen_app.utils.logger import get_logger
+from lumen_app.utils.preset_registry import PresetRegistry
+from lumen_app.web.models.hardware import (
+    DriverCheckResponse,
+    HardwareInfoResponse,
+    HardwarePresetResponse,
+)
+
+logger = get_logger("lumen.web.api.hardware")
+router = APIRouter()
+
+
+def _map_driver_status(status) -> Literal["available", "missing", "incompatible"]:
+    """Map internal DriverStatus enum to API status string."""
+    from lumen_app.utils.env_checker import DriverStatus as InternalDriverStatus
+
+    if status == InternalDriverStatus.AVAILABLE:
+        return "available"
+    elif status == InternalDriverStatus.INCOMPATIBLE:
+        return "incompatible"
+    else:
+        return "missing"
+
+
+@router.get("/info", response_model=HardwareInfoResponse)
+async def get_hardware_info():
+    """Get comprehensive hardware information."""
+    logger.info("Getting hardware info")
+
+    # Get system info
+    info = HardwareInfoResponse(
+        platform=platform.system(),
+        machine=platform.machine(),
+        processor=platform.processor(),
+        python_version=platform.python_version(),
+    )
+
+    # Get all presets
+    presets = []
+    for name in PresetRegistry.get_preset_names():
+        preset_info = PresetRegistry.get_preset(name)
+        if preset_info:
+            try:
+                device_config = preset_info.factory_method()
+                preset = HardwarePresetResponse(
+                    name=name,
+                    description=preset_info.description,
+                    runtime=device_config.runtime.value,
+                    providers=[
+                        p if isinstance(p, str) else p[0]
+                        for p in (device_config.onnx_providers or [])
+                    ],
+                    requires_drivers=preset_info.requires_drivers,
+                )
+                presets.append(preset)
+            except Exception as e:
+                logger.warning(f"Failed to process preset {name}: {e}")
+
+    info.presets = presets
+
+    # Detect recommended preset using priority-based detection order
+    detection_order = PresetRegistry.get_detection_order()
+
+    detected_drivers = []
+    for preset_name in detection_order:
+        if PresetRegistry.preset_exists(preset_name):
+            try:
+                report = EnvironmentChecker.check_preset(preset_name)
+                if report.ready:
+                    info.recommended_preset = preset_name
+                    info.drivers = [
+                        DriverCheckResponse(
+                            name=d.name,
+                            status=_map_driver_status(d.status),
+                            details=d.details,
+                            installable_via_mamba=d.installable_via_mamba,
+                            mamba_config_path=d.mamba_config_path,
+                        )
+                        for d in report.drivers
+                    ]
+                    info.all_drivers_available = True
+                    break
+                elif detected_drivers:
+                    # Collect driver info from first preset with available info
+                    continue
+            except Exception as e:
+                logger.warning(f"Failed to check preset {preset_name}: {e}")
+
+    # If no recommended preset found, default to CPU
+    if not info.recommended_preset:
+        info.recommended_preset = "cpu"
+        info.all_drivers_available = True  # CPU doesn't need drivers
+
+    return info
+
+
+@router.get("/presets", response_model=list[HardwarePresetResponse])
+async def list_hardware_presets():
+    """List all available hardware presets."""
+    logger.info("Listing hardware presets")
+
+    presets = []
+    for name in PresetRegistry.get_preset_names():
+        preset_info = PresetRegistry.get_preset(name)
+        if preset_info:
+            try:
+                device_config = preset_info.factory_method()
+                preset = HardwarePresetResponse(
+                    name=name,
+                    description=preset_info.description,
+                    runtime=device_config.runtime.value,
+                    providers=[
+                        p if isinstance(p, str) else p[0]
+                        for p in (device_config.onnx_providers or [])
+                    ],
+                    requires_drivers=preset_info.requires_drivers,
+                )
+                presets.append(preset)
+            except Exception as e:
+                logger.warning(f"Failed to process preset {name}: {e}")
+
+    return presets
+
+
+@router.get("/presets/{preset_name}/check", response_model=list[DriverCheckResponse])
+async def check_preset_drivers(preset_name: str):
+    """Check driver status for a specific preset."""
+    logger.info(f"Checking drivers for preset: {preset_name}")
+
+    if not PresetRegistry.preset_exists(preset_name):
+        raise HTTPException(status_code=404, detail=f"Preset '{preset_name}' not found")
+
+    try:
+        report = EnvironmentChecker.check_preset(preset_name)
+        return [
+            DriverCheckResponse(
+                name=d.name,
+                status=_map_driver_status(d.status),
+                details=d.details,
+                installable_via_mamba=d.installable_via_mamba,
+                mamba_config_path=d.mamba_config_path,
+            )
+            for d in report.drivers
+        ]
+    except Exception as e:
+        logger.error(f"Failed to check preset {preset_name}: {e}")
+        raise HTTPException(
+            status_code=500, detail=f"Failed to check drivers: {str(e)}"
+        )
+
+
+@router.post("/detect", response_model=dict)
+async def detect_hardware():
+    """Detect available hardware and recommended preset."""
+    logger.info("Detecting hardware")
+
+    # Check each preset in priority order
+    detection_order = PresetRegistry.get_detection_order()
+
+    detected = []
+    recommended = None
+
+    for preset_name in detection_order:
+        if not PresetRegistry.preset_exists(preset_name):
+            continue
+
+        try:
+            report = EnvironmentChecker.check_preset(preset_name)
+            status = {
+                "preset": preset_name,
+                "ready": report.ready,
+                "drivers": [
+                    {
+                        "name": d.name,
+                        "status": _map_driver_status(d.status),
+                        "installable": d.installable_via_mamba,
+                    }
+                    for d in report.drivers
+                ],
+            }
+            detected.append(status)
+
+            if report.ready and not recommended:
+                recommended = preset_name
+        except Exception as e:
+            logger.warning(f"Failed to check {preset_name}: {e}")
+
+    return {
+        "recommended_preset": recommended or "cpu",
+        "detailed_status": detected,
+    }