spl-core 7.3.0rc1__py3-none-any.whl → 7.3.2__py3-none-any.whl

spl_core/kickstart/templates/project/build.ps1

@@ -6,71 +6,42 @@
 param(
     [Parameter(Mandatory = $false, HelpMessage = 'Install all dependencies required to build. (Switch, default: false)')]
     [switch]$install = $false,
+    [Parameter(Mandatory = $false, HelpMessage = 'Install optional dependencies. (Switch, default: false)')]
+    [switch]$installOptional = $false,
     [Parameter(Mandatory = $false, HelpMessage = 'Install Visual Studio Code. (Switch, default: false)')]
     [switch]$installVSCode = $false,
+    [Parameter(Mandatory = $false, HelpMessage = 'Run all CI tests (python tests with pytest) (Switch, default: false)')]
+    [switch]$selftests = $false,
     [Parameter(Mandatory = $false, HelpMessage = 'Build the target.')]
     [switch]$build = $false,
+    [Parameter(Mandatory = $false, HelpMessage = 'Start Visual Studio Code. (Switch, default: false)')]
+    [switch]$startVSCode = $false,
     [Parameter(Mandatory = $false, HelpMessage = 'Command to be executed (String)')]
     [string]$command = "",
     [Parameter(Mandatory = $false, HelpMessage = 'Clean build, wipe out all build artifacts. (Switch, default: false)')]
     [switch]$clean = $false,
     [Parameter(Mandatory = $false, HelpMessage = 'Build kit to be used. (String: "prod" or "test", default: "prod")')]
     [string]$buildKit = "prod",
+    [Parameter(Mandatory = $false, HelpMessage = 'Type of build. (String, default: "Debug")')]
+    [string]$buildType = "Debug",
     [Parameter(Mandatory = $false, HelpMessage = 'Target to be built. (String, default: "all")')]
     [string]$target = "all",
     [Parameter(Mandatory = $false, HelpMessage = 'Variants (of the product) to be built. (List of strings, leave empty to be asked or "all" for automatic build of all variants)')]
     [string[]]$variants = $null,
     [Parameter(Mandatory = $false, HelpMessage = 'filter for self tests, e.g. "Disco or test_Disco.py" (see https://docs.pytest.org/en/stable/usage.html).')]
     [string]$filter = "",
+    [Parameter(Mandatory = $false, HelpMessage = 'Marker for self tests, e.g. "static_analysis" (see https://docs.pytest.org/en/stable/how-to/mark.html).')]
+    [string]$marker = "",
     [Parameter(Mandatory = $false, HelpMessage = 'Additional build arguments for Ninja (e.g., "-d explain -d keepdepfile" for debugging purposes)')]
     [string]$ninjaArgs = "",
     [Parameter(Mandatory = $false, HelpMessage = 'Delete CMake cache and reconfigure. (Switch, default: false)')]
-    [switch]$reconfigure = $false
+    [switch]$reconfigure = $false,
+    [Parameter(Mandatory = $false, HelpMessage = 'Just configure the build and fetch all dependencies. (Switch, default: false)')]
+    [switch]$configureOnly = $false,
+    [Parameter(Mandatory = $false, HelpMessage = 'Wait for a key press before exiting. (Switch, default: false)')]
+    [switch]$waitForKey = $false
 )
 
-# Call a command and handle its exit code
-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 ..."
-            }
-        }
-    }
-}
-
-# 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 Test-RunningInCIorTestEnvironment {
-    return [Boolean]($Env:JENKINS_URL -or $Env:PYTEST_CURRENT_TEST -or $Env:GITHUB_ACTIONS)
-}
-
 # Consider CI environment variables (e.g. on Jenkins BRANCH_NAME and CHANGE_TARGET) to filter tests in release branch builds
 function Get-ReleaseBranchPytestFilter {
     $ChangeId = $env:CHANGE_ID
@@ -95,138 +66,204 @@ function Get-ReleaseBranchPytestFilter {
     return $filter
 }
 
-# Build with given parameters
-Function Invoke-Build {
+# Call build system with given parameters
+function Invoke-Build-System {
     param (
         [Parameter(Mandatory = $false)]
         [bool]$clean = $false,
         [Parameter(Mandatory = $false)]
+        [bool]$build = $false,
+        [Parameter(Mandatory = $false)]
         [string]$buildKit = "prod",
+        [Parameter(Mandatory = $false)]
+        [string]$buildType = "Debug",
         [Parameter(Mandatory = $true)]
         [string]$target = "all",
         [Parameter(Mandatory = $false)]
         [string[]]$variants = $null,
         [Parameter(Mandatory = $false)]
-        [string]$filter = "",
-        [Parameter(Mandatory = $false)]
         [string]$ninjaArgs = "",
         [Parameter(Mandatory = $false)]
-        [bool]$reconfigure = $false
+        [bool]$reconfigure = $false,
+        [Parameter(Mandatory = $false)]
+        [bool]$configureOnly = $false
     )
-    if ("selftests" -eq $target) {
-        # Run python tests to test all relevant variants and platforms (build kits)
-        # (normally run in CI environment/Jenkins)
-        Write-Output "Running all selfstests ..."
-
-        # Build folder for CMake builds
-        $buildFolder = "build"
-
-        # fresh and clean CMake builds
-        if ($clean) {
-            if (Test-Path -Path $buildFolder) {
-                Write-Output "Removing build folder '$buildFolder' ..."
-                Remove-Item $buildFolder -Force -Recurse
-            }
-        }
-
-        # Filter pytest test cases
-        $filterCmd = ''
-        $releaseBranchFilter = Get-ReleaseBranchPytestFilter
-        if ($releaseBranchFilter) {
-            $filterCmd = "-k '$releaseBranchFilter'"
+    # Determine variants to be built
+    $defaultVariantsFolder = ".\variants\"
+    if ((-Not $variants) -or ($variants -eq 'all')) {
+        $variantConfigs = Get-Childitem -Include config.cmake -Path $defaultVariantsFolder -Recurse | Resolve-Path -Relative
+        $variantsList = @()
+        Foreach ($variantConfig in $variantConfigs) {
+            $variant = ((Get-Item $variantConfig).Directory | Resolve-Path -Relative).Replace($defaultVariantsFolder, "").Replace("\", "/")
+            $variantsList += $variant
         }
-        # otherwise consider command line option '-filter' if given
-        elseif ($filter) {
-            $filterCmd = "-k '$filter'"
-        }
-
-        # Test result of pytest
-        $pytestJunitXml = "test/output/test-report.xml"
-
-        # Delete any old pytest result
-        if (Test-Path -Path $pytestJunitXml) {
-            Remove-Item $pytestJunitXml -Force
-        }
-
-        # Finally run pytest
-        Invoke-CommandLine -CommandLine ".venv\Scripts\pipenv run python -m pytest test --junitxml=$pytestJunitXml $filterCmd"
-    }
-    else {
-        if ((-Not $variants) -or ($variants -eq 'all')) {
-            $dirs = Get-Childitem -Include config.cmake -Path variants -Recurse | Resolve-Path -Relative
-            $variantsList = @()
-            Foreach ($dir in $dirs) {
-                $variant = (get-item $dir).Directory.BaseName
-                $variantsList += $variant
+        $variantsSelected = @()
+        if (-Not $variants) {
+            # variant selection by user if not specified
+            Write-Information -Tags "Info:" -MessageData "no '--variant <variant>' was given, please select from list:"
+            Write-Information -Tags "Info:" -MessageData ("(0) all variants")
+            Foreach ($variant in $variantsList) {
+                Write-Information -Tags "Info:" -MessageData ("(" + ([array]::IndexOf($variantsList, $variant) + 1) + ") " + $variant)
             }
-            $variantsSelected = @()
-            if (-Not $variants) {
-                # variant selection by user if not specified
-                Write-Information -Tags "Info:" -MessageData "no '--variant <variant>' was given, please select from list:"
-                Foreach ($variant in $variantsList) {
-                    Write-Information -Tags "Info:" -MessageData ("(" + [array]::IndexOf($variantsList, $variant) + ") " + $variant)
-                }
-                $variantsSelected += $variantsList[[int](Read-Host "Please enter selected variant number")]
-                Write-Information -Tags "Info:" -MessageData "Selected variant is: $variantsSelected"
+            $selection = [int](Read-Host "Please enter selected variant number")
+            if ($selection -eq 0) {
+                # build all variants
+                $variantsSelected = $variantsList
             }
             else {
-                # otherwise build all variants
-                $variantsSelected = $variantsList
+                # build selected variant
+                $variantsSelected += $variantsList[$selection - 1]
             }
+            Write-Information -Tags "Info:" -MessageData "Selected variants: $variantsSelected"
         }
         else {
-            $variantsSelected = $Variants.Replace('\', '/').Replace('./variant/', '').Replace('./variants/', '').Split(',')
+            # otherwise build all variants
+            $variantsSelected = $variantsList
         }
+    }
+    else {
+        $variantsSelected = $Variants.Replace($defaultVariantsFolder, "").Replace("\", "/").Split(',') | ForEach-Object { $_.TrimEnd('/') }
+    }
 
-        # Select 'test' build kit based on target
-        if ($target.Contains("unittests") -or $target.Contains("reports") -or $target.Contains("docs")) {
-            $buildKit = "test"
-        }
+    # Select 'test' build kit based on target
+    if ($target.Contains("unittests") -or $target.Contains("reports")) {
+        $buildKit = "test"
+    }
+    # If buildKit is 'test' then buildType is 'Debug'
+    if ($buildKit -eq "test") {
+        $buildType = "Debug"
+    }
 
-        Foreach ($variant in $variantsSelected) {
-            Write-Output "Building target '$target' with build kit '$buildKit' for variant '$variant' ..."
+    Foreach ($variant in $variantsSelected) {
+        $buildFolder = "build\$variant\$buildKit\$buildType".Replace("/", "\")
+        # fresh and clean build
+        if ($clean) {
+            Remove-Path $buildFolder
+        }
+        New-Directory $buildFolder
 
-            $buildFolder = "build/$variant/$buildKit"
-            # fresh and clean build
-            if ($clean) {
-                if (Test-Path -Path $buildFolder) {
-                    Write-Output "Removing build folder '$buildFolder' ..."
-                    Remove-Item $buildFolder -Force -Recurse
-                }
-            }
+        # delete CMake cache and reconfigure
+        if ($reconfigure -or $configureOnly) {
+            Remove-Path "$buildFolder\CMakeCache.txt"
+            Remove-Path "$buildFolder\CMakeFiles"
+        }
 
-            # delete CMake cache and reconfigure
-            if ($reconfigure) {
-                if (Test-Path -Path "$buildFolder/CMakeCache.txt") {
-                    Remove-Item "$buildFolder/CMakeCache.txt" -Force
-                }
-                if (Test-Path -Path "$buildFolder/CMakeFiles") {
-                    Remove-Item "$buildFolder/CMakeFiles" -Force -Recurse
-                }
-            }
+        if ($build) {
+            Write-Output "Building target '$target' with build kit '$buildKit' and build type '$buildType' for variant '$variant' ..."
 
             # CMake configure
             $additionalConfig = "-DBUILD_KIT='$buildKit'"
+            $additionalConfig += " -DBUILD_TYPE='$buildType'"
             if ($buildKit -eq "test") {
                 $additionalConfig += " -DCMAKE_TOOLCHAIN_FILE='tools/toolchains/gcc/toolchain.cmake'"
             }
-            Invoke-CommandLine -CommandLine ".venv\Scripts\pipenv run cmake -B '$buildFolder' -G Ninja -DVARIANT='$variant' $additionalConfig"
 
-            # CMake clean all dead artifacts. Required when running incremented builds to delete obsolete artifacts.
-            Invoke-CommandLine -CommandLine ".venv\Scripts\pipenv run cmake --build '$buildFolder' --target $target -- -t cleandead"
-            # CMake build
-            Invoke-CommandLine -CommandLine ".venv\Scripts\pipenv run cmake --build '$buildFolder' --target $target -- $ninjaArgs"
+            Invoke-CommandLine -CommandLine "cmake -B '$buildFolder' -G Ninja -DVARIANT='$variant' $additionalConfig"
+
+            if (-Not $configureOnly) {
+                $cmd = "cmake --build '$buildFolder' --config '$buildType' --target $target"
+
+                # CMake clean all dead artifacts. Required when running incremented builds to delete obsolete artifacts.
+                Invoke-CommandLine -CommandLine "$cmd -- -t cleandead"
+                # CMake build
+                Invoke-CommandLine -CommandLine "$cmd -- $ninjaArgs"
+            }
         }
     }
 }
 
+function Invoke-Self-Tests {
+    param (
+        [Parameter(Mandatory = $false)]
+        [bool]$clean = $false,
+        [Parameter(Mandatory = $false)]
+        [string]$filter = "",
+        [Parameter(Mandatory = $false)]
+        [string]$marker = ""
+    )
+
+    # Run python tests to test all relevant variants and platforms (build kits)
+    # (normally run in CI environment/Jenkins)
+    Write-Output "Running all self tests ..."
+
+    if ($clean) {
+        # Remove all build outputs in one step, this will remove obsolete variants, too.
+        Remove-Path "build"
+    }
+
+    # Test result of pytest
+    $pytestJunitXml = "test/output/test-report.xml"
+
+    # Delete any old pytest result
+    Remove-Path $pytestJunitXml
+
+    $pytestArgs = @(
+        "--junitxml=$pytestJunitXml"
+    )
+
+    # Filter pytest test cases
+    $releaseBranchFilter = Get-ReleaseBranchPytestFilter
+    if ($releaseBranchFilter) {
+        $pytestArgs += "-k '$releaseBranchFilter'"
+    }
+    # otherwise consider command line option '-filter' if given
+    elseif ($filter) {
+        $pytestArgs += "-k '$filter'"
+    }
+
+    # Execute marker tests
+    if ($marker) {
+        $pytestArgs += "-m '$marker'"
+    }
+
+    # Finally run pytest and ignore return value. Content of test-report.xml will be evaluated by CI system.
+    $commandLine = "pytest " + ($pytestArgs -join " ")
+    Invoke-CommandLine -CommandLine $commandLine -StopAtError $false
+}
+
+function Remove-Path {
+    param (
+        [Parameter(Mandatory = $true, Position = 0)]
+        [string]$path
+    )
+    if (Test-Path -Path $path -PathType Container) {
+        Write-Output "Deleting directory '$path' ..."
+        Remove-Item $path -Force -Recurse
+    }
+    elseif (Test-Path -Path $path -PathType Leaf) {
+        Write-Output "Deleting file '$path' ..."
+        Remove-Item $path -Force
+    }
+}
+
+function New-Directory {
+    param (
+        [Parameter(Mandatory = $true, Position = 0)]
+        [string]$dir
+    )
+    if (-Not (Test-Path -Path $dir)) {
+        Write-Output "Creating directory '$dir' ..."
+        New-Item -ItemType Directory $dir
+    }
+}
+
+function Get-User-Menu-Selection {
+    Clear-Host
+    Write-Information -Tags "Info:" -MessageData "None of the following command line options was given:"
+    Write-Information -Tags "Info:" -MessageData ("(1) -install: installation of mandatory dependencies")
+    Write-Information -Tags "Info:" -MessageData ("(2) -installOptional: installation of optional dependencies")
+    Write-Information -Tags "Info:" -MessageData ("(3) -installVSCode: installation of Visual Studio Code")
+    Write-Information -Tags "Info:" -MessageData ("(4) -build: execute CMake build")
+    Write-Information -Tags "Info:" -MessageData ("(5) -startVSCode: start Visual Studio Code")
+    Write-Information -Tags "Info:" -MessageData ("(6) quit: exit script")
+    return(Read-Host "Please make a selection")
+}
+
 function Invoke-Bootstrap {
     # Download bootstrap scripts from external repository
     Invoke-RestMethod -Uri https://raw.githubusercontent.com/avengineers/bootstrap-installer/v1.17.0/install.ps1 | Invoke-Expression
     # Execute bootstrap script
     . .\.bootstrap\bootstrap.ps1
-    # For incremental build: clean up virtual environment from old dependencies
-    Invoke-CommandLine ".venv\Scripts\pipenv clean"
 }
 
 ## start of script
@@ -241,30 +278,96 @@ Push-Location $PSScriptRoot
 Write-Output "Running in ${pwd}"
 
 try {
-    if (Test-RunningInCIorTestEnvironment -or $Env:USER_PATH_FIRST) {
-        Initialize-EnvPath
+    if ((-Not $install) -and (-Not $installOptional) -and (-Not $installVSCode) -and (-Not $build) -and (-Not $startVSCode) -and (-Not $command) -and (-Not $selftests)) {
+        $selectedOption = Get-User-Menu-Selection
+
+        switch ($selectedOption) {
+            '1' {
+                Write-Information -Tags "Info:" -MessageData "Installing mandatory dependencies ..."
+                $install = $true
+            }
+            '2' {
+                Write-Information -Tags "Info:" -MessageData "Installing optional dependencies ..."
+                $installOptional = $true
+            }
+            '3' {
+                Write-Information -Tags "Info:" -MessageData "Installing Visual Studio Code ..."
+                $installVSCode = $true
+            }
+            '4' {
+                Write-Information -Tags "Info:" -MessageData "Building ..."
+                $build = $true
+            }
+            '5' {
+                Write-Information -Tags "Info:" -MessageData "Starting VS Code ..."
+                $startVSCode = $true
+            }
+            default {
+                Write-Information -Tags "Info:" -MessageData "Nothing selected."
+                exit
+            }
+        }
     }
 
     if ($install) {
+        if ($clean) {
+            Remove-Path ".venv"
+        }
+
         # bootstrap environment
         Invoke-Bootstrap
+
+        Write-Host -ForegroundColor Black -BackgroundColor Blue "For installation changes to take effect, please close and re-open your current terminal."
+    }
+
+    # Load bootstrap's utility functions
+    . .\.bootstrap\utils.ps1
+
+    Invoke-CommandLine ".venv\Scripts\pypeline run --step GenerateEnvSetupScript"
+
+    # Load environment setup script
+    . .\build\env_setup.ps1
+
+    if ($installOptional) {
+        Import-ScoopFile "scoopfile-optional.json"
+    }
+
+    if ($installVSCode) {
+        Invoke-CommandLine "scoop bucket add extras" -StopAtError $false
+        Invoke-CommandLine "scoop install vscode"
+        Invoke-CommandLine "scoop update vscode" -StopAtError $false
+    }
+
+    if ($startVSCode) {
+        Write-Output "Starting Visual Studio Code..."
+        Invoke-CommandLine "code ." -StopAtError $false
     }
 
     if ($build) {
-        # Call build system
-        Invoke-Build `
+        # Call build system to build variant(s)
+        Invoke-Build-System `
+            -clean $clean `
+            -build $build `
             -target $target `
             -buildKit $buildKit `
+            -buildType $buildType `
             -variants $variants `
-            -clean $clean `
             -reconfigure $reconfigure `
-            -ninjaArgs $ninjaArgs `
-            -filter $filter
+            -configureOnly $configureOnly `
+            -ninjaArgs $ninjaArgs
+    }
+
+    if ($selftests) {
+        Invoke-Self-Tests -clean $clean -filter $filter -marker $marker
+    }
+
+    if ($command -ne '') {
+        Invoke-Expression "$command"
     }
 }
 finally {
     Pop-Location
-    if (-Not (Test-RunningInCIorTestEnvironment)) {
+    if (-Not (Test-RunningInCIorTestEnvironment) -and $waitForKey) {
         Read-Host -Prompt "Press Enter to continue ..."
     }
 }

spl_core/kickstart/templates/project/conf.py

@@ -1,8 +1,9 @@
-""" Configuration  """
+# -*- coding: utf-8 -*-
+"""Configuration"""
 
-import datetime
 import json
 import os
+import datetime
 import re
 
 day = datetime.date.today()
@@ -43,12 +44,12 @@ html_title = f"{project} {release}"
 
 html_theme = "sphinx_rtd_theme"
 
-# Hide hyper link which leeds to the source of page displayed
+# Show hyper link which leeds to the source of page displayed
 html_show_sourcelink = True
 
 html_theme_options = {
     "canonical_url": "",
-    "analytics_id": "",  #  Provided by Google in your dashboard
+    "analytics_id": "",  # Provided by Google in your dashboard
     "display_version": True,
     "prev_next_buttons_location": "bottom",
     "style_external_links": True,
@@ -70,13 +71,10 @@ extensions = []
 extensions.append("sphinx_rtd_size")
 sphinx_rtd_size_width = "90%"
 
-# mermaid config - @see https://pypi.org/project/sphinxcontrib-mermaid/ #####
 extensions.append("sphinxcontrib.mermaid")
 
-# sphinx_needs ###############################################################
 extensions.append("sphinx_needs")
 
-# test_reports ###############################################################
 extensions.append("sphinxcontrib.test_reports")
 tr_report_template = "doc/test_report_template.txt"
 
@@ -143,14 +141,14 @@ needs_types = [
     ),
 ]
 
-
 # Define own options
-needs_extra_options = ["integrity", "assignee", "version"]
-
+needs_extra_options = ["integrity"]
 
 # Define own link types
 needs_extra_links = [
     # SWE.3 BP.5: link from Implementation (Software unit) to Specification (Software detailed design)
+    # AND
+    # SWE.2 BP.7: link from Requirements (Software Requirement) to Architecture (Software Architecture)
     {"option": "implements", "incoming": "is implemented by", "outgoing": "implements"},
     # SWE.4 BP.5: link from Test Case (Unit test specification) to Specification (Software detailed design)
     {"option": "tests", "incoming": "is tested by", "outgoing": "tests"},
@@ -169,19 +167,20 @@ html_context = {
     "config": {},
 }
 
-# Check if the SPHINX_BUILD_CONFIGURATION_FILE environment variable exists
-# and if so, load the JSON file and set the 'html_context' variable
+# pass build configuration to jinja
 if "SPHINX_BUILD_CONFIGURATION_FILE" in os.environ:
-    with open(os.environ["SPHINX_BUILD_CONFIGURATION_FILE"]) as file:
+    with open(os.environ["SPHINX_BUILD_CONFIGURATION_FILE"], "r") as file:
         html_context["build_config"] = json.load(file)
-        include_patterns.extend(html_context["build_config"].get("include_patterns", []))
+        include_patterns.extend(
+            html_context["build_config"].get("include_patterns", [])
+        )
 
-# Check if the SPHINX_BUILD_CONFIGURATION_FILE environment variable exists
-# and if so, load the JSON file and set the 'html_context' variable
+# pass feature configuration to jinja
 if "AUTOCONF_JSON_FILE" in os.environ:
-    with open(os.environ["AUTOCONF_JSON_FILE"]) as file:
+    with open(os.environ["AUTOCONF_JSON_FILE"], "r") as file:
         html_context["config"] = json.load(file)["features"]
 
+# we almost forgot the variant :o)
 if "VARIANT" in os.environ:
     html_context["build_config"]["variant"] = os.environ["VARIANT"]
 

spl_core/kickstart/templates/project/pypeline.yaml

@@ -0,0 +1,9 @@
+pipeline:
+  - step: CreateVEnv
+    module: pypeline.steps.create_venv
+    config:
+      bootstrap_script: .bootstrap/bootstrap.py
+  - step: ScoopInstall
+    module: pypeline.steps.scoop_install
+  - step: GenerateEnvSetupScript
+    module: pypeline.steps.env_setup_script

spl_core/kickstart/templates/project/pyproject.toml

@@ -0,0 +1,18 @@
+[project]
+name = "spled"
+version = "0.0.1"
+description = "SPL demo project"
+authors = [
+    {name = "Avengineers"},
+]
+requires-python = "<3.12,>=3.10"
+
+dependencies = [
+    "spl-core>=7,<8",
+    "pypeline-runner>=1,<2",
+    "pytest>=8,<9",
+    "pip_system_certs>=4.0,<5",
+]
+
+[tool.poetry]
+package-mode = false

spl_core/kickstart/templates/project/pytest.ini

@@ -1,10 +1,15 @@
 [pytest]
 pythonpath =
-    test
+    "test"
 testpaths =
-    test
+    "test"
 junit_logging = all
 addopts =
-    -vv
     --capture=tee-sys
-    --junitxml=build/test-report.xml
+    --verbose
+markers =
+    just_a_try: mark a test as a try
+    unittests: tests of individual units of code
+    reports: tests of the report generation
+    build: tests of the target builds
+    static_analysis: tests of static code analysis

spl_core/kickstart/templates/project/scoopfile.json

@@ -1,14 +1,23 @@
 {
-  "buckets": [
-    {
-      "Name": "versions",
-      "Source": "https://github.com/ScoopInstaller/Versions"
-    }
-  ],
-  "apps": [
-    {
-      "Source": "versions",
-      "Name": "mingw-winlibs-llvm-ucrt"
-    }
-  ]
+    "buckets": [
+        {
+            "Name": "spl",
+            "Source": "https://github.com/avengineers/spl-bucket"
+        },
+        {
+            "Name": "main",
+            "Source": "https://github.com/ScoopInstaller/Main"
+        }
+    ],
+    "apps": [
+        {
+            "Source": "main",
+            "Name": "graphviz"
+        },
+        {
+            "Source": "spl",
+            "Name": "mingw-winlibs-llvm-ucrt",
+            "Version": "14.2.0-19.1.1-12.0.0-r2"
+        }
+    ]
 }

spl_core/kickstart/templates/project/tools/toolchains/clang/toolchain.cmake

@@ -1,8 +1,3 @@
-# TODO: caching required due to cmake tools extension issue: https://github.com/microsoft/vscode-cmake-tools/issues/1188
-# TODO: get debugging running (lldb-mi not found in any current package, switching back to gcc)
 set(CMAKE_C_COMPILER clang CACHE STRING "C Compiler")
-# TODO: clarify why llvm-cov produces invalid gcov files (contain blank lines), related GCOVR issue: https://github.com/gcovr/gcovr/issues/331
-set(GCOVR_ADDITIONAL_OPTIONS --gcov-executable \"llvm-cov gcov\" --gcov-ignore-parse-errors --html-title \"Code Coverage Report \(tool suite: LLVM Clang\)\")
-
 set(CMAKE_CXX_COMPILER clang++ CACHE STRING "CXX Compiler")
 set(CMAKE_ASM_COMPILER ${CMAKE_C_COMPILER} CACHE STRING "ASM Compiler")