lumen-app 0.4.2__py3-none-any.whl

lumen_app/utils/installation/package_installer.py

@@ -0,0 +1,149 @@
+"""Lumen package installer for installing Lumen packages from GitHub Releases."""
+
+import logging
+import subprocess
+from pathlib import Path
+from typing import Callable
+
+from lumen_resources.lumen_config import Region
+
+from ...core.config import DeviceConfig
+from ..package_resolver import GitHubPackageResolver, LumenPackageResolver
+from .env_manager import PythonEnvManager
+
+logger = logging.getLogger(__name__)
+
+
+class LumenPackageInstaller:
+    """Installs Lumen packages from GitHub Releases."""
+
+    def __init__(
+        self,
+        env_manager: PythonEnvManager,
+        github_resolver: GitHubPackageResolver,
+        log_callback: Callable[[str], None] | None = None,
+    ):
+        """Initialize package installer.
+
+        Args:
+            env_manager: Python environment manager
+            github_resolver: GitHub package resolver
+            log_callback: Optional callback for log messages
+        """
+        self.env_manager = env_manager
+        self.github_resolver = github_resolver
+        self.log_callback = log_callback or (lambda msg: None)
+
+        logger.debug("[LumenPackageInstaller] Initialized")
+
+    def install_packages(
+        self,
+        packages: list[str],
+        device_config: DeviceConfig,
+        region: Region,
+    ) -> None:
+        """Install Lumen packages from GitHub Releases.
+
+        Args:
+            packages: List of package names (e.g., ["lumen_ocr", "lumen_clip"])
+            device_config: Device configuration with dependency metadata
+            region: Region for mirror selection
+
+        Raises:
+            Exception: If installation fails
+        """
+        logger.info(f"[LumenPackageInstaller] Installing packages: {packages}")
+        self.log_callback(f"Installing {len(packages)} Lumen package(s)...")
+
+        # Create wheel download directory
+        cache_dir = self.env_manager.cache_dir
+        wheel_dir = cache_dir / "wheels"
+        wheel_dir.mkdir(parents=True, exist_ok=True)
+
+        # Download all wheels first and collect paths
+        self.log_callback("Downloading package wheels...")
+        wheel_paths = {}  # {package_name: wheel_path}
+        for package in packages:
+            wheel_path = self._download_package_wheel(package, wheel_dir)
+            wheel_paths[package] = wheel_path
+
+        # Build pip install command
+        self.log_callback("Building installation command...")
+        pip_args = LumenPackageResolver.build_pip_install_args(
+            packages=packages,
+            device_config=device_config,
+            region=region,
+            wheel_paths=wheel_paths,
+        )
+
+        # Run pip install
+        self.log_callback("Running pip install...")
+        self._run_pip_install(pip_args)
+
+        self.log_callback("All packages installed successfully")
+        logger.info("[LumenPackageInstaller] All packages installed")
+
+    def _download_package_wheel(self, package: str, wheel_dir: Path) -> Path:
+        """Download package wheel from GitHub Releases.
+
+        Args:
+            package: Package name (e.g., "lumen_ocr")
+            wheel_dir: Directory to save wheel files
+
+        Returns:
+            Path to downloaded wheel
+
+        Raises:
+            Exception: If download fails
+        """
+        logger.debug(f"[LumenPackageInstaller] Downloading wheel for {package}")
+        self.log_callback(f"Downloading {package}...")
+
+        try:
+            url, version = self.github_resolver.resolve_package_url(package)
+            logger.debug(f"[LumenPackageInstaller] Resolved {package} {version}: {url}")
+
+            wheel_path = self.github_resolver.download_wheel(
+                url, wheel_dir, self.log_callback
+            )
+
+            logger.info(f"[LumenPackageInstaller] Downloaded {package}: {wheel_path}")
+            return wheel_path
+
+        except Exception as e:
+            logger.error(f"[LumenPackageInstaller] Failed to download {package}: {e}")
+            self.log_callback(f"Failed to download {package}: {e}")
+            raise Exception(f"Failed to download {package}: {e}")
+
+    def _run_pip_install(self, pip_args: list[str]) -> None:
+        """Run pip install command.
+
+        Args:
+            pip_args: Pip command arguments
+
+        Raises:
+            Exception: If installation fails
+        """
+        cmd_str = "pip " + " ".join(pip_args[:3]) + " ..."
+        logger.debug(f"[LumenPackageInstaller] Running: {cmd_str}")
+        self.log_callback("Running: pip install ...")
+
+        try:
+            result = self.env_manager.run_pip(*pip_args)
+
+            if result.returncode != 0:
+                error_msg = result.stderr or result.stdout
+                logger.error(f"[LumenPackageInstaller] Pip install failed: {error_msg}")
+                self.log_callback(f"Installation failed:\n{error_msg}")
+                raise Exception(f"Pip install failed: {error_msg}")
+
+            # Log output
+            if result.stdout:
+                logger.debug(f"[LumenPackageInstaller] Pip output:\n{result.stdout}")
+
+            logger.info("[LumenPackageInstaller] Pip install successful")
+
+        except subprocess.TimeoutExpired:
+            logger.error("[LumenPackageInstaller] Pip install timed out")
+            self.log_callback("Installation timed out")
+            raise Exception("Pip install timed out")

lumen_app/utils/installation/verifier.py

@@ -0,0 +1,95 @@
+"""Installation verifier for validating Lumen package installations."""
+
+import logging
+import subprocess
+
+from .env_manager import PythonEnvManager
+
+logger = logging.getLogger(__name__)
+
+
+class InstallationVerifier:
+    """Verifies Lumen package installations."""
+
+    def __init__(self, env_manager: PythonEnvManager):
+        """Initialize verifier.
+
+        Args:
+            env_manager: Python environment manager
+        """
+        self.env_manager = env_manager
+        logger.debug("[InstallationVerifier] Initialized")
+
+    def verify_imports(self, packages: list[str]) -> dict[str, bool]:
+        """Verify that packages can be imported.
+
+        Args:
+            packages: List of package names (e.g., ["lumen_ocr", "lumen_clip"])
+
+        Returns:
+            Dictionary mapping package names to import success status
+        """
+        logger.info(f"[InstallationVerifier] Verifying imports for: {packages}")
+        results = {}
+
+        for package in packages:
+            # Convert lumen-ocr to lumen_ocr
+            module_name = package.replace("-", "_")
+            success = self._verify_single_import(module_name)
+            results[package] = success
+
+            status = "✓" if success else "✗"
+            logger.info(f"[InstallationVerifier] {status} {package}")
+
+        return results
+
+    def _verify_single_import(self, module_name: str) -> bool:
+        """Verify that a single module can be imported.
+
+        Args:
+            module_name: Module name (e.g., "lumen_ocr")
+
+        Returns:
+            True if import successful
+        """
+        cmd = [
+            str(self.env_manager.micromamba_exe),
+            "run",
+            "-n",
+            PythonEnvManager.ENV_NAME,
+            "python",
+            "-c",
+            f"from {module_name} import *",
+        ]
+
+        logger.debug(f"[InstallationVerifier] Verifying import: {module_name}")
+
+        try:
+            result = subprocess.run(cmd, capture_output=True, text=True, timeout=30)
+
+            if result.returncode == 0:
+                logger.debug(f"[InstallationVerifier] Import successful: {module_name}")
+                return True
+            else:
+                logger.warning(
+                    f"[InstallationVerifier] Import failed for {module_name}: "
+                    f"{result.stderr[:200]}"
+                )
+                return False
+
+        except subprocess.TimeoutExpired:
+            logger.error(f"[InstallationVerifier] Import timed out: {module_name}")
+            return False
+        except Exception as e:
+            logger.error(f"[InstallationVerifier] Import error for {module_name}: {e}")
+            return False
+
+    def verify_env_exists(self) -> bool:
+        """Verify that lumen_env exists.
+
+        Returns:
+            True if environment exists
+        """
+        exists = self.env_manager.env_exists()
+        logger.info(f"[InstallationVerifier] Environment exists: {exists}")
+        return exists

lumen_app/utils/logger.py

@@ -0,0 +1,181 @@
+"""Centralized logging configuration for Lumen applications.
+
+This module provides a unified logging setup with colorized console output
+and optional file logging. Usage:
+
+    from lumen_app.utils.logger import get_logger
+
+    logger = get_logger(__name__)
+    logger.info("Application started")
+
+Or use the predefined loggers:
+
+    from lumen_app.utils.logger import lumen_logger
+
+    lumen_logger.info("Using predefined logger")
+"""
+
+import logging
+import sys
+from pathlib import Path
+from typing import Optional
+
+# Try to import colorlog, fallback to standard logging
+try:
+    import colorlog
+
+    COLORLOG_AVAILABLE = True
+except ImportError:
+    COLORLOG_AVAILABLE = False
+
+
+# Color scheme for different log levels
+LOG_COLORS = {
+    "DEBUG": "cyan",
+    "INFO": "green",
+    "WARNING": "yellow",
+    "ERROR": "red",
+    "CRITICAL": "red,bg_white",
+}
+
+LOG_FORMAT = "%(asctime)s [%(levelname)s] %(name)s: %(message)s"
+DATE_FORMAT = "%Y-%m-%d %H:%M:%S"
+
+
+def setup_logging(
+    level: int = logging.INFO,
+    log_file: Optional[Path] = None,
+    enable_colors: bool = True,
+) -> None:
+    """Setup root logging configuration.
+
+    Args:
+        level: Logging level (default: INFO)
+        log_file: Optional path to log file
+        enable_colors: Whether to enable colored output (requires colorlog)
+    """
+    # Get root logger
+    root_logger = logging.getLogger()
+    root_logger.setLevel(level)
+
+    # Remove existing handlers
+    root_logger.handlers.clear()
+
+    # Console handler
+    if COLORLOG_AVAILABLE and enable_colors:
+        console_handler = colorlog.StreamHandler(sys.stdout)
+        console_formatter = colorlog.ColoredFormatter(
+            "%(log_color)s%(asctime)s [%(levelname)8s] %(name)s:%(reset)s %(message)s",
+            datefmt=DATE_FORMAT,
+            log_colors=LOG_COLORS,
+        )
+    else:
+        console_handler = logging.StreamHandler(sys.stdout)
+        console_formatter = logging.Formatter(LOG_FORMAT, datefmt=DATE_FORMAT)
+
+    console_handler.setFormatter(console_formatter)
+    console_handler.setLevel(level)
+    root_logger.addHandler(console_handler)
+
+    # File handler (optional)
+    if log_file:
+        log_file.parent.mkdir(parents=True, exist_ok=True)
+        file_handler = logging.FileHandler(log_file, encoding="utf-8")
+        file_formatter = logging.Formatter(LOG_FORMAT, datefmt=DATE_FORMAT)
+        file_handler.setFormatter(file_formatter)
+        file_handler.setLevel(level)
+        root_logger.addHandler(file_handler)
+
+    # Suppress verbose third-party loggers
+    _suppress_third_party_loggers()
+
+
+def _suppress_third_party_loggers() -> None:
+    """Suppress verbose debug logging from third-party libraries."""
+    # List of loggers to suppress
+    suppressed_loggers = {
+        "flet": logging.WARNING,
+        "flet_core": logging.WARNING,
+        "flet.view": logging.WARNING,
+        "flet_web": logging.WARNING,
+        "flet_web.fastapi": logging.WARNING,
+        "httpx": logging.WARNING,
+        "urllib3": logging.WARNING,
+        "websockets": logging.WARNING,
+        "asyncio": logging.WARNING,
+    }
+
+    for logger_name, logger_level in suppressed_loggers.items():
+        third_party_logger = logging.getLogger(logger_name)
+        third_party_logger.setLevel(logger_level)
+
+
+def get_logger(name: str) -> logging.Logger:
+    """Get a logger instance with the given name.
+
+    Args:
+        name: Logger name (typically __name__ from the calling module)
+
+    Returns:
+        Logger instance
+
+    Example:
+        logger = get_logger(__name__)
+        logger.info("Message")
+    """
+    return logging.getLogger(name)
+
+
+# Predefined loggers for common modules
+def _get_module_logger(module_name: str) -> logging.Logger:
+    """Get or create a logger for a specific module."""
+    logger = logging.getLogger(module_name)
+    # Ensure logger has a level set (root level will be used if not set)
+    if not logger.setLevel:
+        logger.setLevel(logging.DEBUG)
+    return logger
+
+
+# Export predefined loggers
+lumen_logger = _get_module_logger("lumen")
+config_logger = _get_module_logger("lumen.config")
+env_checker_logger = _get_module_logger("lumen.env_checker")
+installer_logger = _get_module_logger("lumen.installer")
+ui_logger = _get_module_logger("lumen.ui")
+
+
+# Auto-setup on import (can be called explicitly if needed)
+def initialize(
+    level: int = logging.INFO,
+    log_file: Optional[Path] = None,
+    log_dir: Optional[Path] = None,
+) -> None:
+    """Initialize logging system.
+
+    This is called automatically on import with default settings.
+    Call it explicitly to customize logging behavior.
+
+    Args:
+        level: Logging level (e.g., logging.DEBUG, logging.INFO)
+        log_file: Specific log file path
+        log_dir: Directory for log files (alternative to log_file)
+
+    Example:
+        # Initialize with DEBUG level and custom log file
+        initialize(
+            level=logging.DEBUG,
+            log_file=Path("~/lumen_logs/app.log")
+        )
+    """
+    # Determine log file path
+    if log_file is None and log_dir is not None:
+        from datetime import datetime
+
+        timestamp = datetime.now().strftime("%Y%m%d_%H%M%S")
+        log_file = log_dir / f"lumen_{timestamp}.log"
+
+    setup_logging(level=level, log_file=log_file, enable_colors=COLORLOG_AVAILABLE)
+
+
+# Auto-initialize with defaults
+initialize(level=logging.INFO)

lumen_app/utils/mamba/cuda.yaml

@@ -0,0 +1,12 @@
+name: lumen_env
+channels:
+    - nvidia
+    - conda-forge
+    - defaults
+dependencies:
+    - python=3.11
+    - pip
+    - cuda-version=12.6
+    - cuda-toolkit
+    - cudnn
+    - cutensor

lumen_app/utils/mamba/default.yaml

@@ -0,0 +1,6 @@
+name: lumen_env
+channels:
+    - conda-forge
+dependencies:
+    - python=3.11
+    - uv

lumen_app/utils/mamba/openvino.yaml

@@ -0,0 +1,7 @@
+name: lumen_env
+channels:
+    - conda-forge
+dependencies:
+    - python=3.11
+    - openvino=2025.3.0
+    - pip

lumen_app/utils/mamba/tensorrt.yaml

@@ -0,0 +1,13 @@
+name: lumen_env
+channels:
+    - nvidia
+    - conda-forge
+    - defaults
+dependencies:
+    - python=3.11
+    - pip
+    - cuda-version=12.6
+    - cuda-toolkit
+    - cudnn
+    - cutensor
+    - tensorrt