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

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

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

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

@@ -1,6 +1,6 @@
 [tool.poetry]
 name = "pypeline-runner"
-version = "1.23.0"
+version = "1.23.2"
 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.2/src/pypeline/__init__.py

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

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

@@ -583,6 +583,7 @@ class CreateVirtualEnvironment(Runnable):
         self,
         root_dir: Path,
         bootstrap_env: CreateBootstrapEnvironment,
+        skip_venv_delete: bool = False,
     ) -> None:
         self.root_dir = root_dir
         self.venv_dir = self.root_dir / ".venv"
@@ -591,6 +592,7 @@ class CreateVirtualEnvironment(Runnable):
         self.bootstrap_env = bootstrap_env
         self.config = bootstrap_env.config
         self.python_version_marker = self.venv_dir / VENV_PYTHON_VERSION_MARKER
+        self.skip_venv_delete = skip_venv_delete
 
     @property
     def package_manager_name(self) -> str:
@@ -602,6 +604,7 @@ class CreateVirtualEnvironment(Runnable):
 
         If the Python version has changed (e.g., switching branches), delete the
         existing venv so it can be recreated by the package manager.
+        If skip_venv_delete is True, log a warning instead of deleting.
         """
         if not self.venv_dir.exists():
             return
@@ -609,19 +612,27 @@ class CreateVirtualEnvironment(Runnable):
         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)
+            if self.skip_venv_delete:
+                logger.warning(f"No Python version marker found in {self.venv_dir}. Cannot verify venv compatibility, but skipping deletion as requested.")
+            else:
+                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)
+                if self.skip_venv_delete:
+                    logger.warning(
+                        f"Python version changed from {stored_version} to {current_version}. Skipping venv deletion as requested - dependencies will be updated in place."
+                    )
+                else:
+                    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}")
 
@@ -632,22 +643,31 @@ class CreateVirtualEnvironment(Runnable):
         except OSError as exc:
             logger.warning(f"Could not write Python version marker: {exc}")
 
+    def _set_env_var(self, key: str, value: str) -> None:
+        """Helper method to set environment variables (easier to mock in tests)."""
+        os.environ[key] = value
+
     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"
+            self._set_env_var("POETRY_VIRTUALENVS_IN_PROJECT", "true")
         elif self.package_manager_name == "pipenv":
             # Set environment variable for pipenv
-            os.environ["PIPENV_VENV_IN_PROJECT"] = "1"
+            self._set_env_var("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"
+            self._set_env_var("POETRY_VIRTUALENVS_PREFER_ACTIVE_PYTHON", "false")
+            self._set_env_var("POETRY_VIRTUALENVS_USE_POETRY_PYTHON", "true")
+        elif self.package_manager_name == "uv":
+            # Make UV use the Python interpreter it's being run with
+            self._set_env_var("UV_PYTHON", self.config.python_version)
+            self._set_env_var("UV_MANAGED_PYTHON", "false")
+            self._set_env_var("UV_NO_PYTHON_DOWNLOADS", "true")
 
     def _get_install_argument(self) -> str:
         if self.package_manager_name == "uv":
@@ -763,11 +783,11 @@ def main() -> int:
             help="Specify the project directory (default: current working directory).",
         )
         parser.add_argument(
-            "--skip-venv-creation",
+            "--skip-venv-delete",
             action="store_true",
             required=False,
             default=False,
-            help="Skip the virtual environment creation process.",
+            help="Skip deleting the virtual environment (used when running from within the venv). Dependencies will still be updated.",
         )
         parser.add_argument(
             "--config",
@@ -795,13 +815,11 @@ def main() -> int:
         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.")
+        # When skip_venv_delete is True (e.g., running from within the venv),
+        # we still update dependencies but skip deleting the venv to avoid write access exceptions
+        project_venv = CreateVirtualEnvironment(project_dir, bootstrap_env, skip_venv_delete=args.skip_venv_delete)
+        project_executor = Executor(project_venv.venv_dir)
+        project_executor.execute(project_venv)
 
     except UserNotificationException as exc:
         logger.error(exc)

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

@@ -287,11 +287,11 @@ class CreateVEnv(PipelineStep[ExecutionContext]):
             ).execute()
         else:
             # Use internal bootstrap script
-            skip_venv_creation = False
+            skip_venv_delete = 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
+                self.logger.info(f"Detected that the python executable '{python_executable}' is from the virtual environment. Will update dependencies but skip venv deletion.")
+                skip_venv_delete = True
 
             # Create bootstrap.json with all configuration
             bootstrap_config = {}
@@ -330,8 +330,8 @@ class CreateVEnv(PipelineStep[ExecutionContext]):
             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")
+            if skip_venv_delete:
+                bootstrap_args.append("--skip-venv-delete")
 
             # Copy the internal bootstrap script to the project root .bootstrap/bootstrap.py
             self.target_internal_bootstrap_script.parent.mkdir(exist_ok=True)

pypeline_runner-1.23.0/src/pypeline/__init__.py

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