exonware-xwlazy 0.1.0.23__py3-none-any.whl → 1.0.1.2__py3-none-any.whl

exonware/xwlazy/package/services/host_packages.py

@@ -1,180 +0,0 @@
-"""Lightweight helpers for registering host packages with xwlazy."""
-
-from __future__ import annotations
-
-import os
-import sys
-import functools
-from typing import Iterable, Sequence
-
-# Lazy imports to avoid circular dependency
-def _get_config_package_lazy_install_enabled():
-    """Get config_package_lazy_install_enabled (lazy import to avoid circular dependency)."""
-    from ...facade import config_package_lazy_install_enabled
-    return config_package_lazy_install_enabled
-
-def _get_install_import_hook():
-    """Get install_import_hook (lazy import to avoid circular dependency)."""
-    from ...facade import install_import_hook
-    return install_import_hook
-
-def _get_is_lazy_install_enabled():
-    """Get is_lazy_install_enabled (lazy import to avoid circular dependency)."""
-    from ...facade import is_lazy_install_enabled
-    return is_lazy_install_enabled
-
-def _get_register_lazy_module_methods():
-    """Get register_lazy_module_methods (lazy import to avoid circular dependency)."""
-    from ...facade import register_lazy_module_methods
-    return register_lazy_module_methods
-
-def _get_register_lazy_module_prefix():
-    """Get register_lazy_module_prefix (lazy import to avoid circular dependency)."""
-    from ...facade import register_lazy_module_prefix
-    return register_lazy_module_prefix
-
-# Note: LazyMetaPathFinder is implemented in module/meta_path_finder.py
-# For now, create a placeholder
-class LazyMetaPathFinder:
-    """Placeholder for LazyMetaPathFinder - to be implemented in hooks domain."""
-    def __init__(self, package_name: str):
-        self.package_name = package_name
-    
-    def _enhance_classes_with_class_methods(self, module):
-        """Enhance classes with lazy-aware static/class method behavior."""
-        
-        for name, cls in vars(module).items():
-            if not isinstance(cls, type):
-                continue
-            
-            # Skip if not a serializer (heuristic)
-            if not name.endswith('Serializer'):
-                continue
-
-            # Methods to patch
-            for method_name in ['encode', 'decode']:
-                if not hasattr(cls, method_name):
-                    continue
-
-                original_method = getattr(cls, method_name)
-                if not callable(original_method):
-                    continue
-                
-                # Check if already patched to avoid recursion/duplication
-                if getattr(original_method, '_is_lazy_wrapper', False):
-                    continue
-
-                @functools.wraps(original_method)
-                def wrapper(first_arg, *args, **kwargs):
-                    # Check if first_arg is 'self' (instance of cls)
-                    if isinstance(first_arg, cls):
-                        return original_method(first_arg, *args, **kwargs)
-                    
-                    # Called as class method or static usage: Class.encode(data)
-                    # first_arg is actually the data
-                    # Instantiate to trigger lazy loading (__init__)
-                    instance = cls()
-                    return original_method(instance, first_arg, *args, **kwargs)
-                
-                wrapper._is_lazy_wrapper = True
-                setattr(cls, method_name, wrapper)
-
-_TRUTHY = {"1", "true", "yes", "on"}
-_REGISTERED: dict[str, dict[str, tuple[str, ...]]] = {}
-
-def _normalized(items: Iterable[str]) -> tuple[str, ...]:
-    seen = []
-    for item in items:
-        if item not in seen:
-            seen.append(item)
-    return tuple(seen)
-
-def register_host_package(
-    package_name: str,
-    module_prefixes: Iterable[str] = (),
-    method_prefixes: Iterable[str] = (),
-    method_names: Sequence[str] = ("encode", "decode"),
-    auto_config: bool = True,
-    env_var: str | None = None,
-) -> None:
-    """
-    Register a host package (e.g., xwsystem) with xwlazy.
-
-    Args:
-        package_name: Host package name.
-        module_prefixes: Prefixes that should be lazily wrapped.
-        method_prefixes: Prefixes whose classes expose class-level helpers.
-        method_names: Methods to expose at class level (default encode/decode).
-        auto_config: If True, record lazy config but do not install hook yet.
-        env_var: Optional environment variable to force enable (defaults to
-                 ``{PACKAGE}_LAZY_INSTALL``).
-    """
-    package_name = package_name.lower()
-
-    module_prefixes = _normalized(module_prefixes)
-    method_prefixes = _normalized(method_prefixes)
-    _REGISTERED[package_name] = {
-        "module_prefixes": module_prefixes,
-        "method_prefixes": method_prefixes,
-    }
-
-    for prefix in module_prefixes:
-        _get_register_lazy_module_prefix()(prefix)
-
-    for prefix in method_prefixes:
-        _get_register_lazy_module_methods()(prefix, tuple(method_names))
-
-    if auto_config:
-        # Detect if lazy should be enabled (checks keyword, marker package, etc.)
-        _get_config_package_lazy_install_enabled()(package_name, enabled=None, install_hook=False)
-        
-        # If detection found that lazy should be enabled, install the hook automatically
-        if _get_is_lazy_install_enabled()(package_name):
-            try:
-                _get_install_import_hook()(package_name)
-            except Exception:
-                # Best-effort: package import must continue even if hook installation fails
-                pass
-
-    _apply_wrappers_for_loaded_modules(package_name, module_prefixes, method_prefixes)
-
-    env_key = env_var or f"{package_name.upper()}_LAZY_INSTALL"
-    flag = os.environ.get(env_key, "")
-    if flag.strip().lower() in _TRUTHY:
-        _get_config_package_lazy_install_enabled()(package_name, enabled=True)
-        try:
-            _get_install_import_hook()(package_name)
-        except Exception:
-            # Best-effort: package import must continue even if hook installation fails
-            pass
-
-def refresh_host_package(package_name: str) -> None:
-    """Re-apply wrappers for a registered package."""
-    data = _REGISTERED.get(package_name.lower())
-    if not data:
-        return
-    _apply_wrappers_for_loaded_modules(
-        package_name,
-        data["module_prefixes"],
-        data["method_prefixes"],
-    )
-
-def _apply_wrappers_for_loaded_modules(
-    package_name: str,
-    module_prefixes: Iterable[str],
-    method_prefixes: Iterable[str],
-) -> None:
-    """Enhance already-imported modules so encode/decode helpers work immediately."""
-    prefixes = _normalized((*module_prefixes, *method_prefixes))
-    if not prefixes:
-        return
-
-    finder = LazyMetaPathFinder(package_name)
-    for module_name, module in list(sys.modules.items()):
-        if not isinstance(module_name, str) or module is None:
-            continue
-        if any(module_name.startswith(prefix) for prefix in prefixes):
-            try:
-                finder._enhance_classes_with_class_methods(module)  # type: ignore[attr-defined]
-            except Exception:
-                continue

exonware/xwlazy/package/services/install_async.py

@@ -1,291 +0,0 @@
-"""
-Async Installation Mixin
-
-Company: eXonware.com
-Author: Eng. Muhammad AlShehri
-Email: connect@exonware.com
-
-Generation Date: 15-Nov-2025
-
-Mixin for async installation operations.
-"""
-
-import os
-import asyncio
-import threading
-import importlib
-from typing import Optional, Any
-
-from .async_install_handle import AsyncInstallHandle
-from .manifest import PackageManifest
-from .config_manager import LazyInstallConfig
-from .install_policy import LazyInstallPolicy
-from ...defs import LazyInstallMode
-
-# Lazy imports
-def _get_logger():
-    """Get logger (lazy import to avoid circular dependency)."""
-    from ...common.logger import get_logger
-    return get_logger("xwlazy.lazy_installer")
-
-def _get_log_event():
-    """Get log_event function (lazy import to avoid circular dependency)."""
-    from ...common.logger import log_event
-    return log_event
-
-logger = None
-_log = None
-
-# Environment variables
-_ENV_ASYNC_INSTALL = os.environ.get("XWLAZY_ASYNC_INSTALL", "").strip().lower() in {"1", "true", "yes", "on"}
-_ENV_ASYNC_WORKERS = int(os.environ.get("XWLAZY_ASYNC_WORKERS", "0") or 0)
-
-def _ensure_logging_initialized():
-    """Ensure logging utilities are initialized."""
-    global logger, _log
-    if logger is None:
-        logger = _get_logger()
-        if logger is None:
-            import logging
-            logger = logging.getLogger("xwlazy.lazy_installer.fallback")
-            logger.addHandler(logging.NullHandler())
-    if _log is None:
-        _log = _get_log_event()
-        if _log is None:
-            # Simple fallback
-            def _fallback_log(event, *args, **kwargs):
-                pass
-            _log = _fallback_log
-
-class AsyncInstallMixin:
-    """Mixin for async installation operations."""
-    
-    def _ensure_async_loop(self) -> asyncio.AbstractEventLoop:
-        """Ensure async event loop is running in background thread."""
-        if self._async_loop is not None and self._async_loop.is_running():  # type: ignore[attr-defined]
-            return self._async_loop  # type: ignore[attr-defined]
-        
-        with self._lock:  # type: ignore[attr-defined]
-            if self._async_loop is None or not self._async_loop.is_running():  # type: ignore[attr-defined]
-                loop_ready = threading.Event()
-                loop_ref = [None]
-                
-                def _run_loop():
-                    loop = asyncio.new_event_loop()
-                    asyncio.set_event_loop(loop)
-                    loop_ref[0] = loop
-                    self._async_loop = loop  # type: ignore[attr-defined]
-                    loop_ready.set()
-                    loop.run_forever()
-                
-                self._loop_thread = threading.Thread(  # type: ignore[attr-defined]
-                    target=_run_loop,
-                    daemon=True,
-                    name=f"xwlazy-{self._package_name}-async"  # type: ignore[attr-defined]
-                )
-                self._loop_thread.start()  # type: ignore[attr-defined]
-                
-                if not loop_ready.wait(timeout=5.0):
-                    raise RuntimeError(f"Failed to start async loop for {self._package_name}")  # type: ignore[attr-defined]
-        
-        return self._async_loop  # type: ignore[attr-defined]
-    
-    def apply_manifest(self, manifest: Optional[PackageManifest]) -> None:
-        """Apply manifest-driven configuration such as async installs."""
-        env_override = _ENV_ASYNC_INSTALL
-        # Force disable async install unless strictly overridden by env var (safety default)
-        if not env_override:
-            desired_async = False
-        else:
-            desired_async = True
-        # desired_async = bool(env_override or (manifest and manifest.async_installs))
-        desired_workers = _ENV_ASYNC_WORKERS or (manifest.async_workers if manifest else 1)
-        desired_workers = max(1, desired_workers)
-        
-        with self._lock:  # type: ignore[attr-defined]
-            self._async_workers = desired_workers  # type: ignore[attr-defined]
-            
-            if desired_async:
-                self._ensure_async_loop()
-            else:
-                if self._async_loop is not None:  # type: ignore[attr-defined]
-                    for task in list(self._async_tasks.values()):  # type: ignore[attr-defined]
-                        if not task.done():
-                            task.cancel()
-                    self._async_tasks.clear()  # type: ignore[attr-defined]
-            
-            self._async_enabled = desired_async  # type: ignore[attr-defined]
-    
-    def is_async_enabled(self) -> bool:
-        """Return True if async installers are enabled for this package."""
-        return self._async_enabled  # type: ignore[attr-defined]
-    
-    def ensure_async_install(self, module_name: str) -> Optional[AsyncInstallHandle]:
-        """Schedule (or reuse) an async install job for module_name if async is enabled."""
-        if not self._async_enabled:  # type: ignore[attr-defined]
-            return None
-        return self.schedule_async_install(module_name)
-    
-    async def _get_package_size_mb(self, package_name: str) -> Optional[float]:
-        """Get package size in MB by checking pip show or download size."""
-        from ...common.services.install_async_utils import get_package_size_mb
-        return await get_package_size_mb(package_name)
-    
-    async def _async_install_package(self, package_name: str, module_name: str) -> bool:
-        """Async version of install_package using asyncio subprocess."""
-        _ensure_logging_initialized()
-        # SIZE_AWARE mode: Check package size before installing
-        if self._mode == LazyInstallMode.SIZE_AWARE:  # type: ignore[attr-defined]
-            mode_config = LazyInstallConfig.get_mode_config(self._package_name)  # type: ignore[attr-defined]
-            threshold_mb = mode_config.large_package_threshold_mb if mode_config else 50.0
-            
-            size_mb = await self._get_package_size_mb(package_name)
-            if size_mb is not None and size_mb >= threshold_mb:
-                logger.warning(
-                    f"Package '{package_name}' is {size_mb:.1f}MB (>= {threshold_mb}MB threshold), "
-                    f"skipping installation in SIZE_AWARE mode"
-                )
-                print(
-                    f"[SIZE_AWARE] Skipping large package '{package_name}' "
-                    f"({size_mb:.1f}MB >= {threshold_mb}MB)"
-                )
-                self._failed_packages.add(package_name)  # type: ignore[attr-defined]
-                return False
-        
-        # Check cache first
-        if self._install_from_cached_tree(package_name):  # type: ignore[attr-defined]
-            self._finalize_install_success(package_name, "cache-tree")  # type: ignore[attr-defined]
-            return True
-        
-        # Use asyncio subprocess for pip install
-        try:
-            policy_args = LazyInstallPolicy.get_pip_args(self._package_name) or []  # type: ignore[attr-defined]
-            from ...common.services.install_async_utils import async_install_package
-            success, error_msg = await async_install_package(package_name, policy_args)
-            
-            if success:
-                self._finalize_install_success(package_name, "pip-async")  # type: ignore[attr-defined]
-                
-                # For CLEAN mode, schedule async uninstall after completion
-                if self._mode == LazyInstallMode.CLEAN:  # type: ignore[attr-defined]
-                    asyncio.create_task(self._schedule_clean_uninstall(package_name))
-                
-                # For TEMPORARY mode, uninstall immediately after installation
-                if self._mode == LazyInstallMode.TEMPORARY:  # type: ignore[attr-defined]
-                    asyncio.create_task(self.uninstall_package_async(package_name, quiet=True))
-                
-                return True
-            else:
-                self._failed_packages.add(package_name)  # type: ignore[attr-defined]
-                return False
-        except Exception as e:
-            logger.error(f"Error in async install of {package_name}: {e}")
-            self._failed_packages.add(package_name)  # type: ignore[attr-defined]
-            return False
-    
-    async def _schedule_clean_uninstall(self, package_name: str) -> None:
-        """Schedule uninstall for CLEAN mode after a delay."""
-        await asyncio.sleep(1.0)
-        await self.uninstall_package_async(package_name, quiet=True)
-    
-    async def uninstall_package_async(self, package_name: str, quiet: bool = True) -> bool:
-        """Uninstall a package asynchronously in quiet mode."""
-        with self._lock:  # type: ignore[attr-defined]
-            if package_name not in self._installed_packages:  # type: ignore[attr-defined]
-                return True
-        
-        from ...common.services.install_async_utils import async_uninstall_package
-        success = await async_uninstall_package(package_name, quiet)
-        
-        if success:
-            with self._lock:  # type: ignore[attr-defined]
-                self._installed_packages.discard(package_name)  # type: ignore[attr-defined]
-        
-        return success
-    
-    def schedule_async_install(self, module_name: str) -> Optional[AsyncInstallHandle]:
-        """Schedule installation of a dependency in the background using asyncio."""
-        _ensure_logging_initialized()
-        if not self._async_enabled:  # type: ignore[attr-defined]
-            return None
-        
-        package_name = self._dependency_mapper.get_package_name(module_name) or module_name  # type: ignore[attr-defined]
-        if not package_name:
-            return None
-        
-        with self._lock:  # type: ignore[attr-defined]
-            task = self._async_tasks.get(module_name)  # type: ignore[attr-defined]
-            if task is None or task.done():
-                self._mark_module_missing(module_name)  # type: ignore[attr-defined]
-                loop = self._ensure_async_loop()
-                
-                async def _install_and_cleanup():
-                    try:
-                        result = await self._async_install_package(package_name, module_name)
-                        if result:
-                            self._clear_module_missing(module_name)  # type: ignore[attr-defined]
-                            try:
-                                imported_module = importlib.import_module(module_name)
-                                if self._mode == LazyInstallMode.TEMPORARY:  # type: ignore[attr-defined]
-                                    asyncio.create_task(self.uninstall_package_async(package_name, quiet=True))
-                            except Exception:
-                                pass
-                        return result
-                    finally:
-                        with self._lock:  # type: ignore[attr-defined]
-                            self._async_tasks.pop(module_name, None)  # type: ignore[attr-defined]
-                
-                task = asyncio.run_coroutine_threadsafe(_install_and_cleanup(), loop)
-                self._async_tasks[module_name] = task  # type: ignore[attr-defined]
-        
-        return AsyncInstallHandle(task, module_name, package_name, self._package_name)  # type: ignore[attr-defined]
-    
-    async def install_all_dependencies(self) -> None:
-        """Install all dependencies from discovered requirements (FULL mode)."""
-        _ensure_logging_initialized()
-        if self._mode != LazyInstallMode.FULL:  # type: ignore[attr-defined]
-            return
-        
-        try:
-            # Lazy import to avoid circular dependency
-            from .discovery import get_lazy_discovery
-            discovery = get_lazy_discovery()
-            if discovery:
-                all_deps = discovery.discover_all_dependencies()
-                if not all_deps:
-                    return
-                
-                packages_to_install = [
-                    (import_name, package_name)
-                    for import_name, package_name in all_deps.items()
-                    if package_name not in self._installed_packages  # type: ignore[attr-defined]
-                ]
-                
-                if not packages_to_install:
-                    _log("install", f"All dependencies already installed for {self._package_name}")  # type: ignore[attr-defined]
-                    return
-                
-                _log(
-                    "install",
-                    f"Installing {len(packages_to_install)} dependencies for {self._package_name} (FULL mode)"
-                )
-                
-                batch_size = min(self._async_workers * 2, 10)  # type: ignore[attr-defined]
-                for i in range(0, len(packages_to_install), batch_size):
-                    batch = packages_to_install[i:i + batch_size]
-                    tasks = [
-                        self._async_install_package(package_name, import_name)
-                        for import_name, package_name in batch
-                    ]
-                    results = await asyncio.gather(*tasks, return_exceptions=True)
-                    
-                    for (import_name, package_name), result in zip(batch, results):
-                        if isinstance(result, Exception):
-                            logger.error(f"Failed to install {package_name}: {result}")
-                        elif result:
-                            _log("install", f"✓ Installed {package_name}")
-                
-                _log("install", f"Completed installing all dependencies for {self._package_name}")  # type: ignore[attr-defined]
-        except Exception as e:
-            logger.warning(f"Failed to install all dependencies for {self._package_name}: {e}")  # type: ignore[attr-defined]
-

exonware/xwlazy/package/services/install_cache.py

@@ -1,145 +0,0 @@
-"""
-Installation Cache Mixin
-
-Company: eXonware.com
-Author: Eng. Muhammad AlShehri
-Email: connect@exonware.com
-
-Generation Date: 15-Nov-2025
-
-Mixin for cache management (wheels, install trees, known missing modules).
-Uses shared utilities from common/services/install_cache_utils.
-"""
-
-import os
-import time
-from pathlib import Path
-from typing import Optional
-from collections import OrderedDict
-
-# Import shared utilities
-from ...common.services.install_cache_utils import (
-    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 as _install_from_cached_tree_util,
-    materialize_cached_tree as _materialize_cached_tree_util,
-    has_cached_install_tree as _has_cached_install_tree_util,
-    install_from_cached_wheel as _install_from_cached_wheel_util,
-)
-
-# Lazy imports
-def _get_spec_cache_clear():
-    """Get spec_cache_clear function (lazy import to avoid circular dependency)."""
-    from ...common.services.spec_cache import _spec_cache_clear
-    return _spec_cache_clear
-
-_spec_cache_clear = None
-
-# Environment variables
-_KNOWN_MISSING_CACHE_LIMIT = int(os.environ.get("XWLAZY_MISSING_CACHE_MAX", "128") or 128)
-_KNOWN_MISSING_CACHE_TTL = float(os.environ.get("XWLAZY_MISSING_CACHE_TTL", "120") or 120.0)
-
-def _ensure_spec_cache_initialized():
-    """Ensure spec cache utilities are initialized."""
-    global _spec_cache_clear
-    if _spec_cache_clear is None:
-        _spec_cache_clear = _get_spec_cache_clear()
-
-class InstallCacheMixin:
-    """Mixin for cache management (wheels, install trees, known missing modules)."""
-    
-    def _prune_known_missing(self) -> None:
-        """Remove stale entries from the known-missing cache."""
-        if not self._known_missing:  # type: ignore[attr-defined]
-            return
-        now = time.monotonic()
-        with self._lock:  # type: ignore[attr-defined]
-            while self._known_missing:  # type: ignore[attr-defined]
-                _, ts = next(iter(self._known_missing.items()))  # type: ignore[attr-defined]
-                if now - ts <= _KNOWN_MISSING_CACHE_TTL:
-                    break
-                self._known_missing.popitem(last=False)  # type: ignore[attr-defined]
-    
-    def _mark_module_missing(self, module_name: str) -> None:
-        """Remember modules that failed to import recently."""
-        _ensure_spec_cache_initialized()
-        with self._lock:  # type: ignore[attr-defined]
-            self._prune_known_missing()
-            _spec_cache_clear(module_name)
-            self._known_missing[module_name] = time.monotonic()  # type: ignore[attr-defined]
-            while len(self._known_missing) > _KNOWN_MISSING_CACHE_LIMIT:  # type: ignore[attr-defined]
-                self._known_missing.popitem(last=False)  # type: ignore[attr-defined]
-    
-    def _clear_module_missing(self, module_name: str) -> None:
-        """Remove a module from the known-missing cache."""
-        with self._lock:  # type: ignore[attr-defined]
-            self._known_missing.pop(module_name, None)  # type: ignore[attr-defined]
-    
-    def is_module_known_missing(self, module_name: str) -> bool:
-        """Return True if module recently failed to import."""
-        self._prune_known_missing()
-        with self._lock:  # type: ignore[attr-defined]
-            return module_name in self._known_missing  # type: ignore[attr-defined]
-    
-    def _get_async_cache_dir(self) -> Path:
-        """Get the async cache directory."""
-        return get_cache_dir(self._async_cache_dir)  # type: ignore[attr-defined]
-    
-    def _cached_wheel_name(self, package_name: str) -> Path:
-        """Get the cached wheel file path for a package."""
-        return get_wheel_path(package_name, self._async_cache_dir)  # type: ignore[attr-defined]
-    
-    def _install_from_cached_wheel(self, package_name: str, policy_args: Optional[list[str]] = None) -> bool:
-        """Install from a cached wheel file."""
-        return _install_from_cached_wheel_util(
-            package_name,
-            policy_args,
-            self._async_cache_dir  # type: ignore[attr-defined]
-        )
-    
-    def _pip_install_from_path(self, wheel_path: Path, policy_args: Optional[list[str]] = None) -> bool:
-        """Install a wheel file using pip."""
-        return pip_install_from_path(wheel_path, policy_args)
-    
-    def _ensure_cached_wheel(self, package_name: str, policy_args: Optional[list[str]] = None) -> Optional[Path]:
-        """Ensure a wheel is cached, downloading it if necessary."""
-        return ensure_cached_wheel(
-            package_name,
-            policy_args,
-            self._async_cache_dir  # type: ignore[attr-defined]
-        )
-    
-    def _cached_install_dir(self, package_name: str) -> Path:
-        """Get the cached install directory for a package."""
-        return get_install_tree_dir(package_name, self._async_cache_dir)  # type: ignore[attr-defined]
-    
-    def _has_cached_install_tree(self, package_name: str) -> bool:
-        """Check if a cached install tree exists."""
-        return _has_cached_install_tree_util(
-            package_name,
-            self._async_cache_dir  # type: ignore[attr-defined]
-        )
-    
-    def _site_packages_dir(self) -> Path:
-        """Get the site-packages directory."""
-        return get_site_packages_dir()
-    
-    def _install_from_cached_tree(self, package_name: str) -> bool:
-        """Install from a cached install tree."""
-        return _install_from_cached_tree_util(
-            package_name,
-            self._async_cache_dir  # type: ignore[attr-defined]
-        )
-    
-    def _materialize_cached_tree(self, package_name: str, wheel_path: Path) -> None:
-        """Materialize a cached install tree from a wheel file."""
-        _materialize_cached_tree_util(
-            package_name,
-            wheel_path,
-            self._async_cache_dir  # type: ignore[attr-defined]
-        )
-

exonware/xwlazy/package/services/install_interactive.py

@@ -1,59 +0,0 @@
-"""
-Interactive Installation Mixin
-
-Company: eXonware.com
-Author: Eng. Muhammad AlShehri
-Email: connect@exonware.com
-
-Generation Date: 15-Nov-2025
-
-Mixin for interactive user prompts during installation.
-"""
-
-from typing import TYPE_CHECKING
-
-if TYPE_CHECKING:
-    from .lazy_installer import LazyInstaller
-
-class InteractiveInstallMixin:
-    """Mixin for interactive user prompts during installation."""
-    
-    def _ask_user_permission(self, package_name: str, module_name: str) -> bool:
-        """Ask user for permission to install a package."""
-        if self._auto_approve_all:  # type: ignore[attr-defined]
-            return True
-        
-        print(f"\n{'='*60}")
-        print(f"Lazy Installation Active - {self._package_name}")  # type: ignore[attr-defined]
-        print(f"{'='*60}")
-        print(f"Package: {package_name}")
-        print(f"Module:  {module_name}")
-        print(f"{'='*60}")
-        print(f"\nThe module '{module_name}' is not installed.")
-        print(f"Would you like to install '{package_name}'?")
-        print(f"\nOptions:")
-        print(f"  [Y] Yes - Install this package")
-        print(f"  [N] No  - Skip this package")
-        print(f"  [A] All - Install this and all future packages without asking")
-        print(f"  [Q] Quit - Cancel and raise ImportError")
-        print(f"{'='*60}")
-        
-        while True:
-            try:
-                choice = input("Your choice [Y/N/A/Q]: ").strip().upper()
-                
-                if choice in ('Y', 'YES', ''):
-                    return True
-                elif choice in ('N', 'NO'):
-                    return False
-                elif choice in ('A', 'ALL'):
-                    self._auto_approve_all = True  # type: ignore[attr-defined]
-                    return True
-                elif choice in ('Q', 'QUIT'):
-                    raise KeyboardInterrupt("User cancelled installation")
-                else:
-                    print(f"Invalid choice '{choice}'. Please enter Y, N, A, or Q.")
-            except (EOFError, KeyboardInterrupt):
-                print("\n❌ Installation cancelled by user")
-                return False
-