feat(release): Bump version to 1.0.5 after successful stress test and add combo handling logic

Author: 1minds3t

omnipkg/loader.py

@@ -1,8 +1,11 @@
+# Enhanced loader for better C extension handling
+
 import sys
 import json
 from pathlib import Path
 import site
 from importlib.metadata import version as get_version, PackageNotFoundError
+import importlib
 
 class omnipkgLoader:
     """
@@ -20,14 +23,38 @@ def __init__(self):
 
         # Track active bubbles for cleanup
         self.active_bubbles = set()
+        self.original_sys_path = sys.path.copy()
+
+    def _get_package_modules(self, pkg_name: str):
+        """Get all modules related to a package"""
+        pkg_name_normalized = pkg_name.replace('-', '_')
+        return [mod for mod in list(sys.modules.keys()) 
+                if mod.startswith(pkg_name_normalized) or 
+                   mod.replace('_', '-').startswith(pkg_name)]
+
+    def _aggressive_module_cleanup(self, pkg_name: str):
+        """Aggressively clean package modules from sys.modules"""
+        modules_to_clear = self._get_package_modules(pkg_name)
+        
+        for mod_name in modules_to_clear:
+            if mod_name in sys.modules:
+                del sys.modules[mod_name]
+        
+        # Force garbage collection
+        import gc
+        gc.collect()
+        
+        # Invalidate import caches
+        if hasattr(importlib, 'invalidate_caches'):
+            importlib.invalidate_caches()
 
     def _deactivate_package_bubbles(self, pkg_name: str):
         """Remove any active bubbles for the given package from sys.path"""
         if not self.multiversion_base:
             return
 
         bubbles_to_remove = []
-        for path_str in sys.path:
+        for path_str in sys.path[:]:  # Create a copy to iterate over
             path = Path(path_str)
             # Check if this path is a bubble for the given package
             if (path.parent == self.multiversion_base and 
@@ -39,6 +66,27 @@ def _deactivate_package_bubbles(self, pkg_name: str):
             self.active_bubbles.discard(bubble_path)
             print(f" 🧹 Deactivated bubble: {Path(bubble_path).name}")
 
+    def _prioritize_bubble_in_path(self, bubble_path_str: str):
+        """Ensure bubble is at the very front of sys.path"""
+        # Remove from current position if it exists
+        if bubble_path_str in sys.path:
+            sys.path.remove(bubble_path_str)
+        
+        # Insert at position 0 (highest priority)
+        sys.path.insert(0, bubble_path_str)
+        
+        # Also remove any site-packages paths that might contain the same package
+        # and move them after our bubble
+        site_packages_paths = []
+        for i, path in enumerate(sys.path[1:], 1):  # Skip our bubble at index 0
+            if 'site-packages' in path and Path(path).exists():
+                site_packages_paths.append((i, path))
+        
+        # Move site-packages to after our bubble (but keep their relative order)
+        for i, (original_index, path) in enumerate(reversed(site_packages_paths)):
+            sys.path.remove(path)
+            sys.path.insert(i + 1, path)  # Insert after bubble
+
     def activate_snapshot(self, package_spec: str) -> bool:
         """
         Activates a specific package version bubble, or confirms if the
@@ -56,12 +104,10 @@ def activate_snapshot(self, package_spec: str) -> bool:
         # First, deactivate any existing bubbles for this package
         self._deactivate_package_bubbles(pkg_name)
 
-        # Clear any cached imports for this package to ensure fresh import
-        modules_to_clear = [mod for mod in sys.modules.keys() if mod.startswith(pkg_name.replace('-', '_'))]
-        for mod in modules_to_clear:
-            del sys.modules[mod]
+        # Aggressively clear modules for this package (silent)
+        self._aggressive_module_cleanup(pkg_name)
 
-        # Check if the currently installed system version matches after bubble cleanup
+        # Check if we need a bubble (system version doesn't match)
         try:
             active_version = get_version(pkg_name)
             if active_version == requested_version:
@@ -71,7 +117,7 @@ def activate_snapshot(self, package_spec: str) -> bool:
             # The package isn't in the main environment, so we must use a bubble.
             pass
 
-        # If the system version doesn't match, proceed to find and activate a bubble.
+        # Find and activate the bubble
         if not self.multiversion_base or not self.multiversion_base.exists():
             print(f" ❌ Bubble directory not found at {self.multiversion_base}")
             return False
@@ -84,12 +130,14 @@ def activate_snapshot(self, package_spec: str) -> bool:
                 print(f" ❌ Bubble not found for {package_spec} at {bubble_path}")
                 return False
 
-            # Activate the bubble by putting it at the front of sys.path
             bubble_path_str = str(bubble_path)
-            sys.path.insert(0, bubble_path_str)
+            
+            # Prioritize this bubble in sys.path
+            self._prioritize_bubble_in_path(bubble_path_str)
             self.active_bubbles.add(bubble_path_str)
 
             print(f" ✅ Activated bubble: {bubble_path_str}")
+            print(f" 🔧 sys.path[0]: {sys.path[0]}")
 
             # Show bubble info if manifest exists
             manifest_path = bubble_path / '.omnipkg_manifest.json'
@@ -103,4 +151,11 @@ def activate_snapshot(self, package_spec: str) -> bool:
 
         except Exception as e:
             print(f" ❌ Error during bubble activation for {package_spec}: {e}")
-            return False
+            return False
+
+    def reset_environment(self):
+        """Reset sys.path to its original state"""
+        print(" 🔄 Resetting environment to original state...")
+        sys.path.clear()
+        sys.path.extend(self.original_sys_path)
+        self.active_bubbles.clear()

omnipkg/stress_test.py

@@ -2,8 +2,12 @@
 import importlib
 import shutil
 import time
+import gc
 from .loader import omnipkgLoader
 from .core import omnipkg as OmnipkgCore, ConfigManager
+from pathlib import Path
+import os
+import subprocess
 
 def print_header(title):
     """Prints a consistent, pretty header for the test stages."""
@@ -20,13 +24,11 @@ def setup():
     packages_to_test = ["numpy", "scipy"]
 
     for pkg in packages_to_test:
-        # Find all bubble directories for this package
         for bubble in omnipkg_core.multiversion_base.glob(f"{pkg}-*"):
             if bubble.is_dir():
                 print(f"   - Removing old bubble: {bubble.name}")
                 shutil.rmtree(bubble)
 
-    # Use omnipkg to ensure the 'good' versions are installed
     print("   - Setting main environment to a known good state...")
     omnipkg_core.smart_install(["numpy==1.26.4", "scipy==1.16.1"])
     print("✅ Environment is clean and ready for testing.")
@@ -39,47 +41,135 @@ def run_test():
     print("\n💥 NUMPY VERSION JUGGLING:")
     for numpy_ver in ["1.24.3", "1.26.4"]:
         print(f"\n⚡ Switching to numpy=={numpy_ver}")
+        
         if loader.activate_snapshot(f"numpy=={numpy_ver}"):
             import numpy as np
-            importlib.reload(np)
+            
             print(f"   ✅ Version: {np.__version__}")
             print(f"   🔢 Array sum: {np.array([1,2,3]).sum()}")
+            
+            if np.__version__ != numpy_ver:
+                print(f"   ⚠️ WARNING: Expected {numpy_ver}, got {np.__version__}!")
+            else:
+                print(f"   🎯 Version verification: PASSED")
         else:
             print(f"   ❌ Activation failed for numpy=={numpy_ver}!")
 
     # ===== SCIPY C-EXTENSION CHAOS =====
     print("\n\n🔥 SCIPY C-EXTENSION TEST:")
     for scipy_ver in ["1.12.0", "1.16.1"]:
         print(f"\n🌋 Switching to scipy=={scipy_ver}")
+        
         if loader.activate_snapshot(f"scipy=={scipy_ver}"):
+            import scipy as sp
             import scipy.sparse
             import scipy.linalg
-            importlib.reload(scipy)
-            print(f"   ✅ Version: {scipy.__version__}")
-            eye = scipy.sparse.eye(3)
-            print(f"   ♻️ Sparse matrix: {eye.nnz} non-zeros")
-            det = scipy.linalg.det([[0, 2], [1, 1]])
-            print(f"   📐 Linalg det: {det}")
+            
+            print(f"   ✅ Version: {sp.__version__}")
+            print(f"   ♻️ Sparse matrix: {sp.sparse.eye(3).nnz} non-zeros")
+            print(f"   📐 Linalg det: {sp.linalg.det([[0, 2], [1, 1]])}")
+            
+            if sp.__version__ != scipy_ver:
+                print(f"   ⚠️ WARNING: Expected {scipy_ver}, got {sp.__version__}!")
+            else:
+                print(f"   🎯 Version verification: PASSED")
         else:
             print(f"   ❌ Activation failed for scipy=={scipy_ver}!")
 
-    # ===== THE IMPOSSIBLE TEST =====
+    # ===== THE IMPOSSIBLE TEST (using clean process) =====
     print("\n\n🤯 NUMPY + SCIPY VERSION MIXING:")
     combos = [("1.24.3", "1.12.0"), ("1.26.4", "1.16.1")]
+    
+    temp_script_path = Path(os.getcwd()) / "omnipkg_combo_test.py"
+
     for np_ver, sp_ver in combos:
         print(f"\n🌀 COMBO: numpy=={np_ver} + scipy=={sp_ver}")
-        loader.activate_snapshot(f"numpy=={np_ver}")
-        loader.activate_snapshot(f"scipy=={sp_ver}")
 
-        import numpy as np
-        import scipy.sparse
-        importlib.reload(np)
-        importlib.reload(scipy)
+        # Get bubble paths
+        config_manager = ConfigManager()
+        omnipkg_core = OmnipkgCore(config_manager.config)
+        multiversion_base = omnipkg_core.multiversion_base
 
-        print(f"   🧪 numpy: {np.__version__}, scipy: {scipy.__version__}")
-        result = np.array([1,2,3]) @ scipy.sparse.eye(3)
-        print(f"   🔗 Compatibility check: {result}")
+        numpy_bubble = multiversion_base / f"numpy-{np_ver}"
+        scipy_bubble = multiversion_base / f"scipy-{sp_ver}"
 
+        # Build PYTHONPATH with bubbles at the front
+        bubble_paths = []
+        if numpy_bubble.exists():
+            bubble_paths.append(str(numpy_bubble))
+        if scipy_bubble.exists():
+            bubble_paths.append(str(scipy_bubble))
+            
+        # Write the subprocess script
+        temp_script_content = f"""
+import sys
+import os
+
+# Verify the bubbles are in our path
+print("🔍 Python path (first 5 entries):")
+for idx, path in enumerate(sys.path[:5]):
+    print(f"   {{idx}}: {{path}}")
+
+try:
+    import numpy as np
+    import scipy as sp
+    import scipy.sparse
+    
+    print(f"   🧪 numpy: {{np.__version__}}, scipy: {{sp.__version__}}")
+    print(f"   📍 numpy location: {{np.__file__}}")
+    print(f"   📍 scipy location: {{sp.__file__}}")
+    
+    result = np.array([1,2,3]) @ sp.sparse.eye(3).toarray()
+    print(f"   🔗 Compatibility check: {{result}}")
+    
+    if np.__version__ != "{np_ver}" or sp.__version__ != "{sp_ver}":
+        print(f"   ❌ Version mismatch! Expected numpy=={np_ver}, scipy=={sp_ver} but got numpy={{np.__version__}}, scipy={{sp.__version__}}", file=sys.stderr)
+        sys.exit(1)
+    else:
+        print(f"   🎯 Version verification: BOTH PASSED!")
+
+except Exception as e:
+    print(f"   ❌ Test failed in subprocess: {{e}}", file=sys.stderr)
+    import traceback
+    traceback.print_exc(file=sys.stderr)
+    sys.exit(1)
+"""
+        try:
+            with open(temp_script_path, "w") as f:
+                f.write(temp_script_content)
+
+            # Create clean environment with bubbles prioritized
+            clean_env = os.environ.copy()
+            
+            # Build PYTHONPATH with bubbles first, then existing paths
+            existing_pythonpath = clean_env.get('PYTHONPATH', '')
+            if existing_pythonpath:
+                new_pythonpath = ':'.join(bubble_paths + [existing_pythonpath])
+            else:
+                new_pythonpath = ':'.join(bubble_paths)
+            
+            clean_env['PYTHONPATH'] = new_pythonpath
+            
+            # Remove any conda/pip environment variables that might interfere
+            env_vars_to_remove = ['CONDA_DEFAULT_ENV', 'CONDA_PREFIX', 'PIP_TARGET']
+            for var in env_vars_to_remove:
+                clean_env.pop(var, None)
+            
+            print(f"   🔧 PYTHONPATH: {new_pythonpath}")
+            
+            subprocess.run(
+                [sys.executable, temp_script_path],
+                check=True,
+                cwd=os.getcwd(),
+                env=clean_env
+            )
+        except subprocess.CalledProcessError as e:
+            print(f"   ❌ Subprocess test failed for combo numpy=={np_ver} + scipy=={sp_ver}")
+            print(f"   💥 Exit code: {e.returncode}")
+        finally:
+            if temp_script_path.exists():
+                os.remove(temp_script_path)
+            
     print("\n\n 🚨 OMNIPKG SURVIVED NUCLEAR TESTING! 🎇")
 
 def cleanup():
@@ -103,7 +193,6 @@ def run():
     try:
         setup()
 
-        # --- Create the bubbles for the test ---
         print_header("STEP 2: Creating Test Bubbles with `omnipkg`")
         config_manager = ConfigManager()
         omnipkg_core = OmnipkgCore(config_manager.config)
@@ -115,9 +204,8 @@ def run():
             name, version = pkg.split('==')
             print(f"\n--- Creating bubble for {name}=={version} ---")
             omnipkg_core.bubble_manager.create_isolated_bubble(name, version)
-            time.sleep(1) # Give filesystem a moment to settle
+            time.sleep(1)
 
-        # --- Run the actual test ---
         print_header("STEP 3: Executing the Nuclear Test")
         run_test()
 
@@ -126,8 +214,7 @@ def run():
         import traceback
         traceback.print_exc()
     finally:
-        # --- ALWAYS run the cleanup ---
         cleanup()
 
 if __name__ == "__main__":
-    run()
+    run()

pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "omnipkg"
-version = "1.0.4"
+version = "1.0.5"
 authors = [
   { name = "1minds3t", email = "omnipkg@proton.me" },
 ]