pypeline-runner 1.21.1__tar.gz → 1.23.0__tar.gz

{pypeline_runner-1.21.1 → pypeline_runner-1.23.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: pypeline-runner
-Version: 1.21.1
+Version: 1.23.0
 Summary: Configure and execute pipelines with Python (similar to GitHub workflows or Jenkins pipelines).
 License: MIT
 License-File: LICENSE

{pypeline_runner-1.21.1 → pypeline_runner-1.23.0}/pyproject.toml

@@ -1,6 +1,6 @@
 [tool.poetry]
 name = "pypeline-runner"
-version = "1.21.1"
+version = "1.23.0"
 description = "Configure and execute pipelines with Python (similar to GitHub workflows or Jenkins pipelines)."
 authors = ["cuinixam <me@cuinixam.com>"]
 license = "MIT"

pypeline_runner-1.23.0/src/pypeline/__init__.py

@@ -0,0 +1 @@
+__version__ = "1.23.0"

{pypeline_runner-1.21.1 → pypeline_runner-1.23.0}/src/pypeline/bootstrap/run.py

@@ -692,22 +692,27 @@ class CreateVirtualEnvironment(Runnable):
         return "create-virtual-environment"
 
     def get_inputs(self) -> List[Path]:
-        venv_relevant_files = [
-            "uv.lock",
-            "poetry.lock",
-            "poetry.toml",
-            "pyproject.toml",
-            ".env",
-            "Pipfile",
-            "Pipfile.lock",
-            "bootstrap.json",
-            ".bootstrap/bootstrap.ps1",
-            ".bootstrap/bootstrap.py",
-            "bootstrap.ps1",
-            "bootstrap.py",
-            str(self.bootstrap_env.marker_file),
-        ]
-        return [self.root_dir / file for file in venv_relevant_files]
+        """Get input dependencies based on package manager and actual bootstrap configuration."""
+        inputs = []
+
+        # Add package manager specific lock/config files
+        package_manager_files = {
+            "uv": ["uv.lock", "pyproject.toml"],
+            "poetry": ["poetry.lock", "poetry.toml", "pyproject.toml"],
+            "pipenv": ["Pipfile", "Pipfile.lock", ".env"],
+        }
+
+        if self.package_manager_name in package_manager_files:
+            for file in package_manager_files[self.package_manager_name]:
+                inputs.append(self.root_dir / file)
+
+        # Add bootstrap script (always tracked since CreateVEnv creates it)
+        inputs.append(self.bootstrap_dir / "bootstrap.py")
+
+        # Add the bootstrap environment marker
+        inputs.append(self.bootstrap_env.marker_file)
+
+        return inputs
 
     def get_outputs(self) -> List[Path]:
         """
@@ -721,6 +726,15 @@ class CreateVirtualEnvironment(Runnable):
             self.bootstrap_env.virtual_env.scripts_path(),
         ]
 
+    def get_config(self) -> Optional[dict[str, Any]]:
+        """Return configuration that affects the project environment."""
+        return {
+            "package_manager": self.config.package_manager,
+            "package_manager_args": self.config.package_manager_args,
+            "venv_install_command": self.config.venv_install_command,
+            "python_version": self.config.python_version,
+        }
+
 
 def print_environment_info() -> None:
     str_bar = "".join(["-" for _ in range(80)])

{pypeline_runner-1.21.1 → pypeline_runner-1.23.0}/src/pypeline/steps/create_venv.py

@@ -2,6 +2,7 @@ import io
 import json
 import re
 import shutil
+import subprocess
 import sys
 import traceback
 from dataclasses import dataclass
@@ -16,9 +17,8 @@ from py_app_dev.core.logging import logger
 
 from pypeline import __version__
 from pypeline.bootstrap.run import get_bootstrap_script
-
-from ..domain.execution_context import ExecutionContext
-from ..domain.pipeline import PipelineStep
+from pypeline.domain.execution_context import ExecutionContext
+from pypeline.domain.pipeline import PipelineStep
 
 
 @dataclass
@@ -86,17 +86,73 @@ class CreateVEnv(PipelineStep[ExecutionContext]):
             ]
         )
 
+    def _verify_python_version(self, executable: str, expected_version: str) -> bool:
+        """
+        Verify that a Python executable matches the expected version.
+
+        Args:
+        ----
+            executable: Name or path of Python executable to check
+            expected_version: Expected version string (e.g., "3.11" or "3.11.5")
+
+        Returns:
+        -------
+            True if the executable's version matches expected_version (ignoring patch),
+            False otherwise or if the executable cannot be queried.
+
+        """
+        try:
+            # Run python --version to get the version string
+            result = subprocess.run(
+                [executable, "--version"],  # noqa: S603
+                capture_output=True,
+                text=True,
+                check=False,
+            )
+
+            if result.returncode != 0:
+                return False
+
+            # Parse version from output (e.g., "Python 3.11.5")
+            version_output = result.stdout.strip()
+            match = re.match(r"Python\s+(\d+)\.(\d+)(?:\.\d+)?", version_output)
+            if not match:
+                self.logger.warning(f"Could not parse version from: {version_output}")
+                return False
+
+            actual_major = match.group(1)
+            actual_minor = match.group(2)
+
+            # Parse expected version
+            expected_parts = expected_version.split(".")
+            if len(expected_parts) == 0:
+                return False
+
+            expected_major = expected_parts[0]
+            # If only major version specified, only compare major
+            if len(expected_parts) == 1:
+                return actual_major == expected_major
+
+            # Compare major.minor
+            expected_minor = expected_parts[1]
+            return actual_major == expected_major and actual_minor == expected_minor
+
+        except (FileNotFoundError, OSError) as e:
+            self.logger.debug(f"Failed to verify Python version for {executable}: {e}")
+            return False
+
     def _find_python_executable(self, python_version: str) -> Optional[str]:
         """
         Find Python executable based on version string.
 
         Supports version formats:
-        - "3.11.5" or "3.11" -> tries python3.11, python311
-        - "3" -> tries python3
+        - "3.11.5" or "3.11" -> tries python3.11, python311, then falls back to python
+        - "3" -> tries python3, then falls back to python
 
-        Always ignores patch version. No fallbacks to generic python.
+        Always ignores patch version. Falls back to generic 'python' if version-specific
+        executables are not found, but verifies the version matches.
 
-        Returns the first executable found in PATH, or None if not found.
+        Returns the first executable found in PATH, or None if not found or version mismatch.
         """
         # Handle empty string
         if not python_version:
@@ -134,7 +190,16 @@ class CreateVEnv(PipelineStep[ExecutionContext]):
                 self.logger.debug(f"Found Python executable: {executable_path} (candidate: {candidate})")
                 return candidate
 
-        # No fallback - return None if specific version not found
+        # Fallback to generic 'python' executable with version verification
+        self.logger.debug(f"No version-specific Python executable found for {python_version}, trying generic 'python'")
+        if shutil.which("python"):
+            if self._verify_python_version("python", python_version):
+                self.logger.info(f"Using generic 'python' executable (verified as Python {python_version})")
+                return "python"
+            else:
+                self.logger.warning(f"Generic 'python' executable found but version does not match {python_version}")
+
+        # No suitable executable found
         return None
 
     @property
@@ -143,15 +208,27 @@ class CreateVEnv(PipelineStep[ExecutionContext]):
         Get python executable to use.
 
         Priority:
-        1. User-specified python_executable config
-        2. Auto-detect from python_version config
-        3. Current Python interpreter (sys.executable)
+        1. Input from execution context (execution_context.get_input("python_version"))
+        2. User-specified python_executable config
+        3. Auto-detect from python_version config
+        4. Current Python interpreter (sys.executable)
         """
-        # Priority 1: User explicitly specified executable
+        # Priority 1: Check execution context inputs first
+        input_python_version = self.execution_context.get_input("python_version")
+        if input_python_version:
+            found_executable = self._find_python_executable(input_python_version)
+            if found_executable:
+                return found_executable
+            # If version specified via input but not found, fail with helpful error
+            raise UserNotificationException(
+                f"Could not find Python {input_python_version} in PATH. Please install Python {input_python_version} or specify python_executable explicitly."
+            )
+
+        # Priority 2: User explicitly specified executable
         if self.user_config.python_executable:
             return self.user_config.python_executable
 
-        # Priority 2: Auto-detect from python_version
+        # Priority 3: Auto-detect from python_version config
         if self.user_config.python_version:
             found_executable = self._find_python_executable(self.user_config.python_version)
             if found_executable:
@@ -161,7 +238,7 @@ class CreateVEnv(PipelineStep[ExecutionContext]):
                 f"Could not find Python {self.user_config.python_version} in PATH. Please install Python {self.user_config.python_version} or specify python_executable explicitly."
             )
 
-        # Priority 3: Use current interpreter
+        # Priority 4: Use current interpreter
         return sys.executable
 
     @property
@@ -220,8 +297,14 @@ class CreateVEnv(PipelineStep[ExecutionContext]):
             bootstrap_config = {}
             if self.user_config.package_manager:
                 bootstrap_config["python_package_manager"] = self.user_config.package_manager
-            if self.user_config.python_version:
+
+            # Priority: input python_version takes precedence over config python_version
+            input_python_version = self.execution_context.get_input("python_version")
+            if input_python_version:
+                bootstrap_config["python_version"] = input_python_version
+            elif self.user_config.python_version:
                 bootstrap_config["python_version"] = self.user_config.python_version
+
             if self.user_config.package_manager_args:
                 bootstrap_config["python_package_manager_args"] = self.user_config.package_manager_args
             if self.user_config.bootstrap_packages:

pypeline_runner-1.23.0/src/pypeline/steps/env_setup_script.py

@@ -0,0 +1,117 @@
+import platform
+from pathlib import Path
+from typing import Any, Dict, List, Optional
+
+from py_app_dev.core.env_setup_scripts import BatEnvSetupScriptGenerator, EnvSetupScriptGenerator, Ps1EnvSetupScriptGenerator
+from py_app_dev.core.logging import logger
+
+from pypeline.domain.execution_context import ExecutionContext
+from pypeline.domain.pipeline import PipelineStep
+
+
+def read_dot_env_file(dot_env_file: Path) -> Dict[str, str]:
+    """Reads a .env file and returns a dictionary of environment variables."""
+    env_vars = {}
+    with dot_env_file.open("r") as f:
+        for line in f:
+            line = line.strip()
+            if line and not line.startswith("#"):
+                key, value = line.split("=", 1)
+                env_vars[key.strip()] = value.strip().strip('"').strip("'")
+    return env_vars
+
+
+class ShEnvSetupScriptGenerator(EnvSetupScriptGenerator):
+    """Generates a bash/sh script to set environment variables and update PATH."""
+
+    def generate_content(self) -> str:
+        lines = ["#!/bin/bash"]
+
+        for key, value in self.environment.items():
+            # Escape single quotes by replacing ' with '\''
+            # This closes the string, adds an escaped quote, then reopens the string
+            escaped_value = value.replace("'", "'\\''")
+            # Use single quotes for the value to prevent variable expansion
+            lines.append(f"export {key}='{escaped_value}'")
+
+        if self.install_dirs:
+            # Convert to POSIX paths to ensure forward slashes on all platforms
+            path_string = ":".join([path.as_posix() for path in self.install_dirs])
+            # Escape single quotes in paths
+            escaped_path_string = path_string.replace("'", "'\\''")
+            lines.append(f"export PATH='{escaped_path_string}':\"$PATH\"")
+        else:
+            self.logger.debug("No install directories provided for PATH update.")
+        lines.append("")
+
+        return "\n".join(lines)
+
+
+class GenerateEnvSetupScript(PipelineStep[ExecutionContext]):
+    def __init__(self, execution_context: ExecutionContext, group_name: Optional[str], config: Optional[Dict[str, Any]] = None) -> None:
+        super().__init__(execution_context, group_name, config)
+        self._generated_scripts: List[Path] = []
+
+    def run(self) -> None:
+        logger.info(f"Generating environment setup scripts under {self.output_dir} ...")
+
+        # Read the .env file and set up the environment variables
+        dot_env_file = self.execution_context.project_root_dir.joinpath(".env")
+        if dot_env_file.exists():
+            logger.debug(f"Reading .env file: {dot_env_file}")
+            env_vars = read_dot_env_file(dot_env_file)
+        else:
+            logger.info(f".env file not found: {dot_env_file}.")
+            env_vars = {}
+
+        # Merge execution context environment variables
+        env_vars.update(self.execution_context.env_vars)
+        # Update the execution context with the merged environment variables to ensure they are available for subsequent steps
+        self.execution_context.env_vars.update(env_vars)
+
+        # Get generate-all option and detect OS
+        generate_all = self.execution_context.get_input("generate-all") or False
+        is_windows = platform.system() == "Windows"
+
+        # Generate Windows scripts if on Windows OR generate-all is True
+        if is_windows or generate_all:
+            bat_script = self.output_dir.joinpath("env_setup.bat")
+            BatEnvSetupScriptGenerator(
+                install_dirs=self.execution_context.install_dirs,
+                environment=env_vars,
+                output_file=bat_script,
+            ).to_file()
+            self._generated_scripts.append(bat_script)
+
+            ps1_script = self.output_dir.joinpath("env_setup.ps1")
+            Ps1EnvSetupScriptGenerator(
+                install_dirs=self.execution_context.install_dirs,
+                environment=env_vars,
+                output_file=ps1_script,
+            ).to_file()
+            self._generated_scripts.append(ps1_script)
+
+        # Generate Unix/Linux/macOS script if NOT on Windows OR generate-all is True
+        if not is_windows or generate_all:
+            sh_script = self.output_dir.joinpath("env_setup.sh")
+            ShEnvSetupScriptGenerator(
+                install_dirs=self.execution_context.install_dirs,
+                environment=env_vars,
+                output_file=sh_script,
+            ).to_file()
+            self._generated_scripts.append(sh_script)
+
+    def get_inputs(self) -> List[Path]:
+        return []
+
+    def get_outputs(self) -> List[Path]:
+        return self._generated_scripts
+
+    def get_name(self) -> str:
+        return self.__class__.__name__
+
+    def update_execution_context(self) -> None:
+        pass
+
+    def get_needs_dependency_management(self) -> bool:
+        return False

pypeline_runner-1.21.1/src/pypeline/__init__.py

@@ -1 +0,0 @@
-__version__ = "1.21.1"

pypeline_runner-1.21.1/src/pypeline/steps/env_setup_script.py

@@ -1,65 +0,0 @@
-from pathlib import Path
-from typing import Dict, List
-
-from py_app_dev.core.env_setup_scripts import BatEnvSetupScriptGenerator, Ps1EnvSetupScriptGenerator
-from py_app_dev.core.logging import logger
-
-from pypeline.domain.execution_context import ExecutionContext
-from pypeline.domain.pipeline import PipelineStep
-
-
-def read_dot_env_file(dot_env_file: Path) -> Dict[str, str]:
-    """Reads a .env file and returns a dictionary of environment variables."""
-    env_vars = {}
-    with dot_env_file.open("r") as f:
-        for line in f:
-            line = line.strip()
-            if line and not line.startswith("#"):
-                key, value = line.split("=", 1)
-                env_vars[key.strip()] = value.strip().strip('"').strip("'")
-    return env_vars
-
-
-class GenerateEnvSetupScript(PipelineStep[ExecutionContext]):
-    def run(self) -> None:
-        logger.info(f"Generating environment setup scripts under {self.output_dir} ...")
-        # Read the .env file and set up the environment variables
-        dot_env_file = self.execution_context.project_root_dir.joinpath(".env")
-        if dot_env_file.exists():
-            logger.debug(f"Reading .env file: {dot_env_file}")
-            env_vars = read_dot_env_file(dot_env_file)
-        else:
-            logger.warning(f".env file not found: {dot_env_file}")
-            env_vars = {}
-
-        # Merge execution context environment variables
-        env_vars.update(self.execution_context.env_vars)
-        # Update the execution context with the merged environment variables to ensure they are available for subsequent steps
-        self.execution_context.env_vars.update(env_vars)
-
-        # Generate the environment setup scripts
-        BatEnvSetupScriptGenerator(
-            install_dirs=self.execution_context.install_dirs,
-            environment=env_vars,
-            output_file=self.output_dir.joinpath("env_setup.bat"),
-        ).to_file()
-        Ps1EnvSetupScriptGenerator(
-            install_dirs=self.execution_context.install_dirs,
-            environment=env_vars,
-            output_file=self.output_dir.joinpath("env_setup.ps1"),
-        ).to_file()
-
-    def get_inputs(self) -> List[Path]:
-        return []
-
-    def get_outputs(self) -> List[Path]:
-        return []
-
-    def get_name(self) -> str:
-        return self.__class__.__name__
-
-    def update_execution_context(self) -> None:
-        pass
-
-    def get_needs_dependency_management(self) -> bool:
-        return False