exonware-xwlazy 0.1.0.11__py3-none-any.whl → 0.1.0.19__py3-none-any.whl

exonware/xwlazy/package/services/install_async.py

@@ -0,0 +1,278 @@
+"""
+Async Installation Mixin
+
+Company: eXonware.com
+Author: Eng. Muhammad AlShehri
+Email: connect@exonware.com
+Version: 0.1.0.19
+Generation Date: 15-Nov-2025
+
+Mixin for async installation operations.
+"""
+
+import os
+import asyncio
+import threading
+import importlib
+from typing import Optional, Dict, 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 _log is None:
+        _log = _get_log_event()
+
+
+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
+        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

@@ -0,0 +1,146 @@
+"""
+Installation Cache Mixin
+
+Company: eXonware.com
+Author: Eng. Muhammad AlShehri
+Email: connect@exonware.com
+Version: 0.1.0.19
+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, List
+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

@@ -0,0 +1,60 @@
+"""
+Interactive Installation Mixin
+
+Company: eXonware.com
+Author: Eng. Muhammad AlShehri
+Email: connect@exonware.com
+Version: 0.1.0.19
+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
+

exonware/xwlazy/package/services/install_policy.py

@@ -0,0 +1,158 @@
+"""
+Install Policy
+
+Company: eXonware.com
+Author: Eng. Muhammad AlShehri
+Email: connect@exonware.com
+Version: 0.1.0.19
+Generation Date: 15-Nov-2025
+
+Security and policy configuration for lazy installation.
+"""
+
+import threading
+from typing import Dict, List, Optional, Set, Tuple
+
+# Lazy import to avoid circular dependency
+def _get_log_event():
+    """Get log_event function (lazy import to avoid circular dependency)."""
+    from ...common.logger import log_event
+    return log_event
+
+_log = None  # Will be initialized on first use
+
+
+class LazyInstallPolicy:
+    """
+    Security and policy configuration for lazy installation.
+    Per-package allow/deny lists, index URLs, and security settings.
+    """
+    __slots__ = ()
+    
+    _allow_lists: Dict[str, Set[str]] = {}
+    _deny_lists: Dict[str, Set[str]] = {}
+    _index_urls: Dict[str, str] = {}
+    _extra_index_urls: Dict[str, List[str]] = {}
+    _trusted_hosts: Dict[str, List[str]] = {}
+    _require_hashes: Dict[str, bool] = {}
+    _verify_ssl: Dict[str, bool] = {}
+    _lockfile_paths: Dict[str, str] = {}
+    _lock = threading.RLock()
+    
+    @classmethod
+    def _ensure_logging(cls):
+        """Ensure logging is initialized."""
+        global _log
+        if _log is None:
+            _log = _get_log_event()
+    
+    @classmethod
+    def set_allow_list(cls, package_name: str, allowed_packages: List[str]) -> None:
+        """Set allow list for a package (only these can be installed)."""
+        cls._ensure_logging()
+        with cls._lock:
+            cls._allow_lists[package_name] = set(allowed_packages)
+            _log("config", f"Set allow list for {package_name}: {len(allowed_packages)} packages")
+    
+    @classmethod
+    def set_deny_list(cls, package_name: str, denied_packages: List[str]) -> None:
+        """Set deny list for a package (these cannot be installed)."""
+        cls._ensure_logging()
+        with cls._lock:
+            cls._deny_lists[package_name] = set(denied_packages)
+            _log("config", f"Set deny list for {package_name}: {len(denied_packages)} packages")
+    
+    @classmethod
+    def add_to_allow_list(cls, package_name: str, allowed_package: str) -> None:
+        """Add single package to allow list."""
+        with cls._lock:
+            if package_name not in cls._allow_lists:
+                cls._allow_lists[package_name] = set()
+            cls._allow_lists[package_name].add(allowed_package)
+    
+    @classmethod
+    def add_to_deny_list(cls, package_name: str, denied_package: str) -> None:
+        """Add single package to deny list."""
+        with cls._lock:
+            if package_name not in cls._deny_lists:
+                cls._deny_lists[package_name] = set()
+            cls._deny_lists[package_name].add(denied_package)
+    
+    @classmethod
+    def is_package_allowed(cls, installer_package: str, target_package: str) -> Tuple[bool, str]:
+        """Check if target_package can be installed by installer_package."""
+        with cls._lock:
+            if installer_package in cls._deny_lists:
+                if target_package in cls._deny_lists[installer_package]:
+                    return False, f"Package '{target_package}' is in deny list"
+            
+            if installer_package in cls._allow_lists:
+                if target_package not in cls._allow_lists[installer_package]:
+                    return False, f"Package '{target_package}' not in allow list"
+            
+            return True, "OK"
+    
+    @classmethod
+    def set_index_url(cls, package_name: str, index_url: str) -> None:
+        """Set PyPI index URL for a package."""
+        cls._ensure_logging()
+        with cls._lock:
+            cls._index_urls[package_name] = index_url
+            _log("config", f"Set index URL for {package_name}: {index_url}")
+    
+    @classmethod
+    def set_extra_index_urls(cls, package_name: str, urls: List[str]) -> None:
+        """Set extra index URLs for a package."""
+        cls._ensure_logging()
+        with cls._lock:
+            cls._extra_index_urls[package_name] = urls
+            _log("config", f"Set {len(urls)} extra index URLs for {package_name}")
+    
+    @classmethod
+    def add_trusted_host(cls, package_name: str, host: str) -> None:
+        """Add trusted host for a package."""
+        with cls._lock:
+            if package_name not in cls._trusted_hosts:
+                cls._trusted_hosts[package_name] = []
+            cls._trusted_hosts[package_name].append(host)
+    
+    @classmethod
+    def get_pip_args(cls, package_name: str) -> List[str]:
+        """Get pip install arguments for a package based on policy."""
+        args = []
+        
+        with cls._lock:
+            if package_name in cls._index_urls:
+                args.extend(['--index-url', cls._index_urls[package_name]])
+            
+            if package_name in cls._extra_index_urls:
+                for url in cls._extra_index_urls[package_name]:
+                    args.extend(['--extra-index-url', url])
+            
+            if package_name in cls._trusted_hosts:
+                for host in cls._trusted_hosts[package_name]:
+                    args.extend(['--trusted-host', host])
+            
+            if cls._require_hashes.get(package_name, False):
+                args.append('--require-hashes')
+            
+            if not cls._verify_ssl.get(package_name, True):
+                args.append('--no-verify-ssl')
+        
+        return args
+    
+    @classmethod
+    def set_lockfile_path(cls, package_name: str, path: str) -> None:
+        """Set lockfile path for a package."""
+        with cls._lock:
+            cls._lockfile_paths[package_name] = path
+    
+    @classmethod
+    def get_lockfile_path(cls, package_name: str) -> Optional[str]:
+        """Get lockfile path for a package."""
+        with cls._lock:
+            return cls._lockfile_paths.get(package_name)
+
+
+__all__ = ['LazyInstallPolicy']
+