lumen-app 0.4.2__py3-none-any.whl

lumen_app/core/installer.py

@@ -0,0 +1,274 @@
+"""
+Core installer for managing environment and driver installations.
+
+This module provides installation functionality including:
+- Micromamba installation
+- Python environment setup via micromamba
+- Driver installation via micromamba
+"""
+
+from __future__ import annotations
+
+import subprocess
+from pathlib import Path
+from typing import Iterable
+
+import yaml
+from lumen_resources import LumenConfig
+from lumen_resources.lumen_config import Region
+
+from lumen_app.core.config import DeviceConfig
+from lumen_app.utils.env_checker import DependencyInstaller
+from lumen_app.utils.installation import MicromambaInstaller, PythonEnvManager
+from lumen_app.utils.logger import get_logger
+from lumen_app.utils.package_resolver import (
+    GitHubPackageResolver,
+    LumenPackageResolver,
+)
+
+logger = get_logger("lumen.core.installer")
+
+
+class CoreInstaller:
+    """Core installer that manages micromamba and environment setup."""
+
+    def __init__(
+        self,
+        cache_dir: str | Path,
+        env_name: str = "lumen_env",
+        mamba_configs_dir: str | Path | None = None,
+        micromamba_target: str = "micromamba",
+        region: Region = Region.other,
+    ) -> None:
+        self.cache_dir = Path(cache_dir).expanduser()
+        self.env_name = env_name
+        self.mamba_configs_dir = Path(mamba_configs_dir) if mamba_configs_dir else None
+        self.micromamba_target = micromamba_target
+        self.region = region
+
+    @property
+    def micromamba_exe(self) -> str:
+        installer = MicromambaInstaller(self.cache_dir)
+        return str(installer.get_executable())
+
+    @property
+    def root_prefix(self) -> str:
+        return str(self.cache_dir / self.micromamba_target)
+
+    def install_micromamba(self, dry_run: bool = False) -> tuple[bool, str]:
+        """Install micromamba into cache_dir."""
+        logger.info("Installing micromamba...")
+        try:
+            installer = MicromambaInstaller(self.cache_dir)
+            exe_path = installer.install(dry_run=dry_run)
+            return True, f"Micromamba installed successfully at {exe_path}"
+        except Exception as e:
+            logger.error("Failed to install micromamba: %s", e)
+            return False, f"Failed to install micromamba: {e}"
+
+    def create_environment(
+        self,
+        config_filename: str = "default.yaml",
+        dry_run: bool = False,
+    ) -> tuple[bool, str]:
+        """Create Python environment using micromamba and a config file."""
+        logger.info(
+            "Creating environment '%s' with config '%s'",
+            self.env_name,
+            config_filename,
+        )
+
+        if dry_run:
+            logger.info("Dry run mode - skipping execution")
+            return True, f"Would create environment {self.env_name}"
+
+        try:
+            # Extract yaml_config name from filename (e.g., "default.yaml" -> "default")
+            yaml_config = config_filename.replace(".yaml", "")
+
+            env_manager = PythonEnvManager(
+                cache_dir=self.cache_dir,
+                micromamba_exe=self.micromamba_exe,
+            )
+            env_path = env_manager.create_env(yaml_config=yaml_config)
+            logger.info(
+                "Successfully created environment %s at %s", self.env_name, env_path
+            )
+            return True, f"Successfully created environment {self.env_name}"
+
+        except Exception as e:
+            logger.error("Environment creation error: %s: %s", type(e).__name__, e)
+            return False, f"Environment creation error: {str(e)}"
+
+    def install_lumen_packages(
+        self,
+        lumen_config: LumenConfig,
+        device_config: DeviceConfig,
+        quiet: bool = True,
+    ) -> tuple[bool, str]:
+        """Install Lumen packages derived from LumenConfig.
+
+        Downloads wheels from GitHub Releases and installs them with proper
+        dependencies based on device configuration.
+
+        Args:
+            lumen_config: Lumen configuration with deployment services
+            device_config: Device configuration with dependency metadata
+            quiet: Whether to suppress pip output
+
+        Returns:
+            Tuple of (success, message)
+        """
+        logger.info("Installing Lumen packages from GitHub Releases")
+
+        # Check environment exists
+        env_manager = PythonEnvManager(
+            cache_dir=self.cache_dir,
+            micromamba_exe=self.micromamba_exe,
+        )
+
+        if not env_manager.env_exists():
+            return False, f"Environment not found at {env_manager.get_env_path()}"
+
+        try:
+            # Resolve package names from config
+            package_list = LumenPackageResolver.resolve_packages(lumen_config)
+
+            if not package_list:
+                logger.info("No packages to install.")
+                return True, "No packages to install"
+
+            logger.info("Packages to install: %s", ", ".join(package_list))
+
+            # Create wheel download directory
+            wheel_dir = self.cache_dir / "wheels"
+            wheel_dir.mkdir(parents=True, exist_ok=True)
+
+            # Initialize GitHub resolver
+            github_resolver = GitHubPackageResolver(region=self.region)
+
+            # Download all wheels first
+            wheel_paths = {}
+            for package in package_list:
+                logger.info("Downloading wheel for %s...", package)
+                try:
+                    url, version = github_resolver.resolve_package_url(package)
+                    wheel_path = github_resolver.download_wheel(url, wheel_dir)
+                    wheel_paths[package] = wheel_path
+                    logger.info("Downloaded %s version %s", package, version)
+                except Exception as e:
+                    logger.error("Failed to download %s: %s", package, e)
+                    return False, f"Failed to download {package}: {e}"
+
+            # Build pip install command with device-specific extras
+            pip_args = LumenPackageResolver.build_pip_install_args(
+                packages=package_list,
+                device_config=device_config,
+                region=self.region,
+                wheel_paths=wheel_paths,
+            )
+
+            if quiet:
+                pip_args.extend(["--quiet", "--no-warn-script-location"])
+
+            # Run pip install
+            logger.info("Running pip install with device-specific extras")
+            result = env_manager.run_pip(*pip_args)
+
+            if result.returncode == 0:
+                logger.info("All packages installed successfully")
+                return True, "All packages installed successfully"
+            else:
+                error_msg = result.stderr or result.stdout
+                logger.error("Package installation failed: %s", error_msg)
+                return False, f"Package installation failed: {error_msg}"
+
+        except subprocess.TimeoutExpired:
+            logger.error("Package installation timed out")
+            return False, "Package installation timed out"
+        except Exception as e:
+            logger.error("Package installation error: %s", e)
+            return False, f"Package installation error: {e}"
+
+    def verify_installation(self) -> tuple[bool, str]:
+        """Verify micromamba and environment are installed."""
+        try:
+            # Check micromamba
+            installer = MicromambaInstaller(self.cache_dir)
+            check_result = installer.check()
+
+            if check_result.status.value != "installed":
+                return False, "Micromamba not found"
+
+            # Check environment
+            env_manager = PythonEnvManager(
+                cache_dir=self.cache_dir,
+                micromamba_exe=self.micromamba_exe,
+            )
+
+            if not env_manager.env_exists():
+                return False, "Python environment not found"
+
+            # Optional: check uv availability
+            env_path = env_manager.get_env_path()
+            cmd = [
+                str(self.micromamba_exe),
+                "run",
+                "-p",
+                str(env_path),
+                "uv",
+                "--version",
+            ]
+            try:
+                result = subprocess.run(cmd, capture_output=True, text=True, timeout=10)
+                if result.returncode == 0:
+                    logger.info("uv installed: %s", result.stdout.strip())
+            except subprocess.TimeoutExpired:
+                logger.warning("uv check timed out")
+
+            return True, "Installation verified"
+        except Exception as e:
+            logger.error("Verification error: %s", e)
+            return False, f"Verification error: {e}"
+
+    def save_config(
+        self, lumen_config: LumenConfig, config_filename: str = "lumen-config.yaml"
+    ) -> tuple[bool, str]:
+        """Persist LumenConfig to disk."""
+        config_path = self.cache_dir / config_filename
+
+        try:
+            self.cache_dir.mkdir(parents=True, exist_ok=True)
+            config_dict = lumen_config.model_dump(mode="json")
+            with open(config_path, "w", encoding="utf-8") as f:
+                yaml.dump(config_dict, f, default_flow_style=False, allow_unicode=True)
+            return True, f"Config saved: {config_path}"
+        except Exception as e:
+            logger.error("Failed to save config: %s", e)
+            return False, f"Failed to save config: {e}"
+
+    def install_drivers(
+        self, driver_names: Iterable[str], dry_run: bool = False
+    ) -> list[tuple[str, bool, str]]:
+        """Install driver packages using micromamba.
+
+        Returns:
+            List of (driver_name, success, message)
+        """
+        installer = DependencyInstaller(
+            mamba_configs_dir=self.mamba_configs_dir,
+            micromamba_path=self.micromamba_exe,
+            root_prefix=self.root_prefix,
+        )
+
+        results: list[tuple[str, bool, str]] = []
+        for name in driver_names:
+            logger.info("Installing driver '%s'...", name)
+            success, message = installer.install_driver(
+                driver_name=name,
+                env_name=self.env_name,
+                dry_run=dry_run,
+            )
+            results.append((name, success, message))
+
+        return results

lumen_app/core/loader.py

@@ -0,0 +1,45 @@
+import importlib
+from typing import Any, Type
+
+from lumen_app.utils.logger import get_logger
+
+logger = get_logger("lumen.loader")
+
+
+class ServiceLoader:
+    """
+    负责从字符串路径动态加载 Python 类。
+    例如将 "lumen_ocr.registry.GeneralOcrService" 转换为可调用的类对象。
+    """
+
+    @staticmethod
+    def get_class(class_path: str) -> Type[Any]:
+        """
+        根据类路径字符串获取类对象。
+
+        Args:
+            class_path: 格式为 'package.module.ClassName'
+        """
+        if not class_path or "." not in class_path:
+            raise ValueError(f"Invalid class path: {class_path}")
+
+        # 1. 拆分路径，例如：'lumen_ocr.registry' 和 'GeneralOcrService'
+        module_path, class_name = class_path.rsplit(".", 1)
+
+        try:
+            # 2. 动态导入模块
+            # 注意：此时 subprocess 必须运行在已安装该包的 micromamba 环境中
+            module = importlib.import_module(module_path)
+
+            # 3. 从模块中获取类
+            cls = getattr(module, class_name)
+
+            logger.info(f"Successfully imported class: {class_name} from {module_path}")
+            return cls
+
+        except ImportError as e:
+            logger.error(f"Failed to import module {module_path}: {e}")
+            raise
+        except AttributeError as e:
+            logger.error(f"Class {class_name} not found in module {module_path}: {e}")
+            raise

lumen_app/core/router.py

@@ -0,0 +1,87 @@
+# router.py
+import grpc
+
+from lumen_app.proto import ml_service_pb2, ml_service_pb2_grpc
+from lumen_app.utils.logger import get_logger
+
+logger = get_logger("lumen.router")
+
+
+class HubRouter(ml_service_pb2_grpc.InferenceServicer):
+    def __init__(self, services: list):
+        self.services = services
+        # 建立 Task Key -> Service 实例的映射
+        self._route_table = {}
+        for svc in services:
+            for task_key in svc.get_supported_tasks():
+                # 如果 key 已存在，这里可以选择附加到列表或简单的覆盖
+                # 既然你说交给 SDK 判断，Hub 这里默认选择第一个匹配的服务
+                if task_key not in self._route_table:
+                    self._route_table[task_key] = svc
+
+    def Infer(self, request_iterator, context):
+        """多路复用分发推理请求"""
+        # 获取流的第一条消息以识别 Task
+        try:
+            first_req = next(request_iterator)
+        except StopIteration:
+            return
+
+        task_key = first_req.task
+
+        target_svc = self._route_table.get(task_key)
+
+        if not target_svc:
+            context.abort(grpc.StatusCode.NOT_FOUND, f"Task {task_key} not supported")
+
+        if target_svc is not None:
+            # 构造包装后的迭代器透传给子服务
+            def stream_wrapper():
+                yield first_req
+                for req in request_iterator:
+                    yield req
+
+            # 零拷贝转发流式响应
+            for resp in target_svc.Infer(stream_wrapper(), context):
+                yield resp
+
+    def GetCapabilities(self, request, context):
+        """汇总所有子服务的能力宣告"""
+        all_tasks = []
+        for svc in self.services:
+            caps = svc.GetCapabilities(request, context)
+            all_tasks.extend(caps.tasks)
+        return ml_service_pb2.Capability(tasks=all_tasks)
+
+    def attach_to_server(self, server: grpc.Server):
+        """
+        Attach the hub router to the gRPC server.
+
+        This registers the router as the single InferenceServicer that handles
+        all incoming requests and routes them to appropriate services.
+
+        Args:
+            server: The gRPC server instance to attach to
+        """
+        ml_service_pb2_grpc.add_InferenceServicer_to_server(self, server)
+        logger.info(
+            f"HubRouter attached to server with {len(self.services)} service(s)"
+        )
+        logger.debug(f"Route table: {list(self._route_table.keys())}")
+
+    def Health(self, request, context):
+        """健康检查 - 所有子服务都健康才返回健康"""
+        from google.protobuf import empty_pb2
+
+        for svc in self.services:
+            # 调用子服务的 Health 方法
+            try:
+                svc.Health(empty_pb2.Empty(), context)
+            except Exception as e:
+                # 如果任何子服务健康检查失败，返回错误
+                context.abort(
+                    grpc.StatusCode.UNAVAILABLE, f"Service unhealthy: {str(e)}"
+                )
+
+        # 所有服务都健康，返回 Empty
+        return empty_pb2.Empty()