pum 1.3.1__tar.gz → 1.3.3__tar.gz

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: pum
-Version: 1.3.1
+Version: 1.3.3
 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.3}/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):
@@ -112,32 +111,38 @@ class HookHandler:
             parent_dir = str(self.file.parent.resolve())
 
             # Store paths that need to be added for hook execution
-            # Add parent directory of the hook file
-            if parent_dir not in sys.path:
-                self.sys_path_additions.append(parent_dir)
+            # Always add paths even if already in sys.path - we need them at position 0
+            # for priority and we'll track what we added for cleanup
+            self.sys_path_additions.append(parent_dir)
 
             # Also add base_path if provided, to support imports from sibling directories
             if base_path is not None:
                 base_path_str = str(base_path.resolve())
-                if base_path_str not in sys.path and base_path_str != parent_dir:
+                if 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:
+            # 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())
+            # Invalidate caches so Python recognizes the new paths
+            importlib.invalidate_caches()
 
             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)
@@ -176,21 +181,22 @@ class HookHandler:
                     arg for arg in arg_names if arg not in ("self", "connection")
                 ]
 
-            finally:
-                # Remove all paths that were added
-                for path in self.sys_path_additions:
-                    if path in sys.path:
-                        sys.path.remove(path)
+            except Exception:
+                # On error, clean up paths we added
+                self.cleanup_sys_path()
+                raise
+
+    def cleanup_sys_path(self) -> None:
+        """Remove paths that were added to sys.path for this hook.
 
-    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.
+        This should be called when the hook is no longer needed to prevent
+        sys.path pollution.
         """
-        for module_name in self._imported_modules:
-            if module_name in sys.modules:
-                del sys.modules[module_name]
-        self._imported_modules.clear()
+        for path in self.sys_path_additions:
+            # Remove all occurrences of this path (we may have added it multiple times)
+            while path in sys.path:
+                sys.path.remove(path)
+        self.sys_path_additions.clear()
 
     def __repr__(self) -> str:
         """Return a string representation of the Hook instance."""

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

@@ -184,15 +184,31 @@ class PumConfig:
         return self._base_path
 
     def cleanup_hook_imports(self) -> None:
-        """Clean up imported modules from hooks to prevent conflicts when switching versions.
+        """Clean up imported modules and sys.path entries from hooks.
 
         This should be called when switching to a different module version to ensure
         that cached imports from the previous version don't cause conflicts.
         """
+        # First, clean up sys.path additions from all cached handlers
         for handler in self._cached_handlers:
-            if hasattr(handler, "cleanup_imports"):
-                handler.cleanup_imports()
-        # Clear the cache after cleanup
+            handler.cleanup_sys_path()
+
+        # 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.3}/pum.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: pum
-Version: 1.3.1
+Version: 1.3.3
 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.3}/test/test_config.py

@@ -199,17 +199,28 @@ class TestConfig(unittest.TestCase):
         This test simulates the QGIS plugin scenario where a user switches from one
         module version to another, which can cause import conflicts if old modules
         are still cached in sys.modules.
+
+        Tests three critical scenarios:
+        1. Simple module imports (top-level imports at module load time)
+        2. Nested submodule imports (e.g., view.submodule.helper)
+        3. Dynamic imports (imports inside run_hook at execution time)
+
+        All three scenarios need proper cleanup to prevent version conflicts.
         """
         import sys
         from unittest.mock import Mock
 
-        # Clear any view modules from sys.modules
+        # Initial cleanup to ensure clean state from any previous test runs
+        # This is the ONLY manual cleanup - everything else should use the API
         modules_to_remove = [
-            key for key in list(sys.modules.keys()) if "view" in key or "helper_v" in key
+            key
+            for key in list(sys.modules.keys())
+            if "view" in key or "helper_v" in key or "helper_dynamic" in key
         ]
         for module in modules_to_remove:
             del sys.modules[module]
 
+        # Test 1: Simple module imports
         # Load version 1
         v1_path = Path("test") / "data" / "hook_version_switch" / "v1"
         cfg_v1 = PumConfig(
@@ -271,6 +282,127 @@ class TestConfig(unittest.TestCase):
             "helper_v2 should be removed from sys.modules after cleanup",
         )
 
+        # Test 2: Nested submodule imports (view.submodule.helper)
+        # This tests the critical case where parent modules cache can prevent
+        # submodule reloading if not properly cleaned up
+        # No manual cleanup needed - the API should handle everything
+
+        # Load submodule cleanup v1
+        submodule_v1_path = Path("test") / "data" / "hook_submodule_cleanup" / "v1"
+        cfg_submodule_v1 = PumConfig(
+            base_path=submodule_v1_path,
+            pum={"module": "test_submodule_v1"},
+            application={"create": [{"file": "app/create_hook.py"}]},
+            validate=False,
+        )
+
+        handlers_submodule_v1 = cfg_submodule_v1.create_app_handlers()
+        self.assertEqual(len(handlers_submodule_v1), 1)
+
+        # Execute v1 hook - imports view.submodule.helper which returns value_from_submodule_v1
+        # The hook has an assertion that will fail if wrong version is imported
+        handlers_submodule_v1[0].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 submodule imports
+        cfg_submodule_v1.cleanup_hook_imports()
+
+        # 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 submodule cleanup v2 - critical test for proper submodule cleanup
+        # Without proper cleanup, Python would use cached view.submodule.helper from v1
+        submodule_v2_path = Path("test") / "data" / "hook_submodule_cleanup" / "v2"
+        cfg_submodule_v2 = PumConfig(
+            base_path=submodule_v2_path,
+            pum={"module": "test_submodule_v2"},
+            application={"create": [{"file": "app/create_hook.py"}]},
+            validate=False,
+        )
+
+        handlers_submodule_v2 = cfg_submodule_v2.create_app_handlers()
+        self.assertEqual(len(handlers_submodule_v2), 1)
+
+        # Execute v2 hook - should import fresh view.submodule.helper which returns value_from_submodule_v2
+        # The assertion inside the hook will fail if the wrong version is loaded
+        handlers_submodule_v2[0].execute(connection=mock_conn, parameters={})
+
+        # Clean up
+        cfg_submodule_v2.cleanup_hook_imports()
+
+        # Test 3: Dynamic imports (imports inside run_hook, not at module load time)
+        # This is the critical case that wasn't covered before - imports that happen
+        # during hook execution need cleanup too
+        # No manual cleanup needed - the API should handle everything
+
+        # Load dynamic import v1
+        dynamic_v1_path = Path("test") / "data" / "hook_dynamic_import_switch" / "v1"
+        cfg_dynamic_v1 = PumConfig(
+            base_path=dynamic_v1_path,
+            pum={"module": "test_dynamic_v1"},
+            application={"create": [{"file": "app/create_hook.py"}]},
+            validate=False,
+        )
+
+        handlers_dynamic_v1 = cfg_dynamic_v1.create_app_handlers()
+        self.assertEqual(len(handlers_dynamic_v1), 1)
+
+        # Execute v1 hook - this does a dynamic import of helper_dynamic_v1 inside run_hook
+        handlers_dynamic_v1[0].execute(connection=mock_conn, parameters={})
+
+        # Verify the dynamically imported module is in sys.modules
+        self.assertTrue(
+            any("helper_dynamic_v1" in mod for mod in sys.modules),
+            "helper_dynamic_v1 should be in sys.modules after dynamic import",
+        )
+
+        # Clean up v1 dynamic imports
+        cfg_dynamic_v1.cleanup_hook_imports()
+
+        # Verify dynamically imported modules were cleaned up
+        remaining_dynamic_v1_modules = [mod for mod in sys.modules if "helper_dynamic_v1" in mod]
+        self.assertEqual(
+            len(remaining_dynamic_v1_modules),
+            0,
+            f"Dynamic import modules should be cleaned up, but found: {remaining_dynamic_v1_modules}",
+        )
+
+        # Load dynamic import v2 - critical test for cleanup after dynamic imports
+        # Without proper cleanup, Python might use cached helper_dynamic_v1
+        dynamic_v2_path = Path("test") / "data" / "hook_dynamic_import_switch" / "v2"
+        cfg_dynamic_v2 = PumConfig(
+            base_path=dynamic_v2_path,
+            pum={"module": "test_dynamic_v2"},
+            application={"create": [{"file": "app/create_hook.py"}]},
+            validate=False,
+        )
+
+        handlers_dynamic_v2 = cfg_dynamic_v2.create_app_handlers()
+        self.assertEqual(len(handlers_dynamic_v2), 1)
+
+        # Execute v2 hook - should dynamically import fresh helper_dynamic_v2
+        # The assertion inside the hook will fail if the wrong version is loaded
+        handlers_dynamic_v2[0].execute(connection=mock_conn, parameters={})
+
+        # Verify v2 was imported
+        self.assertTrue(
+            any("helper_dynamic_v2" in mod for mod in sys.modules),
+            "helper_dynamic_v2 should be in sys.modules",
+        )
+
+        # Clean up
+        cfg_dynamic_v2.cleanup_hook_imports()
+
     def test_parameter_type_string_conversion(self) -> None:
         """Test that ParameterType enums convert to string values correctly.
 

pum-1.3.3/test/test_hooks.py

@@ -0,0 +1,64 @@
+"""Test module for hook functionality."""
+
+import sys
+import unittest
+from pathlib import Path
+from unittest.mock import Mock
+
+from pum.hook import HookHandler
+
+
+class TestHooks(unittest.TestCase):
+    """Test the hook functionality."""
+
+    def test_hook_with_local_imports(self) -> None:
+        """Test that a hook file can import from its own directory.
+
+        This test verifies that PUM hook files can properly import from their
+        own directory. The test uses a hook file in app/ that imports from
+        local_helper.py in the same directory.
+        """
+        test_dir = Path("test") / "data" / "hook_local_imports"
+        hook_file = test_dir / "app" / "create_hook.py"
+
+        # Create hook handler - this should not raise an error
+        handler = HookHandler(base_path=test_dir, file=str(hook_file.relative_to(test_dir)))
+
+        # Verify the hook was loaded correctly
+        self.assertIsNotNone(handler.hook_instance)
+        self.assertTrue(hasattr(handler.hook_instance, "run_hook"))
+
+        # Execute the hook to ensure imports work at runtime
+        mock_conn = Mock()
+        handler.execute(connection=mock_conn, parameters={})
+
+    def test_hook_with_dynamic_imports(self) -> None:
+        """Test that a hook file can import modules dynamically inside run_hook.
+
+        This test verifies that PUM hook files can properly import modules
+        during hook execution (inside run_hook), not just at module load time.
+        This is critical because hooks may need to import modules based on runtime
+        conditions or call functions that themselves import modules.
+
+        This was the bug that wasn't caught by existing tests - all previous tests
+        used top-level imports which happen during __init__, not during execute().
+
+        Also tests that hooks can be executed multiple times with consistent behavior.
+        """
+        test_dir = Path("test") / "data" / "hook_dynamic_import"
+        hook_file = test_dir / "app" / "create_hook.py"
+
+        # Create hook handler - this should not raise an error
+        handler = HookHandler(base_path=test_dir, file=str(hook_file.relative_to(test_dir)))
+
+        # Verify the hook was loaded correctly
+        self.assertIsNotNone(handler.hook_instance)
+        self.assertTrue(hasattr(handler.hook_instance, "run_hook"))
+
+        # Execute the hook - this is where the dynamic import happens
+        # Without proper sys.path management during execute(), this will fail
+        mock_conn = Mock()
+        handler.execute(connection=mock_conn, parameters={})
+
+        # Execute again to verify it works multiple times
+        handler.execute(connection=mock_conn, parameters={})

pum-1.3.1/test/test_hooks.py

@@ -1,202 +0,0 @@
-"""Test module for hook functionality."""
-
-import unittest
-from pathlib import Path
-from unittest.mock import Mock
-
-from pum.hook import HookHandler
-
-
-class TestHooks(unittest.TestCase):
-    """Test the hook functionality."""
-
-    def test_hook_with_sibling_imports(self) -> None:
-        """Test that a hook file can import from a sibling directory.
-
-        This test verifies that PUM hook files can properly import from sibling
-        directories. The test uses a hook file in app/ that imports from view/,
-        which is a sibling directory.
-        """
-        import sys
-
-        test_dir = Path("test") / "data" / "hook_sibling_imports"
-        hook_file = test_dir / "app" / "create_hook.py"
-
-        # Clear any previously imported modules to ensure fresh import
-        modules_to_remove = [key for key in sys.modules if "view.helper" in key or "view" == key]
-        for module in modules_to_remove:
-            del sys.modules[module]
-
-        # Create hook handler - this should not raise an error
-        handler = HookHandler(base_path=test_dir, file=str(hook_file.relative_to(test_dir)))
-
-        # Verify the hook was loaded correctly
-        self.assertIsNotNone(handler.hook_instance)
-        self.assertTrue(hasattr(handler.hook_instance, "run_hook"))
-
-        # At this point sys.path should not contain the hook paths anymore
-        test_dir_str = str(test_dir.resolve())
-        app_dir_str = str((test_dir / "app").resolve())
-        self.assertNotIn(test_dir_str, sys.path, "base_path should have been removed from sys.path")
-        self.assertNotIn(app_dir_str, sys.path, "parent dir should have been removed from sys.path")
-
-        # Execute the hook to ensure imports work at runtime
-        # This is where the bug should manifest - view.helper won't be importable
-        mock_conn = Mock()
-        handler.execute(connection=mock_conn, parameters={})
-
-    def test_hook_with_dynamic_sibling_imports(self) -> None:
-        """Test that a hook file can dynamically import from a sibling directory at runtime.
-
-        This test verifies that PUM hook files can properly import from sibling
-        directories even when the import happens inside run_hook (not at module load time).
-        """
-        import sys
-
-        test_dir = Path("test") / "data" / "hook_sibling_imports"
-        hook_file = test_dir / "app" / "dynamic_import_hook.py"
-
-        # Clear any previously imported modules to ensure fresh import
-        modules_to_remove = [key for key in sys.modules if "view.helper" in key or "view" == key]
-        for module in modules_to_remove:
-            del sys.modules[module]
-
-        # Create hook handler
-        handler = HookHandler(base_path=test_dir, file=str(hook_file.relative_to(test_dir)))
-
-        # Verify the hook was loaded correctly
-        self.assertIsNotNone(handler.hook_instance)
-        self.assertTrue(hasattr(handler.hook_instance, "run_hook"))
-
-        # Execute the hook - this should fail because sys.path modifications were removed
-        mock_conn = Mock()
-        handler.execute(connection=mock_conn, parameters={})
-
-    def test_hook_with_local_imports(self) -> None:
-        """Test that a hook file can import from its own directory.
-
-        This test verifies that PUM hook files can properly import from their
-        own directory. The test uses a hook file in app/ that imports from
-        local_helper.py in the same directory.
-        """
-        test_dir = Path("test") / "data" / "hook_local_imports"
-        hook_file = test_dir / "app" / "create_hook.py"
-
-        # Create hook handler - this should not raise an error
-        handler = HookHandler(base_path=test_dir, file=str(hook_file.relative_to(test_dir)))
-
-        # Verify the hook was loaded correctly
-        self.assertIsNotNone(handler.hook_instance)
-        self.assertTrue(hasattr(handler.hook_instance, "run_hook"))
-
-        # Execute the hook to ensure imports work at runtime
-        mock_conn = Mock()
-        handler.execute(connection=mock_conn, parameters={})
-
-    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.
-        """
-        import sys
-
-        test_dir = Path("test") / "data" / "hook_sibling_imports"
-        hook_file = test_dir / "app" / "create_hook.py"
-
-        # Clear any previously imported modules to ensure fresh import
-        modules_to_remove = [key for key in sys.modules if "view" in key]
-        for module in modules_to_remove:
-            del sys.modules[module]
-
-        # 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(
-            view_module_found, "view module should be in sys.modules after loading hook"
-        )
-
-        # Execute the hook to make sure it works before cleanup
-        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"
-        )
-
-        # 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"]
-        self.assertEqual(
-            len(view_modules_after),
-            0,
-            f"view modules should be removed from sys.modules after cleanup, but found: {view_modules_after}",
-        )
-
-    def test_hook_cleanup_and_reload(self) -> None:
-        """Test that hooks can be reloaded after cleanup without conflicts.
-
-        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"
-
-        # Clear any previously imported modules
-        modules_to_remove = [key for key in sys.modules if "view" in key]
-        for module in modules_to_remove:
-            del sys.modules[module]
-
-        # First load
-        handler1 = HookHandler(base_path=test_dir, file=str(hook_file.relative_to(test_dir)))
-        mock_conn = Mock()
-        handler1.execute(connection=mock_conn, parameters={})
-
-        # Get the module object for comparison
-        view_module_id_1 = None
-        for mod_name in sys.modules:
-            if mod_name == "view" or mod_name.startswith("view."):
-                view_module_id_1 = id(sys.modules[mod_name])
-                break
-
-        # Clean up
-        handler1.cleanup_imports()
-
-        # Verify cleanup worked
-        view_modules = [mod for mod in sys.modules if "view.helper" in mod or mod == "view"]
-        self.assertEqual(len(view_modules), 0, "Modules should be cleaned up")
-
-        # Second load - should work without conflicts
-        handler2 = HookHandler(base_path=test_dir, file=str(hook_file.relative_to(test_dir)))
-        handler2.execute(connection=mock_conn, parameters={})
-
-        # Verify it's a fresh import (different module object)
-        view_module_id_2 = None
-        for mod_name in sys.modules:
-            if mod_name == "view" or mod_name.startswith("view."):
-                view_module_id_2 = id(sys.modules[mod_name])
-                break
-
-        # Both should have found view modules
-        self.assertIsNotNone(view_module_id_1, "First load should have imported view")
-        self.assertIsNotNone(view_module_id_2, "Second load should have imported view")
-
-        # Clean up after test
-        handler2.cleanup_imports()