pum 1.3.0__tar.gz → 1.3.2__tar.gz

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: pum
-Version: 1.3.0
+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.0 → 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.0 → 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.0 → pum-1.3.2}/pum/schema_migrations.py

@@ -74,10 +74,9 @@ class SchemaMigrations:
             "schema": psycopg.sql.Literal(self.config.config.pum.migration_table_schema),
         }
 
-        with connection.transaction():
-            cursor = SqlContent(query).execute(connection, parameters=parameters)
-            result = cursor._pum_results[0] if cursor._pum_results else None
-            return result[0] if result else False
+        cursor = SqlContent(query).execute(connection, parameters=parameters)
+        result = cursor._pum_results[0] if cursor._pum_results else None
+        return result[0] if result else False
 
     def exists_in_other_schemas(self, connection: psycopg.Connection) -> list[str]:
         """Check if the schema_migrations information table exists in other schemas.
@@ -100,9 +99,8 @@ class SchemaMigrations:
         parameters = {
             "schema": psycopg.sql.Literal(self.config.config.pum.migration_table_schema),
         }
-        with connection.transaction():
-            cursor = SqlContent(query).execute(connection, parameters=parameters)
-            return [row[0] for row in (cursor._pum_results or [])]
+        cursor = SqlContent(query).execute(connection, parameters=parameters)
+        return [row[0] for row in (cursor._pum_results or [])]
 
     def create(
         self,
@@ -346,14 +344,13 @@ INSERT INTO {table} (
             "table": self.migration_table_identifier,
         }
 
-        with connection.transaction():
-            cursor = SqlContent(query).execute(connection, parameters=parameters)
-            row = cursor._pum_results[0] if cursor._pum_results else None
-            if row is None:
-                raise PumSchemaMigrationNoBaselineError(
-                    f"Baseline version not found in the {self.migration_table_identifier_str} table."
-                )
-            return packaging.version.parse(row[0])
+        cursor = SqlContent(query).execute(connection, parameters=parameters)
+        row = cursor._pum_results[0] if cursor._pum_results else None
+        if row is None:
+            raise PumSchemaMigrationNoBaselineError(
+                f"Baseline version not found in the {self.migration_table_identifier_str} table."
+            )
+        return packaging.version.parse(row[0])
 
     def migration_details(self, connection: psycopg.Connection, version: str | None = None) -> dict:
         """Return the migration details from the migration table.
@@ -404,14 +401,13 @@ INSERT INTO {table} (
                 "version": psycopg.sql.Literal(version),
             }
 
-        with connection.transaction():
-            cursor = SqlContent(query).execute(connection, parameters=parameters)
-            row = cursor._pum_results[0] if cursor._pum_results else None
-            if row is None:
-                raise PumSchemaMigrationError(
-                    f"Migration details not found for version {version} in the {self.migration_table_identifier_str} table."
-                )
-            return dict(zip([desc[0] for desc in cursor._pum_description], row, strict=False))
+        cursor = SqlContent(query).execute(connection, parameters=parameters)
+        row = cursor._pum_results[0] if cursor._pum_results else None
+        if row is None:
+            raise PumSchemaMigrationError(
+                f"Migration details not found for version {version} in the {self.migration_table_identifier_str} table."
+            )
+        return dict(zip([desc[0] for desc in cursor._pum_description], row, strict=False))
 
     def compare(self, connection: psycopg.Connection) -> int:
         """Compare the migrations details in the database to the changelogs in the source.

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: pum
-Version: 1.3.0
+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.0 → pum-1.3.2}/pum.egg-info/SOURCES.txt

@@ -38,5 +38,4 @@ test/test_hooks.py
 test/test_roles.py
 test/test_schema_migrations.py
 test/test_sql_content.py
-test/test_transaction_fix.py
 test/test_upgrader.py

{pum-1.3.0 → 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)

pum-1.3.0/test/test_transaction_fix.py

@@ -1,100 +0,0 @@
-import unittest
-from pathlib import Path
-
-import psycopg
-
-from pum.pum_config import PumConfig
-from pum.schema_migrations import SchemaMigrations
-
-
-class TestTransactionFix(unittest.TestCase):
-    """Test that verifies the transaction fix prevents 'idle in transaction' state."""
-
-    def setUp(self) -> None:
-        """Set up the test environment."""
-        self.pg_service = "pum_test"
-
-    def test_schema_migrations_exists_transaction_state(self) -> None:
-        """Test that schema_migrations.exists() doesn't leave connection in 'idle in transaction'."""
-        test_dir = Path("test") / "data" / "single_changelog"
-        cfg = PumConfig(test_dir, pum={"module": "test_single_changelog"})
-        sm = SchemaMigrations(cfg)
-
-        with psycopg.connect(f"service={self.pg_service}") as conn:
-            # Clean up any existing table
-            with conn.transaction():
-                conn.execute("DROP TABLE IF EXISTS public.pum_migrations")
-
-            # Initial state should be IDLE
-            self.assertEqual(conn.info.transaction_status.name, "IDLE")
-
-            # Call exists() which executes a query
-            sm.exists(conn)
-
-            # After the call, connection should still be IDLE (not "IDLE_IN_TRANSACTION")
-            # This will FAIL if the transaction block is not used in exists()
-            transaction_status = conn.info.transaction_status.name
-            self.assertEqual(
-                transaction_status,
-                "IDLE",
-                f"Connection in '{transaction_status}' state after exists() - should use transaction block",
-            )
-
-    def test_schema_migrations_baseline_transaction_state(self) -> None:
-        """Test that schema_migrations.baseline() doesn't leave connection in 'idle in transaction'."""
-        test_dir = Path("test") / "data" / "single_changelog"
-        cfg = PumConfig(test_dir, pum={"module": "test_single_changelog"})
-        sm = SchemaMigrations(cfg)
-
-        with psycopg.connect(f"service={self.pg_service}") as conn:
-            # Create the migrations table with some data
-            with conn.transaction():
-                sm.create(conn)
-                sm.set_baseline(conn, "1.0.0", commit=False)
-
-            # Initial state should be IDLE
-            self.assertEqual(conn.info.transaction_status.name, "IDLE")
-
-            # Call baseline() which executes a query
-            sm.baseline(conn)
-
-            # After the call, connection should still be IDLE
-            transaction_status = conn.info.transaction_status.name
-            self.assertEqual(
-                transaction_status,
-                "IDLE",
-                f"Connection in '{transaction_status}' state after baseline() - should use transaction block",
-            )
-
-            # Clean up
-            with conn.transaction():
-                conn.execute("DROP TABLE IF EXISTS public.pum_migrations")
-
-    def test_multiple_queries_without_transaction_causes_idle_in_transaction(self) -> None:
-        """Test that demonstrates the problem: queries without transaction blocks cause 'idle in transaction'."""
-        with psycopg.connect(f"service={self.pg_service}") as conn:
-            # Start with IDLE state
-            self.assertEqual(conn.info.transaction_status.name, "IDLE")
-
-            # Execute a query WITHOUT using a transaction block
-            # This simulates the old buggy behavior
-            cursor = conn.cursor()
-            cursor.execute("SELECT 1")
-            cursor.fetchone()
-            cursor.close()
-
-            # Now the connection is stuck in INTRANS (idle in transaction)
-            transaction_status = conn.info.transaction_status.name
-            self.assertEqual(
-                transaction_status,
-                "INTRANS",
-                "Without transaction blocks, connection gets stuck in INTRANS (idle in transaction)",
-            )
-
-            # Need to explicitly commit to get back to IDLE
-            conn.commit()
-            self.assertEqual(conn.info.transaction_status.name, "IDLE")
-
-
-if __name__ == "__main__":
-    unittest.main()