pum 1.3.1__tar.gz → 1.3.2__tar.gz

{pum-1.3.1 → pum-1.3.2}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: pum
-Version: 1.3.1
+Version: 1.3.2
 Summary: Pum stands for "Postgres Upgrades Manager". It is a Database migration management tool very similar to flyway-db or Liquibase, based on metadata tables.
 Author-email: Denis Rouzaud <denis@opengis.ch>
 License-Expression: GPL-2.0-or-later

{pum-1.3.1 → pum-1.3.2}/pum/hook.py

@@ -93,7 +93,6 @@ class HookHandler:
         self.code = code
         self.hook_instance = None
         self.sys_path_additions = []  # Store paths to add during execution
-        self._imported_modules = []  # Track modules imported by this hook
 
         if file:
             if isinstance(file, str):
@@ -122,22 +121,25 @@ class HookHandler:
                 if base_path_str not in sys.path and base_path_str != parent_dir:
                     self.sys_path_additions.append(base_path_str)
 
-            # Temporarily add paths for module loading
-            for path in self.sys_path_additions:
+            # Temporarily add paths for module loading - insert at position 0 for priority
+            for path in reversed(self.sys_path_additions):
                 sys.path.insert(0, path)
 
-            # Track modules before loading to detect new imports
-            modules_before = set(sys.modules.keys())
-
             try:
-                spec = importlib.util.spec_from_file_location(self.file.stem, self.file)
+                logger.debug(f"Loading hook from: {self.file}")
+                logger.debug(f"sys.path additions: {self.sys_path_additions}")
+                spec = importlib.util.spec_from_file_location(
+                    self.file.stem,
+                    self.file,
+                    submodule_search_locations=[parent_dir],
+                )
                 module = importlib.util.module_from_spec(spec)
+                # Set __path__ to enable package-like imports from the hook's directory
+                module.__path__ = [parent_dir]
+                # Add to sys.modules before executing so imports can find it
+                sys.modules[self.file.stem] = module
                 spec.loader.exec_module(module)
 
-                # Track modules that were imported by this hook
-                modules_after = set(sys.modules.keys())
-                self._imported_modules = list(modules_after - modules_before)
-
                 # Check that the module contains a class named Hook inheriting from HookBase
                 # Do this BEFORE removing paths from sys.path
                 hook_class = getattr(module, "Hook", None)
@@ -182,16 +184,6 @@ class HookHandler:
                     if path in sys.path:
                         sys.path.remove(path)
 
-    def cleanup_imports(self):
-        """Remove imported modules from sys.modules cache.
-        This should be called when switching to a different module version
-        to prevent import conflicts.
-        """
-        for module_name in self._imported_modules:
-            if module_name in sys.modules:
-                del sys.modules[module_name]
-        self._imported_modules.clear()
-
     def __repr__(self) -> str:
         """Return a string representation of the Hook instance."""
         return f"<hook: {self.file}>"

{pum-1.3.1 → pum-1.3.2}/pum/pum_config.py

@@ -189,10 +189,22 @@ class PumConfig:
         This should be called when switching to a different module version to ensure
         that cached imports from the previous version don't cause conflicts.
         """
-        for handler in self._cached_handlers:
-            if hasattr(handler, "cleanup_imports"):
-                handler.cleanup_imports()
-        # Clear the cache after cleanup
+        # Clear all modules that were loaded from this base_path
+        base_path_str = str(self._base_path.resolve())
+        modules_to_remove = []
+
+        for module_name, module in list(sys.modules.items()):
+            if module is None:
+                continue
+            module_file = getattr(module, "__file__", None)
+            if module_file and module_file.startswith(base_path_str):
+                modules_to_remove.append(module_name)
+
+        for module_name in modules_to_remove:
+            if module_name in sys.modules:
+                logger.debug(f"Removing cached module: {module_name}")
+                del sys.modules[module_name]
+
         self._cached_handlers.clear()
 
     def parameters(self) -> list[ParameterDefinition]:

{pum-1.3.1 → pum-1.3.2}/pum.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: pum
-Version: 1.3.1
+Version: 1.3.2
 Summary: Pum stands for "Postgres Upgrades Manager". It is a Database migration management tool very similar to flyway-db or Liquibase, based on metadata tables.
 Author-email: Denis Rouzaud <denis@opengis.ch>
 License-Expression: GPL-2.0-or-later

{pum-1.3.1 → pum-1.3.2}/test/test_hooks.py

@@ -1,5 +1,6 @@
 """Test module for hook functionality."""
 
+import sys
 import unittest
 from pathlib import Path
 from unittest.mock import Mock
@@ -7,6 +8,24 @@ from unittest.mock import Mock
 from pum.hook import HookHandler
 
 
+def cleanup_modules_by_path(base_path: Path) -> None:
+    """Clean up all modules imported from a base path.
+
+    This is a test helper that mimics the cleanup logic from PumConfig.cleanup_hook_imports().
+    """
+    base_path_str = str(base_path.resolve())
+    modules_to_remove = []
+    for module_name, module in list(sys.modules.items()):
+        if module is None:
+            continue
+        module_file = getattr(module, "__file__", None)
+        if module_file and module_file.startswith(base_path_str):
+            modules_to_remove.append(module_name)
+    for module_name in modules_to_remove:
+        if module_name in sys.modules:
+            del sys.modules[module_name]
+
+
 class TestHooks(unittest.TestCase):
     """Test the hook functionality."""
 
@@ -96,12 +115,10 @@ class TestHooks(unittest.TestCase):
     def test_hook_cleanup_imports(self) -> None:
         """Test that hook imports can be cleaned up to prevent conflicts when switching versions.
 
-        This test verifies that when hooks are cleaned up, their imported modules
-        are removed from sys.modules cache, allowing fresh imports when switching
-        to a different module version.
+        This test verifies that when hooks are cleaned up via path-based cleanup,
+        their imported modules are removed from sys.modules cache, allowing fresh imports
+        when switching to a different module version.
         """
-        import sys
-
         test_dir = Path("test") / "data" / "hook_sibling_imports"
         hook_file = test_dir / "app" / "create_hook.py"
 
@@ -113,15 +130,6 @@ class TestHooks(unittest.TestCase):
         # Load the hook - this will import view.helper
         handler = HookHandler(base_path=test_dir, file=str(hook_file.relative_to(test_dir)))
 
-        # Verify that view.helper was imported and tracked
-        self.assertGreater(
-            len(handler._imported_modules), 0, "Should have tracked imported modules"
-        )
-        self.assertTrue(
-            any("view" in mod for mod in handler._imported_modules),
-            "Should have tracked view module",
-        )
-
         # Verify view.helper is in sys.modules
         view_module_found = any("view" in mod for mod in sys.modules)
         self.assertTrue(
@@ -132,13 +140,8 @@ class TestHooks(unittest.TestCase):
         mock_conn = Mock()
         handler.execute(connection=mock_conn, parameters={})
 
-        # Clean up imports
-        handler.cleanup_imports()
-
-        # Verify that tracked modules were cleared
-        self.assertEqual(
-            len(handler._imported_modules), 0, "Should have cleared tracked modules list"
-        )
+        # Clean up imports via path-based cleanup
+        cleanup_modules_by_path(test_dir)
 
         # Verify that view modules were removed from sys.modules
         view_modules_after = [mod for mod in sys.modules if "view.helper" in mod or mod == "view"]
@@ -154,8 +157,6 @@ class TestHooks(unittest.TestCase):
         This test simulates switching between module versions by loading a hook,
         cleaning it up, and loading it again.
         """
-        import sys
-
         test_dir = Path("test") / "data" / "hook_sibling_imports"
         hook_file = test_dir / "app" / "create_hook.py"
 
@@ -176,8 +177,8 @@ class TestHooks(unittest.TestCase):
                 view_module_id_1 = id(sys.modules[mod_name])
                 break
 
-        # Clean up
-        handler1.cleanup_imports()
+        # Clean up via path-based cleanup
+        cleanup_modules_by_path(test_dir)
 
         # Verify cleanup worked
         view_modules = [mod for mod in sys.modules if "view.helper" in mod or mod == "view"]
@@ -199,4 +200,53 @@ class TestHooks(unittest.TestCase):
         self.assertIsNotNone(view_module_id_2, "Second load should have imported view")
 
         # Clean up after test
-        handler2.cleanup_imports()
+        cleanup_modules_by_path(test_dir)
+
+    def test_hook_submodule_cleanup_on_version_switch(self) -> None:
+        """Test that submodules are properly cleaned up when switching between module versions.
+
+        This test simulates the real-world scenario where a user switches between
+        different versions of a module that imports from nested submodules (e.g., view.submodule.helper).
+        Without proper submodule cleanup, the cached view module from v1 would prevent
+        v2 view.submodule.helper from being imported correctly.
+        """
+        v1_dir = Path("test") / "data" / "hook_submodule_cleanup" / "v1"
+        v2_dir = Path("test") / "data" / "hook_submodule_cleanup" / "v2"
+        hook_file = Path("app") / "create_hook.py"
+
+        # Clear any previously imported view modules
+        modules_to_remove = [key for key in sys.modules if key == "view" or key.startswith("view.")]
+        for module in modules_to_remove:
+            del sys.modules[module]
+
+        # Load v1 hook - imports view.submodule.helper which returns value_from_submodule_v1
+        handler_v1 = HookHandler(base_path=v1_dir, file=str(hook_file))
+        mock_conn = Mock()
+        # Execute v1 hook - the assertion inside run_hook will fail if wrong module is imported
+        handler_v1.execute(connection=mock_conn, parameters={})
+
+        # Verify submodules were imported
+        view_submodules = [mod for mod in sys.modules if mod.startswith("view.submodule")]
+        self.assertGreater(len(view_submodules), 0, "Should have imported view.submodule modules")
+
+        # Clean up v1 imports via path-based cleanup
+        cleanup_modules_by_path(v1_dir)
+
+        # Verify ALL view modules (including submodules) were cleaned up
+        remaining_view_modules = [
+            mod for mod in sys.modules if mod == "view" or mod.startswith("view.")
+        ]
+        self.assertEqual(
+            len(remaining_view_modules),
+            0,
+            f"All view modules should be cleaned up, but found: {remaining_view_modules}",
+        )
+
+        # Load v2 hook - should import fresh view.submodule.helper which returns value_from_submodule_v2
+        # This is the critical part - without submodule cleanup, Python would use the cached
+        # view.submodule.helper from v1 and the assertion inside run_hook would fail
+        handler_v2 = HookHandler(base_path=v2_dir, file=str(hook_file))
+        handler_v2.execute(connection=mock_conn, parameters={})
+
+        # Clean up
+        cleanup_modules_by_path(v2_dir)