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

exonware/xwlazy/package/services/config_manager.py

@@ -0,0 +1,246 @@
+"""
+Configuration management for lazy loading system.
+
+This module contains LazyInstallConfig which manages per-package lazy installation
+configuration. Extracted from lazy_core.py Section 5.
+"""
+
+from typing import Dict, Optional
+from ...common.services import LazyStateManager
+from ...defs import LazyLoadMode, LazyInstallMode, LazyModeConfig
+from ...defs import get_preset_mode
+
+# Lazy import to avoid circular dependency
+def _get_logger():
+    """Get logger (lazy import to avoid circular dependency)."""
+    from ...common.logger import get_logger
+    return get_logger("xwlazy.config")
+
+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  # Will be initialized on first use
+_log = None  # Will be initialized on first use
+
+# Mode enum mapping - extracted from lazy_core.py
+_MODE_ENUM_MAP = {
+    # Core v1.0 modes
+    "none": LazyInstallMode.NONE,
+    "smart": LazyInstallMode.SMART,
+    "full": LazyInstallMode.FULL,
+    "clean": LazyInstallMode.CLEAN,
+    "temporary": LazyInstallMode.TEMPORARY,
+    "size_aware": LazyInstallMode.SIZE_AWARE,
+    # Special purpose modes
+    "interactive": LazyInstallMode.INTERACTIVE,
+    "warn": LazyInstallMode.WARN,
+    "disabled": LazyInstallMode.DISABLED,
+    "dry_run": LazyInstallMode.DRY_RUN,
+    # Legacy aliases
+    "auto": LazyInstallMode.SMART,
+    "on_demand": LazyInstallMode.SMART,
+    "on-demand": LazyInstallMode.SMART,
+    "lazy": LazyInstallMode.SMART,
+}
+
+
+class LazyInstallConfig:
+    """Global configuration for lazy installation per package."""
+    _configs: Dict[str, bool] = {}
+    _modes: Dict[str, str] = {}
+    _load_modes: Dict[str, LazyLoadMode] = {}
+    _install_modes: Dict[str, LazyInstallMode] = {}
+    _mode_configs: Dict[str, LazyModeConfig] = {}
+    _initialized: Dict[str, bool] = {}
+    _manual_overrides: Dict[str, bool] = {}
+    
+    @classmethod
+    def set(
+        cls,
+        package_name: str,
+        enabled: bool,
+        mode: str = "auto",
+        install_hook: bool = True,
+        manual: bool = False,
+        load_mode: Optional[LazyLoadMode] = None,
+        install_mode: Optional[LazyInstallMode] = None,
+        mode_config: Optional[LazyModeConfig] = None,
+    ) -> None:
+        """Enable or disable lazy installation for a specific package."""
+        package_key = package_name.lower()
+        state_manager = LazyStateManager(package_name)
+        
+        if manual:
+            cls._manual_overrides[package_key] = True
+            state_manager.set_manual_state(enabled)
+        elif cls._manual_overrides.get(package_key):
+            global logger
+            if logger is None:
+                logger = _get_logger()
+            logger.debug(
+                f"Lazy install config for {package_key} already overridden manually; skipping auto configuration."
+            )
+            return
+        else:
+            state_manager.set_manual_state(None)
+        
+        cls._configs[package_key] = enabled
+        cls._modes[package_key] = mode
+        
+        # Handle two-dimensional mode configuration
+        if mode_config:
+            cls._mode_configs[package_key] = mode_config
+            cls._load_modes[package_key] = mode_config.load_mode
+            cls._install_modes[package_key] = mode_config.install_mode
+        elif load_mode is not None or install_mode is not None:
+            # Explicit mode specification
+            if load_mode is None:
+                load_mode = LazyLoadMode.AUTO  # Default
+            if install_mode is None:
+                install_mode = _MODE_ENUM_MAP.get(mode.lower(), LazyInstallMode.SMART)
+            cls._load_modes[package_key] = load_mode
+            cls._install_modes[package_key] = install_mode
+            cls._mode_configs[package_key] = LazyModeConfig(
+                load_mode=load_mode,
+                install_mode=install_mode
+            )
+        else:
+            # Legacy mode string - try to resolve to preset or default
+            preset = get_preset_mode(mode)
+            if preset:
+                cls._mode_configs[package_key] = preset
+                cls._load_modes[package_key] = preset.load_mode
+                cls._install_modes[package_key] = preset.install_mode
+            else:
+                # Fallback to legacy behavior
+                install_mode_enum = _MODE_ENUM_MAP.get(mode.lower(), LazyInstallMode.SMART)
+                cls._load_modes[package_key] = LazyLoadMode.AUTO
+                cls._install_modes[package_key] = install_mode_enum
+                cls._mode_configs[package_key] = LazyModeConfig(
+                    load_mode=LazyLoadMode.AUTO,
+                    install_mode=install_mode_enum
+                )
+        
+        cls._initialize_package(package_key, enabled, mode, install_hook=install_hook)
+    
+    @classmethod
+    def _initialize_package(cls, package_key: str, enabled: bool, mode: str, install_hook: bool = True) -> None:
+        """Initialize lazy installation for a specific package."""
+        global logger, _log
+        if logger is None:
+            logger = _get_logger()
+        if _log is None:
+            _log = _get_log_event()
+        
+        # Deferred imports to avoid circular dependency
+        from .install_registry import LazyInstallerRegistry
+        from ...facade import (
+            enable_lazy_install,
+            disable_lazy_install,
+            set_lazy_install_mode,
+            enable_lazy_imports,
+            install_import_hook,
+            uninstall_import_hook,
+            is_import_hook_installed,
+            sync_manifest_configuration,
+        )
+        import asyncio
+        
+        if enabled:
+            try:
+                # Don't call enable_lazy_install() here - it would create infinite recursion
+                # The config is already set by LazyInstallConfig.set() above
+                
+                # Use explicitly set install_mode from config, or derive from mode string
+                # Check if install_mode was explicitly set by checking if package_key exists in _install_modes
+                if package_key in cls._install_modes:
+                    # install_mode was explicitly set in set() method, don't override it
+                    mode_enum = cls._install_modes[package_key]
+                else:
+                    # Not explicitly set, derive from mode string
+                    mode_enum = _MODE_ENUM_MAP.get(mode.lower(), LazyInstallMode.SMART)
+                    set_lazy_install_mode(package_key, mode_enum)
+                
+                # Get load mode from config
+                load_mode = cls.get_load_mode(package_key)
+                
+                # Enable lazy imports with appropriate load mode (skip if NONE mode)
+                if load_mode != LazyLoadMode.NONE:
+                    enable_lazy_imports(load_mode, package_name=package_key)
+                
+                # Enable async for modes that support it
+                installer = LazyInstallerRegistry.get_instance(package_key)
+                if installer and mode_enum in (LazyInstallMode.SMART, LazyInstallMode.FULL, LazyInstallMode.CLEAN, LazyInstallMode.TEMPORARY):
+                    installer._async_enabled = True
+                    installer._ensure_async_loop()
+                    
+                    # For FULL mode, install all dependencies on start
+                    if mode_enum == LazyInstallMode.FULL:
+                        loop = installer._async_loop
+                        if loop:
+                            asyncio.run_coroutine_threadsafe(installer.install_all_dependencies(), loop)
+                
+                if install_hook:
+                    if not is_import_hook_installed(package_key):
+                        install_import_hook(package_key)
+                    _log("config", logger.info, f"✅ Lazy installation initialized for {package_key} (install_mode: {mode}, load_mode: {load_mode.value}, hook: installed)")
+                else:
+                    uninstall_import_hook(package_key)
+                    _log("config", logger.info, f"✅ Lazy installation initialized for {package_key} (install_mode: {mode}, load_mode: {load_mode.value}, hook: disabled)")
+                
+                cls._initialized[package_key] = True
+                sync_manifest_configuration(package_key)
+            except ImportError as e:
+                if logger is None:
+                    logger = _get_logger()
+                logger.warning(f"⚠️ Could not enable lazy install for {package_key}: {e}")
+        else:
+            try:
+                disable_lazy_install(package_key)
+            except ImportError:
+                pass
+            uninstall_import_hook(package_key)
+            cls._initialized[package_key] = False
+            _log("config", logger.info, f"❌ Lazy installation disabled for {package_key}")
+            sync_manifest_configuration(package_key)
+    
+    @classmethod
+    def is_enabled(cls, package_name: str) -> bool:
+        """Check if lazy installation is enabled for a package."""
+        return cls._configs.get(package_name.lower(), False)
+    
+    @classmethod
+    def get_mode(cls, package_name: str) -> str:
+        """Get the lazy installation mode for a package."""
+        return cls._modes.get(package_name.lower(), "auto")
+    
+    @classmethod
+    def get_mode_config(cls, package_name: str) -> Optional[LazyModeConfig]:
+        """Get the full mode configuration for a package."""
+        return cls._mode_configs.get(package_name.lower())
+    
+    @classmethod
+    def get_load_mode(cls, package_name: str) -> LazyLoadMode:
+        """Get the load mode for a package."""
+        return cls._load_modes.get(package_name.lower(), LazyLoadMode.NONE)
+    
+    @classmethod
+    def get_install_mode(cls, package_name: str) -> LazyInstallMode:
+        """Get the install mode for a package."""
+        return cls._install_modes.get(package_name.lower(), LazyInstallMode.NONE)
+    
+    @classmethod
+    def set_install_mode(cls, package_name: str, mode: LazyInstallMode) -> None:
+        """Set the install mode for a package."""
+        package_key = package_name.lower()
+        cls._install_modes[package_key] = mode
+        # Update mode config if it exists
+        if package_key in cls._mode_configs:
+            mode_config = cls._mode_configs[package_key]
+            cls._mode_configs[package_key] = LazyModeConfig(
+                load_mode=mode_config.load_mode,
+                install_mode=mode
+            )
+

exonware/xwlazy/package/services/discovery.py

@@ -0,0 +1,374 @@
+"""
+#exonware/xwlazy/src/exonware/xwlazy/discovery/discovery.py
+
+Package discovery implementation.
+
+Company: eXonware.com
+Author: Eng. Muhammad AlShehri
+Email: connect@exonware.com
+Version: 0.1.0.19
+Generation Date: 10-Oct-2025
+
+This module provides LazyDiscovery class that discovers dependencies from
+project configuration sources with caching support.
+"""
+
+import json
+import re
+import subprocess
+import sys
+import threading
+from pathlib import Path
+from typing import Dict, List, Optional
+
+from ..base import APackageHelper
+from ...defs import DependencyInfo
+from ...common.logger import get_logger, log_event as _log
+
+logger = get_logger("xwlazy.discovery")
+
+
+class LazyDiscovery(APackageHelper):
+    """
+    Discovers dependencies from project configuration sources.
+    Implements caching with file modification time checks.
+    """
+    
+    # System/built-in modules that should NEVER be auto-installed
+    SYSTEM_MODULES_BLACKLIST = {
+        'pwd', 'grp', 'spwd', 'crypt', 'nis', 'syslog', 'termios', 'tty', 'pty',
+        'fcntl', 'resource', 'msvcrt', 'winreg', 'winsound', '_winapi',
+        'rpython', 'rply', 'rnc2rng', '_dbm',
+        'sys', 'os', 'io', 'time', 'datetime', 'json', 'csv', 'math',
+        'random', 're', 'collections', 'itertools', 'functools', 'operator',
+        'pathlib', 'shutil', 'glob', 'tempfile', 'pickle', 'copy', 'types',
+        'typing', 'abc', 'enum', 'dataclasses', 'contextlib', 'warnings',
+        'logging', 'threading', 'multiprocessing', 'subprocess', 'queue',
+        'socket', 'select', 'signal', 'asyncio', 'concurrent', 'email',
+        'http', 'urllib', 'xml', 'html', 'sqlite3', 'base64', 'hashlib',
+        'hmac', 'secrets', 'ssl', 'binascii', 'struct', 'array', 'weakref',
+        'gc', 'inspect', 'traceback', 'atexit', 'codecs', 'locale', 'gettext',
+        'argparse', 'optparse', 'configparser', 'fileinput', 'stat', 'platform',
+        'unittest', 'doctest', 'pdb', 'profile', 'cProfile', 'timeit', 'trace',
+        # Internal / optional modules that must never trigger auto-install
+        'compression', 'socks', 'wimlib',
+    }
+    
+    # Common import name to package name mappings
+    COMMON_MAPPINGS = {
+        'cv2': 'opencv-python',
+        'PIL': 'Pillow',
+        'Pillow': 'Pillow',
+        'yaml': 'PyYAML',
+        'sklearn': 'scikit-learn',
+        'bs4': 'beautifulsoup4',
+        'dateutil': 'python-dateutil',
+        'requests_oauthlib': 'requests-oauthlib',
+        'google': 'google-api-python-client',
+        'jwt': 'PyJWT',
+        'crypto': 'pycrypto',
+        'Crypto': 'pycrypto',
+        'MySQLdb': 'mysqlclient',
+        'psycopg2': 'psycopg2-binary',
+        'bson': 'pymongo',
+        'lxml': 'lxml',
+        'numpy': 'numpy',
+        'pandas': 'pandas',
+        'matplotlib': 'matplotlib',
+        'seaborn': 'seaborn',
+        'plotly': 'plotly',
+        'django': 'Django',
+        'flask': 'Flask',
+        'fastapi': 'fastapi',
+        'uvicorn': 'uvicorn',
+        'pytest': 'pytest',
+        'black': 'black',
+        'isort': 'isort',
+        'mypy': 'mypy',
+        'psutil': 'psutil',
+        'colorama': 'colorama',
+        'pytz': 'pytz',
+        'aiofiles': 'aiofiles',
+        'watchdog': 'watchdog',
+        'wand': 'Wand',
+        'exifread': 'ExifRead',
+        'piexif': 'piexif',
+        'rawpy': 'rawpy',
+        'imageio': 'imageio',
+        'scipy': 'scipy',
+        'scikit-image': 'scikit-image',
+        'opencv-python': 'opencv-python',
+        'opencv-contrib-python': 'opencv-contrib-python',
+        'opentelemetry': 'opentelemetry-api',
+        'opentelemetry.trace': 'opentelemetry-api',
+        'opentelemetry.sdk': 'opentelemetry-sdk',
+    }
+    
+    def _discover_from_sources(self) -> None:
+        """Discover dependencies from all sources."""
+        self._discover_from_pyproject_toml()
+        self._discover_from_requirements_txt()
+        self._discover_from_setup_py()
+        self._discover_from_custom_config()
+        self._add_common_mappings()  # Add well-known mappings (bson->pymongo, cv2->opencv-python, etc.)
+    
+    def _is_cache_valid(self) -> bool:
+        """Check if cached dependencies are still valid."""
+        if not self._cache_valid or not self._cached_dependencies:
+            return False
+        
+        config_files = [
+            self.project_root / 'pyproject.toml',
+            self.project_root / 'requirements.txt',
+            self.project_root / 'setup.py',
+        ]
+        
+        for config_file in config_files:
+            if config_file.exists():
+                try:
+                    current_mtime = config_file.stat().st_mtime
+                    cached_mtime = self._file_mtimes.get(str(config_file), 0)
+                    if current_mtime > cached_mtime:
+                        return False
+                except Exception:
+                    return False
+        
+        return True
+    
+    def _update_file_mtimes(self) -> None:
+        """Update file modification times for cache validation."""
+        config_files = [
+            self.project_root / 'pyproject.toml',
+            self.project_root / 'requirements.txt',
+            self.project_root / 'setup.py',
+        ]
+        for config_file in config_files:
+            if config_file.exists():
+                try:
+                    self._file_mtimes[str(config_file)] = config_file.stat().st_mtime
+                except Exception:
+                    pass
+    
+    def _discover_from_pyproject_toml(self) -> None:
+        """Discover dependencies from pyproject.toml."""
+        pyproject_path = self.project_root / 'pyproject.toml'
+        if not pyproject_path.exists():
+            return
+        
+        try:
+            try:
+                import tomllib  # Python 3.11+
+                toml_parser = tomllib  # type: ignore[assignment]
+            except ImportError:
+                try:
+                    import tomli as tomllib  # type: ignore[assignment]
+                    toml_parser = tomllib
+                except ImportError:
+                    _log(
+                        "discovery",
+                        "TOML parser not available; attempting to lazy-install 'tomli'...",
+                    )
+                    try:
+                        subprocess.run(
+                            [sys.executable, "-m", "pip", "install", "tomli"],
+                            check=False,
+                            capture_output=True,
+                        )
+                        import tomli as tomllib  # type: ignore[assignment]
+                        toml_parser = tomllib
+                    except Exception as install_exc:
+                        logger.warning(
+                            "tomli installation failed; skipping pyproject.toml discovery "
+                            f"({install_exc})"
+                        )
+                        return
+
+            with open(pyproject_path, 'rb') as f:
+                data = toml_parser.load(f)
+            
+            dependencies = []
+            if 'project' in data and 'dependencies' in data['project']:
+                dependencies.extend(data['project']['dependencies'])
+            
+            if 'project' in data and 'optional-dependencies' in data['project']:
+                for group_name, group_deps in data['project']['optional-dependencies'].items():
+                    dependencies.extend(group_deps)
+            
+            if 'build-system' in data and 'requires' in data['build-system']:
+                dependencies.extend(data['build-system']['requires'])
+            
+            for dep in dependencies:
+                self._parse_dependency_string(dep, 'pyproject.toml')
+            
+            self._discovery_sources.append('pyproject.toml')
+        except Exception as e:
+            logger.warning(f"Could not parse pyproject.toml: {e}")
+    
+    def _discover_from_requirements_txt(self) -> None:
+        """Discover dependencies from requirements.txt."""
+        requirements_path = self.project_root / 'requirements.txt'
+        if not requirements_path.exists():
+            return
+        
+        try:
+            with open(requirements_path, 'r', encoding='utf-8') as f:
+                for line in f:
+                    line = line.strip()
+                    if line and not line.startswith('#'):
+                        self._parse_dependency_string(line, 'requirements.txt')
+            
+            self._discovery_sources.append('requirements.txt')
+        except Exception as e:
+            logger.warning(f"Could not parse requirements.txt: {e}")
+    
+    def _discover_from_setup_py(self) -> None:
+        """Discover dependencies from setup.py."""
+        setup_path = self.project_root / 'setup.py'
+        if not setup_path.exists():
+            return
+        
+        try:
+            with open(setup_path, 'r', encoding='utf-8') as f:
+                content = f.read()
+            
+            install_requires_match = re.search(
+                r'install_requires\s*=\s*\[(.*?)\]', 
+                content, 
+                re.DOTALL
+            )
+            if install_requires_match:
+                deps_str = install_requires_match.group(1)
+                deps = re.findall(r'["\']([^"\']+)["\']', deps_str)
+                for dep in deps:
+                    self._parse_dependency_string(dep, 'setup.py')
+            
+            self._discovery_sources.append('setup.py')
+        except Exception as e:
+            logger.warning(f"Could not parse setup.py: {e}")
+    
+    def _discover_from_custom_config(self) -> None:
+        """Discover dependencies from custom configuration files."""
+        config_files = [
+            'dependency-mappings.json',
+            'lazy-dependencies.json',
+            'dependencies.json'
+        ]
+        
+        for config_file in config_files:
+            config_path = self.project_root / config_file
+            if config_path.exists():
+                try:
+                    with open(config_path, 'r', encoding='utf-8') as f:
+                        data = json.load(f)
+                    
+                    if isinstance(data, dict):
+                        for import_name, package_name in data.items():
+                            self.discovered_dependencies[import_name] = DependencyInfo(
+                                import_name=import_name,
+                                package_name=package_name,
+                                source=config_file,
+                                category='custom'
+                            )
+                    
+                    self._discovery_sources.append(config_file)
+                except Exception as e:
+                    logger.warning(f"Could not parse {config_file}: {e}")
+    
+    def _parse_dependency_string(self, dep_str: str, source: str) -> None:
+        """Parse a dependency string and extract dependency information."""
+        dep_str = re.sub(r'[>=<!=~]+.*', '', dep_str)
+        dep_str = re.sub(r'\[.*\]', '', dep_str)
+        dep_str = dep_str.strip()
+        
+        if not dep_str:
+            return
+        
+        import_name = dep_str
+        package_name = dep_str
+        
+        if dep_str in self.COMMON_MAPPINGS:
+            package_name = self.COMMON_MAPPINGS[dep_str]
+        elif dep_str in self.COMMON_MAPPINGS.values():
+            for imp_name, pkg_name in self.COMMON_MAPPINGS.items():
+                if pkg_name == dep_str:
+                    import_name = imp_name
+                    break
+        
+        self.discovered_dependencies[import_name] = DependencyInfo(
+            import_name=import_name,
+            package_name=package_name,
+            source=source,
+            category='discovered'
+        )
+    
+    def _add_common_mappings(self) -> None:
+        """Add common mappings that might not be in dependency files."""
+        for import_name, package_name in self.COMMON_MAPPINGS.items():
+            if import_name not in self.discovered_dependencies:
+                self.discovered_dependencies[import_name] = DependencyInfo(
+                    import_name=import_name,
+                    package_name=package_name,
+                    source='common_mappings',
+                    category='common'
+                )
+    
+    def get_package_for_import(self, import_name: str) -> Optional[str]:
+        """Get package name for a given import name."""
+        mapping = self.discover_all_dependencies()
+        return mapping.get(import_name)
+    
+    def get_imports_for_package(self, package_name: str) -> List[str]:
+        """Get all possible import names for a package."""
+        mapping = self.get_package_import_mapping()
+        return mapping.get(package_name, [package_name])
+    
+    def get_package_import_mapping(self) -> Dict[str, List[str]]:
+        """Get mapping of package names to their possible import names."""
+        self.discover_all_dependencies()
+        
+        package_to_imports = {}
+        for import_name, dep_info in self.discovered_dependencies.items():
+            package_name = dep_info.package_name
+            
+            if package_name not in package_to_imports:
+                package_to_imports[package_name] = [package_name]
+            
+            if import_name != package_name:
+                if import_name not in package_to_imports[package_name]:
+                    package_to_imports[package_name].append(import_name)
+        
+        return package_to_imports
+    
+    def get_import_package_mapping(self) -> Dict[str, str]:
+        """Get mapping of import names to package names."""
+        self.discover_all_dependencies()
+        return {import_name: dep_info.package_name for import_name, dep_info in self.discovered_dependencies.items()}
+    
+    def export_to_json(self, file_path: str) -> None:
+        """Export discovered dependencies to JSON file."""
+        data = {
+            'dependencies': {name: info.package_name for name, info in self.discovered_dependencies.items()},
+            'sources': self.get_discovery_sources(),
+            'total_count': len(self.discovered_dependencies)
+        }
+        
+        with open(file_path, 'w', encoding='utf-8') as f:
+            json.dump(data, f, indent=2, ensure_ascii=False)
+
+
+# Global discovery instance
+_discovery: Optional[LazyDiscovery] = None
+_discovery_lock = threading.RLock()
+
+
+def get_lazy_discovery(project_root: Optional[str] = None) -> LazyDiscovery:
+    """Get or create global discovery instance."""
+    global _discovery
+    with _discovery_lock:
+        if _discovery is None:
+            _discovery = LazyDiscovery(project_root)
+        return _discovery
+
+
+__all__ = ['LazyDiscovery', 'get_lazy_discovery']
+