lumen-app 0.4.2__py3-none-any.whl

lumen_app/web/core/state.py

@@ -0,0 +1,264 @@
+"""Application state management for Lumen Web API."""
+
+from __future__ import annotations
+
+import asyncio
+from dataclasses import dataclass, field
+from typing import Any
+
+from lumen_app.core.config import Config, DeviceConfig
+from lumen_app.utils.env_checker import EnvironmentReport
+from lumen_app.utils.logger import get_logger
+from lumen_app.web.core.server_manager import ServerManager
+
+# Optional import - AppService may not be available if gRPC is not installed
+try:
+    from lumen_app.core.service import AppService
+except ImportError:
+    AppService = None  # type: ignore[misc,assignment]
+
+logger = get_logger("lumen.web.state")
+
+
+@dataclass
+class ServerStatus:
+    """Server process status."""
+
+    running: bool = False
+    pid: int | None = None
+    port: int = 50051
+    config_path: str | None = None
+    logs: list[dict] = field(default_factory=list)
+
+
+@dataclass
+class InstallationTask:
+    """Installation task status."""
+
+    id: str
+    type: str  # "micromamba", "environment", "drivers"
+    status: str  # "pending", "running", "completed", "failed"
+    progress: int = 0
+    message: str = ""
+    created_at: float = field(default_factory=lambda: asyncio.get_event_loop().time())
+
+
+class AppState:
+    """Global application state."""
+
+    def __init__(self):
+        self._initialized = False
+        self.current_config: Config | None = None
+        self.device_config: DeviceConfig | None = None
+        self.environment_report: EnvironmentReport | None = None
+        self.server_status = ServerStatus()
+        self.app_service: AppService | None = None
+
+        # Server manager for gRPC ML server
+        self.server_manager = ServerManager()
+
+        # Installation tasks (old format - to be deprecated)
+        self._tasks: dict[str, InstallationTask] = {}
+        self._task_lock = asyncio.Lock()
+
+        # New installation tasks
+        self._install_tasks: dict[str, Any] = {}  # task_id -> InstallTaskResponse
+        self._install_logs: dict[str, list[str]] = {}  # task_id -> logs
+        self._install_lock = asyncio.Lock()
+
+        # Log subscribers
+        self._log_queues: list[asyncio.Queue] = []
+        self._log_lock = asyncio.Lock()
+
+    async def initialize(self):
+        """Initialize application state."""
+        if self._initialized:
+            return
+
+        logger.info("Initializing application state")
+
+        # Load default configuration
+        try:
+            # Start with CPU preset as default
+            self.device_config = DeviceConfig.cpu()
+            logger.info("Loaded default CPU configuration")
+        except Exception as e:
+            logger.error(f"Failed to load default configuration: {e}")
+
+        self._initialized = True
+        logger.info("Application state initialized")
+
+    async def cleanup(self):
+        """Cleanup application state."""
+        logger.info("Cleaning up application state")
+
+        # Stop server if running
+        if self.server_status.running:
+            await self.stop_server()
+
+        # Clear log queues
+        async with self._log_lock:
+            for queue in self._log_queues:
+                while not queue.empty():
+                    try:
+                        queue.get_nowait()
+                    except asyncio.QueueEmpty:
+                        break
+            self._log_queues.clear()
+
+        self._initialized = False
+        logger.info("Application state cleaned up")
+
+    # Configuration methods
+    def set_config(self, config: Config, device_config: DeviceConfig):
+        """Set current configuration."""
+        self.current_config = config
+        self.device_config = device_config
+        logger.info(f"Configuration updated: {device_config}")
+
+    def get_config(self) -> tuple[Config | None, DeviceConfig | None]:
+        """Get current configuration."""
+        return self.current_config, self.device_config
+
+    # Task management
+    async def create_task(self, task_type: str) -> InstallationTask:
+        """Create a new installation task."""
+        import uuid
+
+        task_id = str(uuid.uuid4())
+        task = InstallationTask(
+            id=task_id,
+            type=task_type,
+            status="pending",
+        )
+
+        async with self._task_lock:
+            self._tasks[task_id] = task
+
+        logger.info(f"Created task {task_id} of type {task_type}")
+        return task
+
+    async def update_task(
+        self,
+        task_id: str,
+        status: str | None = None,
+        progress: int | None = None,
+        message: str | None = None,
+    ):
+        """Update task status."""
+        async with self._task_lock:
+            task = self._tasks.get(task_id)
+            if task:
+                if status:
+                    task.status = status
+                if progress is not None:
+                    task.progress = progress
+                if message:
+                    task.message = message
+
+    async def get_task(self, task_id: str) -> InstallationTask | None:
+        """Get task by ID."""
+        async with self._task_lock:
+            return self._tasks.get(task_id)
+
+    async def get_all_tasks(self) -> list[InstallationTask]:
+        """Get all tasks."""
+        async with self._task_lock:
+            return list(self._tasks.values())
+
+    # New install task management
+    async def store_install_task(self, task_id: str, task: Any):
+        """Store or update an installation task."""
+        async with self._install_lock:
+            self._install_tasks[task_id] = task
+            if task_id not in self._install_logs:
+                self._install_logs[task_id] = []
+
+    async def get_install_task(self, task_id: str) -> Any | None:
+        """Get installation task by ID."""
+        async with self._install_lock:
+            return self._install_tasks.get(task_id)
+
+    async def get_all_install_tasks(self) -> list[Any]:
+        """Get all installation tasks."""
+        async with self._install_lock:
+            return list(self._install_tasks.values())
+
+    async def append_install_log(self, task_id: str, log_line: str):
+        """Append a log line to installation task."""
+        async with self._install_lock:
+            if task_id not in self._install_logs:
+                self._install_logs[task_id] = []
+            self._install_logs[task_id].append(log_line)
+
+    async def get_install_task_logs(self, task_id: str) -> list[str]:
+        """Get installation task logs."""
+        async with self._install_lock:
+            return self._install_logs.get(task_id, [])
+
+    # Log streaming
+    async def subscribe_logs(self) -> asyncio.Queue:
+        """Subscribe to log stream."""
+        queue = asyncio.Queue(maxsize=1000)
+        async with self._log_lock:
+            self._log_queues.append(queue)
+        logger.debug(f"New log subscriber, total: {len(self._log_queues)}")
+        return queue
+
+    async def unsubscribe_logs(self, queue: asyncio.Queue):
+        """Unsubscribe from log stream."""
+        async with self._log_lock:
+            if queue in self._log_queues:
+                self._log_queues.remove(queue)
+        logger.debug(f"Log subscriber removed, remaining: {len(self._log_queues)}")
+
+    async def broadcast_log(self, log_entry: dict):
+        """Broadcast log to all subscribers."""
+        async with self._log_lock:
+            dead_queues = []
+            for queue in self._log_queues:
+                try:
+                    queue.put_nowait(log_entry)
+                except asyncio.QueueFull:
+                    # Remove oldest log if queue is full
+                    try:
+                        queue.get_nowait()
+                        queue.put_nowait(log_entry)
+                    except asyncio.QueueEmpty:
+                        pass
+                except Exception:
+                    dead_queues.append(queue)
+
+            # Remove dead queues
+            for queue in dead_queues:
+                if queue in self._log_queues:
+                    self._log_queues.remove(queue)
+
+    # Server management
+    async def start_server(self, config_path: str | None = None) -> bool:
+        """Start the ML server."""
+        if self.server_status.running:
+            logger.warning("Server is already running")
+            return False
+
+        logger.info("Starting ML server")
+        # TODO: Implement actual server startup logic
+        self.server_status.running = True
+        self.server_status.pid = 0  # Placeholder
+        return True
+
+    async def stop_server(self) -> bool:
+        """Stop the ML server."""
+        if not self.server_status.running:
+            logger.warning("Server is not running")
+            return False
+
+        logger.info("Stopping ML server")
+        # TODO: Implement actual server shutdown logic
+        self.server_status.running = False
+        self.server_status.pid = None
+        return True
+
+
+# Global application state instance
+app_state = AppState()

lumen_app/web/main.py

@@ -0,0 +1,145 @@
+"""FastAPI application entry point for Lumen Web."""
+
+from contextlib import asynccontextmanager
+from pathlib import Path
+
+import uvicorn
+from fastapi import FastAPI
+from fastapi.middleware.cors import CORSMiddleware
+from fastapi.responses import FileResponse
+from fastapi.staticfiles import StaticFiles
+
+from lumen_app.utils.logger import get_logger
+
+from .api.config import router as config_router
+from .api.hardware import router as hardware_router
+from .api.install import router as install_router
+from .api.server import router as server_router
+from .core.state import app_state
+from .websockets.logs import router as logs_ws_router
+
+logger = get_logger("lumen.web")
+
+
+@asynccontextmanager
+async def lifespan(app: FastAPI):
+    """Application lifespan manager."""
+    logger.info("Starting Lumen Web API")
+    await app_state.initialize()
+    yield
+    logger.info("Shutting down Lumen Web API")
+    await app_state.cleanup()
+
+
+def get_webui_dist_paths() -> tuple[Path, Path, Path]:
+    """Resolve the Web UI build directory paths."""
+    module_dir = Path(__file__).resolve().parent
+    packaged_dist = module_dir / "static"
+    repo_dist = module_dir.parents[3] / "web-ui" / "dist"
+    selected = packaged_dist if packaged_dist.exists() else repo_dist
+    return selected, packaged_dist, repo_dist
+
+
+def create_app() -> FastAPI:
+    """Create and configure the FastAPI application."""
+    app = FastAPI(
+        title="Lumen Web API",
+        description="Web API for managing Lumen AI services",
+        version="0.1.0",
+        lifespan=lifespan,
+    )
+
+    # CORS middleware
+    app.add_middleware(
+        CORSMiddleware,
+        allow_origins=["*"],  # Configure for production
+        allow_credentials=True,
+        allow_methods=["*"],
+        allow_headers=["*"],
+    )
+
+    # Include API routers
+    app.include_router(config_router, prefix="/api/v1/config", tags=["config"])
+    app.include_router(hardware_router, prefix="/api/v1/hardware", tags=["hardware"])
+    app.include_router(install_router, prefix="/api/v1/install", tags=["install"])
+    app.include_router(server_router, prefix="/api/v1/server", tags=["server"])
+    app.include_router(logs_ws_router, prefix="/ws", tags=["websocket"])
+
+    @app.get("/health")
+    async def health_check():
+        """Health check endpoint."""
+        return {"status": "ok", "version": "0.1.0"}
+
+    # Static files for Web UI (production build)
+    webui_dist, packaged_dist, repo_dist = get_webui_dist_paths()
+    if webui_dist.exists():
+        # Mount static assets
+        app.mount(
+            "/assets", StaticFiles(directory=str(webui_dist / "assets")), name="assets"
+        )
+
+        # Catch-all route for SPA - serve index.html for all frontend routes
+        @app.get("/{full_path:path}")
+        async def serve_spa(full_path: str):
+            """Serve index.html for all SPA routes."""
+            file_path = webui_dist / full_path
+            # Serve file if it exists (e.g., favicon.ico, robots.txt)
+            if file_path.is_file():
+                return FileResponse(file_path)
+            # Otherwise serve index.html for SPA routing
+            return FileResponse(webui_dist / "index.html")
+    else:
+        raise RuntimeError(
+            "Web UI build not found. Looked in:\n"
+            f"  - packaged: {packaged_dist}\n"
+            f"  - repo: {repo_dist}\n"
+            "Run the web-ui build to enable static hosting."
+        )
+
+    return app
+
+
+def start_server(
+    host: str = "0.0.0.0",
+    port: int = 6658,
+    reload: bool = False,
+    workers: int = 1,
+):
+    """Start the uvicorn server."""
+    logger.info(f"Starting server on {host}:{port}")
+    uvicorn.run(
+        "lumen_app.web.main:create_app",
+        host=host,
+        port=port,
+        reload=reload,
+        workers=workers,
+        factory=True,
+    )
+
+
+def start_webui():
+    """Entry point for lumen-webui command."""
+    import argparse
+
+    parser = argparse.ArgumentParser(description="Lumen Web UI Server")
+    parser.add_argument("--host", default="0.0.0.0", help="Host to bind to")
+    parser.add_argument("--port", type=int, default=8000, help="Port to bind to")
+    parser.add_argument("--reload", action="store_true", help="Enable auto-reload")
+    parser.add_argument("--workers", type=int, default=1, help="Number of workers")
+
+    args = parser.parse_args()
+    start_server(
+        host=args.host,
+        port=args.port,
+        reload=args.reload,
+        workers=args.workers,
+    )
+
+
+def start_app():
+    """Legacy entry point (kept for compatibility)."""
+    start_webui()
+
+
+if __name__ == "__main__":
+    start_webui()

lumen_app/web/models/__init__.py

@@ -0,0 +1,28 @@
+"""Pydantic models for API requests and responses."""
+
+from .config import ConfigRequest, ConfigResponse
+from .hardware import DriverCheckResponse, HardwareInfoResponse, HardwarePresetResponse
+from .install import (
+    InstallLogsResponse,
+    InstallSetupRequest,
+    InstallStatusResponse,
+    InstallTaskListResponse,
+    InstallTaskResponse,
+)
+from .server import ServerConfig, ServerLogs, ServerStatus
+
+__all__ = [
+    "ConfigRequest",
+    "ConfigResponse",
+    "DriverCheckResponse",
+    "HardwareInfoResponse",
+    "HardwarePresetResponse",
+    "InstallLogsResponse",
+    "InstallSetupRequest",
+    "InstallStatusResponse",
+    "InstallTaskListResponse",
+    "InstallTaskResponse",
+    "ServerConfig",
+    "ServerLogs",
+    "ServerStatus",
+]

lumen_app/web/models/config.py

@@ -0,0 +1,63 @@
+"""Configuration models."""
+
+from __future__ import annotations
+
+from typing import Literal, Union
+
+from lumen_resources.lumen_config import Region
+from pydantic import BaseModel, Field
+
+
+class ConfigRequest(BaseModel):
+    """Request to generate configuration.
+
+    This matches the Config class constructor parameters:
+    - cache_dir: str
+    - device_config: DeviceConfig (created from preset)
+    - region: Region
+    - service_name: str
+    - port: int | None
+
+    Plus config generation method selection:
+    - config_type: Literal["minimal", "light_weight", "basic", "brave"]
+    - clip_model: Optional clip model for light_weight and basic configs
+    """
+
+    # Config constructor parameters
+    cache_dir: str = "~/.lumen"
+    preset: str  # Used to create device_config via PresetRegistry
+    region: Region = Region.other
+    service_name: str = "lumen-ai"
+    port: int | None = 50051
+
+    # Config generation method selection
+    config_type: Literal["minimal", "light_weight", "basic", "brave"] = "minimal"
+    clip_model: Union[
+        Literal["MobileCLIP2-S2", "CN-CLIP_ViT-B-16"],  # For light_weight
+        Literal["MobileCLIP2-S4", "CN-CLIP_ViT-L-14"],  # For basic
+        None,
+    ] = None
+
+    class Config:
+        json_schema_extra = {
+            "example": {
+                "cache_dir": "~/.lumen",
+                "preset": "nvidia_gpu",
+                "region": "other",
+                "service_name": "lumen-ai",
+                "port": 50051,
+                "config_type": "light_weight",
+                "clip_model": "MobileCLIP2-S2",
+            }
+        }
+
+
+class ConfigResponse(BaseModel):
+    """Generated configuration response."""
+
+    success: bool
+    preset: str
+    config_path: str | None = None
+    config_content: dict | None = None
+    message: str = ""
+    warnings: list[str] = Field(default_factory=list)

lumen_app/web/models/hardware.py

@@ -0,0 +1,64 @@
+"""Hardware detection and driver response models."""
+
+from __future__ import annotations
+
+from typing import Literal
+
+from pydantic import BaseModel, Field
+
+
+class DriverCheckResponse(BaseModel):
+    """Driver check result for API responses.
+
+    Note: This is different from the internal DriverStatus enum in env_checker.py
+    """
+
+    name: str
+    status: Literal["available", "missing", "incompatible"] = "missing"
+    details: str = ""
+    installable_via_mamba: bool = False
+    mamba_config_path: str | None = None
+
+
+class HardwarePresetResponse(BaseModel):
+    """Hardware preset information for API responses."""
+
+    name: str
+    description: str
+    requires_drivers: bool = True
+    runtime: str
+    providers: list[str] = Field(default_factory=list)
+
+
+class HardwareInfoResponse(BaseModel):
+    """Complete hardware detection report for API responses."""
+
+    # System information
+    platform: str
+    machine: str
+    processor: str
+    python_version: str
+
+    # Detected hardware presets
+    presets: list[HardwarePresetResponse] = Field(default_factory=list)
+    recommended_preset: str | None = None
+
+    # Driver status for recommended preset
+    drivers: list[DriverCheckResponse] = Field(default_factory=list)
+    all_drivers_available: bool = False
+    missing_installable: list[str] = Field(default_factory=list)
+
+    class Config:
+        json_schema_extra = {
+            "example": {
+                "platform": "Linux",
+                "machine": "x86_64",
+                "processor": "x86_64",
+                "python_version": "3.11.0",
+                "presets": [],
+                "recommended_preset": "nvidia_gpu",
+                "drivers": [],
+                "all_drivers_available": False,
+                "missing_installable": [],
+            }
+        }

lumen_app/web/models/install.py

@@ -0,0 +1,134 @@
+"""Installation models - simplified one-click setup."""
+
+from __future__ import annotations
+
+from typing import Literal
+
+from pydantic import BaseModel, Field
+
+
+class InstallSetupRequest(BaseModel):
+    """Request to start a complete installation setup.
+
+    This will automatically install all required components for the selected preset:
+    - micromamba (if not present)
+    - conda environment (if not exists)
+    - required drivers for the preset
+    """
+
+    preset: str
+    cache_dir: str = "~/.lumen"
+    environment_name: str = "lumen_env"
+    force_reinstall: bool = False
+
+    class Config:
+        json_schema_extra = {
+            "example": {
+                "preset": "nvidia_gpu",
+                "cache_dir": "~/.lumen",
+                "environment_name": "lumen_env",
+                "force_reinstall": False,
+            }
+        }
+
+
+class InstallStep(BaseModel):
+    """A single step in the installation process."""
+
+    name: str
+    status: Literal["pending", "running", "completed", "failed", "skipped"] = "pending"
+    progress: int = Field(0, ge=0, le=100)
+    message: str = ""
+    started_at: float | None = None
+    completed_at: float | None = None
+
+
+class InstallTaskResponse(BaseModel):
+    """Installation task status and progress."""
+
+    task_id: str
+    preset: str
+    status: Literal["pending", "running", "completed", "failed"] = "pending"
+    progress: int = Field(0, ge=0, le=100)
+    current_step: str = ""
+    steps: list[InstallStep] = Field(default_factory=list)
+    created_at: float
+    updated_at: float
+    completed_at: float | None = None
+    error: str | None = None
+
+    class Config:
+        json_schema_extra = {
+            "example": {
+                "task_id": "abc-123",
+                "preset": "nvidia_gpu",
+                "status": "running",
+                "progress": 45,
+                "current_step": "Installing CUDA drivers",
+                "steps": [
+                    {
+                        "name": "Check micromamba",
+                        "status": "completed",
+                        "progress": 100,
+                        "message": "micromamba already installed",
+                    },
+                    {
+                        "name": "Create environment",
+                        "status": "running",
+                        "progress": 60,
+                        "message": "Creating lumen_env...",
+                    },
+                ],
+                "created_at": 1234567890.0,
+                "updated_at": 1234567895.0,
+                "completed_at": None,
+                "error": None,
+            }
+        }
+
+
+class InstallTaskListResponse(BaseModel):
+    """List of installation tasks."""
+
+    tasks: list[InstallTaskResponse]
+    total: int
+
+
+class InstallStatusResponse(BaseModel):
+    """Current installation status of the system."""
+
+    micromamba_installed: bool
+    micromamba_path: str | None = None
+    environment_exists: bool
+    environment_name: str | None = None
+    environment_path: str | None = None
+    drivers_checked: bool = False
+    drivers: dict[str, str] = Field(default_factory=dict)  # driver_name -> status
+    ready_for_preset: str | None = None
+    missing_components: list[str] = Field(default_factory=list)
+
+    class Config:
+        json_schema_extra = {
+            "example": {
+                "micromamba_installed": True,
+                "micromamba_path": "/usr/local/bin/micromamba",
+                "environment_exists": True,
+                "environment_name": "lumen_env",
+                "environment_path": "~/.lumen/envs/lumen_env",
+                "drivers_checked": True,
+                "drivers": {
+                    "cuda": "available",
+                    "cudnn": "missing",
+                },
+                "ready_for_preset": "nvidia_gpu",
+                "missing_components": ["cudnn"],
+            }
+        }
+
+
+class InstallLogsResponse(BaseModel):
+    """Installation task logs."""
+
+    task_id: str
+    logs: list[str] = Field(default_factory=list)
+    total_lines: int = 0