pypeline-runner 0.3.1__tar.gz → 1.1.0__tar.gz

{pypeline_runner-0.3.1 → pypeline_runner-1.1.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: pypeline-runner
-Version: 0.3.1
+Version: 1.1.0
 Summary: Configure and execute pipelines with Python (similar to GitHub workflows or Jenkins pipelines).
 Home-page: https://github.com/cuinixam/pypeline
 License: MIT
@@ -16,6 +16,7 @@ Classifier: Programming Language :: Python :: 3
 Classifier: Programming Language :: Python :: 3.10
 Classifier: Programming Language :: Python :: 3.11
 Classifier: Programming Language :: Python :: 3.12
+Classifier: Programming Language :: Python :: 3.13
 Classifier: Topic :: Software Development :: Libraries
 Requires-Dist: py-app-dev (>=2.2,<3.0)
 Requires-Dist: pyyaml (>=6.0,<7.0)

{pypeline_runner-0.3.1 → pypeline_runner-1.1.0}/pyproject.toml

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

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

{pypeline_runner-0.3.1 → pypeline_runner-1.1.0}/src/pypeline/domain/pipeline.py

@@ -4,11 +4,13 @@ from pathlib import Path
 from typing import (
     Any,
     Dict,
+    Generic,
     List,
     Optional,
     OrderedDict,
     Type,
     TypeAlias,
+    TypeVar,
 )
 
 from mashumaro import DataClassDictMixin
@@ -39,25 +41,39 @@ class PipelineStepConfig(DataClassDictMixin):
 
 PipelineConfig: TypeAlias = OrderedDict[str, List[PipelineStepConfig]]
 
+TExecutionContext = TypeVar("TExecutionContext", bound=ExecutionContext)
 
-class PipelineStep(Runnable):
-    def __init__(self, execution_context: ExecutionContext, output_dir: Path, config: Optional[Dict[str, Any]] = None) -> None:
+
+class PipelineStep(Generic[TExecutionContext], Runnable):
+    """One can create subclasses of PipelineStep that specify the type of ExecutionContext they require."""
+
+    def __init__(self, execution_context: TExecutionContext, group_name: str, config: Optional[Dict[str, Any]] = None) -> None:
         super().__init__(self.get_needs_dependency_management())
         self.execution_context = execution_context
-        self.output_dir = output_dir
+        self.group_name = group_name
         self.config = config
         self.project_root_dir = self.execution_context.project_root_dir
 
+    @property
+    def output_dir(self) -> Path:
+        return self.execution_context.create_artifacts_locator().build_dir.joinpath(self.group_name)
+
     @abstractmethod
     def update_execution_context(self) -> None:
+        """
+        Even if the step does not need to run ( because it is not outdated ), it can still update the execution context.
+
+        A typical use case is for steps installing software that need to provide the install directories in the execution context even if all tools are already installed.
+        """
         pass
 
     def get_needs_dependency_management(self) -> bool:
+        """If false, the step executor will not check for outdated dependencies. This is useful for steps consisting of command lines which shall always run."""
         return True
 
 
-class PipelineStepReference:
-    def __init__(self, group_name: str, _class: Type[PipelineStep], config: Optional[Dict[str, Any]] = None) -> None:
+class PipelineStepReference(Generic[TExecutionContext]):
+    def __init__(self, group_name: str, _class: Type[PipelineStep[TExecutionContext]], config: Optional[Dict[str, Any]] = None) -> None:
         self.group_name = group_name
         self._class = _class
         self.config = config

{pypeline_runner-0.3.1 → pypeline_runner-1.1.0}/src/pypeline/kickstart/create.py

@@ -51,6 +51,5 @@ class KickstartProject:
         project_builder = ProjectBuilder(self.project_dir)
         if self.force:
             project_builder.with_disable_target_directory_check()
-        project_builder.with_dir("bootstrap")
         project_builder.with_dir("project")
         project_builder.build()

{pypeline_runner-0.3.1 → pypeline_runner-1.1.0}/src/pypeline/kickstart/templates/project/.gitignore

@@ -1,2 +1,3 @@
+.bootstrap
 .venv
 build/

pypeline_runner-1.1.0/src/pypeline/kickstart/templates/project/bootstrap.ps1

@@ -0,0 +1,31 @@
+<#
+.DESCRIPTION
+    Wrapper for installing dependencies
+#>
+
+function Invoke-Bootstrap {
+    # Download bootstrap scripts from external repository
+    Invoke-RestMethod https://raw.githubusercontent.com/avengineers/bootstrap-installer/v1.15.0/install.ps1 | Invoke-Expression
+    # Execute bootstrap script
+    . .\.bootstrap\bootstrap.ps1
+}
+
+## start of script
+# Always set the $InformationPreference variable to "Continue" globally,
+# this way it gets printed on execution and continues execution afterwards.
+$InformationPreference = "Continue"
+
+# Stop on first error
+$ErrorActionPreference = "Stop"
+
+Push-Location $PSScriptRoot
+Write-Output "Running in ${pwd}"
+
+try {
+    # bootstrap environment
+    Invoke-Bootstrap
+}
+finally {
+    Pop-Location
+}
+## end of script

{pypeline_runner-0.3.1 → pypeline_runner-1.1.0}/src/pypeline/kickstart/templates/project/pypeline.yaml

@@ -2,6 +2,8 @@ pipeline:
   venv:
     - step: CreateVEnv
       module: pypeline.steps.create_venv
+      config:
+        bootstrap_script: .bootstrap/bootstrap.py
   install:
     - step: ScoopInstall
       module: pypeline.steps.scoop_install

{pypeline_runner-0.3.1 → pypeline_runner-1.1.0}/src/pypeline/kickstart/templates/project/steps/my_step.py

@@ -3,10 +3,11 @@ from typing import List
 
 from py_app_dev.core.logging import logger
 
+from pypeline.domain.execution_context import ExecutionContext
 from pypeline.domain.pipeline import PipelineStep
 
 
-class MyStep(PipelineStep):
+class MyStep(PipelineStep[ExecutionContext]):
     def run(self) -> None:
         logger.info(f"Run {self.get_name()} found install dirs:")
         for install_dir in self.execution_context.install_dirs:

{pypeline_runner-0.3.1 → pypeline_runner-1.1.0}/src/pypeline/main.py

@@ -7,6 +7,7 @@ from py_app_dev.core.exceptions import UserNotificationException
 from py_app_dev.core.logging import logger, setup_logger, time_it
 
 from pypeline import __version__
+from pypeline.domain.execution_context import ExecutionContext
 from pypeline.domain.project_slurper import ProjectSlurper
 from pypeline.kickstart.create import KickstartProject
 from pypeline.pypeline import PipelineScheduler, PipelineStepsExecutor
@@ -76,14 +77,14 @@ def run(
     if not project_slurper.pipeline:
         raise UserNotificationException("No pipeline found in the configuration.")
     # Schedule the steps to run
-    steps_references = PipelineScheduler(project_slurper.pipeline, project_dir).get_steps_to_run(step, single)
+    steps_references = PipelineScheduler[ExecutionContext](project_slurper.pipeline, project_dir).get_steps_to_run(step, single)
     if not steps_references:
         if step:
             raise UserNotificationException(f"Step '{step}' not found in the pipeline.")
         logger.info("No steps to run.")
         return
 
-    PipelineStepsExecutor(project_slurper.artifacts_locator, steps_references, force_run, dry_run).run()
+    PipelineStepsExecutor[ExecutionContext](ExecutionContext(project_dir), steps_references, force_run, dry_run).run()
 
 
 def main() -> None:

{pypeline_runner-0.3.1 → pypeline_runner-1.1.0}/src/pypeline/pypeline.py

@@ -4,9 +4,11 @@ from pathlib import Path
 from typing import (
     Any,
     Dict,
+    Generic,
     List,
     Optional,
     Type,
+    cast,
 )
 
 from py_app_dev.core.exceptions import UserNotificationException
@@ -15,10 +17,10 @@ from py_app_dev.core.runnable import Executor
 
 from .domain.artifacts import ProjectArtifactsLocator
 from .domain.execution_context import ExecutionContext
-from .domain.pipeline import PipelineConfig, PipelineStep, PipelineStepConfig, PipelineStepReference
+from .domain.pipeline import PipelineConfig, PipelineStep, PipelineStepConfig, PipelineStepReference, TExecutionContext
 
 
-class PipelineLoader:
+class PipelineLoader(Generic[TExecutionContext]):
     """
     Loads pipeline steps from a pipeline configuration.
 
@@ -31,7 +33,7 @@ class PipelineLoader:
         self.pipeline_config = pipeline_config
         self.project_root_dir = project_root_dir
 
-    def load_steps_references(self) -> List[PipelineStepReference]:
+    def load_steps_references(self) -> List[PipelineStepReference[TExecutionContext]]:
         result = []
         for group_name, steps_config in self.pipeline_config.items():
             result.extend(self._load_steps(group_name, steps_config, self.project_root_dir))
@@ -42,7 +44,7 @@ class PipelineLoader:
         group_name: str,
         steps_config: List[PipelineStepConfig],
         project_root_dir: Path,
-    ) -> List[PipelineStepReference]:
+    ) -> List[PipelineStepReference[TExecutionContext]]:
         result = []
         for step_config in steps_config:
             step_class_name = step_config.class_name or step_config.step
@@ -54,11 +56,11 @@ class PipelineLoader:
                 step_class = PipelineLoader._create_run_command_step_class(step_config.run, step_class_name)
             else:
                 raise UserNotificationException(f"Step '{step_class_name}' has no 'module' nor 'file' nor `run` defined." " Please check your pipeline configuration.")
-            result.append(PipelineStepReference(group_name, step_class, step_config.config))
+            result.append(PipelineStepReference[TExecutionContext](group_name, cast(Type[PipelineStep[TExecutionContext]], step_class), step_config.config))
         return result
 
     @staticmethod
-    def _load_user_step(python_file: Path, step_class_name: str) -> Type[PipelineStep]:
+    def _load_user_step(python_file: Path, step_class_name: str) -> Type[PipelineStep[ExecutionContext]]:
         # Create a module specification from the file path
         spec = spec_from_file_location(f"user__{step_class_name}", python_file)
         if spec and spec.loader:
@@ -73,7 +75,7 @@ class PipelineLoader:
         raise UserNotificationException(f"Could not load file '{python_file}'." " Please check the file for any errors.")
 
     @staticmethod
-    def _load_module_step(module_name: str, step_class_name: str) -> Type[PipelineStep]:
+    def _load_module_step(module_name: str, step_class_name: str) -> Type[PipelineStep[ExecutionContext]]:
         try:
             module = importlib.import_module(module_name)
             step_class = getattr(module, step_class_name)
@@ -84,14 +86,14 @@ class PipelineLoader:
         return step_class
 
     @staticmethod
-    def _create_run_command_step_class(command: str, name: str) -> Type[PipelineStep]:
+    def _create_run_command_step_class(command: str, name: str) -> Type[PipelineStep[ExecutionContext]]:
         """Dynamically creates a step class for a given command."""
 
-        class TmpDynamicRunCommandStep(PipelineStep):
+        class TmpDynamicRunCommandStep(PipelineStep[ExecutionContext]):
             """A simple step that runs a command."""
 
-            def __init__(self, execution_context: ExecutionContext, output_dir: Path, config: Optional[Dict[str, Any]] = None) -> None:
-                super().__init__(execution_context, output_dir, config)
+            def __init__(self, execution_context: ExecutionContext, group_name: str, config: Optional[Dict[str, Any]] = None) -> None:
+                super().__init__(execution_context, group_name, config)
                 self.command = command
                 self.name = name
 
@@ -122,29 +124,31 @@ class PipelineLoader:
         return type(name, (TmpDynamicRunCommandStep,), {})
 
 
-class PipelineStepsExecutor:
+class PipelineStepsExecutor(Generic[TExecutionContext]):
     """Executes a list of pipeline steps sequentially."""
 
     def __init__(
         self,
-        artifacts_locator: ProjectArtifactsLocator,
-        steps_references: List[PipelineStepReference],
+        execution_context: TExecutionContext,
+        steps_references: List[PipelineStepReference[TExecutionContext]],
         force_run: bool = False,
         dry_run: bool = False,
     ) -> None:
         self.logger = logger.bind()
-        self.artifacts_locator = artifacts_locator
+        self.execution_context = execution_context
         self.steps_references = steps_references
         self.force_run = force_run
         self.dry_run = dry_run
 
+    @property
+    def artifacts_locator(self) -> ProjectArtifactsLocator:
+        return self.execution_context.create_artifacts_locator()
+
     def run(self) -> None:
-        execution_context = ExecutionContext(project_root_dir=self.artifacts_locator.project_root_dir, install_dirs=[])
         for step_reference in self.steps_references:
-            step_output_dir = self.artifacts_locator.build_dir / step_reference.group_name
+            step = step_reference._class(self.execution_context, step_reference.group_name, step_reference.config)
             # Create the step output directory, to make sure that files can be created.
-            step_output_dir.mkdir(parents=True, exist_ok=True)
-            step = step_reference._class(execution_context, step_output_dir, step_reference.config)
+            step.output_dir.mkdir(parents=True, exist_ok=True)
             # Execute the step is necessary. If the step is not dirty, it will not be executed
             Executor(step.output_dir, self.force_run, self.dry_run).execute(step)
             # Independent if the step was executed or not, every step shall update the context
@@ -153,7 +157,7 @@ class PipelineStepsExecutor:
         return
 
 
-class PipelineScheduler:
+class PipelineScheduler(Generic[TExecutionContext]):
     """
     Schedules which steps must be executed based on the provided configuration.
 
@@ -168,16 +172,16 @@ class PipelineScheduler:
         self.project_root_dir = project_root_dir
         self.logger = logger.bind()
 
-    def get_steps_to_run(self, step_name: Optional[str] = None, single: bool = False) -> List[PipelineStepReference]:
-        pipeline_loader = PipelineLoader(self.pipeline, self.project_root_dir)
+    def get_steps_to_run(self, step_name: Optional[str] = None, single: bool = False) -> List[PipelineStepReference[TExecutionContext]]:
+        pipeline_loader = PipelineLoader[TExecutionContext](self.pipeline, self.project_root_dir)
         return self.filter_steps_references(pipeline_loader.load_steps_references(), step_name, single)
 
     @staticmethod
     def filter_steps_references(
-        steps_references: List[PipelineStepReference],
+        steps_references: List[PipelineStepReference[TExecutionContext]],
         step_name: Optional[str],
         single: Optional[bool],
-    ) -> List[PipelineStepReference]:
+    ) -> List[PipelineStepReference[TExecutionContext]]:
         if step_name:
             step_reference = next((step for step in steps_references if step.name == step_name), None)
             if not step_reference:

{pypeline_runner-0.3.1 → pypeline_runner-1.1.0}/src/pypeline/steps/create_venv.py

@@ -15,9 +15,9 @@ class CreateVEnvConfig(DataClassDictMixin):
     bootstrap_script: str = "bootstrap.py"
 
 
-class CreateVEnv(PipelineStep):
-    def __init__(self, execution_context: ExecutionContext, output_dir: Path, config: Optional[Dict[str, Any]] = None) -> None:
-        super().__init__(execution_context, output_dir, config)
+class CreateVEnv(PipelineStep[ExecutionContext]):
+    def __init__(self, execution_context: ExecutionContext, group_name: str, config: Optional[Dict[str, Any]] = None) -> None:
+        super().__init__(execution_context, group_name, config)
         self.logger = logger.bind()
         self.logger = logger.bind()
 

{pypeline_runner-0.3.1 → pypeline_runner-1.1.0}/src/pypeline/steps/scoop_install.py

@@ -45,9 +45,9 @@ def create_scoop_wrapper() -> ScoopWrapper:
     return ScoopWrapper()
 
 
-class ScoopInstall(PipelineStep):
-    def __init__(self, execution_context: ExecutionContext, output_dir: Path, config: Optional[Dict[str, Any]] = None) -> None:
-        super().__init__(execution_context, output_dir, config)
+class ScoopInstall(PipelineStep[ExecutionContext]):
+    def __init__(self, execution_context: ExecutionContext, group_name: str, config: Optional[Dict[str, Any]] = None) -> None:
+        super().__init__(execution_context, group_name, config)
         self.logger = logger.bind()
         self.execution_info = ScoopInstallExecutionInfo([])
         # One needs to keep track of the installed apps to get the required paths

{pypeline_runner-0.3.1 → pypeline_runner-1.1.0}/src/pypeline/steps/west_install.py

@@ -8,9 +8,9 @@ from ..domain.execution_context import ExecutionContext
 from ..domain.pipeline import PipelineStep
 
 
-class WestInstall(PipelineStep):
-    def __init__(self, execution_context: ExecutionContext, output_dir: Path, config: Optional[Dict[str, Any]] = None) -> None:
-        super().__init__(execution_context, output_dir, config)
+class WestInstall(PipelineStep[ExecutionContext]):
+    def __init__(self, execution_context: ExecutionContext, group_name: str, config: Optional[Dict[str, Any]] = None) -> None:
+        super().__init__(execution_context, group_name, config)
         self.logger = logger.bind()
         self.artifacts_locator = execution_context.create_artifacts_locator()
 

pypeline_runner-0.3.1/src/pypeline/__init__.py

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

pypeline_runner-0.3.1/src/pypeline/kickstart/templates/bootstrap/bootstrap.ps1

@@ -1,137 +0,0 @@
-<#
-.DESCRIPTION
-    Script to install python and start the bootstrap.py.
-    This file was generated by yanga.
-    VERSION: 0.6.1
-#>
-
-$ErrorActionPreference = "Stop"
-
-###################################################################################################
-# Configuration
-###################################################################################################
-$bootstrapJsonPath = Join-Path $PSScriptRoot "bootstrap.json"
-if (Test-Path $bootstrapJsonPath) {
-    $json = Get-Content $bootstrapJsonPath | ConvertFrom-Json
-    $config = @{
-        pythonVersion = $json.python_version
-        scoopInstaller = $json.scoop_installer
-        scoopMainBucketBaseUrl = $json.scoop_main_bucket_base_url
-        scoopPythonBucketBaseUrl = $json.scoop_python_bucket_base_url
-    }
-} else {
-    $config = @{
-        pythonVersion = "3.10"
-        scoopInstaller = "https://raw.githubusercontent.com/ScoopInstaller/Install/master/install.ps1"
-        scoopMainBucketBaseUrl = "https://raw.githubusercontent.com/ScoopInstaller/Main/master/bucket"
-        scoopPythonBucketBaseUrl = "https://raw.githubusercontent.com/ScoopInstaller/Versions/master/bucket"
-    }
-}
-
-###################################################################################################
-# Utility functions
-###################################################################################################
-
-# Update/Reload current environment variable PATH with settings from registry
-Function Initialize-EnvPath {
-    # workaround for system-wide installations
-    if ($Env:USER_PATH_FIRST) {
-        $Env:Path = [System.Environment]::GetEnvironmentVariable("Path", "User") + ";" + [System.Environment]::GetEnvironmentVariable("Path", "Machine")
-    }
-    else {
-        $Env:Path = [System.Environment]::GetEnvironmentVariable("Path", "Machine") + ";" + [System.Environment]::GetEnvironmentVariable("Path", "User")
-    }
-}
-
-Function Invoke-CommandLine {
-    [Diagnostics.CodeAnalysis.SuppressMessageAttribute('PSAvoidUsingInvokeExpression', '', Justification = 'Usually this statement must be avoided (https://learn.microsoft.com/en-us/powershell/scripting/learn/deep-dives/avoid-using-invoke-expression?view=powershell-7.3), here it is OK as it does not execute unknown code.')]
-    param (
-        [Parameter(Mandatory = $true, Position = 0)]
-        [string]$CommandLine,
-        [Parameter(Mandatory = $false, Position = 1)]
-        [bool]$StopAtError = $true,
-        [Parameter(Mandatory = $false, Position = 2)]
-        [bool]$Silent = $false
-    )
-    if (-Not $Silent) {
-        Write-Output "Executing: $CommandLine"
-    }
-    $global:LASTEXITCODE = 0
-    Invoke-Expression $CommandLine
-    if ($global:LASTEXITCODE -ne 0) {
-        if ($StopAtError) {
-            Write-Error "Command line call `"$CommandLine`" failed with exit code $global:LASTEXITCODE"
-        }
-        else {
-            if (-Not $Silent) {
-                Write-Output "Command line call `"$CommandLine`" failed with exit code $global:LASTEXITCODE, continuing ..."
-            }
-        }
-    }
-}
-
-Function Install-Scoop {
-    # Initial Scoop installation
-    if (-Not (Get-Command 'scoop' -ErrorAction SilentlyContinue)) {
-        $tempDir = [System.IO.Path]::GetTempPath()
-        $tempFile = "$tempDir\install.ps1"
-        Invoke-RestMethod $config.scoopInstaller -OutFile $tempFile
-        if ((New-Object Security.Principal.WindowsPrincipal([Security.Principal.WindowsIdentity]::GetCurrent())).IsInRole([Security.Principal.WindowsBuiltInRole]::Administrator)) {
-            & $tempFile -RunAsAdmin
-        }
-        else {
-            & $tempFile
-        }
-        Initialize-EnvPath
-        Remove-Item $tempFile
-    }
-
-    # Install needed tools
-    Invoke-CommandLine "scoop update"
-    # Avoid deadlocks while updating scoop buckets
-    Invoke-CommandLine "scoop config autostash_on_conflict $true" -Silent $true
-
-    Initialize-EnvPath
-}
-
-###################################################################################################
-# Main
-###################################################################################################
-
-# python executable name
-$python = "python" + $config.pythonVersion.Replace(".", "")
-
-# Check if scoop is installed
-$scoopPath = (Get-Command scoop -ErrorAction SilentlyContinue).Source
-if ($scoopPath -eq $null) {
-    Write-Output "Scoop not found. Trying to install scoop ..."
-    Install-Scoop
-}
-else {
-    Write-Output "Found scoop under $scoopPath."
-}
-# Check if python is installed
-$pythonPath = (Get-Command $python -ErrorAction SilentlyContinue).Source
-if ($pythonPath -eq $null) {
-    Write-Output "$python not found. Try to install $python via scoop ..."
-    # Install Python installer dependencies
-    Invoke-CommandLine "scoop install $($config.scoopMainBucketBaseUrl)/dark.json"
-    Invoke-CommandLine "scoop install $($config.scoopMainBucketBaseUrl)/lessmsi.json"
-    # Install python
-    Invoke-CommandLine "scoop install $($config.scoopPythonBucketBaseUrl)/$python.json"
-}
-else {
-    Write-Output "$python found in $pythonPath"
-    # Extract the directory of python exe file and add it to PATH. It needs to be the first entry in PATH
-    # such that this version is used when the user calls python and not python311
-    $pythonDir = [System.IO.Path]::GetDirectoryName($pythonPath)
-    Write-Output "Adding $pythonDir to PATH"
-    $Env:Path += ";$pythonDir"
-}
-
-# Call the bootstrap.py if it exists with all provided arguments
-$buildScript = Join-Path $PSScriptRoot "bootstrap.py"
-if (Test-Path $buildScript) {
-    Write-Output "Calling $buildScript ..."
-    & $python $buildScript $args
-}

pypeline_runner-0.3.1/src/pypeline/kickstart/templates/bootstrap/bootstrap.py

@@ -1,428 +0,0 @@
-#!/usr/bin/env python3
-# This file was generated by yanga.
-# VERSION: 0.6.1
-import configparser
-import hashlib
-import json
-import logging
-import os
-import re
-import subprocess  # nosec
-import sys
-import tempfile
-import venv
-from abc import ABC, abstractmethod
-from dataclasses import dataclass
-from enum import Enum
-from pathlib import Path
-from typing import List, Optional
-
-logging.basicConfig(level=logging.INFO)
-logger = logging.getLogger("bootstrap")
-
-
-this_dir = Path(__file__).parent
-this_file = Path(__file__).name
-bootstrap_json_path = Path(__file__).parent / "bootstrap.json"
-if bootstrap_json_path.exists():
-    with bootstrap_json_path.open("r") as f:
-        config = json.load(f)
-    package_manager = config.get("python_package_manager", "poetry>=1.7.1")
-else:
-    package_manager = "poetry>=1.7.1"
-
-
-@dataclass
-class PyPiSource:
-    name: str
-    url: str
-
-
-@dataclass
-class TomlSection:
-    name: str
-    content: str
-
-    def __str__(self) -> str:
-        return f"[{self.name}]\n{self.content}"
-
-
-class PyPiSourceParser:
-    tool_poetry_source_section = "tool.poetry.source"
-
-    @staticmethod
-    def from_pyproject_toml(pyproject_toml: Path) -> Optional[PyPiSource]:
-        if not pyproject_toml.exists():
-            return None
-        return PyPiSourceParser.from_pyproject_toml_content(pyproject_toml.read_text())
-
-    @staticmethod
-    def from_pyproject_toml_content(content: str) -> Optional[PyPiSource]:
-        sections = PyPiSourceParser.get_toml_sections(content)
-        for section in sections:
-            if section.name == PyPiSourceParser.tool_poetry_source_section:
-                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 as e:
-                    raise UserNotificationException(
-                        f"Could not parse PyPi source from pyproject.toml section {section.name}. "
-                        f"Please make sure the section has the following format:\n"
-                        f"[{PyPiSourceParser.tool_poetry_source_section}]\n"
-                        f'name = "name"\n'
-                        f'url = "https://url"\n'
-                        f"verify_ssl = true"
-                    ) from e
-        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
-        raw_sections = re.findall(r"^\[+.*\]+\n(?:[^[]*\n)*", toml_content, re.MULTILINE)
-
-        # Process each section
-        sections = []
-        for section in raw_sections:
-            # Split the lines, from the first line extract the section name
-            # and merge all the other lines into the content
-            lines = section.splitlines()
-            name_match = re.match(r"^\[+([^]]*)\]+", lines[0])
-            if name_match:
-                name = name_match.group(1).strip()
-                content = "\n".join(lines[1:]).strip()
-                sections.append(TomlSection(name, content))
-
-        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"""
-
-
-class RunInfoStatus(Enum):
-    MATCH = (False, "Nothing changed. Previous execution info matches.")
-    NO_INFO = (True, "No previous execution info found.")
-    FILE_NOT_FOUND = (True, "File not found.")
-    FILE_CHANGED = (True, "File has 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:
-        with open(path, "rb") as file:
-            bytes = file.read()
-            readable_hash = hashlib.sha256(bytes).hexdigest()
-            return readable_hash
-
-    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()},
-        }
-
-        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)
-
-        for file_type in ["inputs", "outputs"]:
-            for path_str, previous_hash in previous_info[file_type].items():
-                path = Path(path_str)
-                if not path.exists():
-                    return RunInfoStatus.FILE_NOT_FOUND
-                elif 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"Runnable '{runnable.get_name()}' must run. {run_info_status.message}")
-            exit_code = runnable.run()
-            self.store_run_info(runnable)
-            return exit_code
-        logger.info(f"Runnable '{runnable.get_name()}' execution skipped. {run_info_status.message}")
-
-        return 0
-
-
-class UserNotificationException(Exception):
-    pass
-
-
-class SubprocessExecutor:
-    def __init__(
-        self,
-        command: List[str | Path],
-        cwd: Optional[Path] = None,
-        capture_output: bool = True,
-    ):
-        self.command = " ".join([str(cmd) for cmd in command])
-        self.current_working_directory = cwd
-        self.capture_output = capture_output
-
-    def execute(self) -> None:
-        result = None
-        try:
-            current_dir = (self.current_working_directory or Path.cwd()).as_posix()
-            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(),  # noqa: S603
-                cwd=current_dir,
-                capture_output=self.capture_output,
-                text=True,  # to get stdout and stderr as strings instead of bytes
-            )  # nosec
-            result.check_returncode()
-        except subprocess.CalledProcessError as e:
-            raise UserNotificationException(
-                f"Command '{self.command}' failed with:\n"
-                f"{result.stdout if result else ''}\n"
-                f"{result.stderr if result else e}"
-            ) from e
-
-
-class VirtualEnvironment(ABC):
-    def __init__(self, venv_dir: Path) -> None:
-        self.venv_dir = venv_dir
-
-    def create(self, clear: bool = False) -> None:
-        """
-        Create a new virtual environment. This should configure the virtual environment such that
-        subsequent calls to `pip` and `run` operate within this environment.
-        """
-        try:
-            venv.create(self.venv_dir, with_pip=True, clear=clear)
-        except PermissionError as e:
-            if "python.exe" in str(e):
-                raise UserNotificationException(
-                    f"Failed to create virtual environment in {self.venv_dir}.\n"
-                    f"Virtual environment python.exe is still running. Please kill all instances and run again.\n"
-                    f"Error: {e}"
-                ) from e
-            raise UserNotificationException(
-                f"Failed to create virtual environment in {self.venv_dir}.\n"
-                f"Please make sure you have the necessary permissions.\n"
-                f"Error: {e}"
-            ) from e
-
-    def pip_configure(self, index_url: str, verify_ssl: bool) -> None:
-        """
-        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 `pip config set global.cert <verify_ssl>` from the
-        command line.
-
-        Args:
-        ----
-            index_url: The index URL to use for pip.
-            verify_ssl: Whether to verify SSL certificates when using pip.
-
-        """
-        # The pip configuration file should be in the virtual environment directory %VIRTUAL_ENV%
-        pip_ini_path = self.pip_config_path()
-        with open(pip_ini_path, "w") as pip_ini_file:
-            match_host = re.match(r"https?://([^/]+)", index_url)
-            pip_ini_file.write(f"[global]\nindex-url = {index_url}\n")
-            if match_host:
-                pip_ini_file.write(f"trusted-host = {match_host.group(1)}\n")
-            if not verify_ssl:
-                pip_ini_file.write("cert = false\n")
-
-    def pip(self, args: List[str]) -> None:
-        SubprocessExecutor([self.pip_path().as_posix(), *args], this_dir).execute()
-
-    @abstractmethod
-    def pip_path(self) -> Path:
-        """
-        Get the path to the pip executable within the virtual environment.
-        """
-
-    @abstractmethod
-    def pip_config_path(self) -> Path:
-        """
-        Get the path to the pip configuration file within the virtual environment.
-        """
-
-    @abstractmethod
-    def run(self, args: List[str], capture_output: bool = True) -> None:
-        """
-        Run an arbitrary command within the virtual environment. This method should behave as if the
-        user had activated the virtual environment and run the given command from the command line.
-
-        Args:
-        ----
-            *args: Command-line arguments. For example, `run('python', 'setup.py', 'install')`
-                   should behave similarly to `python setup.py install` at the command line.
-
-        """
-
-
-class WindowsVirtualEnvironment(VirtualEnvironment):
-    def __init__(self, venv_dir: Path) -> None:
-        super().__init__(venv_dir)
-        self.activate_script = self.venv_dir.joinpath("Scripts/activate")
-
-    def pip_path(self) -> Path:
-        return self.venv_dir.joinpath("Scripts/pip")
-
-    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(
-            [f"cmd /c {self.activate_script.as_posix()} && ", *args],
-            this_dir,
-            capture_output,
-        ).execute()
-
-
-class UnixVirtualEnvironment(VirtualEnvironment):
-    def __init__(self, venv_dir: Path) -> None:
-        super().__init__(venv_dir)
-        self.activate_script = self.venv_dir.joinpath("bin/activate")
-
-    def pip_path(self) -> Path:
-        return self.venv_dir.joinpath("bin/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([f"{Path(temp_script_path).as_posix()}"], this_dir, capture_output).execute()
-        # Delete the temporary script
-        os.remove(temp_script_path)
-
-
-class CreateVirtualEnvironment(Runnable):
-    def __init__(
-        self,
-    ) -> None:
-        self.root_dir = this_dir
-        self.venv_dir = self.root_dir / ".venv"
-        self.virtual_env = self.instantiate_os_specific_venv(self.venv_dir)
-
-    @property
-    def package_manager_name(self) -> str:
-        match = re.match(r"^([a-zA-Z0-9_-]+)", package_manager)
-
-        if match:
-            return match.group(1)
-        else:
-            raise UserNotificationException(f"Could not extract the package manager name from {package_manager}")
-
-    def run(self) -> int:
-        logger.info("Running project build script")
-        self.virtual_env.create(clear=self.venv_dir.exists())
-        pypi_source = PyPiSourceParser.from_pyproject_toml(self.root_dir / "pyproject.toml")
-        if pypi_source:
-            self.virtual_env.pip_configure(index_url=pypi_source.url, verify_ssl=True)
-        self.virtual_env.pip(["install", package_manager])
-        self.virtual_env.run([self.package_manager_name, "install"])
-        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]:
-        bootstrap_files = list(self.root_dir.glob("bootstrap.*"))
-        venv_relevant_files = ["poetry.lock", "poetry.toml", "pyproject.toml"]
-        return [self.root_dir / file for file in venv_relevant_files] + bootstrap_files
-
-    def get_outputs(self) -> List[Path]:
-        return []
-
-
-def print_environment_info() -> None:
-    str_bar = "".join(["-" for _ in range(80)])
-    logger.debug(str_bar)
-    logger.debug("Environment: \n" + json.dumps(dict(os.environ), indent=4))
-    logger.info(str_bar)
-    logger.info(f"Arguments: {sys.argv[1:]}")
-    logger.info(str_bar)
-
-
-def main() -> int:
-    try:
-        # print_environment_info()
-        build = CreateVirtualEnvironment()
-        Executor(build.venv_dir).execute(build)
-    except UserNotificationException as e:
-        logger.error(e)
-        return 1
-    return 0
-
-
-if __name__ == "__main__":
-    sys.exit(main())
-
-if __name__ == "__test_main__":
-    """This is used to execute the build script from a test and
-    it shall not call sys.exit()"""
-    main()