pypeline-runner 1.20.0__py3-none-any.whl → 1.21.1__py3-none-any.whl

pypeline/__init__.py

@@ -1 +1 @@
-__version__ = "1.20.0"
+__version__ = "1.21.1"

pypeline/bootstrap/run.py

@@ -1,30 +1,93 @@
 import argparse
 import configparser
 import ensurepip
+import hashlib
 import json
 import logging
 import os
 import re
-import subprocess
+import shutil
+import subprocess  # nosec
 import sys
-import tempfile
 import venv
 from abc import ABC, abstractmethod
-from dataclasses import dataclass
+from dataclasses import dataclass, field
+from enum import Enum
 from functools import total_ordering
 from pathlib import Path
-from typing import List, Optional, Tuple
+from typing import Any, List, Optional, Sequence, Tuple
 from urllib.parse import urlparse
 
 logging.basicConfig(level=logging.INFO)
 logger = logging.getLogger("bootstrap")
 
 
+DEFAULT_PACKAGE_MANAGER = "poetry>=2.1.0"
+DEFAULT_BOOTSTRAP_PACKAGES = ["pip-system-certs>=4.0,<5.0"]
+BOOTSTRAP_COMPLETE_MARKER = ".bootstrap-complete"
+VENV_PYTHON_VERSION_MARKER = ".python_version"
+
+
 def get_bootstrap_script() -> Path:
     """Get the path to the internal bootstrap script."""
     return Path(__file__)
 
 
+@dataclass
+class BootstrapConfig:
+    """Configuration for the bootstrap process loaded from bootstrap.json."""
+
+    python_version: str = ""
+    package_manager: str = DEFAULT_PACKAGE_MANAGER
+    package_manager_args: List[str] = field(default_factory=list)
+    bootstrap_packages: List[str] = field(default_factory=lambda: list(DEFAULT_BOOTSTRAP_PACKAGES))
+    bootstrap_cache_dir: Optional[Path] = None
+    venv_install_command: Optional[str] = None
+
+    @classmethod
+    def from_json_file(cls, json_path: Path) -> "BootstrapConfig":
+        """Load configuration from a JSON file."""
+        if not json_path.exists():
+            return cls()
+
+        with json_path.open("r") as file_handle:
+            data = json.load(file_handle)
+
+        bootstrap_packages = data.get("bootstrap_packages", list(DEFAULT_BOOTSTRAP_PACKAGES))
+
+        cache_dir_str = data.get("bootstrap_cache_dir")
+        cache_dir = Path(cache_dir_str).expanduser() if cache_dir_str else None
+
+        return cls(
+            python_version=data.get("python_version", ""),
+            package_manager=data.get("python_package_manager", DEFAULT_PACKAGE_MANAGER),
+            package_manager_args=data.get("python_package_manager_args", []),
+            bootstrap_packages=bootstrap_packages,
+            bootstrap_cache_dir=cache_dir,
+            venv_install_command=data.get("venv_install_command"),
+        )
+
+    def get_bootstrap_cache_dir(self) -> Path:
+        """Return the bootstrap cache directory, defaulting to ~/.bootstrap."""
+        if self.bootstrap_cache_dir:
+            return self.bootstrap_cache_dir
+        return Path.home() / ".bootstrap"
+
+    def compute_bootstrap_env_hash(self) -> str:
+        """Compute a hash for the bootstrap environment based on configuration."""
+        if self.python_version:
+            python_major_minor = ".".join(self.python_version.split(".")[:2])
+        else:
+            python_major_minor = f"{sys.version_info[0]}.{sys.version_info[1]}"
+        components = [
+            f"python={python_major_minor}",
+            f"manager={self.package_manager}",
+            f"packages={sorted(self.bootstrap_packages)}",
+        ]
+        content = "|".join(str(component) for component in components)
+        return hashlib.sha256(content.encode()).hexdigest()[:12]
+
+
 @total_ordering
 class Version:
     def __init__(self, version_str: str) -> None:
@@ -32,7 +95,6 @@ class Version:
 
     @staticmethod
     def parse_version(version_str: str) -> Tuple[int, ...]:
-        """Convert a version string into a tuple of integers for comparison."""
         return tuple(map(int, re.split(r"\D+", version_str)))
 
     def __eq__(self, other: object) -> bool:
@@ -40,9 +102,7 @@ class Version:
             return NotImplemented
         return self.version == other.version
 
-    def __lt__(self, other: object) -> bool:
-        if not isinstance(other, Version):
-            return NotImplemented
+    def __lt__(self, other: "Version") -> bool:
         return self.version < other.version
 
     def __repr__(self) -> str:
@@ -65,72 +125,36 @@ class TomlSection:
 
 
 class PyPiSourceParser:
-    @staticmethod
-    def find_pypi_source_in_content(content: str) -> Optional[PyPiSource]:
-        """Parses TOML content, finds the first section containing 'name' and 'url' keys, and returns it as a PyPiSource."""
-        sections = PyPiSourceParser.get_toml_sections(content)
-        logger.debug(f"Found {len(sections)} potential sections in TOML content.")
-
-        for section in sections:
-            logger.debug(f"Checking section: [{section.name}]")
-            try:
-                parser = configparser.ConfigParser(interpolation=None)  # Disable interpolation
-                # Provide the section string directly to read_string
-                # The TomlSection.__str__ method formats it correctly
-                parser.read_string(str(section))
-
-                # Check if the section was parsed and contains the required keys
-                if section.name in parser and "name" in parser[section.name] and "url" in parser[section.name]:
-                    name = parser[section.name]["name"].strip("\"' ")  # Strip quotes and whitespace
-                    url = parser[section.name]["url"].strip("\"' ")  # Strip quotes and whitespace
-
-                    # Ensure values are not empty after stripping
-                    if name and url:
-                        logger.info(f"Found valid PyPI source in section '[{section.name}]': name='{name}', url='{url}'")
-                        return PyPiSource(name=name, url=url)
-                    else:
-                        logger.debug(f"Section '[{section.name}]' contains 'name' and 'url' keys, but one or both values are empty.")
-                else:
-                    logger.debug(f"Section '[{section.name}]' does not contain both 'name' and 'url' keys.")
-
-            except configparser.Error as e:
-                # This might happen if the section content is not valid INI/config format
-                # or if the section name itself causes issues (though get_toml_sections should handle it)
-                logger.debug(f"Could not parse section '[{section.name}]' with configparser: {e}")
-                # Continue to the next section
-                continue
-
-        logger.info("No suitable PyPI source section found in the provided TOML content.")
-        return None
-
     @staticmethod
     def from_pyproject(project_dir: Path) -> Optional[PyPiSource]:
-        """Reads pyproject.toml or Pipfile and finds the PyPI source configuration without relying on a specific section name."""
         pyproject_toml = project_dir / "pyproject.toml"
         pipfile = project_dir / "Pipfile"
-        content = None
-        file_checked = None
-
         if pyproject_toml.exists():
-            logger.debug(f"Checking for PyPI source in {pyproject_toml}")
-            content = pyproject_toml.read_text()
-            file_checked = pyproject_toml
+            return PyPiSourceParser.from_toml_content(pyproject_toml.read_text(), "tool.poetry.source")
         elif pipfile.exists():
-            logger.debug(f"Checking for PyPI source in {pipfile}")
-            content = pipfile.read_text()
-            file_checked = pipfile
-
-        if content:
-            source = PyPiSourceParser.find_pypi_source_in_content(content)
-            if source:
-                return source
-            else:
-                logger.debug(f"No PyPI source definition found in {file_checked}")
-                return None
+            return PyPiSourceParser.from_toml_content(pipfile.read_text(), "source")
         else:
-            logger.debug("Neither pyproject.toml nor Pipfile found in the project directory.")
             return None
 
+    @staticmethod
+    def from_toml_content(content: str, source_section_name: str) -> Optional[PyPiSource]:
+        sections = PyPiSourceParser.get_toml_sections(content)
+        for section in sections:
+            if section.name == source_section_name:
+                try:
+                    parser = configparser.ConfigParser()
+                    parser.read_string(str(section))
+                    name = parser[section.name]["name"].strip('"')
+                    url = parser[section.name]["url"].strip('"')
+                    return PyPiSource(name, url)
+                except KeyError:
+                    raise UserNotificationException(
+                        f"Could not parse PyPi source from section {section.name}. "
+                        f"Please make sure the section has the following format:\n"
+                        f"[{source_section_name}]\nname = 'name'\nurl = 'https://url'\nverify_ssl = true"
+                    ) from None
+        return None
+
     @staticmethod
     def get_toml_sections(toml_content: str) -> List[TomlSection]:
         # Use a regular expression to find all sections with [ or [[ at the beginning of the line
@@ -151,6 +175,118 @@ class PyPiSourceParser:
         return sections
 
 
+class Runnable(ABC):
+    @abstractmethod
+    def run(self) -> int:
+        """Run stage."""
+
+    @abstractmethod
+    def get_name(self) -> str:
+        """Get stage name."""
+
+    @abstractmethod
+    def get_inputs(self) -> List[Path]:
+        """Get stage dependencies."""
+
+    @abstractmethod
+    def get_outputs(self) -> List[Path]:
+        """Get stage outputs."""
+
+    def get_config(self) -> Optional[dict[str, Any]]:
+        """Get stage configuration for change detection."""
+        return None
+
+
+class RunInfoStatus(Enum):
+    MATCH = (False, "Nothing has changed, previous execution information matches.")
+    NO_INFO = (True, "No previous execution information found.")
+    FILE_CHANGED = (True, "Dependencies have been changed.")
+    CONFIG_CHANGED = (True, "Configuration has been changed.")
+
+    def __init__(self, should_run: bool, message: str) -> None:
+        self.should_run = should_run
+        self.message = message
+
+
+class Executor:
+    """
+    Accepts Runnable objects and executes them.
+
+    It create a file with the same name as the runnable's name
+    and stores the inputs and outputs with their hashes.
+    If the file exists, it checks the hashes of the inputs and outputs
+    and if they match, it skips the execution.
+    """
+
+    RUN_INFO_FILE_EXTENSION = ".deps.json"
+
+    def __init__(self, cache_dir: Path) -> None:
+        self.cache_dir = cache_dir
+
+    @staticmethod
+    def get_file_hash(path: Path) -> str:
+        """
+        Get the hash of a file.
+
+        Returns an empty string if the file does not exist.
+        """
+        if path.is_file():
+            with open(path, "rb") as file:
+                bytes = file.read()
+                readable_hash = hashlib.sha256(bytes).hexdigest()
+                return readable_hash
+        else:
+            return ""
+
+    def store_run_info(self, runnable: Runnable) -> None:
+        file_info = {
+            "inputs": {str(path): self.get_file_hash(path) for path in runnable.get_inputs()},
+            "outputs": {str(path): self.get_file_hash(path) for path in runnable.get_outputs()},
+            "config": runnable.get_config() or {},
+        }
+
+        run_info_path = self.get_runnable_run_info_file(runnable)
+        run_info_path.parent.mkdir(parents=True, exist_ok=True)
+        with run_info_path.open("w") as f:
+            # pretty print the json file
+            json.dump(file_info, f, indent=4)
+
+    def get_runnable_run_info_file(self, runnable: Runnable) -> Path:
+        return self.cache_dir / f"{runnable.get_name()}{self.RUN_INFO_FILE_EXTENSION}"
+
+    def previous_run_info_matches(self, runnable: Runnable) -> RunInfoStatus:
+        run_info_path = self.get_runnable_run_info_file(runnable)
+        if not run_info_path.exists():
+            return RunInfoStatus.NO_INFO
+
+        with run_info_path.open() as f:
+            previous_info = json.load(f)
+
+        # Check if config has changed
+        current_config = runnable.get_config() or {}
+        previous_config = previous_info.get("config", {})
+        if current_config != previous_config:
+            return RunInfoStatus.CONFIG_CHANGED
+
+        for file_type in ["inputs", "outputs"]:
+            for path_str, previous_hash in previous_info[file_type].items():
+                path = Path(path_str)
+                if self.get_file_hash(path) != previous_hash:
+                    return RunInfoStatus.FILE_CHANGED
+        return RunInfoStatus.MATCH
+
+    def execute(self, runnable: Runnable) -> int:
+        run_info_status = self.previous_run_info_matches(runnable)
+        if run_info_status.should_run:
+            logger.info(f"Executing '{runnable.get_name()}': {run_info_status.message}")
+            exit_code = runnable.run()
+            self.store_run_info(runnable)
+            return exit_code
+        logger.info(f"Skipping '{runnable.get_name()}': {run_info_status.message}")
+
+        return 0
+
+
 class UserNotificationException(Exception):
     pass
 
@@ -158,7 +294,7 @@ class UserNotificationException(Exception):
 class SubprocessExecutor:
     def __init__(
         self,
-        command: List[str | Path],
+        command: Sequence[str | Path],
         cwd: Optional[Path] = None,
         capture_output: bool = True,
     ):
@@ -173,7 +309,12 @@ class SubprocessExecutor:
             logger.info(f"Running command: {self.command} in {current_dir}")
             # print all virtual environment variables
             logger.debug(json.dumps(dict(os.environ), indent=4))
-            result = subprocess.run(self.command.split(), cwd=current_dir, capture_output=self.capture_output, text=True)  # noqa: S603
+            result = subprocess.run(
+                self.command.split(),  # noqa: S603
+                cwd=current_dir,
+                capture_output=self.capture_output,
+                text=True,  # to get stdout and stderr as strings instead of bytes
+            )
             result.check_returncode()
         except subprocess.CalledProcessError as e:
             raise UserNotificationException(f"Command '{self.command}' failed with:\n{result.stdout if result else ''}\n{result.stderr if result else e}") from e
@@ -196,8 +337,9 @@ class VirtualEnvironment(ABC):
         except PermissionError as e:
             if "python.exe" in str(e):
                 raise UserNotificationException(
-                    f"Failed to create virtual environment in {self.venv_dir}.\nVirtual environment python.exe is still running."
-                    f" Please kill all instances and run again.\nError: {e}"
+                    f"Failed to create virtual environment in {self.venv_dir}.\n"
+                    f"Virtual environment python.exe is still running. "
+                    f"Please kill all instances and run again.\nError: {e}"
                 ) from e
             raise UserNotificationException(f"Failed to create virtual environment in {self.venv_dir}.\nPlease make sure you have the necessary permissions.\nError: {e}") from e
 
@@ -211,8 +353,8 @@ class VirtualEnvironment(ABC):
         """
         Configure pip to use the given index URL and SSL verification setting.
 
-        This method should behave as if the user had activated the virtual environment
-        and run `pip config set global.index-url <index_url>` and
+        This method should behave as if the user had activated the virtual environment and run
+        `pip config set global.index-url <index_url>` and
         `pip config set global.cert <verify_ssl>` from the command line.
 
         Args:
@@ -230,6 +372,10 @@ class VirtualEnvironment(ABC):
     def pip(self, args: List[str]) -> None:
         SubprocessExecutor([self.pip_path().as_posix(), *args]).execute()
 
+    @abstractmethod
+    def python_path(self) -> Path:
+        """Get the path to the Python executable within the virtual environment."""
+
     @abstractmethod
     def pip_path(self) -> Path:
         """Get the path to the pip executable within the virtual environment."""
@@ -239,120 +385,341 @@ class VirtualEnvironment(ABC):
         """Get the path to the pip configuration file within the virtual environment."""
 
     @abstractmethod
-    def run(self, args: List[str], capture_output: bool = True) -> None:
+    def scripts_path(self) -> Path:
+        """Get the path to the Scripts (Windows) or bin (Unix) directory within the virtual environment."""
+
+    def run(self, args: List[str], capture_output: bool = True, cwd: Optional[Path] = None) -> None:
         """
-        Run an arbitrary command within the virtual environment.
+        Run an arbitrary command within the virtual environment using the venv's Python.
 
-        This method should behave as if the user had activated the virtual environment
-        and run the given command from the command line.
+        If the first argument is 'python', it will be replaced with the full path
+        to the virtual environment's Python executable.
+
+        Args:
+        ----
+            args: Command-line arguments. For example, `run(['python', '-m', 'poetry', 'install'])`
+            capture_output: Whether to capture stdout/stderr.
+            cwd: Working directory for the command.
 
         """
+        command = list(args)
+        if command and command[0] == "python":
+            command[0] = self.python_path().as_posix()
+        SubprocessExecutor(command, cwd=cwd, capture_output=capture_output).execute()
 
 
 class WindowsVirtualEnvironment(VirtualEnvironment):
     def __init__(self, venv_dir: Path) -> None:
         super().__init__(venv_dir)
-        self.activate_script = self.venv_dir.joinpath("Scripts/activate")
+
+    def python_path(self) -> Path:
+        return self.scripts_path().joinpath("python.exe")
 
     def pip_path(self) -> Path:
-        return self.venv_dir.joinpath("Scripts/pip.exe")
+        return self.scripts_path().joinpath("pip.exe")
 
     def pip_config_path(self) -> Path:
         return self.venv_dir.joinpath("pip.ini")
 
-    def run(self, args: List[str], capture_output: bool = True) -> None:
-        SubprocessExecutor(
-            command=[f"cmd /c {self.activate_script.as_posix()} && ", *args],
-            capture_output=capture_output,
-        ).execute()
+    def scripts_path(self) -> Path:
+        return self.venv_dir.joinpath("Scripts")
 
 
 class UnixVirtualEnvironment(VirtualEnvironment):
     def __init__(self, venv_dir: Path) -> None:
         super().__init__(venv_dir)
-        self.activate_script = self.venv_dir.joinpath("bin/activate")
+
+    def python_path(self) -> Path:
+        return self.scripts_path().joinpath("python")
 
     def pip_path(self) -> Path:
-        return self.venv_dir.joinpath("bin/pip")
+        return self.scripts_path().joinpath("pip")
 
     def pip_config_path(self) -> Path:
         return self.venv_dir.joinpath("pip.conf")
 
-    def run(self, args: List[str], capture_output: bool = True) -> None:
-        # Create a temporary shell script
-        with tempfile.NamedTemporaryFile("w", delete=False, suffix=".sh") as f:
-            f.write("#!/bin/bash\n")  # Add a shebang line
-            f.write(f"source {self.activate_script.as_posix()}\n")  # Write the activate command
-            f.write(" ".join(args))  # Write the provided command
-            temp_script_path = f.name  # Get the path of the temporary script
-
-        # Make the temporary script executable
-        SubprocessExecutor(["chmod", "+x", temp_script_path]).execute()
-        # Run the temporary script
-        SubprocessExecutor(
-            command=[f"{Path(temp_script_path).as_posix()}"],
-            capture_output=capture_output,
-        ).execute()
-        # Delete the temporary script
-        os.remove(temp_script_path)
-
-
-class CreateVirtualEnvironment:
-    def __init__(self, root_dir: Path, package_manager: str, skip_venv_creation: bool = False) -> None:
+    def scripts_path(self) -> Path:
+        return self.venv_dir.joinpath("bin")
+
+
+def instantiate_os_specific_venv(venv_dir: Path) -> VirtualEnvironment:
+    """Create an OS-specific VirtualEnvironment instance."""
+    if sys.platform.startswith("win32"):
+        return WindowsVirtualEnvironment(venv_dir)
+    elif sys.platform.startswith("linux") or sys.platform.startswith("darwin"):
+        return UnixVirtualEnvironment(venv_dir)
+    else:
+        raise UserNotificationException(f"Unsupported operating system: {sys.platform}")
+
+
+def extract_package_manager_name(package_manager_spec: str) -> str:
+    """Extract the package manager name from a specification like 'poetry>=1.7.1'."""
+    match = re.match(r"^([a-zA-Z0-9_-]+)", package_manager_spec)
+    if match:
+        return match.group(1)
+    raise UserNotificationException(f"Could not extract the package manager name from {package_manager_spec}")
+
+
+class CreateBootstrapEnvironment(Runnable):
+    """
+    Creates a shared bootstrap environment with the package manager installed.
+
+    The bootstrap environment is stored in a user-level cache directory
+    (default: ~/.bootstrap/<hash>/) and is shared across projects with
+    the same configuration.
+    """
+
+    def __init__(self, config: BootstrapConfig, project_dir: Path) -> None:
+        self.config = config
+        self.project_dir = project_dir
+        self.env_hash = config.compute_bootstrap_env_hash()
+        self.bootstrap_env_dir = config.get_bootstrap_cache_dir() / self.env_hash
+        self.venv_dir = self.bootstrap_env_dir / ".venv"
+        self.virtual_env = instantiate_os_specific_venv(self.venv_dir)
+        self.marker_file = self.bootstrap_env_dir / BOOTSTRAP_COMPLETE_MARKER
+
+    def run(self) -> int:
+        self._create_environment_atomic()
+        return 0
+
+    def _is_valid_environment(self) -> bool:
+        """Check if the bootstrap environment exists and is valid."""
+        if not self.marker_file.exists():
+            return False
+
+        try:
+            stored_hash = self.marker_file.read_text().strip()
+            if stored_hash != self.env_hash:
+                logger.info(f"Bootstrap environment hash mismatch: {stored_hash} != {self.env_hash}")
+                return False
+        except OSError:
+            return False
+
+        if not self.virtual_env.pip_path().exists():
+            logger.info("Bootstrap environment pip not found, will recreate.")
+            return False
+
+        return True
+
+    def _create_environment_atomic(self) -> None:
+        """Create the bootstrap environment, replacing any existing invalid environment."""
+        try:
+            # Remove existing directory if present (invalid or leftover from failed attempt)
+            if self.bootstrap_env_dir.exists():
+                logger.info(f"Removing existing bootstrap environment at {self.bootstrap_env_dir}")
+                shutil.rmtree(self.bootstrap_env_dir)
+
+            # Create bootstrap environment directory
+            self.bootstrap_env_dir.mkdir(parents=True, exist_ok=True)
+            bootstrap_venv = instantiate_os_specific_venv(self.venv_dir)
+
+            logger.info(f"Creating bootstrap environment in {self.bootstrap_env_dir}")
+            venv.create(env_dir=self.venv_dir, with_pip=True)
+
+            # Configure pip with PyPI source if available
+            pypi_source = PyPiSourceParser.from_pyproject(self.project_dir)
+            if pypi_source:
+                bootstrap_venv.pip_configure(index_url=pypi_source.url, verify_ssl=True)
+
+            # Build pip install arguments
+            packages_to_install = [self.config.package_manager, *self.config.bootstrap_packages]
+            pip_args = ["install", *packages_to_install]
+
+            # Handle SSL certificates for older pip versions
+            if Version(ensurepip.version()) < Version("24.2"):
+                if pypi_source and (hostname := urlparse(pypi_source.url).hostname):
+                    pip_args.extend(["--trusted-host", hostname])
+                else:
+                    pip_args.extend(
+                        [
+                            "--trusted-host",
+                            "pypi.org",
+                            "--trusted-host",
+                            "pypi.python.org",
+                            "--trusted-host",
+                            "files.pythonhosted.org",
+                        ]
+                    )
+
+            logger.info(f"Installing bootstrap packages: {packages_to_install}")
+            bootstrap_venv.pip(pip_args)
+
+            # Write the completion marker
+            marker_path = self.bootstrap_env_dir / BOOTSTRAP_COMPLETE_MARKER
+            marker_path.write_text(self.env_hash)
+
+            # Update the virtual_env reference
+            self.virtual_env = instantiate_os_specific_venv(self.venv_dir)
+
+            logger.info(f"Bootstrap environment created successfully at {self.bootstrap_env_dir}")
+
+        except Exception as exc:
+            logger.error(f"Bootstrap environment creation failed at {self.bootstrap_env_dir}")
+            raise UserNotificationException(f"Failed to create bootstrap environment: {exc}") from exc
+
+    def get_name(self) -> str:
+        return "create-bootstrap-environment"
+
+    def get_inputs(self) -> List[Path]:
+        # No file-based inputs for shared bootstrap environment
+        return []
+
+    def get_outputs(self) -> List[Path]:
+        return [self.marker_file]
+
+    def get_config(self) -> Optional[dict[str, Any]]:
+        """Return configuration that affects the bootstrap environment."""
+        return {
+            "package_manager": self.config.package_manager,
+            "bootstrap_packages": sorted(self.config.bootstrap_packages),
+            "python_version": self.config.python_version,
+        }
+
+
+class CreateVirtualEnvironment(Runnable):
+    """Creates the project virtual environment using the bootstrap environment's package manager."""
+
+    def __init__(
+        self,
+        root_dir: Path,
+        bootstrap_env: CreateBootstrapEnvironment,
+    ) -> None:
         self.root_dir = root_dir
         self.venv_dir = self.root_dir / ".venv"
-        self.virtual_env = self.instantiate_os_specific_venv(self.venv_dir)
-        self.package_manager = package_manager.replace('"', "").replace("'", "")
-        self.execution_info_file = self.venv_dir / "virtual_env_exec_info.json"
-        self.skip_venv_creation = skip_venv_creation
+        self.bootstrap_dir = self.root_dir / ".bootstrap"
+        self.virtual_env = instantiate_os_specific_venv(self.venv_dir)
+        self.bootstrap_env = bootstrap_env
+        self.config = bootstrap_env.config
+        self.python_version_marker = self.venv_dir / VENV_PYTHON_VERSION_MARKER
 
     @property
     def package_manager_name(self) -> str:
-        match = re.match(r"^([a-zA-Z0-9_-]+)", self.package_manager)
-        if match:
-            return match.group(1)
-        else:
-            raise UserNotificationException(f"Could not extract the package manager name from {self.package_manager}")
+        return extract_package_manager_name(self.config.package_manager)
 
-    def get_install_argument(self) -> str:
-        """Determine the install argument based on the package manager name."""
+    def _check_python_version_compatibility(self) -> None:
+        """
+        Check if the existing venv was created with the same Python version.
+
+        If the Python version has changed (e.g., switching branches), delete the
+        existing venv so it can be recreated by the package manager.
+        """
+        if not self.venv_dir.exists():
+            return
+
+        current_version = f"{sys.version_info.major}.{sys.version_info.minor}.{sys.version_info.micro}"
+
+        if not self.python_version_marker.exists():
+            logger.info(
+                f"No Python version marker found in {self.venv_dir}. "
+                f"This venv may have been created before version tracking was added. "
+                f"Deleting {self.venv_dir} to ensure clean state."
+            )
+            shutil.rmtree(self.venv_dir)
+            return
+
+        try:
+            stored_version = self.python_version_marker.read_text().strip()
+            if stored_version != current_version:
+                logger.info(f"Python version changed from {stored_version} to {current_version}. Deleting {self.venv_dir} for recreation.")
+                shutil.rmtree(self.venv_dir)
+        except OSError as exc:
+            logger.warning(f"Could not read Python version marker: {exc}")
+
+    def _write_python_version_marker(self, version: str) -> None:
+        """Write the Python version marker to track the venv's Python version."""
+        try:
+            self.python_version_marker.write_text(version)
+        except OSError as exc:
+            logger.warning(f"Could not write Python version marker: {exc}")
+
+    def _ensure_in_project_venv(self) -> None:
+        """Configure package managers to create venv in-project (.venv in repository)."""
+        if self.package_manager_name == "poetry":
+            # Set environment variable for poetry to create venv in-project
+            os.environ["POETRY_VIRTUALENVS_IN_PROJECT"] = "true"
+        elif self.package_manager_name == "pipenv":
+            # Set environment variable for pipenv
+            os.environ["PIPENV_VENV_IN_PROJECT"] = "1"
+        # UV creates .venv in-project by default, no configuration needed
+
+    def _ensure_correct_python_version(self) -> None:
+        """Ensure the correct Python version is used in the virtual environment."""
+        if self.package_manager_name == "poetry":
+            # Make Poetry use the Python interpreter it's being run with
+            os.environ["POETRY_VIRTUALENVS_PREFER_ACTIVE_PYTHON"] = "false"
+            os.environ["POETRY_VIRTUALENVS_USE_POETRY_PYTHON"] = "true"
+
+    def _get_install_argument(self) -> str:
         if self.package_manager_name == "uv":
             return "sync"
         return "install"
 
+    def _get_install_command(self) -> List[str]:
+        if self.config.venv_install_command:
+            return self.config.venv_install_command.split()
+
+        return [
+            str(self.bootstrap_env.virtual_env.scripts_path() / self.package_manager_name),
+            self._get_install_argument(),
+            *self.config.package_manager_args,
+        ]
+
     def run(self) -> int:
-        if not self.skip_venv_creation:
-            self.virtual_env.create()
-        else:
-            logger.info("Skipping virtual environment creation as requested.")
+        self._check_python_version_compatibility()
+        self._ensure_in_project_venv()
+        self._ensure_correct_python_version()
 
         # Get the PyPi source from pyproject.toml or Pipfile if it is defined
         pypi_source = PyPiSourceParser.from_pyproject(self.root_dir)
-        if pypi_source:
+
+        # Use the bootstrap environment's package manager to install dependencies
+        # The package manager will create the .venv if it doesn't exist
+        logger.info(f"Using bootstrap environment at {self.bootstrap_env.venv_dir}")
+        self.bootstrap_env.virtual_env.run(self._get_install_command(), capture_output=True, cwd=self.root_dir)
+
+        # Write Python version marker after package manager creates/updates venv
+        if self.venv_dir.exists():
+            current_version = f"{sys.version_info.major}.{sys.version_info.minor}.{sys.version_info.micro}"
+            self._write_python_version_marker(current_version)
+
+        # Configure pip if needed (after venv is created by package manager)
+        if pypi_source and self.venv_dir.exists():
             self.virtual_env.pip_configure(index_url=pypi_source.url, verify_ssl=True)
-        # We need pip-system-certs in venv to use certificates, that are stored in the system's trust store,
-        pip_args = ["install", self.package_manager, "pip-system-certs>=4.0,<5.0"]
-        # but to install it, we need either a pip version with the trust store feature or to trust the host
-        # (trust store feature enabled by default since 24.2)
-        if Version(ensurepip.version()) < Version("24.2"):
-            # Add trusted host of configured source for older Python versions
-            if pypi_source and pypi_source.url:
-                if hostname := urlparse(pypi_source.url).hostname:
-                    pip_args.extend(["--trusted-host", hostname])
-            else:
-                pip_args.extend(["--trusted-host", "pypi.org", "--trusted-host", "pypi.python.org", "--trusted-host", "files.pythonhosted.org"])
-        self.virtual_env.pip(pip_args)
-        self.virtual_env.run(["python", "-m", self.package_manager_name, self.get_install_argument()])
+
         return 0
 
-    @staticmethod
-    def instantiate_os_specific_venv(venv_dir: Path) -> VirtualEnvironment:
-        if sys.platform.startswith("win32"):
-            return WindowsVirtualEnvironment(venv_dir)
-        elif sys.platform.startswith("linux") or sys.platform.startswith("darwin"):
-            return UnixVirtualEnvironment(venv_dir)
-        else:
-            raise UserNotificationException(f"Unsupported operating system: {sys.platform}")
+    def get_name(self) -> str:
+        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]
+
+    def get_outputs(self) -> List[Path]:
+        """
+        Return the Scripts/bin directories for both bootstrap and project environments.
+
+        These paths are recorded in the .deps.json file, allowing other tools to discover
+        the package manager location (bootstrap env) and project tools (project env).
+        """
+        return [
+            self.virtual_env.scripts_path(),
+            self.bootstrap_env.virtual_env.scripts_path(),
+        ]
 
 
 def print_environment_info() -> None:
@@ -388,11 +755,42 @@ def main() -> int:
             default=False,
             help="Skip the virtual environment creation process.",
         )
+        parser.add_argument(
+            "--config",
+            type=Path,
+            required=False,
+            help="Path to bootstrap.json configuration file.",
+        )
         args = parser.parse_args()
 
-        CreateVirtualEnvironment(args.project_dir, package_manager=args.package_manager, skip_venv_creation=args.skip_venv_creation).run()
-    except UserNotificationException as e:
-        logger.error(e)
+        project_dir = args.project_dir
+
+        # Load configuration from bootstrap.json if provided, otherwise use CLI args
+        if args.config:
+            config_path = args.config if args.config.is_absolute() else project_dir / args.config
+            config = BootstrapConfig.from_json_file(config_path)
+        else:
+            # Use CLI arguments for backward compatibility
+            config = BootstrapConfig(
+                package_manager=args.package_manager,
+            )
+
+        # Step 1: Create the bootstrap environment (shared cache)
+        bootstrap_env = CreateBootstrapEnvironment(config, project_dir)
+        bootstrap_executor = Executor(bootstrap_env.bootstrap_env_dir)
+        bootstrap_executor.execute(bootstrap_env)
+
+        # Step 2: Create the project virtual environment using the bootstrap env
+        # Skip if requested (e.g., when running from within the venv)
+        if not args.skip_venv_creation:
+            project_venv = CreateVirtualEnvironment(project_dir, bootstrap_env)
+            project_executor = Executor(project_venv.venv_dir)
+            project_executor.execute(project_venv)
+        else:
+            logger.info("Skipping virtual environment creation as requested.")
+
+    except UserNotificationException as exc:
+        logger.error(exc)
         return 1
     return 0
 

pypeline/main.py

@@ -41,7 +41,7 @@ def init(
     project_dir: Path = typer.Option(Path.cwd().absolute(), help="The project directory"),  # noqa: B008
     force: bool = typer.Option(False, help="Force the initialization of the project even if the directory is not empty."),
 ) -> None:
-    KickstartProject(project_dir, force).run()
+    KickstartProject(project_dir.absolute(), force).run()
 
 
 @app.command()
@@ -61,6 +61,7 @@ def run(
         help="Provide input parameters as key=value pairs (e.g., -i name=value -i flag=true).",
     ),
 ) -> None:
+    project_dir = project_dir.absolute()
     project_slurper = ProjectSlurper(project_dir, config_file)
     if print:
         logger.info("Pipeline steps:")

pypeline/steps/create_venv.py

@@ -1,6 +1,7 @@
 import io
 import json
 import re
+import shutil
 import sys
 import traceback
 from dataclasses import dataclass
@@ -24,7 +25,13 @@ from ..domain.pipeline import PipelineStep
 class CreateVEnvConfig(DataClassDictMixin):
     bootstrap_script: Optional[str] = None
     python_executable: Optional[str] = None
+    # Bootstrap-specific configuration
     package_manager: Optional[str] = None
+    python_version: Optional[str] = None
+    package_manager_args: Optional[List[str]] = None
+    bootstrap_packages: Optional[List[str]] = None
+    bootstrap_cache_dir: Optional[str] = None
+    venv_install_command: Optional[str] = None
 
 
 class BootstrapScriptType(Enum):
@@ -63,9 +70,100 @@ class CreateVEnv(PipelineStep[ExecutionContext]):
         self.logger = logger.bind()
         self.internal_bootstrap_script = get_bootstrap_script()
         self.package_manager = self.user_config.package_manager if self.user_config.package_manager else self.DEFAULT_PACKAGE_MANAGER
-        self.python_executable = self.user_config.python_executable if self.user_config.python_executable else self.DEFAULT_PYTHON_EXECUTABLE
         self.venv_dir = self.project_root_dir / ".venv"
 
+    @property
+    def has_bootstrap_config(self) -> bool:
+        """Check if user provided any bootstrap-specific configuration."""
+        return any(
+            [
+                self.user_config.package_manager,
+                self.user_config.python_version,
+                self.user_config.package_manager_args,
+                self.user_config.bootstrap_packages,
+                self.user_config.bootstrap_cache_dir,
+                self.user_config.venv_install_command,
+            ]
+        )
+
+    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
+
+        Always ignores patch version. No fallbacks to generic python.
+
+        Returns the first executable found in PATH, or None if not found.
+        """
+        # Handle empty string
+        if not python_version:
+            return None
+
+        # Parse version string and extract components
+        version_parts = python_version.split(".")
+
+        if len(version_parts) == 0:
+            return None
+
+        major = version_parts[0]
+
+        # Determine candidates based on version format
+        candidates = []
+
+        if len(version_parts) >= 2:
+            # Has minor version (e.g., "3.11" or "3.11.5") - ignore patch
+            minor = version_parts[1]
+            major_minor = f"{major}.{minor}"
+            major_minor_no_dot = f"{major}{minor}"
+
+            candidates = [
+                f"python{major_minor}",  # python3.11 (Linux/Mac preference)
+                f"python{major_minor_no_dot}",  # python311 (Windows preference)
+            ]
+        else:
+            # Only major version (e.g., "3")
+            candidates = [f"python{major}"]
+
+        # Try to find each candidate in PATH
+        for candidate in candidates:
+            executable_path = shutil.which(candidate)
+            if executable_path:
+                self.logger.debug(f"Found Python executable: {executable_path} (candidate: {candidate})")
+                return candidate
+
+        # No fallback - return None if specific version not found
+        return None
+
+    @property
+    def python_executable(self) -> str:
+        """
+        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)
+        """
+        # Priority 1: User explicitly specified executable
+        if self.user_config.python_executable:
+            return self.user_config.python_executable
+
+        # Priority 2: Auto-detect from python_version
+        if self.user_config.python_version:
+            found_executable = self._find_python_executable(self.user_config.python_version)
+            if found_executable:
+                return found_executable
+            # If version specified but not found, fail with helpful error
+            raise UserNotificationException(
+                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
+        return sys.executable
+
     @property
     def install_dirs(self) -> List[Path]:
         deps_file = self.project_root_dir / ".venv" / "create-virtual-environment.deps.json"
@@ -91,6 +189,10 @@ class CreateVEnv(PipelineStep[ExecutionContext]):
     def target_internal_bootstrap_script(self) -> Path:
         return self.project_root_dir.joinpath(".bootstrap/bootstrap.py")
 
+    @property
+    def bootstrap_config_file(self) -> Path:
+        return self.project_root_dir / ".bootstrap/bootstrap.json"
+
     def get_name(self) -> str:
         return self.__class__.__name__
 
@@ -98,6 +200,7 @@ class CreateVEnv(PipelineStep[ExecutionContext]):
         self.logger.debug(f"Run {self.get_name()} step. Output dir: {self.output_dir}")
 
         if self.user_config.bootstrap_script:
+            # User provided a custom bootstrap script - run it directly
             bootstrap_script = self.project_root_dir / self.user_config.bootstrap_script
             if not bootstrap_script.exists():
                 raise UserNotificationException(f"Bootstrap script {bootstrap_script} does not exist.")
@@ -106,19 +209,44 @@ class CreateVEnv(PipelineStep[ExecutionContext]):
                 cwd=self.project_root_dir,
             ).execute()
         else:
+            # Use internal bootstrap script
             skip_venv_creation = False
             python_executable = Path(sys.executable).absolute()
             if python_executable.is_relative_to(self.project_root_dir):
                 self.logger.info(f"Detected that the python executable '{python_executable}' is from the virtual environment. Skip updating the virtual environment.")
                 skip_venv_creation = True
 
-            # The internal bootstrap script supports arguments.
+            # Create bootstrap.json with all configuration
+            bootstrap_config = {}
+            if self.user_config.package_manager:
+                bootstrap_config["python_package_manager"] = self.user_config.package_manager
+            if 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:
+                bootstrap_config["bootstrap_packages"] = self.user_config.bootstrap_packages
+            if self.user_config.bootstrap_cache_dir:
+                bootstrap_config["bootstrap_cache_dir"] = self.user_config.bootstrap_cache_dir
+            if self.user_config.venv_install_command:
+                bootstrap_config["venv_install_command"] = self.user_config.venv_install_command
+
+            # Write bootstrap.json if any configuration is provided
+            if bootstrap_config:
+                self.bootstrap_config_file.parent.mkdir(exist_ok=True)
+                self.bootstrap_config_file.write_text(json.dumps(bootstrap_config, indent=2))
+                self.logger.info(f"Created bootstrap configuration at {self.bootstrap_config_file}")
+
+            # Build bootstrap script arguments
             bootstrap_args = [
                 "--project-dir",
                 self.project_root_dir.as_posix(),
-                "--package-manager",
-                f'"{self.package_manager}"',
             ]
+
+            # Always use --config if bootstrap.json exists
+            if self.bootstrap_config_file.exists():
+                bootstrap_args.extend(["--config", self.bootstrap_config_file.as_posix()])
+
             if skip_venv_creation:
                 bootstrap_args.append("--skip-venv-creation")
 
@@ -138,12 +266,19 @@ class CreateVEnv(PipelineStep[ExecutionContext]):
 
     def get_inputs(self) -> List[Path]:
         package_manager_relevant_file = self.SUPPORTED_PACKAGE_MANAGERS.get(self.package_manager_name, [])
-        return [self.project_root_dir / file for file in package_manager_relevant_file]
+        inputs = [self.project_root_dir / file for file in package_manager_relevant_file]
+        # Include bootstrap.json if it exists
+        if self.bootstrap_config_file.exists():
+            inputs.append(self.bootstrap_config_file)
+        return inputs
 
     def get_outputs(self) -> List[Path]:
         outputs = [self.venv_dir]
         if self.bootstrap_script_type == BootstrapScriptType.INTERNAL:
             outputs.append(self.target_internal_bootstrap_script)
+            # Include bootstrap.json if it will be created
+            if self.has_bootstrap_config:
+                outputs.append(self.bootstrap_config_file)
         return outputs
 
     def get_config(self) -> Optional[dict[str, str]]:
@@ -157,4 +292,6 @@ class CreateVEnv(PipelineStep[ExecutionContext]):
         self.execution_context.add_install_dirs(self.install_dirs)
 
     def get_needs_dependency_management(self) -> bool:
-        return False if self.bootstrap_script_type == BootstrapScriptType.CUSTOM else True
+        # Always return False - the bootstrap script handles dependency management internally
+        # via its Executor framework which checks input/output hashes and configuration changes
+        return False

pypeline/steps/scoop_install.py

@@ -1,5 +1,6 @@
 import io
 import json
+import platform
 import traceback
 from dataclasses import dataclass, field
 from pathlib import Path
@@ -69,6 +70,12 @@ class ScoopInstall(PipelineStep[ExecutionContext]):
 
     def run(self) -> int:
         self.logger.debug(f"Run {self.get_name()} step. Output dir: {self.output_dir}")
+
+        if platform.system() != "Windows":
+            self.logger.warning(f"ScoopInstall skipped on non-Windows platform ({platform.system()}).")
+            self.execution_info.to_json_file(self.execution_info_file)
+            return 0
+
         installed_apps = create_scoop_wrapper().install(self.scoop_file)
         self.logger.debug("Installed apps:")
         for app in installed_apps:

{pypeline_runner-1.20.0.dist-info → pypeline_runner-1.21.1.dist-info}/METADATA

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

{pypeline_runner-1.20.0.dist-info → pypeline_runner-1.21.1.dist-info}/RECORD

@@ -1,7 +1,7 @@
-pypeline/__init__.py,sha256=Hww1duZrC8kYK7ThBSQVyz0HNOb0ys_o8Pln-wVQ1hI,23
+pypeline/__init__.py,sha256=8XWiNC6QmLA2L7-p8EH42hl-pCAiZP4bTGm0gwwB3vI,23
 pypeline/__run.py,sha256=TCdaX05Qm3g8T4QYryKB25Xxf0L5Km7hFOHe1mK9vI0,350
 pypeline/bootstrap/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-pypeline/bootstrap/run.py,sha256=pi9Kyordk4-Hwz8BsLpOTNu-hJV4imPgOrjPSr9_qRA,16446
+pypeline/bootstrap/run.py,sha256=-DP9os7i5QaxmYdp_kGnEAhMFCILv1YCRwiYxut3lEc,31394
 pypeline/domain/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 pypeline/domain/artifacts.py,sha256=5k7cVfHhLmvWXNuHKxXb9ca4Lxu0JytGQqazENCeKEU,1404
 pypeline/domain/config.py,sha256=6vWdHi7B6MA7NGi9wWXQE-YhSg1COSRmc3b1ji6AdAk,2053
@@ -17,16 +17,16 @@ pypeline/kickstart/templates/project/pypeline.yaml,sha256=KKqRqxH7emAuZI1FBC-ITL
 pypeline/kickstart/templates/project/pyproject.toml,sha256=7hAoK6BammBxxoolMdCkNx7qPSFFiFUkQN8oAbCf7Yk,271
 pypeline/kickstart/templates/project/steps/my_step.py,sha256=b-JEwF9EyF4G6lgvkk3I2aT2wpD_zQ2fTiQrR6lWhs4,788
 pypeline/kickstart/templates/project/west.yaml,sha256=ZfVym7M4yzzC-Nm0vESdhqNYs6EaJuMQWGJBht_i0b4,188
-pypeline/main.py,sha256=2mC2BDB1OWIXhaijBXG6Y1vfT8_yMZ4Dj55w5u7g7-w,4158
+pypeline/main.py,sha256=k1CkeFGRvQ-zLv6C-AMLC2ed1iyFzDUdvEam3HLHy2E,4210
 pypeline/py.typed,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 pypeline/pypeline.py,sha256=mDKUnTuMDw8l-kSDJCHRNbn6zrxAfXhAIAqc5HyHd5M,8758
 pypeline/steps/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-pypeline/steps/create_venv.py,sha256=QAERJItdeHU0gEW4bOEd2P5eBOMttgx8X4CvRV1-CUk,7106
+pypeline/steps/create_venv.py,sha256=PWYX1Abo384QH0IO4o52wTpl6G20NKGOSNd5xIDEvN8,12885
 pypeline/steps/env_setup_script.py,sha256=DRDCNMUDiW2rzkgEs0FhQfA_-WjPzPLb_e9dGc-mjLg,2526
-pypeline/steps/scoop_install.py,sha256=DDXBD-5TVaT-u6Yf7A85uWoCgBVmLvj9nPGrZ8OQCz0,3853
+pypeline/steps/scoop_install.py,sha256=2MhsJ0iPmL8ueQhI52sKjVY9fqzj5xOQweQ65C0onfE,4117
 pypeline/steps/west_install.py,sha256=hPyr28ksdKsQ0tv0gMNytzupgk1IgjN9CpmaBdX5zps,1947
-pypeline_runner-1.20.0.dist-info/METADATA,sha256=WdF9WMRoPZiQ-pBb10GsVB0u41tT7OdXqp1spKTRezc,7659
-pypeline_runner-1.20.0.dist-info/WHEEL,sha256=zp0Cn7JsFoX2ATtOhtaFYIiE2rmFAD4OcMhtUki8W3U,88
-pypeline_runner-1.20.0.dist-info/entry_points.txt,sha256=pe1u0uuhPI_yeQ0KjEw6jK-EvQfPcZwBSajgbAdKz1o,47
-pypeline_runner-1.20.0.dist-info/licenses/LICENSE,sha256=sKxdoqSmW9ezvPvt0ZGJbneyA0SBcm0GiqzTv2jN230,1066
-pypeline_runner-1.20.0.dist-info/RECORD,,
+pypeline_runner-1.21.1.dist-info/METADATA,sha256=AiVxdTBIVOeUwKVeC_ZHCFkcUtXT7bqVZQ7iXfFMaT8,7659
+pypeline_runner-1.21.1.dist-info/WHEEL,sha256=zp0Cn7JsFoX2ATtOhtaFYIiE2rmFAD4OcMhtUki8W3U,88
+pypeline_runner-1.21.1.dist-info/entry_points.txt,sha256=pe1u0uuhPI_yeQ0KjEw6jK-EvQfPcZwBSajgbAdKz1o,47
+pypeline_runner-1.21.1.dist-info/licenses/LICENSE,sha256=sKxdoqSmW9ezvPvt0ZGJbneyA0SBcm0GiqzTv2jN230,1066
+pypeline_runner-1.21.1.dist-info/RECORD,,