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

exonware/xwlazy/package/services/config_manager.py

@@ -1,245 +0,0 @@
-"""
-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

@@ -1,370 +0,0 @@
-"""
-#exonware/xwlazy/src/exonware/xwlazy/discovery/discovery.py
-
-Package discovery implementation.
-
-Company: eXonware.com
-Author: Eng. Muhammad AlShehri
-Email: connect@exonware.com
-
-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']
-