exonware-xwlazy 0.1.0.1__py3-none-any.whl → 0.1.0.8__py3-none-any.whl

exonware/xwlazy/common/services/install_async_utils.py

@@ -1,170 +0,0 @@
-"""
-Installation Async Utilities
-
-Company: eXonware.com
-Author: Eng. Muhammad AlShehri
-Email: connect@exonware.com
-
-Generation Date: 15-Nov-2025
-
-Shared utilities for async installation operations.
-Used by both execution strategies and LazyInstaller.
-"""
-
-import os
-import sys
-import json
-import asyncio
-import subprocess
-from typing import Optional
-
-# Lazy imports
-def _get_logger():
-    """Get logger (lazy import to avoid circular dependency)."""
-    from ..logger import get_logger
-    return get_logger("xwlazy.install_async_utils")
-
-logger = None
-
-def _ensure_logging_initialized():
-    """Ensure logging utilities are initialized."""
-    global logger
-    if logger is None:
-        logger = _get_logger()
-        # Fallback if get_logger returns None (should not happen but safety first)
-        if logger is None:
-            import logging
-            logger = logging.getLogger("xwlazy.install_async_utils.fallback")
-            logger.addHandler(logging.NullHandler())
-
-async def get_package_size_mb(package_name: str) -> Optional[float]:
-    """
-    Get package size in MB by checking pip show or download size.
-    
-    Args:
-        package_name: Package name to check
-        
-    Returns:
-        Size in MB or None if cannot determine
-    """
-    try:
-        process = await asyncio.create_subprocess_exec(
-            sys.executable, '-m', 'pip', 'show', package_name,
-            stdout=asyncio.subprocess.PIPE,
-            stderr=asyncio.subprocess.PIPE
-        )
-        stdout, _ = await process.communicate()
-        
-        if process.returncode == 0:
-            output = stdout.decode()
-            for line in output.split('\n'):
-                if line.startswith('Location:'):
-                    location = line.split(':', 1)[1].strip()
-                    try:
-                        total_size = 0
-                        for dirpath, dirnames, filenames in os.walk(location):
-                            for filename in filenames:
-                                filepath = os.path.join(dirpath, filename)
-                                if os.path.exists(filepath):
-                                    total_size += os.path.getsize(filepath)
-                        return total_size / (1024 * 1024)
-                    except Exception:
-                        pass
-    except Exception:
-        pass
-    
-    # Fallback: Try to get download size from PyPI
-    try:
-        import urllib.request
-        url = f"https://pypi.org/pypi/{package_name}/json"
-        with urllib.request.urlopen(url, timeout=5) as response:
-            data = json.loads(response.read())
-            if 'urls' in data and data['urls']:
-                latest = data['urls'][0]
-                if 'size' in latest:
-                    return latest['size'] / (1024 * 1024)
-    except Exception:
-        pass
-    
-    return None
-
-async def async_install_package(
-    package_name: str,
-    policy_args: Optional[list] = None
-) -> tuple[bool, Optional[str]]:
-    """
-    Install a package asynchronously using asyncio subprocess.
-    
-    Args:
-        package_name: Package name to install
-        policy_args: Optional policy arguments (index URLs, trusted hosts, etc.)
-        
-    Returns:
-        Tuple of (success: bool, error_message: Optional[str])
-    """
-    _ensure_logging_initialized()
-    try:
-        pip_args = [sys.executable, '-m', 'pip', 'install']
-        if policy_args:
-            pip_args.extend(policy_args)
-        pip_args.append(package_name)
-        
-        process = await asyncio.create_subprocess_exec(
-            *pip_args,
-            stdout=asyncio.subprocess.PIPE,
-            stderr=asyncio.subprocess.PIPE
-        )
-        
-        stdout, stderr = await process.communicate()
-        
-        if process.returncode == 0:
-            return True, None
-        else:
-            error_msg = stderr.decode() if stderr else "Unknown error"
-            logger.error(f"Failed to install {package_name}: {error_msg}")
-            return False, error_msg
-    except Exception as e:
-        logger.error(f"Error in async install of {package_name}: {e}")
-        return False, str(e)
-
-async def async_uninstall_package(
-    package_name: str,
-    quiet: bool = True
-) -> bool:
-    """
-    Uninstall a package asynchronously.
-    
-    Args:
-        package_name: Package name to uninstall
-        quiet: If True, suppress output
-        
-    Returns:
-        True if successful, False otherwise
-    """
-    _ensure_logging_initialized()
-    try:
-        pip_args = [sys.executable, '-m', 'pip', 'uninstall', '-y', package_name]
-        
-        process = await asyncio.create_subprocess_exec(
-            *pip_args,
-            stdout=asyncio.subprocess.PIPE if quiet else None,
-            stderr=asyncio.subprocess.PIPE if quiet else None
-        )
-        
-        await process.communicate()
-        
-        if process.returncode == 0:
-            if not quiet:
-                logger.info(f"Uninstalled {package_name}")
-            return True
-        return False
-    except Exception as e:
-        logger.debug(f"Failed to uninstall {package_name}: {e}")
-        return False
-
-__all__ = [
-    'get_package_size_mb',
-    'async_install_package',
-    'async_uninstall_package',
-]
-

exonware/xwlazy/common/services/install_cache_utils.py

@@ -1,245 +0,0 @@
-"""
-Installation Cache Utilities
-
-Company: eXonware.com
-Author: Eng. Muhammad AlShehri
-Email: connect@exonware.com
-
-Generation Date: 15-Nov-2025
-
-Shared utilities for cache management (wheels, install trees).
-Used by both execution strategies and LazyInstaller.
-"""
-
-import os
-import sys
-import shutil
-import sysconfig
-import tempfile
-import subprocess
-import zipfile
-from pathlib import Path
-from typing import Optional
-from contextlib import suppress
-
-# Lazy imports
-def _get_logger():
-    """Get logger (lazy import to avoid circular dependency)."""
-    from ..logger import get_logger
-    return get_logger("xwlazy.install_cache_utils")
-
-logger = None
-
-# Environment variables
-_DEFAULT_ASYNC_CACHE_DIR = Path(
-    os.environ.get(
-        "XWLAZY_ASYNC_CACHE_DIR",
-        os.path.join(os.path.expanduser("~"), ".xwlazy", "wheel-cache"),
-    )
-)
-
-def _ensure_logging_initialized():
-    """Ensure logging utilities are initialized."""
-    global logger
-    if logger is None:
-        logger = _get_logger()
-
-def get_default_cache_dir() -> Path:
-    """Get the default cache directory."""
-    return _DEFAULT_ASYNC_CACHE_DIR
-
-def get_cache_dir(cache_dir: Optional[Path] = None) -> Path:
-    """Get cache directory, creating it if necessary."""
-    if cache_dir is None:
-        cache_dir = _DEFAULT_ASYNC_CACHE_DIR
-    path = Path(cache_dir).expanduser()
-    path.mkdir(parents=True, exist_ok=True)
-    return path
-
-def get_wheel_path(package_name: str, cache_dir: Optional[Path] = None) -> Path:
-    """Get the cached wheel file path for a package."""
-    cache = get_cache_dir(cache_dir)
-    safe = package_name.replace("/", "_").replace("\\", "_").replace(":", "_")
-    return cache / f"{safe}.whl"
-
-def get_install_tree_dir(package_name: str, cache_dir: Optional[Path] = None) -> Path:
-    """Get the cached install directory for a package."""
-    cache = get_cache_dir(cache_dir)
-    safe = package_name.replace("/", "_").replace("\\", "_").replace(":", "_")
-    return cache / "installs" / safe
-
-def get_site_packages_dir() -> Path:
-    """Get the site-packages directory."""
-    purelib = sysconfig.get_paths().get("purelib")
-    if not purelib:
-        purelib = sysconfig.get_paths().get("platlib", sys.prefix)
-    path = Path(purelib)
-    path.mkdir(parents=True, exist_ok=True)
-    return path
-
-def pip_install_from_path(wheel_path: Path, policy_args: Optional[list[str]] = None) -> bool:
-    """Install a wheel file using pip."""
-    try:
-        pip_args = [
-            sys.executable,
-            '-m',
-            'pip',
-            'install',
-            '--no-deps',
-            '--no-input',
-            '--disable-pip-version-check',
-        ]
-        if policy_args:
-            pip_args.extend(policy_args)
-        pip_args.append(str(wheel_path))
-        result = subprocess.run(
-            pip_args,
-            capture_output=True,
-            text=True,
-            check=True,
-        )
-        return result.returncode == 0
-    except subprocess.CalledProcessError:
-        return False
-
-def ensure_cached_wheel(
-    package_name: str,
-    policy_args: Optional[list[str]] = None,
-    cache_dir: Optional[Path] = None
-) -> Optional[Path]:
-    """Ensure a wheel is cached, downloading it if necessary."""
-    wheel_path = get_wheel_path(package_name, cache_dir)
-    if wheel_path.exists():
-        return wheel_path
-    
-    cache = get_cache_dir(cache_dir)
-    try:
-        pip_args = [
-            sys.executable,
-            '-m',
-            'pip',
-            'wheel',
-            '--no-deps',
-            '--disable-pip-version-check',
-        ]
-        if policy_args:
-            pip_args.extend(policy_args)
-        pip_args.extend(['--wheel-dir', str(cache), package_name])
-        result = subprocess.run(
-            pip_args,
-            capture_output=True,
-            text=True,
-            check=True,
-        )
-        if result.returncode != 0:
-            return None
-        candidates = sorted(cache.glob("*.whl"), key=lambda p: p.stat().st_mtime, reverse=True)
-        if not candidates:
-            return None
-        primary = candidates[0]
-        if wheel_path.exists():
-            with suppress(Exception):
-                wheel_path.unlink()
-        primary.rename(wheel_path)
-        for leftover in candidates[1:]:
-            with suppress(Exception):
-                leftover.unlink()
-        return wheel_path
-    except subprocess.CalledProcessError:
-        return None
-
-def install_from_cached_tree(
-    package_name: str,
-    cache_dir: Optional[Path] = None
-) -> bool:
-    """Install from a cached install tree."""
-    _ensure_logging_initialized()
-    src = get_install_tree_dir(package_name, cache_dir)
-    if not src.exists() or not any(src.iterdir()):
-        return False
-    target_root = get_site_packages_dir()
-    try:
-        for item in src.iterdir():
-            dest = target_root / item.name
-            if dest.exists():
-                if dest.is_dir():
-                    shutil.rmtree(dest, ignore_errors=True)
-                else:
-                    with suppress(FileNotFoundError):
-                        dest.unlink()
-            if item.is_dir():
-                shutil.copytree(item, dest)
-            else:
-                dest.parent.mkdir(parents=True, exist_ok=True)
-                shutil.copy2(item, dest)
-        return True
-    except Exception as exc:
-        logger.debug("Cached tree install failed for %s: %s", package_name, exc)
-        return False
-
-def materialize_cached_tree(
-    package_name: str,
-    wheel_path: Path,
-    cache_dir: Optional[Path] = None
-) -> None:
-    """Materialize a cached install tree from a wheel file."""
-    _ensure_logging_initialized()
-    if not wheel_path or not wheel_path.exists():
-        return
-    target_dir = get_install_tree_dir(package_name, cache_dir)
-    if target_dir.exists() and any(target_dir.iterdir()):
-        return
-    parent = target_dir.parent
-    parent.mkdir(parents=True, exist_ok=True)
-    temp_dir = Path(
-        tempfile.mkdtemp(prefix="xwlazy-cache-", dir=str(parent))
-    )
-    try:
-        with zipfile.ZipFile(wheel_path, "r") as archive:
-            archive.extractall(temp_dir)
-        if target_dir.exists():
-            shutil.rmtree(target_dir, ignore_errors=True)
-        shutil.move(str(temp_dir), str(target_dir))
-    except Exception as exc:
-        logger.debug("Failed to materialize cached tree for %s: %s", package_name, exc)
-        with suppress(Exception):
-            shutil.rmtree(temp_dir, ignore_errors=True)
-    else:
-        return
-    finally:
-        if temp_dir.exists():
-            shutil.rmtree(temp_dir, ignore_errors=True)
-
-def has_cached_install_tree(
-    package_name: str,
-    cache_dir: Optional[Path] = None
-) -> bool:
-    """Check if a cached install tree exists."""
-    target = get_install_tree_dir(package_name, cache_dir)
-    return target.exists() and any(target.iterdir())
-
-def install_from_cached_wheel(
-    package_name: str,
-    policy_args: Optional[list[str]] = None,
-    cache_dir: Optional[Path] = None
-) -> bool:
-    """Install from a cached wheel file."""
-    wheel_path = get_wheel_path(package_name, cache_dir)
-    if not wheel_path.exists():
-        return False
-    return pip_install_from_path(wheel_path, policy_args)
-
-__all__ = [
-    'get_default_cache_dir',
-    'get_cache_dir',
-    'get_wheel_path',
-    'get_install_tree_dir',
-    'get_site_packages_dir',
-    'pip_install_from_path',
-    'ensure_cached_wheel',
-    'install_from_cached_tree',
-    'materialize_cached_tree',
-    'has_cached_install_tree',
-    'install_from_cached_wheel',
-]
-

exonware/xwlazy/common/services/keyword_detection.py

@@ -1,283 +0,0 @@
-"""
-Keyword-based detection for lazy installation.
-
-This module provides functionality to detect packages that opt-in to lazy loading
-by including specific keywords in their metadata.
-"""
-
-import os
-import sys
-import threading
-from typing import Optional
-
-from ..logger import get_logger
-
-logger = get_logger("xwlazy.discovery.keyword")
-
-# Global configuration
-_KEYWORD_DETECTION_ENABLED: bool = True
-_KEYWORD_TO_CHECK: str = "xwlazy-enabled"
-_keyword_config_lock = threading.RLock()
-
-# Detection cache
-_lazy_detection_cache: dict[str, bool] = {}
-_lazy_detection_lock = threading.RLock()
-
-def _check_package_keywords(package_name: Optional[str] = None, keyword: Optional[str] = None) -> bool:
-    """
-    Check if any installed package has the specified keyword in its metadata.
-    
-    This allows packages to opt-in to lazy loading by adding:
-    [project]
-    keywords = ["xwlazy-enabled"]
-    
-    in their pyproject.toml file. The keyword is stored in the package's
-    metadata when installed.
-    
-    Args:
-        package_name: The package name to check (or None to check all packages)
-        keyword: The keyword to look for (default: uses _KEYWORD_TO_CHECK)
-    
-    Returns:
-        True if the keyword is found in any relevant package's metadata
-    """
-    if not _KEYWORD_DETECTION_ENABLED:
-        return False
-    
-    if sys.version_info < (3, 8):
-        return False
-    
-    try:
-        from importlib import metadata
-    except Exception as exc:
-        logger.debug(f"importlib.metadata unavailable for keyword detection: {exc}")
-        return False
-    
-    with _keyword_config_lock:
-        search_keyword = (keyword or _KEYWORD_TO_CHECK).lower()
-    
-    try:
-        if package_name:
-            # Check specific package
-            try:
-                dist = metadata.distribution(package_name)
-                keywords = dist.metadata.get_all('Keywords', [])
-                if keywords:
-                    # Keywords can be a single string or list
-                    all_keywords = []
-                    for kw in keywords:
-                        if isinstance(kw, str):
-                            # Split comma-separated keywords
-                            all_keywords.extend(k.strip().lower() for k in kw.split(','))
-                        else:
-                            all_keywords.append(str(kw).lower())
-                    
-                    if search_keyword in all_keywords:
-                        logger.info(f"✅ Detected '{search_keyword}' keyword in package: {package_name}")
-                        return True
-            except metadata.PackageNotFoundError:
-                return False
-        else:
-            # Check all installed packages
-            for dist in metadata.distributions():
-                try:
-                    keywords = dist.metadata.get_all('Keywords', [])
-                    if keywords:
-                        all_keywords = []
-                        for kw in keywords:
-                            if isinstance(kw, str):
-                                all_keywords.extend(k.strip().lower() for k in kw.split(','))
-                            else:
-                                all_keywords.append(str(kw).lower())
-                        
-                        if search_keyword in all_keywords:
-                            package_found = dist.metadata.get('Name', 'unknown')
-                            logger.info(f"✅ Detected '{search_keyword}' keyword in package: {package_found}")
-                            return True
-                except Exception:
-                    continue
-    except Exception as exc:
-        logger.debug(f"Failed to check package keywords: {exc}")
-    
-    return False
-
-def _lazy_marker_installed() -> bool:
-    """Check if the exonware-xwlazy marker package is installed."""
-    if sys.version_info < (3, 8):
-        return False
-
-    try:
-        from importlib import metadata
-    except Exception as exc:
-        logger.debug(f"importlib.metadata unavailable for lazy detection: {exc}")
-        return False
-
-    try:
-        metadata.distribution("exonware-xwlazy")
-        logger.info("✅ Detected exonware-xwlazy marker package")
-        return True
-    except metadata.PackageNotFoundError:
-        logger.debug("❌ exonware-xwlazy marker package not installed")
-        return False
-
-def _lazy_env_override(package_name: str) -> Optional[bool]:
-    """Check environment variable override for lazy installation."""
-    env_var = f"{package_name.upper()}_LAZY_INSTALL"
-    raw_value = os.environ.get(env_var)
-    if raw_value is None:
-        return None
-
-    normalized = raw_value.strip().lower()
-    if normalized in ("true", "1", "yes", "on"):
-        return True
-    if normalized in ("false", "0", "no", "off"):
-        return False
-    return None
-
-def _detect_meta_info_mode(package_name: str) -> Optional[str]:
-    """
-    Detect lazy mode from package metadata keywords.
-    
-    Checks for keywords like:
-    - xwlazy-load-install-uninstall (clean mode)
-    - xwlazy-lite (lite mode)
-    - xwlazy-smart (smart mode)
-    - xwlazy-full (full mode)
-    - xwlazy-auto (auto mode)
-    
-    Returns:
-        Mode string or None if not found
-    """
-    try:
-        import importlib.metadata
-        try:
-            dist = importlib.metadata.distribution(package_name)
-            keywords = dist.metadata.get_all("Keywords", [])
-            if not keywords:
-                return None
-            
-            keyword_str = " ".join(keywords).lower()
-            
-            if "xwlazy-load-install-uninstall" in keyword_str:
-                return "clean"
-            if "xwlazy-lite" in keyword_str:
-                return "lite"
-            if "xwlazy-smart" in keyword_str:
-                return "smart"
-            if "xwlazy-full" in keyword_str:
-                return "full"
-            if "xwlazy-auto" in keyword_str:
-                return "auto"
-        except importlib.metadata.PackageNotFoundError:
-            return None
-    except Exception:
-        pass
-    return None
-
-def enable_keyword_detection(enabled: bool = True, keyword: Optional[str] = None) -> None:
-    """
-    Enable/disable keyword-based auto-detection of lazy loading.
-    
-    When enabled, xwlazy will check installed packages for a keyword
-    (default: "xwlazy-enabled") in their metadata. Packages can opt-in
-    by adding the keyword to their pyproject.toml:
-    
-    [project]
-    keywords = ["xwlazy-enabled"]
-    
-    Args:
-        enabled: Whether to enable keyword detection (default: True)
-        keyword: Custom keyword to check (default: "xwlazy-enabled")
-    """
-    global _KEYWORD_DETECTION_ENABLED, _KEYWORD_TO_CHECK
-    with _keyword_config_lock:
-        _KEYWORD_DETECTION_ENABLED = enabled
-        if keyword is not None:
-            _KEYWORD_TO_CHECK = keyword
-        # Clear cache to force re-detection
-        with _lazy_detection_lock:
-            _lazy_detection_cache.clear()
-
-def is_keyword_detection_enabled() -> bool:
-    """Return whether keyword-based detection is enabled."""
-    with _keyword_config_lock:
-        return _KEYWORD_DETECTION_ENABLED
-
-def get_keyword_detection_keyword() -> str:
-    """Get the keyword currently being checked for auto-detection."""
-    with _keyword_config_lock:
-        return _KEYWORD_TO_CHECK
-
-def check_package_keywords(package_name: Optional[str] = None, keyword: Optional[str] = None) -> bool:
-    """
-    Check if a package (or any package) has the specified keyword in its metadata.
-    
-    This is the public API for the keyword detection functionality.
-    
-    Args:
-        package_name: The package name to check (or None to check all packages)
-        keyword: The keyword to look for (default: uses configured keyword)
-    
-    Returns:
-        True if the keyword is found in the package's metadata
-    """
-    return _check_package_keywords(package_name, keyword)
-
-def _detect_lazy_installation(package_name: str) -> bool:
-    """
-    Detect if lazy installation should be enabled for a package.
-    
-    This function checks multiple sources in order:
-    1. Environment variable override
-    2. Manual state (from state manager)
-    3. Cached auto state
-    4. Marker package detection
-    5. Keyword detection
-    
-    Args:
-        package_name: The package name to check
-    
-    Returns:
-        True if lazy installation should be enabled
-    """
-    with _lazy_detection_lock:
-        cached = _lazy_detection_cache.get(package_name)
-        if cached is not None:
-            return cached
-
-    env_override = _lazy_env_override(package_name)
-    if env_override is not None:
-        with _lazy_detection_lock:
-            _lazy_detection_cache[package_name] = env_override
-        return env_override
-
-    from .state_manager import LazyStateManager
-    state_manager = LazyStateManager(package_name)
-    manual_state = state_manager.get_manual_state()
-    if manual_state is not None:
-        with _lazy_detection_lock:
-            _lazy_detection_cache[package_name] = manual_state
-        return manual_state
-
-    cached_state = state_manager.get_cached_auto_state()
-    if cached_state is not None:
-        with _lazy_detection_lock:
-            _lazy_detection_cache[package_name] = cached_state
-        return cached_state
-
-    # Check marker package first (existing behavior)
-    marker_detected = _lazy_marker_installed()
-    
-    # Also check for keyword in package metadata (new feature)
-    keyword_detected = _check_package_keywords(package_name)
-    
-    # Enable if either marker package OR keyword is found
-    detected = marker_detected or keyword_detected
-    
-    state_manager.set_auto_state(detected)
-
-    with _lazy_detection_lock:
-        _lazy_detection_cache[package_name] = detected
-
-    return detected
-