pum 1.2.2__py3-none-any.whl → 1.3.0__py3-none-any.whl

pum/hook.py

@@ -15,8 +15,8 @@ logger = logging.getLogger(__name__)
 
 
 class HookBase(abc.ABC):
-    """Base class for Python migration hooks.
-    This class defines the interface for migration hooks that can be implemented in Python.
+    """Base class for Python application hooks.
+    This class defines the interface for application hooks that can be implemented in Python.
     It requires the implementation of the `run_hook` method, which will be called during the migration process.
     It can call the execute method to run SQL statements with the provided connection and parameters.
     """
@@ -68,8 +68,8 @@ class HookBase(abc.ABC):
 
 
 class HookHandler:
-    """Handler for migration hooks.
-    This class manages the execution of migration hooks, which can be either SQL files or Python functions."""
+    """Handler for application hooks.
+    This class manages the execution of application hooks, which can be either SQL files or Python functions."""
 
     def __init__(
         self,
@@ -92,6 +92,8 @@ class HookHandler:
         self.file = file
         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):
@@ -106,37 +108,89 @@ class HookHandler:
                 raise PumHookError(f"Hook file {self.file} is not a file.")
 
         if self.file and self.file.suffix == ".py":
-            # Support local imports in hook files by adding parent dir to sys.path
+            # Support local imports in hook files by adding parent dir and base_path to sys.path
             parent_dir = str(self.file.parent.resolve())
-            sys_path_modified = False
+
+            # Store paths that need to be added for hook execution
+            # Add parent directory of the hook file
             if parent_dir not in sys.path:
-                sys.path.insert(0, parent_dir)
-                sys_path_modified = True
+                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:
+                    self.sys_path_additions.append(base_path_str)
+
+            # Temporarily add paths for module loading
+            for path in 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)
                 module = importlib.util.module_from_spec(spec)
                 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)
+                if not hook_class or not inspect.isclass(hook_class):
+                    raise PumHookError(
+                        f"Python hook file {self.file} must define a class named 'Hook'."
+                    )
+
+                # Check inheritance by class name to handle multiple pum installations
+                # (e.g., installed pum vs. libs/pum in QGIS plugin)
+                base_classes = [base.__name__ for base in inspect.getmro(hook_class)]
+                if "HookBase" not in base_classes:
+                    # Get more info for debugging
+                    hook_bases = [
+                        f"{base.__module__}.{base.__name__}" for base in inspect.getmro(hook_class)
+                    ]
+                    logger.error(f"Hook class MRO: {hook_bases}")
+                    logger.error(
+                        f"Expected HookBase from: {HookBase.__module__}.{HookBase.__name__}"
+                    )
+                    raise PumHookError(
+                        f"Class 'Hook' in {self.file} must inherit from HookBase. "
+                        f"Found bases: {', '.join(base_classes)}"
+                    )
+
+                if not hasattr(hook_class, "run_hook"):
+                    raise PumHookError(f"Hook function 'run_hook' not found in {self.file}.")
+
+                self.hook_instance = hook_class()
+                arg_names = list(inspect.signature(hook_class.run_hook).parameters.keys())
+                if "connection" not in arg_names:
+                    raise PumHookError(
+                        f"Hook function 'run_hook' in {self.file} must accept 'connection' as an argument."
+                    )
+                self.parameter_args = [
+                    arg for arg in arg_names if arg not in ("self", "connection")
+                ]
+
             finally:
-                if sys_path_modified:
-                    sys.path.remove(parent_dir)
-            # Check that the module contains a class named Hook inheriting from HookBase
-            hook_class = getattr(module, "Hook", None)
-            if not hook_class or not inspect.isclass(hook_class):
-                raise PumHookError(
-                    f"Python hook file {self.file} must define a class named 'Hook'."
-                )
-            if not issubclass(hook_class, HookBase):
-                raise PumHookError(f"Class 'Hook' in {self.file} must inherit from HookBase.")
-            if not hasattr(hook_class, "run_hook"):
-                raise PumHookError(f"Hook function 'run_hook' not found in {self.file}.")
-
-            self.hook_instance = hook_class()
-            arg_names = list(inspect.signature(hook_class.run_hook).parameters.keys())
-            if "connection" not in arg_names:
-                raise PumHookError(
-                    f"Hook function 'run_hook' in {self.file} must accept 'connection' as an argument."
-                )
-            self.parameter_args = [arg for arg in arg_names if arg not in ("self", "connection")]
+                # Remove all paths that were added
+                for path in self.sys_path_additions:
+                    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."""
@@ -188,7 +242,7 @@ class HookHandler:
             parameters (dict, optional): Parameters to bind to the SQL statement. Defaults to ().
 
         """
-        logger.info(
+        logger.debug(
             f"Executing hook from file: {self.file} or SQL code with parameters: {parameters}",
         )
 
@@ -216,6 +270,13 @@ class HookHandler:
                         if key in self.parameter_args:
                             _hook_parameters[key] = value
                 self.hook_instance._prepare(connection=connection, parameters=parameters)
+
+                # Temporarily add sys.path entries for hook execution
+                # This allows dynamic imports inside run_hook to work
+                for path in self.sys_path_additions:
+                    if path not in sys.path:
+                        sys.path.insert(0, path)
+
                 try:
                     if _hook_parameters:
                         self.hook_instance.run_hook(connection=connection, **_hook_parameters)
@@ -223,6 +284,11 @@ class HookHandler:
                         self.hook_instance.run_hook(connection=connection)
                 except PumSqlError as e:
                     raise PumHookError(f"Error executing Python hook from {self.file}: {e}") from e
+                finally:
+                    # Remove the paths after execution
+                    for path in self.sys_path_additions:
+                        if path in sys.path:
+                            sys.path.remove(path)
 
             else:
                 raise PumHookError(

pum/info.py

@@ -6,8 +6,6 @@ from .pum_config import PumConfig
 from .schema_migrations import SchemaMigrations, MIGRATION_TABLE_NAME
 
 logger = logging.getLogger(__name__)
-# set to info here
-logger.setLevel(logging.INFO)
 
 
 def run_info(connection: psycopg.Connection, config: PumConfig) -> None:

pum/parameter.py

@@ -20,6 +20,10 @@ class ParameterType(Enum):
     DECIMAL = "decimal"
     PATH = "path"
 
+    def __str__(self) -> str:
+        """Return the string value of the enum (e.g., 'integer' instead of 'ParameterType.INTEGER')."""
+        return self.value
+
 
 class ParameterDefinition:
     """A class to define a migration parameter."""

pum/pum_config.py

@@ -2,14 +2,15 @@ from pathlib import Path
 import psycopg
 import yaml
 import packaging
+import packaging.version
 from pydantic import ValidationError
 import logging
 import importlib.metadata
 import glob
 import os
+import subprocess
+from typing import TYPE_CHECKING
 
-
-from .changelog import Changelog
 from .dependency_handler import DependencyHandler
 from .exceptions import PumConfigError, PumException, PumHookError, PumInvalidChangelog, PumSqlError
 from .parameter import ParameterDefinition
@@ -20,6 +21,10 @@ import tempfile
 import sys
 
 
+if TYPE_CHECKING:
+    from .changelog import Changelog
+
+
 try:
     PUM_VERSION = packaging.version.Version(importlib.metadata.version("pum"))
 except importlib.metadata.PackageNotFoundError:
@@ -37,9 +42,49 @@ except importlib.metadata.PackageNotFoundError:
                         break
     if versions:
         # Pick the highest version
-        PUM_VERSION = max((packaging.version.Version(v) for v in versions))
+        PUM_VERSION = max(packaging.version.Version(v) for v in versions)
     else:
-        PUM_VERSION = packaging.version.Version("0.0.0")
+        # Fallback: try to get version from git (for development from source)
+        try:
+            git_dir = Path(__file__).parent.parent / ".git"
+            if git_dir.exists():
+                result = subprocess.run(
+                    ["git", "describe", "--tags", "--always", "--dirty"],
+                    cwd=Path(__file__).parent.parent,
+                    capture_output=True,
+                    text=True,
+                    check=False,
+                )
+                if result.returncode == 0 and result.stdout.strip():
+                    git_version = result.stdout.strip()
+                    # Clean up git version to be PEP 440 compatible
+                    # e.g., "0.9.2-10-g1234567" -> "0.9.2.post10"
+                    # e.g., "0.9.2" -> "0.9.2"
+                    # e.g., "1234567" (no tags) -> "0.0.0+1234567"
+                    if "-" in git_version:
+                        parts = git_version.split("-")
+                        if len(parts) >= 3 and parts[0][0].isdigit():
+                            # Tagged version with commits after: "0.9.2-10-g1234567"
+                            base_version = parts[0]
+                            commits_after = parts[1]
+                            PUM_VERSION = packaging.version.Version(
+                                f"{base_version}.post{commits_after}"
+                            )
+                        else:
+                            # Untagged: just use the commit hash
+                            PUM_VERSION = packaging.version.Version(f"0.0.0+{parts[0]}")
+                    elif git_version[0].isdigit():
+                        # Clean tag version
+                        PUM_VERSION = packaging.version.Version(git_version)
+                    else:
+                        # Just a commit hash (no tags)
+                        PUM_VERSION = packaging.version.Version(f"0.0.0+{git_version}")
+                else:
+                    PUM_VERSION = packaging.version.Version("0.0.0")
+            else:
+                PUM_VERSION = packaging.version.Version("0.0.0")
+        except Exception:
+            PUM_VERSION = packaging.version.Version("0.0.0")
 
 
 logger = logging.getLogger(__name__)
@@ -76,6 +121,7 @@ class PumConfig:
         self._base_path = base_path
 
         self.dependency_path = None
+        self._cached_handlers = []  # Cache handlers for cleanup
 
         try:
             self.config = ConfigModel(**kwargs)
@@ -137,6 +183,18 @@ class PumConfig:
         """Return the base path used for configuration and changelogs."""
         return self._base_path
 
+    def cleanup_hook_imports(self) -> None:
+        """Clean up imported modules from hooks to prevent conflicts when switching versions.
+
+        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
+        self._cached_handlers.clear()
+
     def parameters(self) -> list[ParameterDefinition]:
         """Return a list of migration parameters.
 
@@ -145,7 +203,8 @@ class PumConfig:
 
         """
         return [
-            ParameterDefinition(**parameter.model_dump()) for parameter in self.config.parameters
+            ParameterDefinition(**parameter.model_dump(mode="python"))
+            for parameter in self.config.parameters
         ]
 
     def parameter(self, name: str) -> ParameterDefinition:
@@ -163,7 +222,7 @@ class PumConfig:
         """
         for parameter in self.config.parameters:
             if parameter.name == name:
-                return ParameterDefinition(**parameter.model_dump())
+                return ParameterDefinition(**parameter.model_dump(mode="python"))
         raise PumConfigError(f"Parameter '{name}' not found in configuration.") from KeyError
 
     def last_version(
@@ -195,7 +254,11 @@ class PumConfig:
             return None
         return changelogs[-1].version
 
-    def changelogs(self, min_version: str | None = None, max_version: str | None = None) -> list:
+    def changelogs(
+        self,
+        min_version: str | packaging.version.Version | None = None,
+        max_version: str | packaging.version.Version | None = None,
+    ) -> "list[Changelog]":
         """Return a list of changelogs.
         The changelogs are sorted by version.
 
@@ -213,6 +276,9 @@ class PumConfig:
         if not path.iterdir():
             raise PumException(f"Changelogs directory `{path}` is empty.")
 
+        # Local import avoids circular imports at module import time.
+        from .changelog import Changelog
+
         changelogs = [Changelog(d) for d in path.iterdir() if d.is_dir()]
 
         if min_version:
@@ -234,25 +300,42 @@ class PumConfig:
             return RoleManager([])
         return RoleManager([role.model_dump() for role in self.config.roles])
 
-    def pre_hook_handlers(self) -> list[HookHandler]:
-        """Return the list of pre-migration hook handlers."""
-        return (
+    def drop_app_handlers(self) -> list[HookHandler]:
+        """Return the list of drop app hook handlers."""
+        handlers = (
+            [
+                HookHandler(base_path=self._base_path, **hook.model_dump())
+                for hook in self.config.application.drop
+            ]
+            if self.config.application.drop
+            else []
+        )
+        # Cache handlers for cleanup
+        self._cached_handlers.extend(handlers)
+        return handlers
+
+    def create_app_handlers(self) -> list[HookHandler]:
+        """Return the list of create app hook handlers."""
+        handlers = (
             [
                 HookHandler(base_path=self._base_path, **hook.model_dump())
-                for hook in self.config.migration_hooks.pre
+                for hook in self.config.application.create
             ]
-            if self.config.migration_hooks.pre
+            if self.config.application.create
             else []
         )
+        # Cache handlers for cleanup
+        self._cached_handlers.extend(handlers)
+        return handlers
 
-    def post_hook_handlers(self) -> list[HookHandler]:
-        """Return the list of post-migration hook handlers."""
+    def uninstall_handlers(self) -> list[HookHandler]:
+        """Return the list of uninstall hook handlers."""
         return (
             [
                 HookHandler(base_path=self._base_path, **hook.model_dump())
-                for hook in self.config.migration_hooks.post
+                for hook in self.config.uninstall
             ]
-            if self.config.migration_hooks.post
+            if self.config.uninstall
             else []
         )
 
@@ -300,10 +383,10 @@ class PumConfig:
                 raise PumInvalidChangelog(f"Changelog `{changelog}` is invalid.") from e
 
         hook_handlers = []
-        if self.config.migration_hooks.pre:
-            hook_handlers.extend(self.pre_hook_handlers())
-        if self.config.migration_hooks.post:
-            hook_handlers.extend(self.post_hook_handlers())
+        if self.config.application.drop:
+            hook_handlers.extend(self.drop_app_handlers())
+        if self.config.application.create:
+            hook_handlers.extend(self.create_app_handlers())
         for hook_handler in hook_handlers:
             try:
                 hook_handler.validate(parameter_defaults)