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

exonware/xwlazy/package/services/config_manager.py

@@ -5,7 +5,7 @@ This module contains LazyInstallConfig which manages per-package lazy installati
 configuration. Extracted from lazy_core.py Section 5.
 """
 
-from typing import Dict, Optional
+from typing import Optional
 from ...common.services import LazyStateManager
 from ...defs import LazyLoadMode, LazyInstallMode, LazyModeConfig
 from ...defs import get_preset_mode
@@ -47,13 +47,13 @@ _MODE_ENUM_MAP = {
 
 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] = {}
+    _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(
@@ -171,15 +171,19 @@ class LazyInstallConfig:
                 
                 # 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()
+                if installer:
+                    # CRITICAL: Enable the installer (it's disabled by default)
+                    installer.enable()
                     
-                    # 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 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):

exonware/xwlazy/package/services/discovery.py

@@ -19,7 +19,7 @@ import subprocess
 import sys
 import threading
 from pathlib import Path
-from typing import Dict, List, Optional
+from typing import Optional
 
 from ..base import APackageHelper
 from ...defs import DependencyInfo
@@ -54,32 +54,59 @@ class LazyDiscovery(APackageHelper):
     }
     
     # Common import name to package name mappings
+    # Quick access list: Works without loading project configs
+    # Includes exonware-common packages for instant resolution
     COMMON_MAPPINGS = {
+        # Image processing
         'cv2': 'opencv-python',
         'PIL': 'Pillow',
         'Pillow': 'Pillow',
+        
+        # Data formats
         'yaml': 'PyYAML',
+        'bson': 'pymongo',
+        'msgpack': 'msgpack',  # Exonware common: MessagePack
+        'cbor2': 'cbor2',  # Exonware common: CBOR
+        'cbor': 'cbor2',
+        
+        # Machine learning / Data science
         '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',
+        'scipy': 'scipy',
+        'scikit-image': 'scikit-image',
+        
+        # Web frameworks
         'django': 'Django',
         'flask': 'Flask',
         'fastapi': 'fastapi',
         'uvicorn': 'uvicorn',
+        
+        # Database
+        'MySQLdb': 'mysqlclient',
+        'psycopg2': 'psycopg2-binary',
+        
+        # Serialization (Exonware common)
+        'lxml': 'lxml',
+        'xml': 'lxml',
+        'fastavro': 'fastavro',  # Exonware common: Avro
+        'avro': 'fastavro',
+        'protobuf': 'protobuf',  # Exonware common: Protocol Buffers
+        'pyarrow': 'pyarrow',  # Exonware common: Parquet/Feather
+        'parquet': 'pyarrow',
+        'feather': 'pyarrow',
+        
+        # Utilities
+        'dateutil': 'python-dateutil',
+        'requests_oauthlib': 'requests-oauthlib',
+        'google': 'google-api-python-client',
+        'jwt': 'PyJWT',
+        'crypto': 'pycrypto',
+        'Crypto': 'pycrypto',
         'pytest': 'pytest',
         'black': 'black',
         'isort': 'isort',
@@ -89,20 +116,58 @@ class LazyDiscovery(APackageHelper):
         'pytz': 'pytz',
         'aiofiles': 'aiofiles',
         'watchdog': 'watchdog',
+        
+        # Image utilities
         'wand': 'Wand',
         'exifread': 'ExifRead',
         'piexif': 'piexif',
         'rawpy': 'rawpy',
         'imageio': 'imageio',
-        'scipy': 'scipy',
-        'scikit-image': 'scikit-image',
+        
+        # OpenCV
         'opencv-python': 'opencv-python',
         'opencv-contrib-python': 'opencv-contrib-python',
+        
+        # Observability
         'opentelemetry': 'opentelemetry-api',
         'opentelemetry.trace': 'opentelemetry-api',
         'opentelemetry.sdk': 'opentelemetry-sdk',
     }
     
+    # ========================================================================
+    # Stub Implementations for APackageHelper (Installation methods not used by Discovery)
+    # ========================================================================
+    
+    def install_package(self, package_name: str, module_name: Optional[str] = None) -> bool:
+        return False
+
+    def _check_security_policy(self, package_name: str) -> tuple[bool, str]:
+        return (False, "Discovery only")
+
+    def _run_pip_install(self, package_name: str, args: list[str]) -> bool:
+        return False
+
+    def is_cache_valid(self, key: str) -> bool:
+        return False
+
+    def _check_importability(self, package_name: str) -> bool:
+        return False
+    
+    def _check_persistent_cache(self, package_name: str) -> bool:
+        return False
+    
+    def _mark_installed_in_persistent_cache(self, package_name: str) -> None:
+        pass
+    
+    def _mark_uninstalled_in_persistent_cache(self, package_name: str) -> None:
+        pass
+    
+    def _run_install(self, *package_names: str) -> None:
+        pass
+    
+    def _run_uninstall(self, *package_names: str) -> None:
+        pass
+
     def _discover_from_sources(self) -> None:
         """Discover dependencies from all sources."""
         self._discover_from_pyproject_toml()
@@ -316,12 +381,12 @@ class LazyDiscovery(APackageHelper):
         mapping = self.discover_all_dependencies()
         return mapping.get(import_name)
     
-    def get_imports_for_package(self, package_name: str) -> List[str]:
+    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]]:
+    def get_package_import_mapping(self) -> dict[str, list[str]]:
         """Get mapping of package names to their possible import names."""
         self.discover_all_dependencies()
         
@@ -338,7 +403,7 @@ class LazyDiscovery(APackageHelper):
         
         return package_to_imports
     
-    def get_import_package_mapping(self) -> Dict[str, str]:
+    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()}

exonware/xwlazy/package/services/host_packages.py

@@ -4,7 +4,8 @@ from __future__ import annotations
 
 import os
 import sys
-from typing import Iterable, Sequence, Tuple
+import functools
+from typing import Iterable, Sequence
 
 # Lazy imports to avoid circular dependency
 def _get_config_package_lazy_install_enabled():
@@ -40,13 +41,48 @@ class LazyMetaPathFinder:
         self.package_name = package_name
     
     def _enhance_classes_with_class_methods(self, module):
-        """Placeholder method."""
-        pass
+        """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, ...]]] = {}
+_REGISTERED: dict[str, dict[str, tuple[str, ...]]] = {}
 
-def _normalized(items: Iterable[str]) -> Tuple[str, ...]:
+def _normalized(items: Iterable[str]) -> tuple[str, ...]:
     seen = []
     for item in items:
         if item not in seen:
@@ -142,4 +178,3 @@ def _apply_wrappers_for_loaded_modules(
                 finder._enhance_classes_with_class_methods(module)  # type: ignore[attr-defined]
             except Exception:
                 continue
-

exonware/xwlazy/package/services/install_async.py

@@ -14,7 +14,7 @@ import os
 import asyncio
 import threading
 import importlib
-from typing import Optional, Dict, Any
+from typing import Optional, Any
 
 from .async_install_handle import AsyncInstallHandle
 from .manifest import PackageManifest
@@ -45,8 +45,17 @@ def _ensure_logging_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."""
@@ -84,7 +93,12 @@ class AsyncInstallMixin:
     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))
+        # 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)
         

exonware/xwlazy/package/services/install_cache.py

@@ -14,7 +14,7 @@ Uses shared utilities from common/services/install_cache_utils.
 import os
 import time
 from pathlib import Path
-from typing import Optional, List
+from typing import Optional
 from collections import OrderedDict
 
 # Import shared utilities
@@ -93,7 +93,7 @@ class InstallCacheMixin:
         """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:
+    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,
@@ -101,11 +101,11 @@ class InstallCacheMixin:
             self._async_cache_dir  # type: ignore[attr-defined]
         )
     
-    def _pip_install_from_path(self, wheel_path: Path, policy_args: Optional[List[str]] = None) -> bool:
+    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]:
+    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,

exonware/xwlazy/package/services/install_policy.py

@@ -11,7 +11,7 @@ Security and policy configuration for lazy installation.
 """
 
 import threading
-from typing import Dict, List, Optional, Set, Tuple
+from typing import Optional
 
 # Lazy import to avoid circular dependency
 def _get_log_event():
@@ -28,14 +28,14 @@ class LazyInstallPolicy:
     """
     __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] = {}
+    _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
@@ -46,7 +46,7 @@ class LazyInstallPolicy:
             _log = _get_log_event()
     
     @classmethod
-    def set_allow_list(cls, package_name: str, allowed_packages: List[str]) -> None:
+    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:
@@ -54,7 +54,7 @@ class LazyInstallPolicy:
             _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:
+    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:
@@ -78,7 +78,7 @@ class LazyInstallPolicy:
             cls._deny_lists[package_name].add(denied_package)
     
     @classmethod
-    def is_package_allowed(cls, installer_package: str, target_package: str) -> Tuple[bool, str]:
+    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:
@@ -100,7 +100,7 @@ class LazyInstallPolicy:
             _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:
+    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:
@@ -116,7 +116,7 @@ class LazyInstallPolicy:
             cls._trusted_hosts[package_name].append(host)
     
     @classmethod
-    def get_pip_args(cls, package_name: str) -> List[str]:
+    def get_pip_args(cls, package_name: str) -> list[str]:
         """Get pip install arguments for a package based on policy."""
         args = []
         

exonware/xwlazy/package/services/install_registry.py

@@ -11,14 +11,14 @@ Registry to manage separate lazy installer instances per package.
 """
 
 import threading
-from typing import Dict, TYPE_CHECKING
+from typing import TYPE_CHECKING
 
 if TYPE_CHECKING:
     from .lazy_installer import LazyInstaller
 
 class LazyInstallerRegistry:
     """Registry to manage separate lazy installer instances per package."""
-    _instances: Dict[str, 'LazyInstaller'] = {}
+    _instances: dict[str, 'LazyInstaller'] = {}
     _lock = threading.RLock()
     
     @classmethod
@@ -40,7 +40,7 @@ class LazyInstallerRegistry:
             return cls._instances[package_name]
     
     @classmethod
-    def get_all_instances(cls) -> Dict[str, 'LazyInstaller']:
+    def get_all_instances(cls) -> dict[str, 'LazyInstaller']:
         """
         Get all lazy installer instances.
         

exonware/xwlazy/package/services/install_sbom.py

@@ -15,7 +15,7 @@ import sys
 import subprocess
 from datetime import datetime
 from pathlib import Path
-from typing import Dict
+from typing import
 
 from .install_policy import LazyInstallPolicy
 

exonware/xwlazy/package/services/installer_engine.py

@@ -15,7 +15,7 @@ import sys
 import asyncio
 import threading
 import importlib.metadata
-from typing import Dict, List, Optional, Set, Callable
+from typing import Optional, Callable
 
 from .install_result import InstallResult, InstallStatus
 from .install_policy import LazyInstallPolicy
@@ -55,7 +55,7 @@ class InstallerEngine:
         self._loop: Optional[asyncio.AbstractEventLoop] = None
         self._loop_thread: Optional[threading.Thread] = None
         self._lock = threading.RLock()
-        self._active_installs: Set[str] = set()  # Track active installs to prevent duplicates
+        self._active_installs: set[str] = set()  # Track active installs to prevent duplicates
         
         # Get install mode from config
         self._mode = LazyInstallConfig.get_install_mode(package_name) or LazyInstallMode.SMART
@@ -275,7 +275,7 @@ class InstallerEngine:
         self,
         *package_names: str,
         callback: Optional[Callable[[str, InstallResult], None]] = None
-    ) -> Dict[str, InstallResult]:
+    ) -> dict[str, InstallResult]:
         """
         Install multiple packages in parallel (async), but wait for all to complete.