pum 1.0.0__py3-none-any.whl → 1.1.1__py3-none-any.whl

pum/__init__.py

@@ -1,4 +1,5 @@
 from .changelog import Changelog
+from .dependency_handler import DependencyHandler
 from .dumper import Dumper, DumpFormat
 from .pum_config import PumConfig
 from .hook import HookHandler, HookBase
@@ -10,6 +11,7 @@ from .upgrader import Upgrader
 
 __all__ = [
     "Changelog",
+    "DependencyHandler",
     "Dumper",
     "DumpFormat",
     "HookBase",

pum/cli.py

@@ -303,9 +303,9 @@ def cli() -> int:  # noqa: PLR0912
         parser.exit()
 
     if args.config_file:
-        config = PumConfig.from_yaml(args.config_file)
+        config = PumConfig.from_yaml(args.config_file, install_dependencies=True)
     else:
-        config = PumConfig.from_yaml(Path(args.dir) / ".pum.yaml")
+        config = PumConfig.from_yaml(Path(args.dir) / ".pum.yaml", install_dependencies=True)
 
     with psycopg.connect(f"service={args.pg_service}") as conn:
         # Check if the connection is successful

pum/config_model.py

@@ -132,6 +132,36 @@ class DemoDataModel(PumCustomBaseModel):
     file: str = Field(..., description="Path to the demo data file.")
 
 
+class DependencyModel(PumCustomBaseModel):
+    """
+    DependencyModel represents a Python dependency for PUM.
+
+    Attributes:
+        name: Name of the Python dependency.
+        version: Version of the dependency.
+    """
+
+    model_config = {"arbitrary_types_allowed": True}
+
+    name: str = Field(..., description="Name of the Python dependency.")
+    minimum_version: Optional[packaging.version.Version] = Field(
+        default=None,
+        description="Specific minimum required version of the package.",
+    )
+    maximum_version: Optional[packaging.version.Version] = Field(
+        default=None,
+        description="Specific maximum required version of the package.",
+    )
+
+    @model_validator(mode="before")
+    def parse_version(cls, values):
+        for value in ("minimum_version", "maximum_version"):
+            ver = values.get(value)
+            if isinstance(ver, str):
+                values[value] = packaging.version.Version(ver)
+            return values
+
+
 class ConfigModel(PumCustomBaseModel):
     """
     ConfigModel represents the main configuration schema for the application.
@@ -150,3 +180,4 @@ class ConfigModel(PumCustomBaseModel):
     changelogs_directory: Optional[str] = "changelogs"
     roles: Optional[List[RoleModel]] = []
     demo_data: Optional[List[DemoDataModel]] = []
+    dependencies: Optional[List[DependencyModel]] = []

pum/dependency_handler.py

@@ -0,0 +1,95 @@
+import logging
+import packaging
+import packaging.version
+import os
+import sys
+import importlib.metadata
+import subprocess
+
+from .exceptions import PumDependencyError
+
+logger = logging.getLogger(__name__)
+
+
+class DependencyHandler:
+    def __init__(
+        self,
+        name: str,
+        *,
+        minimum_version: packaging.version.Version | None,
+        maximum_version: packaging.version.Version | None,
+    ):
+        """
+        Initialize the DependencyHandler with a dependency name and version.
+        Args:
+            name (str): The name of the dependency.
+            version (packaging.version.Version | None): The version of the dependency, or None if not specified.
+        """
+        self.name = name
+        self.minimum_version = minimum_version
+        self.maximum_version = maximum_version
+
+    def resolve(self, install_dependencies: bool = False, install_path: str | None = None):
+        """
+        Resolve the dependency by checking if it is installed and compatible with the current PUM version.
+
+        Args:
+            install_dependencies: If True, the dependency will be locally installed.
+        Raises:
+            PumConfigError: If the dependency is not installed or is incompatible.
+        """
+        try:
+            importlib.metadata.version(self.name)
+
+            installed_version = packaging.version.Version(importlib.metadata.version(self.name))
+            if self.minimum_version and installed_version < self.minimum_version:
+                raise PumDependencyError(
+                    f"Installed version of `{self.name}` ({installed_version}) is lower than the minimum required ({self.minimum_version})."
+                )
+            if self.maximum_version and installed_version > self.maximum_version:
+                raise PumDependencyError(
+                    f"Installed version of `{self.name}` ({installed_version}) is higher than the maximum allowed ({self.maximum_version})."
+                )
+
+            logger.info(f"Dependency {self.name} is satisfied.")
+
+        except importlib.metadata.PackageNotFoundError as e:
+            if not install_dependencies:
+                raise PumDependencyError(
+                    f"Dependency `{self.name}` is not installed. You can activate the installation."
+                ) from e
+            else:
+                logger.warning(f"Dependency {self.name} is not installed: {e}")
+                self.pip_install(install_path=install_path)
+
+                logger.info(f"Dependency {self.name} is now installed in {install_path}")
+
+    def pip_install(self, install_path: str):
+        """
+        Installs given reqs with pip
+        Code copied from qpip plugin
+        """
+
+        req = self.name
+        if self.minimum_version and self.maximum_version:
+            req += f">={self.minimum_version},<={self.maximum_version}"
+        elif self.minimum_version:
+            req += f">={self.minimum_version}"
+        elif self.maximum_version:
+            req += f"<={self.maximum_version}"
+
+        command = [self.python_command(), "-m", "pip", "install", req, "--target", install_path]
+
+        try:
+            output = subprocess.run(command, capture_output=True, text=True, check=False)
+            if output.returncode != 0:
+                logger.error("pip installed failed: %s", output.stderr)
+                raise PumDependencyError(output.stderr)
+        except TypeError:
+            logger.error("Invalid command: %s", " ".join(command))
+            raise PumDependencyError("invalid command: {}".format(" ".join(filter(None, command))))
+
+    def python_command(self):
+        # python is normally found at sys.executable, but there is an issue on windows qgis so use 'python' instead
+        # https://github.com/qgis/QGIS/issues/45646
+        return "python" if os.name == "nt" else sys.executable

pum/exceptions.py

@@ -3,6 +3,10 @@ class PumException(Exception):
     """Base class for all exceptions raised by PUM."""
 
 
+class PumDependencyError(PumException):
+    """Exception when dependency are not resolved"""
+
+
 # --- Configuration and Validation Errors ---
 
 

pum/pum_config.py

@@ -5,20 +5,42 @@ import packaging
 from pydantic import ValidationError
 import logging
 import importlib.metadata
+import glob
+import os
 
 
 from .changelog import Changelog
+from .dependency_handler import DependencyHandler
 from .exceptions import PumConfigError, PumException, PumHookError, PumInvalidChangelog, PumSqlError
 from .parameter import ParameterDefinition
 from .role_manager import RoleManager
 from .config_model import ConfigModel
 from .hook import HookHandler
+import tempfile
+import sys
+import atexit
 
 
 try:
     PUM_VERSION = packaging.version.Version(importlib.metadata.version("pum"))
 except importlib.metadata.PackageNotFoundError:
-    PUM_VERSION = packaging.version.Version("0.0.0")
+    # Fallback: try to read from pum-*.dist-info/METADATA
+    dist_info_dirs = glob.glob(os.path.join(os.path.dirname(__file__), "..", "pum-*.dist-info"))
+    version = None
+    for dist_info in dist_info_dirs:
+        metadata_path = os.path.join(dist_info, "METADATA")
+        if os.path.isfile(metadata_path):
+            with open(metadata_path) as f:
+                for line in f:
+                    if line.startswith("Version:"):
+                        version = line.split(":", 1)[1].strip()
+                        break
+        if version:
+            break
+    if version:
+        PUM_VERSION = packaging.version.Version(version)
+    else:
+        PUM_VERSION = packaging.version.Version("0.0.0")
 
 
 logger = logging.getLogger(__name__)
@@ -27,12 +49,20 @@ logger = logging.getLogger(__name__)
 class PumConfig:
     """A class to hold configuration settings."""
 
-    def __init__(self, base_path: str | Path, validate: bool = True, **kwargs: dict) -> None:
+    def __init__(
+        self,
+        base_path: str | Path,
+        *,
+        validate: bool = True,
+        install_dependencies: bool = False,
+        **kwargs: dict,
+    ) -> None:
         """Initialize the configuration with key-value pairs.
 
         Args:
             base_path: The directory where the changelogs are located.
-            validate: Whether to validate the changelogs and hooks.
+            validate: Whether to validate the changelogs and hooks and resolve dependencies. Defaults to True.
+            install_dependencies: Whether to temporarily install dependencies.
             **kwargs: Key-value pairs representing configuration settings.
 
         Raises:
@@ -46,6 +76,8 @@ class PumConfig:
             raise PumConfigError(f"Directory `{base_path}` does not exist.")
         self._base_path = base_path
 
+        self.dependency_path = None
+
         try:
             self.config = ConfigModel(**kwargs)
         except ValidationError as e:
@@ -58,19 +90,26 @@ class PumConfig:
                     f"Minimum required version of pum is {self.config.pum.minimum_version}, but the current version is {PUM_VERSION}. Please upgrade pum."
                 )
             try:
-                self.validate()
+                self.validate(install_dependencies=install_dependencies)
             except (PumInvalidChangelog, PumHookError) as e:
                 raise PumConfigError(
                     f"Configuration is invalid: {e}. You can disable the validation when constructing the config."
                 ) from e
 
     @classmethod
-    def from_yaml(cls, file_path: str | Path, *, validate: bool = True) -> "PumConfig":
+    def from_yaml(
+        cls,
+        file_path: str | Path,
+        *,
+        validate: bool = True,
+        install_dependencies: bool = False,
+    ) -> "PumConfig":
         """Create a PumConfig instance from a YAML file.
 
         Args:
             file_path: The path to the YAML file.
             validate: Whether to validate the changelogs and hooks.
+            install_dependencies: Wheter to temporarily install dependencies.
 
         Returns:
             PumConfig: An instance of the PumConfig class.
@@ -87,7 +126,12 @@ class PumConfig:
             raise PumConfigError("base_path not allowed in configuration instead.")
 
         base_path = Path(file_path).parent
-        return cls(base_path=base_path, validate=validate, **data)
+        return cls(
+            base_path=base_path,
+            validate=validate,
+            install_dependencies=install_dependencies,
+            **data,
+        )
 
     @property
     def base_path(self) -> Path:
@@ -206,13 +250,33 @@ class PumConfig:
         """Return a dictionary of demo data files defined in the configuration."""
         return {dm.name: dm.file for dm in self.config.demo_data}
 
-    def validate(self) -> None:
-        """Validate the chanbgelogs and hooks."""
+    def validate(self, install_dependencies: bool = False) -> None:
+        """Validate the changelogs and hooks.
+
+        Args:
+            install_dependencies (bool): Whether to temporarily install dependencies.
+        """
+
+        if install_dependencies and self.config.dependencies:
+            temp_dir = tempfile.TemporaryDirectory()
+            self.dependency_path = Path(temp_dir.name)
+            sys.path.insert(0, str(self.dependency_path))
+
+            def cleanup():
+                sys.path = [p for p in sys.path if p != str(self.dependency_path)]
+                temp_dir.cleanup()
+
+            atexit.register(cleanup)
 
         parameter_defaults = {}
         for parameter in self.config.parameters:
             parameter_defaults[parameter.name] = psycopg.sql.Literal(parameter.default)
 
+        for dependency in self.config.dependencies:
+            DependencyHandler(**dependency.model_dump()).resolve(
+                install_dependencies=install_dependencies, install_path=self.dependency_path
+            )
+
         for changelog in self.changelogs():
             try:
                 changelog.validate(parameters=parameter_defaults)

{pum-1.0.0.dist-info → pum-1.1.1.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: pum
-Version: 1.0.0
+Version: 1.1.1
 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.0.0.dist-info → pum-1.1.1.dist-info}/RECORD

@@ -1,22 +1,23 @@
-pum/__init__.py,sha256=IG1g3LMuqSxlW8GC1-H5XdnPX3KF-Irq7MuMEbCYCUM,684
+pum/__init__.py,sha256=P-NHd6_SYpk9aypefLI62QCZ3f5APOMCwSzrFFCKAew,759
 pum/changelog.py,sha256=yDc5swmMd5gb2vCEAlenoq5gs-ZEGc4uXicBtiGxkOk,3692
 pum/checker.py,sha256=GT2v7793HP1g94dv0mL6CHtQfblQwAyeFHEWCy44lkc,14379
-pum/cli.py,sha256=GcxBiQM_S4CDG1v1Gy9xj0noaf-GdeJFi8jc2yfVjLU,13956
-pum/config_model.py,sha256=G8FsVGsYzMEQKrVIc3SltycbJvwmgfhu6uNduAL-D8E,5107
+pum/cli.py,sha256=-GRjvGlBx-ok05CKb9-84MmYs44azn4off71nqs3NdY,14010
+pum/config_model.py,sha256=8FREAJpnm6-4Mby_udKpNo4WPbgn-4ZL1e-02a2FUFY,6147
+pum/dependency_handler.py,sha256=34wvDGWlI-vsMFm1z0XcSDN2cnL_VFAh61GWmeYEzk4,3841
 pum/dumper.py,sha256=EJZ8T44JM0GKgdqw1ENOfhZ-RI89OQ4DNdoTZKtLdEw,3404
-pum/exceptions.py,sha256=HYgC0kLk6Gel7RtT9AjxHdtkmZ4BtjKdB5BHYL67LVs,1042
+pum/exceptions.py,sha256=xyzzY4ht1nKfrVt59Giulflpmu83nJhxoTygrqiqPlw,1137
 pum/hook.py,sha256=L4Cnr34zrgPzxso9CdsUYWmtuOXRmFccQZ9Lp4IYCBM,9326
 pum/info.py,sha256=VSCUZJJ_ae-khKaudwbgqszZXBMKB_yskuQo5Mc1PgY,1024
 pum/parameter.py,sha256=e9f80kMZpART9laeImW_YECeTvwDyDSmZlTeJGvpS_8,2449
-pum/pum_config.py,sha256=WopogLoPEJkvuKEdpWq56YZaZc3mgK-pnII0TbYtIlQ,8454
+pum/pum_config.py,sha256=7rGPaLreOOLl3kuBK_FzYxW02PiWHT4ayenWzOiJWJA,10566
 pum/role_manager.py,sha256=yr-fmytflGqANY3IZIpgJBoMOK98ynTWfemIBhAy79A,10131
 pum/schema_migrations.py,sha256=FiaqAbhFX7vd3Rk_R43kd7-QWfil-Q5587EU8xSLBkA,10504
 pum/sql_content.py,sha256=gwgvcdXOXxNz3RvLtL8Bqr5WO3KKq3sluhbj4OAEnQs,9756
 pum/upgrader.py,sha256=jvl6vmpgxGyYiw8rrWC_bDC7Zd4wHJqGLXCK8EMt9wY,7109
 pum/conf/pum_config_example.yaml,sha256=_nwV_7z6S_Se-mejh_My0JFLY-A0Q4nigeLGPZAfcqg,424
-pum-1.0.0.dist-info/licenses/LICENSE,sha256=2ylvL381vKOhdO-w6zkrOxe9lLNBhRQpo9_0EbHC_HM,18046
-pum-1.0.0.dist-info/METADATA,sha256=HVBChQBJ0xnjyYYxnYyU7EAhU4CLs0V8SIJhM09j9iE,3146
-pum-1.0.0.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
-pum-1.0.0.dist-info/entry_points.txt,sha256=U6dmxSpKs1Pe9vWiR29VPhJMDjrmZeJCSxvfLGR8BD4,36
-pum-1.0.0.dist-info/top_level.txt,sha256=ddiI4HLBhY6ql-NNm0Ez0JhoOHdWDIzrHeCdHmmagcc,4
-pum-1.0.0.dist-info/RECORD,,
+pum-1.1.1.dist-info/licenses/LICENSE,sha256=2ylvL381vKOhdO-w6zkrOxe9lLNBhRQpo9_0EbHC_HM,18046
+pum-1.1.1.dist-info/METADATA,sha256=1YYn57IUQU69qAwyguFJGizQNG5mtu96NMj9t-PgfWI,3146
+pum-1.1.1.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
+pum-1.1.1.dist-info/entry_points.txt,sha256=U6dmxSpKs1Pe9vWiR29VPhJMDjrmZeJCSxvfLGR8BD4,36
+pum-1.1.1.dist-info/top_level.txt,sha256=ddiI4HLBhY6ql-NNm0Ez0JhoOHdWDIzrHeCdHmmagcc,4
+pum-1.1.1.dist-info/RECORD,,