lumen-app 0.4.2__py3-none-any.whl

lumen_app/utils/package_resolver.py

@@ -0,0 +1,309 @@
+"""Package resolver for Lumen installations.
+
+This module provides utilities for resolving package URLs from GitHub Releases,
+selecting appropriate mirrors based on region, and building pip installation commands.
+"""
+
+import logging
+import urllib.request
+from pathlib import Path
+from typing import Callable
+
+from lumen_resources.lumen_config import LumenConfig, Region
+
+from ..core.config import DeviceConfig
+
+logger = logging.getLogger(__name__)
+
+
+class MirrorSelector:
+    """Selects mirror URLs based on region."""
+
+    GITHUB_MIRROR_CN = "https://gh-proxy.org/https://github.com"
+    PYPI_MIRROR_CN = "https://mirrors.aliyun.com/pypi/simple/"
+
+    def get_github_urls(self, base_url: str, region: Region) -> list[str]:
+        """Get GitHub URLs with mirror fallback.
+
+        Args:
+            base_url: Original GitHub URL (e.g., https://github.com/...)
+            region: Region.cn or Region.other
+
+        Returns:
+            List of URLs to try (mirror first if cn, then original)
+        """
+        urls = []
+        if region == Region.cn:
+            # Apply ghproxy mirror
+            mirror_url = base_url.replace("https://github.com", self.GITHUB_MIRROR_CN)
+            urls.append(mirror_url)
+        urls.append(base_url)
+        return urls
+
+    def get_pypi_indexes(self, region: Region) -> list[str]:
+        """Get PyPI index URLs with mirror fallback.
+
+        Args:
+            region: Region.cn or Region.other
+
+        Returns:
+            List of index URLs (mirror first if cn, then original)
+        """
+        indexes = []
+        if region == Region.cn:
+            indexes.append(self.PYPI_MIRROR_CN)
+        # Always include PyPI official as fallback
+        indexes.append("https://pypi.org/simple/")
+        return indexes
+
+
+class GitHubPackageResolver:
+    """Resolves package download URLs from GitHub Releases."""
+
+    REPO_OWNER = "EdwinZhanCN"
+    REPO_NAME = "Lumen"
+    API_BASE = "https://api.github.com"
+
+    def __init__(self, region: Region):
+        """Initialize resolver.
+
+        Args:
+            region: Region for mirror selection
+        """
+        self.region = region
+        self.mirror_selector = MirrorSelector()
+
+    def get_latest_release(self) -> str:
+        """Get latest release tag from GitHub API.
+
+        Returns:
+            Release tag (e.g., "v0.1.0")
+
+        Raises:
+            Exception: If API call fails
+        """
+        url = (
+            f"{self.API_BASE}/repos/{self.REPO_OWNER}/{self.REPO_NAME}/releases/latest"
+        )
+
+        logger.debug(f"[GitHubPackageResolver] Fetching latest release from {url}")
+
+        try:
+            with urllib.request.urlopen(url, timeout=30) as response:
+                import json
+
+                data = json.loads(response.read().decode())
+                tag = data.get("tag_name")
+                if not tag:
+                    raise Exception("No tag_name found in release")
+                logger.info(f"[GitHubPackageResolver] Latest release: {tag}")
+                return tag
+        except Exception as e:
+            logger.error(f"[GitHubPackageResolver] Failed to fetch release: {e}")
+            raise Exception(f"Failed to fetch latest release: {e}")
+
+    def resolve_package_url(self, package_name: str) -> tuple[str, str]:
+        """Resolve package wheel download URL.
+
+        Args:
+            package_name: Package name (e.g., "lumen_ocr")
+
+        Returns:
+            Tuple of (download_url, version)
+
+        Raises:
+            Exception: If wheel file not found
+        """
+        # Get latest release tag
+        tag = self.get_latest_release()
+
+        # We need to get the actual wheel filename from the release assets
+        api_url = f"{self.API_BASE}/repos/{self.REPO_OWNER}/{self.REPO_NAME}/releases/tags/{tag}"
+
+        logger.debug(f"[GitHubPackageResolver] Fetching release assets from {api_url}")
+
+        try:
+            with urllib.request.urlopen(api_url, timeout=30) as response:
+                import json
+
+                data = json.loads(response.read().decode())
+                assets = data.get("assets", [])
+
+                # Find matching wheel
+                for asset in assets:
+                    name = asset.get("name", "")
+                    if name.startswith(package_name) and name.endswith(
+                        "-py3-none-any.whl"
+                    ):
+                        download_url = asset.get("browser_download_url")
+                        logger.info(f"[GitHubPackageResolver] Found wheel: {name}")
+                        return download_url, tag
+
+                raise Exception(f"Wheel file not found for {package_name}")
+
+        except Exception as e:
+            logger.error(f"[GitHubPackageResolver] Failed to resolve package URL: {e}")
+            raise Exception(f"Failed to resolve package URL for {package_name}: {e}")
+
+    def download_wheel(
+        self,
+        url: str,
+        dest_dir: Path,
+        log_callback: Callable[[str], None] | None = None,
+    ) -> Path:
+        """Download wheel file to destination directory.
+
+        Args:
+            url: Download URL
+            dest_dir: Destination directory
+            log_callback: Optional callback for log messages
+
+        Returns:
+            Path to downloaded wheel file
+
+        Raises:
+            Exception: If download fails
+        """
+        dest_dir = Path(dest_dir)
+        dest_dir.mkdir(parents=True, exist_ok=True)
+
+        # Extract filename from URL
+        filename = url.split("/")[-1]
+        dest_path = dest_dir / filename
+
+        # Get URLs with mirror fallback
+        urls = self.mirror_selector.get_github_urls(url, self.region)
+
+        # Try each URL
+        for download_url in urls:
+            try:
+                if log_callback:
+                    log_callback(f"Downloading {filename}...")
+
+                logger.debug(f"[GitHubPackageResolver] Downloading from {download_url}")
+
+                def download_progress(block_num, block_size, total_size):
+                    if log_callback and total_size > 0:
+                        progress = (block_num * block_size / total_size) * 100
+                        if progress % 10 < 5:  # Log every ~10%
+                            log_callback(f"Downloading {filename}: {progress:.0f}%")
+
+                urllib.request.urlretrieve(download_url, dest_path, download_progress)
+
+                logger.info(f"[GitHubPackageResolver] Downloaded: {dest_path}")
+                if log_callback:
+                    log_callback(f"Downloaded {filename}")
+
+                return dest_path
+
+            except Exception as e:
+                logger.warning(
+                    f"[GitHubPackageResolver] Failed to download from {download_url}: {e}"
+                )
+                if log_callback:
+                    log_callback(f"Failed: {e}, trying next source...")
+                continue
+
+        raise Exception(f"Failed to download wheel from all sources: {filename}")
+
+
+class LumenPackageResolver:
+    """Resolves Lumen package names and installation commands."""
+
+    @staticmethod
+    def resolve_packages(lumen_config: LumenConfig) -> list[str]:
+        """Extract package names from LumenConfig.
+
+        Args:
+            lumen_config: Lumen configuration
+
+        Returns:
+            List of package names (e.g., ["lumen_ocr", "lumen_clip"])
+        """
+        packages = []
+
+        # Get deployment services
+        deployment = lumen_config.deployment
+
+        if hasattr(deployment, "services") and deployment.services:
+            for service in deployment.services:
+                if hasattr(service, "root"):
+                    root = service.root
+                    package_name = f"lumen_{root}"
+                    packages.append(package_name)
+
+        logger.info(f"[LumenPackageResolver] Resolved packages: {packages}")
+        return list(set(packages))  # Remove duplicates
+
+    @staticmethod
+    def build_pip_install_args(
+        packages: list[str],
+        device_config: DeviceConfig,
+        region: Region,
+        wheel_paths: dict[str, Path] | None = None,
+    ) -> list[str]:
+        """Build pip installation command arguments.
+
+        Args:
+            packages: List of package names (e.g., ["lumen_ocr", "lumen_clip"])
+            device_config: Device configuration with dependency metadata
+            region: Region for mirror selection
+            wheel_paths: Dictionary mapping package names to wheel file paths
+
+        Returns:
+            List of pip command arguments
+
+        Example:
+            ["install", "--index-url", "...", "--extra-index-url", "...",
+             "/path/to/lumen_ocr-0.4.1-py3-none-any.whl[apple]", "--no-cache-dir"]
+        """
+        args = ["install"]
+
+        # Add index URLs
+        mirror_selector = MirrorSelector()
+        indexes = mirror_selector.get_pypi_indexes(region)
+
+        # Add --index-url (first mirror)
+        if indexes:
+            args.extend(["--index-url", indexes[0]])
+
+        # Add custom extra index URLs (for CUDA, etc.)
+        # NOTE: Don't add PyPI as extra-index-url automatically to preserve mirror speed
+        if device_config.dependency_metadata:
+            meta = device_config.dependency_metadata
+
+            # Add custom extra index URLs
+            if meta.extra_index_url:
+                for url in meta.extra_index_url:
+                    args.extend(["--extra-index-url", url])
+
+        # Add wheel file paths with extras
+        if wheel_paths:
+            for pkg in packages:
+                if pkg in wheel_paths:
+                    wheel_path = str(wheel_paths[pkg])
+
+                    # Add extras if specified
+                    if (
+                        device_config.dependency_metadata
+                        and device_config.dependency_metadata.extra_deps
+                    ):
+                        extra_deps = ",".join(
+                            device_config.dependency_metadata.extra_deps
+                        )
+                        wheel_path = f"{wheel_path}[{extra_deps}]"
+
+                    args.append(wheel_path)
+
+        # Add additional install args
+        if (
+            device_config.dependency_metadata
+            and device_config.dependency_metadata.install_args
+        ):
+            args.extend(device_config.dependency_metadata.install_args)
+
+        # Add --no-cache-dir to avoid cache issues
+        args.append("--no-cache-dir")
+
+        logger.debug(f"[LumenPackageResolver] Pip args: {args}")
+        return args

lumen_app/utils/preset_registry.py

@@ -0,0 +1,219 @@
+"""
+Preset registry for Lumen device configurations.
+
+Provides dynamic discovery of available presets from DeviceConfig,
+eliminating hardcoded preset identifiers.
+"""
+
+from __future__ import annotations
+
+import inspect
+from dataclasses import dataclass
+from typing import Callable
+
+from lumen_app.core.config import DeviceConfig
+from lumen_app.utils.logger import get_logger
+
+logger = get_logger("lumen.preset_registry")
+
+
+@dataclass
+class PresetInfo:
+    """Information about a device preset."""
+
+    name: str
+    description: str
+    factory_method: Callable[[], DeviceConfig]
+    requires_drivers: bool = True
+    priority: int = 50  # Lower number = higher priority (0-100)
+
+
+class PresetRegistry:
+    """
+    Dynamic registry of DeviceConfig presets.
+
+    Automatically discovers all factory methods (classmethods) from DeviceConfig
+    that return DeviceConfig instances, eliminating the need for hardcoded preset names.
+    """
+
+    _presets: dict[str, PresetInfo] | None = None
+
+    # Preset priority mapping (lower = higher priority)
+    _PRESET_PRIORITIES = {
+        "nvidia_gpu_high": 5,
+        "nvidia_gpu": 10,
+        "nvidia_jetson_high": 12,
+        "nvidia_jetson": 15,
+        "apple_silicon": 20,
+        "rockchip": 25,
+        "intel_gpu": 30,
+        "amd_gpu_win": 35,
+        "amd_npu": 40,
+        "cpu": 100,  # Lowest priority (fallback)
+    }
+
+    @classmethod
+    def _discover_presets(cls) -> dict[str, PresetInfo]:
+        """Discover all preset factory methods from DeviceConfig."""
+        if cls._presets is not None:
+            return cls._presets
+
+        presets = {}
+
+        # Scan all members of DeviceConfig (including bound methods)
+        for name in dir(DeviceConfig):
+            # Skip private attributes
+            if name.startswith("_"):
+                continue
+
+            # Get the member
+            try:
+                member = getattr(DeviceConfig, name)
+            except AttributeError:
+                continue
+
+            # Skip non-methods and dataclass fields
+            if not callable(member):
+                continue
+
+            # Check if it's a classmethod descriptor
+            is_classmethod = False
+            try:
+                raw_attr = inspect.getattr_static(DeviceConfig, name)
+                is_classmethod = isinstance(raw_attr, classmethod)
+            except AttributeError:
+                pass
+
+            if not is_classmethod:
+                continue
+
+            # Try to call it and see if it returns a DeviceConfig
+            try:
+                result = member()
+                if isinstance(result, DeviceConfig):
+                    # Get description from DeviceConfig.description or docstring
+                    if hasattr(result, "description") and result.description:
+                        description = result.description
+                    else:
+                        docstring = inspect.getdoc(member) or ""
+                        description = docstring.split("\n")[0] if docstring else name
+
+                    # Get priority from mapping, default to 50
+                    priority = cls._PRESET_PRIORITIES.get(name, 50)
+
+                    presets[name] = PresetInfo(
+                        name=name,
+                        description=description,
+                        factory_method=member,
+                        requires_drivers=name
+                        != "cpu",  # CPU preset requires no special drivers
+                        priority=priority,
+                    )
+                    logger.debug(f"Discovered preset: {name} (priority: {priority})")
+            except Exception as e:
+                logger.debug(f"Skipping {name}: {e}")
+                continue
+
+        cls._presets = presets
+        logger.info(f"Discovered {len(presets)} device presets")
+        return presets
+
+    @classmethod
+    def get_all_presets(cls) -> dict[str, PresetInfo]:
+        """Get all available presets."""
+        return cls._discover_presets().copy()
+
+    @classmethod
+    def get_preset(cls, name: str) -> PresetInfo | None:
+        """Get a specific preset by name."""
+        presets = cls._discover_presets()
+        return presets.get(name)
+
+    @classmethod
+    def preset_exists(cls, name: str) -> bool:
+        """Check if a preset exists."""
+        return name in cls._discover_presets()
+
+    @classmethod
+    def get_preset_names(cls) -> list[str]:
+        """Get list of all preset names."""
+        return list(cls._discover_presets().keys())
+
+    @classmethod
+    def get_detection_order(cls) -> list[str]:
+        """
+        Get preset names in detection order (highest to lowest priority).
+
+        Returns presets sorted by priority, with lower numbers checked first.
+        This ensures the best available hardware is detected first.
+        """
+        presets = cls._discover_presets()
+        # Sort by priority (lower number = higher priority)
+        sorted_presets = sorted(presets.values(), key=lambda p: p.priority)
+        return [p.name for p in sorted_presets]
+
+    @classmethod
+    def create_config(cls, preset_name: str) -> DeviceConfig:
+        """
+        Create a DeviceConfig from preset name.
+
+        Args:
+            preset_name: Name of the preset (e.g., "nvidia_gpu", "apple_silicon")
+
+        Returns:
+            DeviceConfig instance
+
+        Raises:
+            ValueError: If preset doesn't exist
+        """
+        preset = cls.get_preset(preset_name)
+        if preset is None:
+            available = ", ".join(cls.get_preset_names())
+            raise ValueError(
+                f"Unknown preset '{preset_name}'. Available presets: {available}"
+            )
+
+        return preset.factory_method()
+
+    @classmethod
+    def get_driver_requirements(cls, preset_name: str) -> list[str]:
+        """
+        Get required driver checks for a preset.
+
+        Args:
+            preset_name: Name of the preset
+
+        Returns:
+            List of driver names to check
+        """
+        preset = cls.get_preset(preset_name)
+        if preset is None or not preset.requires_drivers:
+            return []
+
+        config = preset.factory_method()
+
+        # Map runtime/providers to required drivers
+        requirements = []
+        providers = config.onnx_providers or []
+
+        for provider in providers:
+            provider_name = (
+                provider
+                if isinstance(provider, str)
+                else (provider[0] if provider else "")
+            )
+
+            if "CUDA" in provider_name or "TensorRT" in provider_name:
+                requirements.append("cuda")
+            elif "CoreML" in provider_name:
+                requirements.append("coreml")
+            elif "OpenVINO" in provider_name:
+                requirements.append("openvino")
+            elif "DML" in provider_name:
+                requirements.append("directml")
+
+        # RKNN runtime
+        if config.runtime.value == "rknn":
+            requirements.append("rknn")
+
+        return list(set(requirements))  # Remove duplicates

lumen_app/web/__init__.py

@@ -0,0 +1,3 @@
+"""Lumen Web API - FastAPI-based web interface for Lumen AI services."""
+
+__version__ = "0.1.0"

lumen_app/web/api/__init__.py

@@ -0,0 +1 @@
+"""API routers for Lumen Web."""