ScriptCollection 3.5.13__py3-none-any.whl → 3.5.15__py3-none-any.whl

ScriptCollection/Executables.py

@@ -356,3 +356,16 @@ def ChangeFileExtensions() -> int:
     args = parser.parse_args()
     ScriptCollectionCore().change_file_extensions(args.folder, args.source_extension, args.target_extension, args.recursive, args.ignore_case)
     return 0
+
+
+def GenerateARC42ReferenceTemplate() -> int:
+    parser = argparse.ArgumentParser()
+    parser.add_argument('-f', '--folder', required=False)
+    parser.add_argument('-p', '--productname', required=False)
+    args = parser.parse_args()
+
+    folder = args.folder
+    if folder is None:
+        folder = os.getcwd()
+    ScriptCollectionCore().generate_arc42_reference_template(folder, args.productname)
+    return 0

ScriptCollection/GeneralUtilities.py

@@ -67,7 +67,7 @@ class GeneralUtilities:
         @functools.wraps(func)
         def new_func(*args, **kwargs):
             warnings.simplefilter('always', DeprecationWarning)
-            warnings.warn(f"Call to deprecated function {func.__name__}",                        category=DeprecationWarning,                        stacklevel=2)
+            warnings.warn(f"Call to deprecated function {func.__name__}", category=DeprecationWarning, stacklevel=2)
             warnings.simplefilter('default', DeprecationWarning)
             return func(*args, **kwargs)
         return new_func

ScriptCollection/ProgramRunnerPopen.py

@@ -7,7 +7,7 @@ from .ProgramRunnerBase import ProgramRunnerBase
 class ProgramRunnerPopen(ProgramRunnerBase):
 
     @GeneralUtilities.check_arguments
-    def run_program_argsasarray_async_helper(self, program: str, arguments_as_array: list[str] = [], working_directory: str = None, custom_argument: object = None, interactive:bool=False) -> Popen:
+    def run_program_argsasarray_async_helper(self, program: str, arguments_as_array: list[str] = [], working_directory: str = None, custom_argument: object = None, interactive: bool = False) -> Popen:
         arguments_for_process = [program]
         arguments_for_process.extend(arguments_as_array)
         # "shell=True" is not allowed because it is not recommended and also something like
@@ -15,9 +15,9 @@ class ProgramRunnerPopen(ProgramRunnerBase):
         # would not be possible anymore because the ampersand will be treated as shell-command.
         try:
             if interactive:
-                result = Popen(arguments_for_process, cwd=working_directory , stdout=PIPE, stderr=PIPE, shell=False, stdin = sys.stdin)  # pylint: disable=consider-using-with
+                result = Popen(arguments_for_process, cwd=working_directory, stdout=PIPE, stderr=PIPE, shell=False, text=True, stdin=sys.stdin)  # pylint: disable=consider-using-with
             else:
-                result = Popen(arguments_for_process, cwd=working_directory,  stdout=PIPE, stderr=PIPE, shell=False)  # pylint: disable=consider-using-with
+                result = Popen(arguments_for_process, cwd=working_directory,  stdout=PIPE, stderr=PIPE, shell=False, text=True)  # pylint: disable=consider-using-with
         except FileNotFoundError as fileNotFoundError:
             raise FileNotFoundError(f"Starting '{program}' in '{working_directory}' resulted in a FileNotFoundError: '{fileNotFoundError.filename}'")
         return result
@@ -34,18 +34,18 @@ class ProgramRunnerPopen(ProgramRunnerBase):
         return result
 
     @GeneralUtilities.check_arguments
-    def run_program_argsasarray(self, program: str, arguments_as_array: list[str] = [], working_directory: str = None, custom_argument: object = None, interactive:bool=False) -> tuple[int, str, str, int]:
-        process: Popen = self.run_program_argsasarray_async_helper(program, arguments_as_array, working_directory, custom_argument,interactive)
+    def run_program_argsasarray(self, program: str, arguments_as_array: list[str] = [], working_directory: str = None, custom_argument: object = None, interactive: bool = False) -> tuple[int, str, str, int]:
+        process: Popen = self.run_program_argsasarray_async_helper(program, arguments_as_array, working_directory, custom_argument, interactive)
         return self.wait(process, custom_argument)
 
     @GeneralUtilities.check_arguments
-    def run_program(self, program: str, arguments: str = "", working_directory: str = None, custom_argument: object = None, interactive:bool=False) -> tuple[int, str, str, int]:
+    def run_program(self, program: str, arguments: str = "", working_directory: str = None, custom_argument: object = None, interactive: bool = False) -> tuple[int, str, str, int]:
         return self.run_program_argsasarray(program, GeneralUtilities.arguments_to_array(arguments), working_directory, custom_argument)
 
     @GeneralUtilities.check_arguments
-    def run_program_argsasarray_async(self, program: str, arguments_as_array: list[str] = [], working_directory: str = None, custom_argument: object = None, interactive:bool=False) -> int:
-        return self.run_program_argsasarray_async_helper(program, arguments_as_array, working_directory, custom_argument,interactive).pid
+    def run_program_argsasarray_async(self, program: str, arguments_as_array: list[str] = [], working_directory: str = None, custom_argument: object = None, interactive: bool = False) -> int:
+        return self.run_program_argsasarray_async_helper(program, arguments_as_array, working_directory, custom_argument, interactive).pid
 
     @GeneralUtilities.check_arguments
-    def run_program_async(self, program: str, arguments: str = "", working_directory: str = None, custom_argument: object = None, interactive:bool=False) -> int:
-        return self.run_program_argsasarray_async(program, GeneralUtilities.arguments_to_array(arguments), working_directory, custom_argument,interactive)
+    def run_program_async(self, program: str, arguments: str = "", working_directory: str = None, custom_argument: object = None, interactive: bool = False) -> int:
+        return self.run_program_argsasarray_async(program, GeneralUtilities.arguments_to_array(arguments), working_directory, custom_argument, interactive)

ScriptCollection/ScriptCollectionCore.py

@@ -1,19 +1,20 @@
-import time
+import sys
 from datetime import timedelta, datetime
 import json
 import binascii
 import filecmp
 import hashlib
-from io import BufferedReader, BytesIO
+import time
+from io import BytesIO
 import itertools
 import math
 import os
+from queue import Queue, Empty
+from concurrent.futures import ThreadPoolExecutor
 from pathlib import Path
-from random import randrange
 from subprocess import Popen
 import re
 import shutil
-import traceback
 import uuid
 import tempfile
 import io
@@ -29,7 +30,7 @@ from .ProgramRunnerBase import ProgramRunnerBase
 from .ProgramRunnerPopen import ProgramRunnerPopen
 from .ProgramRunnerEpew import ProgramRunnerEpew, CustomEpewArgument
 
-version = "3.5.13"
+version = "3.5.15"
 __version__ = version
 
 
@@ -40,11 +41,12 @@ class ScriptCollectionCore:
     mock_program_calls: bool = False
     # The purpose of this property is to use it when testing your code which uses scriptcollection for external program-calls.
     execute_program_really_if_no_mock_call_is_defined: bool = False
-    __mocked_program_calls: list = list()
+    __mocked_program_calls: list = None
     program_runner: ProgramRunnerBase = None
 
     def __init__(self):
         self.program_runner = ProgramRunnerPopen()
+        self.__mocked_program_calls = list[ScriptCollectionCore.__MockProgramCall]()
 
     @staticmethod
     @GeneralUtilities.check_arguments
@@ -59,8 +61,7 @@ class ScriptCollectionCore:
             errorsonly_argument = ""
         else:
             errorsonly_argument = " --errors-only"
-        (exit_code, stdout, stderr, _) = self.run_program("pylint", filename +
-                                                          errorsonly_argument, working_directory, throw_exception_if_exitcode_is_not_zero=False)
+        (exit_code, stdout, stderr, _) = self.run_program("pylint", filename + errorsonly_argument, working_directory, throw_exception_if_exitcode_is_not_zero=False)
         if (exit_code != 0):
             errors.append(f"Linting-issues of {file}:")
             errors.append(f"Pylint-exitcode: {exit_code}")
@@ -74,18 +75,15 @@ class ScriptCollectionCore:
 
     @GeneralUtilities.check_arguments
     def replace_version_in_dockerfile_file(self, dockerfile: str, new_version_value: str) -> None:
-        GeneralUtilities.write_text_to_file(dockerfile, re.sub(
-            "ARG Version=\"\\d+\\.\\d+\\.\\d+\"", f"ARG Version=\"{new_version_value}\"", GeneralUtilities.read_text_from_file(dockerfile)))
+        GeneralUtilities.write_text_to_file(dockerfile, re.sub("ARG Version=\"\\d+\\.\\d+\\.\\d+\"", f"ARG Version=\"{new_version_value}\"", GeneralUtilities.read_text_from_file(dockerfile)))
 
     @GeneralUtilities.check_arguments
     def replace_version_in_python_file(self, file: str, new_version_value: str):
-        GeneralUtilities.write_text_to_file(file, re.sub(
-            "version = \"\\d+\\.\\d+\\.\\d+\"", f"version = \"{new_version_value}\"", GeneralUtilities.read_text_from_file(file)))
+        GeneralUtilities.write_text_to_file(file, re.sub("version = \"\\d+\\.\\d+\\.\\d+\"", f"version = \"{new_version_value}\"", GeneralUtilities.read_text_from_file(file)))
 
     @GeneralUtilities.check_arguments
     def replace_version_in_ini_file(self, file: str, new_version_value: str):
-        GeneralUtilities.write_text_to_file(file, re.sub(
-            "version = \\d+\\.\\d+\\.\\d+", f"version = {new_version_value}", GeneralUtilities.read_text_from_file(file)))
+        GeneralUtilities.write_text_to_file(file, re.sub("version = \\d+\\.\\d+\\.\\d+", f"version = {new_version_value}", GeneralUtilities.read_text_from_file(file)))
 
     @GeneralUtilities.check_arguments
     def replace_version_in_nuspec_file(self, nuspec_file: str, new_version: str) -> None:
@@ -96,8 +94,7 @@ class ScriptCollectionCore:
         if pattern.match(new_version):
             GeneralUtilities.write_text_to_file(nuspec_file, re.sub(f"<version>{versionregex}<\\/version>", f"<version>{new_version}</version>", GeneralUtilities.read_text_from_file(nuspec_file)))
         else:
-            raise ValueError(
-                f"Version '{new_version}' does not match version-regex '{versiononlyregex}'")
+            raise ValueError(f"Version '{new_version}' does not match version-regex '{versiononlyregex}'")
 
     @GeneralUtilities.check_arguments
     def replace_version_in_csproj_file(self, csproj_file: str, current_version: str):
@@ -106,25 +103,20 @@ class ScriptCollectionCore:
         pattern = re.compile(versiononlyregex)
         if pattern.match(current_version):
             for tag in ["Version", "AssemblyVersion", "FileVersion"]:
-                GeneralUtilities.write_text_to_file(csproj_file, re.sub(
-                    f"<{tag}>{versionregex}(.\\d+)?<\\/{tag}>", f"<{tag}>{current_version}</{tag}>", GeneralUtilities.read_text_from_file(csproj_file)))
+                GeneralUtilities.write_text_to_file(csproj_file, re.sub(f"<{tag}>{versionregex}(.\\d+)?<\\/{tag}>", f"<{tag}>{current_version}</{tag}>", GeneralUtilities.read_text_from_file(csproj_file)))
         else:
-            raise ValueError(
-                f"Version '{current_version}' does not match version-regex '{versiononlyregex}'")
+            raise ValueError(f"Version '{current_version}' does not match version-regex '{versiononlyregex}'")
 
     @GeneralUtilities.check_arguments
     def push_nuget_build_artifact(self, nupkg_file: str, registry_address: str, api_key: str, verbosity: int = 1):
         nupkg_file_name = os.path.basename(nupkg_file)
         nupkg_file_folder = os.path.dirname(nupkg_file)
-        self.run_program(
-            "dotnet", f"nuget push {nupkg_file_name} --force-english-output --source {registry_address} --api-key {api_key}", nupkg_file_folder, verbosity)
+        self.run_program("dotnet", f"nuget push {nupkg_file_name} --force-english-output --source {registry_address} --api-key {api_key}", nupkg_file_folder, verbosity)
 
     @GeneralUtilities.check_arguments
     def dotnet_build(self, repository_folder: str, projectname: str, configuration: str):
-        self.run_program(
-            "dotnet", f"clean -c {configuration}", repository_folder)
-        self.run_program(
-            "dotnet", f"build {projectname}/{projectname}.csproj -c {configuration}", repository_folder)
+        self.run_program("dotnet", f"clean -c {configuration}", repository_folder)
+        self.run_program("dotnet", f"build {projectname}/{projectname}.csproj -c {configuration}", repository_folder)
 
     @GeneralUtilities.check_arguments
     def find_file_by_extension(self, folder: str, extension: str):
@@ -162,8 +154,7 @@ class ScriptCollectionCore:
             subfolder_argument = ""
         else:
             subfolder_argument = f" -- {subfolder}"
-        log_result = self.run_program(
-            "git", f'log --pretty=%aN{space_character}%aE%n%cN{space_character}%cE HEAD{subfolder_argument}', repository_folder, verbosity=0)
+        log_result = self.run_program("git", f'log --pretty=%aN{space_character}%aE%n%cN{space_character}%cE HEAD{subfolder_argument}', repository_folder, verbosity=0)
         plain_content: list[str] = list(
             set([line for line in log_result[1].split("\n") if len(line) > 0]))
         result: list[tuple[str, str]] = []
@@ -179,8 +170,7 @@ class ScriptCollectionCore:
     def get_commit_ids_between_dates(self, repository_folder: str, since: datetime, until: datetime, ignore_commits_which_are_not_in_history_of_head: bool = True) -> None:
         since_as_string = self.__datetime_to_string_for_git(since)
         until_as_string = self.__datetime_to_string_for_git(until)
-        result = filter(lambda line: not GeneralUtilities.string_is_none_or_whitespace(line), self.run_program(
-            "git", f'log --since "{since_as_string}" --until "{until_as_string}" --pretty=format:"%H" --no-patch', repository_folder, throw_exception_if_exitcode_is_not_zero=True)[1].split("\n").replace("\r", ""))
+        result = filter(lambda line: not GeneralUtilities.string_is_none_or_whitespace(line), self.run_program("git", f'log --since "{since_as_string}" --until "{until_as_string}" --pretty=format:"%H" --no-patch', repository_folder, throw_exception_if_exitcode_is_not_zero=True)[1].split("\n").replace("\r", ""))
         if ignore_commits_which_are_not_in_history_of_head:
             result = [commit_id for commit_id in result if self.git_commit_is_ancestor(
                 repository_folder, commit_id)]
@@ -192,8 +182,7 @@ class ScriptCollectionCore:
 
     @GeneralUtilities.check_arguments
     def git_commit_is_ancestor(self, repository_folder: str,  ancestor: str, descendant: str = "HEAD") -> bool:
-        exit_code = self.run_program_argsasarray(
-            "git", ["merge-base", "--is-ancestor", ancestor, descendant], repository_folder, throw_exception_if_exitcode_is_not_zero=False)[0]
+        exit_code = self.run_program_argsasarray("git", ["merge-base", "--is-ancestor", ancestor, descendant], repository_folder, throw_exception_if_exitcode_is_not_zero=False)[0]
         if exit_code == 0:
             return True
         elif exit_code == 1:
@@ -203,8 +192,7 @@ class ScriptCollectionCore:
 
     @GeneralUtilities.check_arguments
     def __git_changes_helper(self, repository_folder: str, arguments_as_array: list[str]) -> bool:
-        lines = GeneralUtilities.string_to_lines(self.run_program_argsasarray(
-            "git", arguments_as_array, repository_folder, throw_exception_if_exitcode_is_not_zero=True, verbosity=0)[1], False)
+        lines = GeneralUtilities.string_to_lines(self.run_program_argsasarray("git", arguments_as_array, repository_folder, throw_exception_if_exitcode_is_not_zero=True, verbosity=0)[1], False)
         for line in lines:
             if GeneralUtilities.string_has_content(line):
                 return True
@@ -245,8 +233,7 @@ class ScriptCollectionCore:
 
     @GeneralUtilities.check_arguments
     def git_get_commit_date(self, repository_folder: str, commit: str = "HEAD") -> datetime:
-        result: tuple[int, str, str, int] = self.run_program_argsasarray(
-            "git", ["show", "-s", "--format=%ci", commit], repository_folder, throw_exception_if_exitcode_is_not_zero=True, verbosity=0)
+        result: tuple[int, str, str, int] = self.run_program_argsasarray("git", ["show", "-s", "--format=%ci", commit], repository_folder, throw_exception_if_exitcode_is_not_zero=True, verbosity=0)
         date_as_string = result[1].replace('\n', '')
         result = datetime.strptime(date_as_string, '%Y-%m-%d %H:%M:%S %z')
         return result
@@ -359,8 +346,7 @@ class ScriptCollectionCore:
         self.run_program_argsasarray("git", ['checkout', '.'], directory, throw_exception_if_exitcode_is_not_zero=True, verbosity=0)
 
     @GeneralUtilities.check_arguments
-    def git_commit(self, directory: str, message: str, author_name: str = None, author_email: str = None, stage_all_changes: bool = True,
-                   no_changes_behavior: int = 0) -> str:
+    def git_commit(self, directory: str, message: str, author_name: str = None, author_email: str = None, stage_all_changes: bool = True, no_changes_behavior: int = 0) -> str:
         # no_changes_behavior=0 => No commit
         # no_changes_behavior=1 => Commit anyway
         # no_changes_behavior=2 => Exception
@@ -410,7 +396,7 @@ class ScriptCollectionCore:
     @GeneralUtilities.check_arguments
     def git_checkout(self, directory: str, branch: str) -> None:
         self.run_program_argsasarray("git", ["checkout", branch], directory, throw_exception_if_exitcode_is_not_zero=True, verbosity=0)
-        self.run_program_argsasarray("git", ["submodule", "update", "--recursive"],                                     directory, throw_exception_if_exitcode_is_not_zero=True, verbosity=0)
+        self.run_program_argsasarray("git", ["submodule", "update", "--recursive"], directory, throw_exception_if_exitcode_is_not_zero=True, verbosity=0)
 
     @GeneralUtilities.check_arguments
     def git_merge_abort(self, directory: str) -> None:
@@ -450,7 +436,7 @@ class ScriptCollectionCore:
                     self.git_fetch(target_directory)
                 else:
                     # clone
-                    self.git_clone(target_repository, source_repository,                                   include_submodules=True, mirror=True)
+                    self.git_clone(target_repository, source_repository, include_submodules=True, mirror=True)
 
     def get_git_submodules(self, folder: str) -> list[str]:
         e = self.run_program("git", "submodule status", folder)
@@ -472,8 +458,7 @@ class ScriptCollectionCore:
             return True
         if (exit_code == 1):
             return False
-        raise ValueError(
-            f"Unable to calculate whether '{file_in_repository}' in repository '{repositorybasefolder}' is ignored due to git-exitcode {exit_code}.")
+        raise ValueError(f"Unable to calculate whether '{file_in_repository}' in repository '{repositorybasefolder}' is ignored due to git-exitcode {exit_code}.")
 
     @GeneralUtilities.check_arguments
     def git_discard_all_changes(self, repository: str) -> None:
@@ -553,8 +538,7 @@ class ScriptCollectionCore:
         for file_or_folder, item_type in items.items():
             truncated_file = file_or_folder[path_prefix:]
             if (filter_function is None or filter_function(folder, truncated_file)):
-                owner_and_permisssion = self.get_file_owner_and_file_permission(
-                    file_or_folder)
+                owner_and_permisssion = self.get_file_owner_and_file_permission(file_or_folder)
                 user = owner_and_permisssion[0]
                 permissions = owner_and_permisssion[1]
                 lines.append(f"{truncated_file};{item_type};{user};{permissions}")
@@ -579,8 +563,7 @@ class ScriptCollectionCore:
             foldername = os.path.basename(subfolder)
             if ".git" in foldername:
                 new_name = foldername.replace(".git", ".gitx")
-                subfolder2 = os.path.join(
-                    str(Path(subfolder).parent), new_name)
+                subfolder2 = os.path.join(str(Path(subfolder).parent), new_name)
                 os.rename(subfolder, subfolder2)
                 renamed_items[subfolder2] = subfolder
             else:
@@ -921,29 +904,6 @@ class ScriptCollectionCore:
                 line[0], line[1], line[2], line[3], line[4])
         GeneralUtilities.write_message_to_stdout(separator_line)
 
-    @GeneralUtilities.check_arguments
-    def SCUploadFileToFileHost(self, file: str, host: str) -> int:
-        try:
-            GeneralUtilities.write_message_to_stdout(
-                self.upload_file_to_file_host(file, host))
-            return 0
-        except Exception as exception:
-            GeneralUtilities.write_exception_to_stderr_with_traceback(exception, traceback)
-            return 1
-
-    @GeneralUtilities.check_arguments
-    def SCFileIsAvailableOnFileHost(self, file: str) -> int:
-        try:
-            if self.file_is_available_on_file_host(file):
-                GeneralUtilities.write_message_to_stdout(f"'{file}' is available")
-                return 0
-            else:
-                GeneralUtilities.write_message_to_stdout(f"'{file}' is not available")
-                return 1
-        except Exception as exception:
-            GeneralUtilities.write_exception_to_stderr_with_traceback(exception, traceback)
-            return 2
-
     @GeneralUtilities.check_arguments
     def SCCalculateBitcoinBlockHash(self, block_version_number: str, previousblockhash: str, transactionsmerkleroot: str, timestamp: str, target: str, nonce: str) -> str:
         # Example-values:
@@ -994,13 +954,11 @@ class ScriptCollectionCore:
                 with (open(full_path, "rb").read()) as text_io_wrapper:
                     content = text_io_wrapper
                     path_in_iso = '/' + files_directory + \
-                        self.__adjust_folder_name(
-                            full_path[len(folder)::1]).upper()
+                        self.__adjust_folder_name(full_path[len(folder)::1]).upper()
                     if path_in_iso not in created_directories:
                         iso.add_directory(path_in_iso)
                         created_directories.append(path_in_iso)
-                    iso.add_fp(BytesIO(content), len(content),
-                               path_in_iso + '/' + file.upper() + ';1')
+                    iso.add_fp(BytesIO(content), len(content), path_in_iso + '/' + file.upper() + ';1')
         iso.write(iso_file)
         iso.close()
 
@@ -1048,8 +1006,7 @@ class ScriptCollectionCore:
                 new_file_name = os.path.join(
                     os.path.dirname(file), new_file_name_without_path)
                 os.rename(file, new_file_name)
-                GeneralUtilities.append_line_to_file(namemappingfile, os.path.basename(
-                    file) + ";" + new_file_name_without_path + ";" + hash_value)
+                GeneralUtilities.append_line_to_file(namemappingfile, os.path.basename(file) + ";" + new_file_name_without_path + ";" + hash_value)
         else:
             raise ValueError(f"Directory not found: '{inputfolder}'")
 
@@ -1066,15 +1023,12 @@ class ScriptCollectionCore:
         for line in reversed(lines):
             if not GeneralUtilities.string_is_none_or_whitespace(line):
                 if "RunningHealthy (" in line:  # TODO use regex
-                    GeneralUtilities.write_message_to_stderr(
-                        f"Healthy running due to line '{line}' in file '{file}'.")
+                    GeneralUtilities.write_message_to_stderr(f"Healthy running due to line '{line}' in file '{file}'.")
                     return 0
                 else:
-                    GeneralUtilities.write_message_to_stderr(
-                        f"Not healthy running due to line '{line}' in file '{file}'.")
+                    GeneralUtilities.write_message_to_stderr(f"Not healthy running due to line '{line}' in file '{file}'.")
                     return 1
-        GeneralUtilities.write_message_to_stderr(
-            f"No valid line found for healthycheck in file '{file}'.")
+        GeneralUtilities.write_message_to_stderr(f"No valid line found for healthycheck in file '{file}'.")
         return 2
 
     @GeneralUtilities.check_arguments
@@ -1132,44 +1086,6 @@ class ScriptCollectionCore:
         tor_version = version_with_overhead.split("~")[0]
         return tor_version
 
-    @GeneralUtilities.check_arguments
-    def upload_file_to_file_host(self, file: str, host: str) -> int:
-        if (host is None):
-            return self.upload_file_to_random_filesharing_service(file)
-        elif host == "anonfiles.com":
-            return self.upload_file_to_anonfiles(file)
-        elif host == "bayfiles.com":
-            return self.upload_file_to_bayfiles(file)
-        GeneralUtilities.write_message_to_stderr("Unknown host: "+host)
-        return 1
-
-    @GeneralUtilities.check_arguments
-    def upload_file_to_random_filesharing_service(self, file: str) -> int:
-        host = randrange(2)
-        if host == 0:
-            return self.upload_file_to_anonfiles(file)
-        if host == 1:
-            return self.upload_file_to_bayfiles(file)
-        return 1
-
-    @GeneralUtilities.check_arguments
-    def upload_file_to_anonfiles(self, file) -> int:
-        return self.upload_file_by_using_simple_curl_request("https://api.anonfiles.com/upload", file)
-
-    @GeneralUtilities.check_arguments
-    def upload_file_to_bayfiles(self, file) -> int:
-        return self.upload_file_by_using_simple_curl_request("https://api.bayfiles.com/upload", file)
-
-    @GeneralUtilities.check_arguments
-    def upload_file_by_using_simple_curl_request(self, api_url: str, file: str) -> int:
-        # TODO implement
-        return 1
-
-    @GeneralUtilities.check_arguments
-    def file_is_available_on_file_host(self, file) -> int:
-        # TODO implement
-        return 1
-
     def run_testcases_for_python_project(self, repository_folder: str):
         self.run_program("coverage", "run -m pytest", repository_folder)
         self.run_program("coverage", "xml", repository_folder)
@@ -1180,13 +1096,12 @@ class ScriptCollectionCore:
 
     @GeneralUtilities.check_arguments
     def get_file_permission(self, file: str) -> str:
-        """This function returns an usual octet-triple, for example "0700"."""
-        ls_output = self.__ls(file)
+        """This function returns an usual octet-triple, for example "700"."""
+        ls_output: str = self.run_ls_for_folder(file)
         return self.__get_file_permission_helper(ls_output)
 
     @GeneralUtilities.check_arguments
-    def __get_file_permission_helper(self, ls_output: str) -> str:
-        permissions = ' '.join(ls_output.split()).split(' ')[0][1:]
+    def __get_file_permission_helper(self, permissions: str) -> str:
         return str(self.__to_octet(permissions[0:3]))+str(self.__to_octet(permissions[3:6]))+str(self.__to_octet(permissions[6:9]))
 
     @GeneralUtilities.check_arguments
@@ -1203,33 +1118,44 @@ class ScriptCollectionCore:
     @GeneralUtilities.check_arguments
     def get_file_owner(self, file: str) -> str:
         """This function returns the user and the group in the format "user:group"."""
-        ls_output = self.__ls(file)
+        ls_output: str = self.run_ls_for_folder(file)
         return self.__get_file_owner_helper(ls_output)
 
     @GeneralUtilities.check_arguments
     def __get_file_owner_helper(self, ls_output: str) -> str:
-        try:
-            splitted = ' '.join(ls_output.split()).split(' ')
-            return f"{splitted[2]}:{splitted[3]}"
-        except Exception as exception:
-            raise ValueError(
-                f"ls-output '{ls_output}' not parsable") from exception
+        splitted = ls_output.split()
+        return f"{splitted[2]}:{splitted[3]}"
 
     @GeneralUtilities.check_arguments
     def get_file_owner_and_file_permission(self, file: str) -> str:
-        ls_output = self.__ls(file)
+        ls_output: str = self.run_ls_for_folder(file)
         return [self.__get_file_owner_helper(ls_output), self.__get_file_permission_helper(ls_output)]
 
     @GeneralUtilities.check_arguments
-    def __ls(self, file: str) -> str:
-        file = file.replace("\\", "/")
-        GeneralUtilities.assert_condition(os.path.isfile(file) or os.path.isdir(
-            file), f"Can not execute 'ls' because '{file}' does not exist")
-        result = self.run_program_argsasarray("ls", ["-ld", file])
-        GeneralUtilities.assert_condition(result[0] == 0, f"'ls -ld {file}' resulted in exitcode {str(result[0])}. StdErr: {result[2]}")
-        GeneralUtilities.assert_condition(not GeneralUtilities.string_is_none_or_whitespace(
-            result[1]), f"'ls' of '{file}' had an empty output. StdErr: '{result[2]}'")
-        return result[1]
+    def run_ls_for_folder(self, file_or_folder: str) -> str:
+        file_or_folder = file_or_folder.replace("\\", "/")
+        GeneralUtilities.assert_condition(os.path.isfile(file_or_folder) or os.path.isdir(file_or_folder), f"Can not execute 'ls -ld' because '{file_or_folder}' does not exist.")
+        ls_result = self.run_program_argsasarray("ls", ["-ld", file_or_folder])
+        GeneralUtilities.assert_condition(ls_result[0] == 0, f"'ls -ld {file_or_folder}' resulted in exitcode {str(ls_result[0])}. StdErr: {ls_result[2]}")
+        GeneralUtilities.assert_condition(not GeneralUtilities.string_is_none_or_whitespace(ls_result[1]), f"'ls -ld' of '{file_or_folder}' had an empty output. StdErr: '{ls_result[2]}'")
+        GeneralUtilities.write_message_to_stdout(ls_result[1])
+        output = ls_result[1]
+        result = output.replace("\n", "")
+        result = ' '.join(result.split())   # reduce multiple whitespaces to one
+        return result
+
+    @GeneralUtilities.check_arguments
+    def run_ls_for_folder_content(self, file_or_folder: str) -> list[str]:
+        file_or_folder = file_or_folder.replace("\\", "/")
+        GeneralUtilities.assert_condition(os.path.isfile(file_or_folder) or os.path.isdir(file_or_folder), f"Can not execute 'ls -la' because '{file_or_folder}' does not exist.")
+        ls_result = self.run_program_argsasarray("ls", ["-la", file_or_folder])
+        GeneralUtilities.assert_condition(ls_result[0] == 0, f"'ls -la {file_or_folder}' resulted in exitcode {str(ls_result[0])}. StdErr: {ls_result[2]}")
+        GeneralUtilities.assert_condition(not GeneralUtilities.string_is_none_or_whitespace(ls_result[1]), f"'ls -la' of '{file_or_folder}' had an empty output. StdErr: '{ls_result[2]}'")
+        GeneralUtilities.write_message_to_stdout(ls_result[1])
+        output = ls_result[1]
+        result = output.split("\n")[3:]  # skip the lines with "Total", "." and ".."
+        result = [' '.join(line.split()) for line in result]  # reduce multiple whitespaces to one
+        return result
 
     @GeneralUtilities.check_arguments
     def set_permission(self, file_or_folder: str, permissions: str, recursive: bool = False) -> None:
@@ -1268,8 +1194,36 @@ class ScriptCollectionCore:
         popen: Popen = self.program_runner.run_program_argsasarray_async_helper(program, arguments_as_array, working_directory, custom_argument, interactive)
         return popen
 
-    # Return-values program_runner: Exitcode, StdOut, StdErr, Pid
+    @staticmethod
+    def __enqueue_output(file, queue):
+        for line in iter(file.readline, ''):
+            queue.put(line)
+        file.close()
+
+    @staticmethod
+    def __read_popen_pipes(p: Popen):
+        with ThreadPoolExecutor(2) as pool:
+            q_stdout = Queue()
+            q_stderr = Queue()
+
+            pool.submit(ScriptCollectionCore.__enqueue_output, p.stdout, q_stdout)
+            pool.submit(ScriptCollectionCore.__enqueue_output, p.stderr, q_stderr)
+            while (p.poll() is None) or (not q_stdout.empty()) or (not q_stderr.empty()):
+                time.sleep(0.01)
+                out_line = None
+                err_line = None
+                try:
+                    out_line = q_stdout.get_nowait()
+                except Empty:
+                    pass
+                try:
+                    err_line = q_stderr.get_nowait()
+                except Empty:
+                    pass
 
+                yield (out_line, err_line)
+
+    # Return-values program_runner: Exitcode, StdOut, StdErr, Pid
     @GeneralUtilities.check_arguments
     def run_program_argsasarray(self, program: str, arguments_as_array: list[str] = [], working_directory: str = None, verbosity: int = 1, print_errors_as_information: bool = False, log_file: str = None, timeoutInSeconds: int = 600, addLogOverhead: bool = False, title: str = None, log_namespace: str = "", arguments_for_log:  list[str] = None, throw_exception_if_exitcode_is_not_zero: bool = True, custom_argument: object = None, interactive: bool = False) -> tuple[int, str, str, int]:
         # verbosity 1: No output will be logged.
@@ -1297,82 +1251,68 @@ class ScriptCollectionCore:
 
             if verbosity >= 3:
                 GeneralUtilities.write_message_to_stdout(f"Run '{info_for_log}'.")
-            with self.__run_program_argsasarray_async_helper(program, arguments_as_array, working_directory, verbosity, print_errors_as_information, log_file, timeoutInSeconds, addLogOverhead, title, log_namespace, arguments_for_log, custom_argument, interactive) as process:
-                pid = process.pid
-
-                stdout_lines = list[str]()
-                stderr_lines = list[str]()
 
-                live_console_output_printing = 2 < verbosity and interactive
+            print_live_output = 1 < verbosity
 
-                log_to_file = log_file is not None
-                if log_to_file:
-                    GeneralUtilities.ensure_file_exists(log_file)
+            exit_code: int = None
+            stdout: str = ""
+            stderr: str = ""
+            pid: int = None
 
-                if interactive:
-                    # there are 2 issues in this part:
-                    # 1.: ctrl+c
-                    # 2.: sometimes this function does not terminate even if the started process exited
-                    def stream_process(process) -> bool:
-                        try:
-                            go: bool = process.poll() is None
-
-                            stdoutreader: BufferedReader = process.stdout
-                            if stdoutreader.readable():
-                                stdoutresultb: bytes = stdoutreader.read()
-                                stdoutresult = GeneralUtilities.bytes_to_string(
-                                    stdoutresultb)
-                                stdoutlines = GeneralUtilities.string_to_lines(stdoutresult)
-                                for line in stdoutlines:
-                                    line_stripped = line.replace("\r", "").strip()
-                                    if len(line_stripped) > 0:
-                                        line_str = line_stripped
-                                        stdout_lines.append(line_str)
-                                        if live_console_output_printing:
-                                            GeneralUtilities.write_message_to_stdout(line_str)
-                                        if log_to_file:
-                                            GeneralUtilities.append_line_to_file(
-                                                log_file, line_str)
-
-                            stderrreader: BufferedReader = process.stderr
-                            if stderrreader.readable():
-                                stderrresultb: bytes = stderrreader.read()
-                                stderrresult = GeneralUtilities.bytes_to_string(stderrresultb)
-                                stderrlines = GeneralUtilities.string_to_lines(stderrresult)
-                                for line in stderrlines:
-                                    line_stripped = line.replace("\r", "").strip()
-                                    if len(line_stripped) > 0:
-                                        line_str = line_stripped
-                                        stderr_lines.append(line_str)
-                                        if live_console_output_printing:
-                                            if print_errors_as_information:
-                                                GeneralUtilities.write_message_to_stdout(line_str)
-                                            else:
-                                                GeneralUtilities.write_message_to_stderr(line_str)
-                                        if log_to_file:
-                                            GeneralUtilities.append_line_to_file(log_file, line_str)
-
-                            return go
-                        except Exception:
-                            return False
-
-                    while stream_process(process):
-                        time.sleep(0.1)
-
-                    exit_code = process.poll()
-                    stdout = '\n'.join(stdout_lines)
-                    stderr = '\n'.join(stderr_lines)
-                else:
-                    stdout, stderr = process.communicate()
-                    exit_code = process.wait()
-                    stdout = GeneralUtilities.bytes_to_string(stdout).replace('\r', '')
-                    stderr = GeneralUtilities.bytes_to_string(stderr).replace('\r', '')
-
-                if throw_exception_if_exitcode_is_not_zero and exit_code != 0:
-                    raise ValueError(f"Program '{working_directory}>{program} {arguments_for_log_as_string}' resulted in exitcode {exit_code}. (StdOut: '{stdout}', StdErr: '{stderr}')")
+            with self.__run_program_argsasarray_async_helper(program, arguments_as_array, working_directory, verbosity, print_errors_as_information, log_file, timeoutInSeconds, addLogOverhead, title, log_namespace, arguments_for_log, custom_argument, interactive) as process:
 
-                result = (exit_code, stdout, stderr, pid)
-                return result
+                if log_file is not None:
+                    GeneralUtilities.ensure_file_exists(log_file)
+                pid = process.pid
+                for out_line_plain, err_line_plain in ScriptCollectionCore.__read_popen_pipes(process):  # see https://stackoverflow.com/a/57084403/3905529
+
+                    if out_line_plain is not None:
+                        out_line: str = None
+                        if isinstance(out_line_plain, str):
+                            out_line = out_line_plain
+                        elif isinstance(out_line_plain, bytes):
+                            out_line = GeneralUtilities.bytes_to_string(out_line_plain)
+                        else:
+                            raise ValueError(f"Unknown type of output: {str(type(out_line_plain))}")
+
+                        if out_line is not None and GeneralUtilities.string_has_content(out_line):
+                            if out_line.endswith("\n"):
+                                out_line = out_line[:-1]
+                            if print_live_output:
+                                print(out_line, end='\n', file=sys.stdout,  flush=True)
+                            if 0 < len(stdout):
+                                stdout = stdout+"\n"
+                            stdout = stdout+out_line
+                            if log_file is not None:
+                                GeneralUtilities.append_line_to_file(log_file, out_line)
+
+                    if err_line_plain is not None:
+                        err_line: str = None
+                        if isinstance(err_line_plain, str):
+                            err_line = err_line_plain
+                        elif isinstance(err_line_plain, bytes):
+                            err_line = GeneralUtilities.bytes_to_string(err_line_plain)
+                        else:
+                            raise ValueError(f"Unknown type of output: {str(type(err_line_plain))}")
+                        if err_line is not None and GeneralUtilities.string_has_content(err_line):
+                            if err_line.endswith("\n"):
+                                err_line = err_line[:-1]
+                            if print_live_output:
+                                print(err_line, end='\n', file=sys.stderr,  flush=True)
+                            if 0 < len(stderr):
+                                stderr = stderr+"\n"
+                            stderr = stderr+err_line
+                            if log_file is not None:
+                                GeneralUtilities.append_line_to_file(log_file, err_line)
+
+            exit_code = process.returncode
+
+            if throw_exception_if_exitcode_is_not_zero and exit_code != 0:
+                raise ValueError(f"Program '{working_directory}>{program} {arguments_for_log_as_string}' resulted in exitcode {exit_code}. (StdOut: '{stdout}', StdErr: '{stderr}')")
+
+            GeneralUtilities.assert_condition(exit_code is not None, f"Exitcode of program-run of '{info_for_log}' is None.")
+            result = (exit_code, stdout, stderr, pid)
+            return result
         except Exception as e:
             raise e
 
@@ -1415,8 +1355,7 @@ class ScriptCollectionCore:
     @GeneralUtilities.check_arguments
     def verify_no_pending_mock_program_calls(self):
         if (len(self.__mocked_program_calls) > 0):
-            raise AssertionError(
-                "The following mock-calls were not called:\n"+",\n    ".join([self.__format_mock_program_call(r) for r in self.__mocked_program_calls]))
+            raise AssertionError("The following mock-calls were not called:\n"+",\n    ".join([self.__format_mock_program_call(r) for r in self.__mocked_program_calls]))
 
     @GeneralUtilities.check_arguments
     def __format_mock_program_call(self, r) -> str:
@@ -1451,8 +1390,7 @@ class ScriptCollectionCore:
                 result = mock_call
                 break
         if result is None:
-            raise LookupError(
-                f"Tried to execute mock-call '{workingdirectory}>{program} {argument}' but no mock-call was defined for that execution")
+            raise LookupError(f"Tried to execute mock-call '{workingdirectory}>{program} {argument}' but no mock-call was defined for that execution")
         else:
             self.__mocked_program_calls.remove(result)
             return (result.exit_code, result.stdout, result.stderr, result.pid)
@@ -1501,8 +1439,7 @@ class ScriptCollectionCore:
 
     @GeneralUtilities.check_arguments
     def check_system_time_with_default_tolerance(self) -> None:
-        self.check_system_time(
-            self.__get_default_tolerance_for_system_time_equals_internet_time())
+        self.check_system_time(self.__get_default_tolerance_for_system_time_equals_internet_time())
 
     @GeneralUtilities.check_arguments
     def __get_default_tolerance_for_system_time_equals_internet_time(self) -> timedelta:
@@ -1529,13 +1466,11 @@ class ScriptCollectionCore:
             result = self.get_version_from_gitversion(repository_folder, "MajorMinorPatch")
             if self.git_repository_has_uncommitted_changes(repository_folder):
                 if self.get_current_git_branch_has_tag(repository_folder):
-                    id_of_latest_tag = self.git_get_commitid_of_tag(
-                        repository_folder, self.get_latest_git_tag(repository_folder))
+                    id_of_latest_tag = self.git_get_commitid_of_tag(repository_folder, self.get_latest_git_tag(repository_folder))
                     current_commit = self.git_get_commit_id(repository_folder)
                     current_commit_is_on_latest_tag = id_of_latest_tag == current_commit
                     if current_commit_is_on_latest_tag:
-                        result = self.increment_version(
-                            result, False, False, True)
+                        result = self.increment_version(result, False, False, True)
         else:
             result = "0.1.0"
         return result
@@ -1573,8 +1508,7 @@ class ScriptCollectionCore:
         self.run_program("openssl", f'genrsa -out {filename}.key {rsa_key_length}', folder)
         self.run_program("openssl", f'req -new -subj /C={subj_c}/ST={subj_st}/L={subj_l}/O={subj_o}/CN={domain}/OU={subj_ou} -x509 -key {filename}.key -out {filename}.unsigned.crt -days {days_until_expire}', folder)
         self.run_program("openssl", f'pkcs12 -export -out {filename}.selfsigned.pfx -password pass:{password} -inkey {filename}.key -in {filename}.unsigned.crt', folder)
-        GeneralUtilities.write_text_to_file(
-            os.path.join(folder, f"{filename}.password"), password)
+        GeneralUtilities.write_text_to_file(os.path.join(folder, f"{filename}.password"), password)
         GeneralUtilities.write_text_to_file(os.path.join(folder, f"{filename}.san.conf"), f"""[ req ]
 default_bits        = {rsa_key_length}
 distinguished_name  = req_distinguished_name
@@ -1600,8 +1534,7 @@ DNS                 = {domain}
 
     @GeneralUtilities.check_arguments
     def generate_certificate_sign_request(self, folder: str, domain: str, filename: str, subj_c: str, subj_st: str, subj_l: str, subj_o: str, subj_ou: str) -> None:
-        self.run_program(
-            "openssl", f'req -new -subj /C={subj_c}/ST={subj_st}/L={subj_l}/O={subj_o}/CN={domain}/OU={subj_ou} -key {filename}.key -out {filename}.csr -config {filename}.san.conf', folder)
+        self.run_program("openssl", f'req -new -subj /C={subj_c}/ST={subj_st}/L={subj_l}/O={subj_o}/CN={domain}/OU={subj_ou} -key {filename}.key -out {filename}.csr -config {filename}.san.conf', folder)
 
     @GeneralUtilities.check_arguments
     def sign_certificate(self, folder: str, ca_folder: str, ca_name: str, domain: str, filename: str, days_until_expire: int = None) -> None:
@@ -1629,11 +1562,13 @@ DNS                 = {domain}
         elif ">" in line:
             try:
                 # line is something like "cyclonedx-bom>=2.0.2" and the function must return with the updated version
-                # (something like "cyclonedx-bom>=3.11.0" for example)
+                # (something like "cyclonedx-bom>=2.11.0" for example)
                 package = line.split(">")[0]
                 operator = ">=" if ">=" in line else ">"
                 response = requests.get(f'https://pypi.org/pypi/{package}/json', timeout=5)
                 latest_version = response.json()['info']['version']
+                # TODO update only minor- and patch-version
+                # TODO print info if there is a new major-version
                 return package+operator+latest_version
             except:
                 return line
@@ -1696,8 +1631,7 @@ DNS                 = {domain}
         GeneralUtilities.ensure_directory_exists(packagecontent_entireresult_folder)
 
         # create "debian-binary"-file
-        debianbinary_file = os.path.join(
-            packagecontent_entireresult_folder, "debian-binary")
+        debianbinary_file = os.path.join(packagecontent_entireresult_folder, "debian-binary")
         GeneralUtilities.ensure_file_exists(debianbinary_file)
         GeneralUtilities.write_text_to_file(debianbinary_file, "2.0\n")
 
@@ -1714,10 +1648,10 @@ DNS                 = {domain}
         link_file = f"/usr/bin/{toolname.lower()}"
         permission = str(permission_of_executable_file_as_octet_triple)
         GeneralUtilities.write_text_to_file(postinst_file, f"""#!/bin/sh
-    ln -s {exe_file} {link_file}
-    chmod {permission} {exe_file}
-    chmod {permission} {link_file}
-    """)
+ln -s {exe_file} {link_file}
+chmod {permission} {exe_file}
+chmod {permission} {link_file}
+""")
 
         #  control
         control_file = os.path.join(packagecontent_control_folder, "control")
@@ -1733,16 +1667,14 @@ DNS                 = {domain}
         #  copy binaries
         usr_bin_folder = os.path.join(packagecontent_data_folder, "usr/bin")
         GeneralUtilities.ensure_directory_exists(usr_bin_folder)
-        usr_bin_content_folder = os.path.join(
-            usr_bin_folder, tool_content_folder_name)
+        usr_bin_content_folder = os.path.join(usr_bin_folder, tool_content_folder_name)
         GeneralUtilities.copy_content_of_folder(bin_folder, usr_bin_content_folder)
 
         # create debfile
         deb_filename = f"{toolname}.deb"
         self.run_program_argsasarray("tar", ["czf", f"../{entireresult_content_folder_name}/control.tar.gz", "*"], packagecontent_control_folder, verbosity=verbosity)
         self.run_program_argsasarray("tar", ["czf", f"../{entireresult_content_folder_name}/data.tar.gz", "*"], packagecontent_data_folder, verbosity=verbosity)
-        self.run_program_argsasarray("ar", ["r", deb_filename, "debian-binary", "control.tar.gz",
-                                     "data.tar.gz"], packagecontent_entireresult_folder, verbosity=verbosity)
+        self.run_program_argsasarray("ar", ["r", deb_filename, "debian-binary", "control.tar.gz", "data.tar.gz"], packagecontent_entireresult_folder, verbosity=verbosity)
         result_file = os.path.join(packagecontent_entireresult_folder, deb_filename)
         shutil.copy(result_file, os.path.join(deb_output_folder, deb_filename))
 
@@ -1788,8 +1720,7 @@ DNS                 = {domain}
         proxies = None
         if GeneralUtilities.string_has_content(proxy):
             proxies = {"http": proxy}
-        response = requests.get('https://ipinfo.io',
-                                proxies=proxies, timeout=5)
+        response = requests.get('https://ipinfo.io',  proxies=proxies, timeout=5)
         network_information_as_json_string = GeneralUtilities.bytes_to_string(
             response.content)
         return network_information_as_json_string
@@ -1802,10 +1733,133 @@ DNS                 = {domain}
         else:
             extension_to_compare = from_extension
         for file in GeneralUtilities.get_direct_files_of_folder(folder):
-            if (ignore_case and file.lower().endswith(f".{extension_to_compare}")
-                    or not ignore_case and file.endswith(f".{extension_to_compare}")):
+            if (ignore_case and file.lower().endswith(f".{extension_to_compare}") or not ignore_case and file.endswith(f".{extension_to_compare}")):
                 p = Path(file)
                 p.rename(p.with_suffix('.'+to_extension))
         if recursive:
             for subfolder in GeneralUtilities.get_direct_folders_of_folder(folder):
                 self.change_file_extensions(subfolder, from_extension, to_extension, recursive, ignore_case)
+
+    @GeneralUtilities.check_arguments
+    def __add_chapter(self, main_reference_file, reference_content_folder, number: int, chaptertitle: str, content: str = None):
+        if content is None:
+            content = "TXDX add content here"
+        filename = str(number).zfill(2)+"_"+chaptertitle.replace(' ', '-')
+        file = f"{reference_content_folder}/{filename}.md"
+        full_title = f"{number}. {chaptertitle}"
+
+        GeneralUtilities.append_line_to_file(main_reference_file, f"- [{full_title}](./{filename}.md)")
+
+        GeneralUtilities.ensure_file_exists(file)
+        GeneralUtilities.write_text_to_file(file, f"""# {full_title}
+
+{content}
+""".replace("XDX", "ODO"))
+
+    @GeneralUtilities.check_arguments
+    def generate_arc42_reference_template(self, repository: str, productname: str = None):
+        productname: str
+        if productname is None:
+            productname = os.path.basename(repository)
+        reference_root_folder = f"{repository}/Other/Resources/Reference"
+        reference_content_folder = reference_root_folder + "/Technical"
+        if os.path.isdir(reference_root_folder):
+            raise ValueError(f"The folder '{reference_root_folder}' does already exist.")
+        GeneralUtilities.ensure_directory_exists(reference_root_folder)
+        GeneralUtilities.ensure_directory_exists(reference_content_folder)
+        main_reference_file = f"{reference_root_folder}/Reference.md"
+        GeneralUtilities.ensure_file_exists(main_reference_file)
+        GeneralUtilities.write_text_to_file(main_reference_file, f"""# {productname}
+    
+TXDX add minimal service-description here.
+
+## Technical documentation
+
+""".replace("XDX", "ODO"))
+        self.__add_chapter(main_reference_file, reference_content_folder, 1, 'Introduction and Goals', """## Overview
+
+TXDX
+
+# Quality goals
+
+ TXDX
+
+# Stakeholder
+
+| Name | How to contact | Reason |
+| ---- | -------------- | ------ |""")
+        self.__add_chapter(main_reference_file, reference_content_folder, 2, 'Constraints', """## Technical constraints
+
+| Constraint-identifier | Constraint | Reason |
+| --------------------- | ---------- | ------ |
+
+## Organizational constraints
+
+| Constraint-identifier | Constraint | Reason |
+| --------------------- | ---------- | ------ |""")
+        self.__add_chapter(main_reference_file, reference_content_folder, 3, 'Context and Scope', """## Context
+
+TXDX
+
+## Scope
+
+ TXDX""")
+        self.__add_chapter(main_reference_file, reference_content_folder, 4, 'Solution Strategy', """TXDX""")
+        self.__add_chapter(main_reference_file, reference_content_folder, 5, 'Building Block View', """TXDX""")
+        self.__add_chapter(main_reference_file, reference_content_folder, 6, 'Runtime View', """TXDX""")
+        self.__add_chapter(main_reference_file, reference_content_folder, 7, 'Deployment View', """## Infrastructure-overview
+
+TXDX
+
+## Infrastructure-requirements
+
+TXDX
+
+## Deployment-proecsses
+
+TXDX
+""")
+        self.__add_chapter(main_reference_file, reference_content_folder, 8, 'Crosscutting Concepts', """TXDX""")
+        self.__add_chapter(main_reference_file, reference_content_folder, 9, 'Architectural Decisions', """## Decision-board
+
+| Decision-identifier | Date | Decision | Reason and notes |
+| ------------------- | ---- | -------- | ---------------- |""")  # empty because there are no decsions yet
+        self.__add_chapter(main_reference_file, reference_content_folder, 10, 'Quality Requirements', """TXDX""")
+        self.__add_chapter(main_reference_file, reference_content_folder, 11, 'Risks and Technical Debt', """## Risks
+
+Currently there are no known risks.
+
+## Technical debts
+
+Currently there are no technical depts.""")
+        self.__add_chapter(main_reference_file, reference_content_folder, 12, 'Glossary', """## Terms
+
+| Term | Meaning |
+| ---- | ------- |
+
+## Abbreviations
+
+| Abbreviation | Meaning |
+| ------------ | ------- |""")
+
+        GeneralUtilities.append_to_file(main_reference_file, """
+
+## Responsibilities
+
+| Responsibility  | Name and contact-information |
+| --------------- | ---------------------------- |
+| Pdocut-owner    | TXDX                         |
+| Product-manager | TXDX                         |
+| Support         | TXDX                         |
+
+## License & Pricing
+
+TXDX
+
+## External resources
+
+- [Repository](TXDX)
+- [Productive-System](TXDX)
+- [QualityCheck-system](TXDX)
+
+""")

ScriptCollection/TasksForCommonProjectStructure.py

@@ -241,11 +241,11 @@ class TasksForCommonProjectStructure:
                 GeneralUtilities.ensure_directory_exists(web_folder)
                 GeneralUtilities.copy_content_of_folder(web_relase_folder, web_folder)
             elif target == "windows":
-                windows_relase_folder = os.path.join(src_folder, "build/windows/runner/Release")
+                windows_release_folder = os.path.join(src_folder, "build/windows/x64/runner/Release")
                 windows_folder = os.path.join(artifacts_folder, "BuildResult_Windows")
                 GeneralUtilities.ensure_directory_does_not_exist(windows_folder)
                 GeneralUtilities.ensure_directory_exists(windows_folder)
-                GeneralUtilities.copy_content_of_folder(windows_relase_folder, windows_folder)
+                GeneralUtilities.copy_content_of_folder(windows_release_folder, windows_folder)
             elif target == "ios":
                 raise ValueError("building for ios is not implemented yet")
             elif target == "appbundle":
@@ -2238,16 +2238,16 @@ class TasksForCommonProjectStructure:
                 raise ValueError("Can not download FFMPEG.")
 
     @GeneralUtilities.check_arguments
-    def ensure_plantuml_is_available(self, codeunit_folder: str) -> None:
-        self.ensure_file_from_github_assets_is_available(codeunit_folder, "plantuml", "plantuml", "PlantUML", "plantuml.jar", lambda latest_version: "plantuml.jar")
+    def ensure_plantuml_is_available(self, target_folder: str) -> None:
+        self.ensure_file_from_github_assets_is_available(target_folder, "plantuml", "plantuml", "PlantUML", "plantuml.jar", lambda latest_version: "plantuml.jar")
 
     @GeneralUtilities.check_arguments
-    def ensure_androidappbundletool_is_available(self, codeunit_folder: str) -> None:
-        self.ensure_file_from_github_assets_is_available(codeunit_folder, "google", "bundletool", "AndroidAppBundleTool", "bundletool.jar", lambda latest_version: f"bundletool-all-{latest_version}.jar")
+    def ensure_androidappbundletool_is_available(self, target_folder: str) -> None:
+        self.ensure_file_from_github_assets_is_available(target_folder, "google", "bundletool", "AndroidAppBundleTool", "bundletool.jar", lambda latest_version: f"bundletool-all-{latest_version}.jar")
 
     @GeneralUtilities.check_arguments
-    def ensure_file_from_github_assets_is_available(self, codeunit_folder: str, githubuser: str, githubprojectname: str, resource_name: str, local_filename: str, get_filename_on_github) -> None:
-        resource_folder = os.path.join(codeunit_folder, "Other", "Resources", resource_name)
+    def ensure_file_from_github_assets_is_available(self, target_folder: str, githubuser: str, githubprojectname: str, resource_name: str, local_filename: str, get_filename_on_github) -> None:
+        resource_folder = os.path.join(target_folder, "Other", "Resources", resource_name)
         internet_connection_is_available = GeneralUtilities.internet_connection_is_available()
         file = f"{resource_folder}/{local_filename}"
         file_exists = os.path.isfile(file)
@@ -2266,10 +2266,10 @@ class TasksForCommonProjectStructure:
                 raise ValueError(f"Can not download {resource_name}.")
 
     @GeneralUtilities.check_arguments
-    def generate_svg_files_from_plantuml_files(self, codeunit_folder: str) -> None:
-        self.ensure_plantuml_is_available(codeunit_folder)
-        plant_uml_folder = os.path.join(codeunit_folder, "Other", "Resources", "PlantUML")
-        files_folder = os.path.join(codeunit_folder, "Other/Reference")
+    def generate_svg_files_from_plantuml_files(self, target_folder: str) -> None:
+        self.ensure_plantuml_is_available(target_folder)
+        plant_uml_folder = os.path.join(target_folder, "Other", "Resources", "PlantUML")
+        files_folder = os.path.join(target_folder, "Other/Reference")
         sc = ScriptCollectionCore()
         for file in GeneralUtilities.get_all_files_of_folder(files_folder):
             if file.endswith(".plantuml"):

{ScriptCollection-3.5.13.dist-info → ScriptCollection-3.5.15.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: ScriptCollection
-Version: 3.5.13
+Version: 3.5.15
 Summary: The ScriptCollection is the place for reusable scripts.
 Home-page: https://github.com/anionDev/ScriptCollection
 Author: Marius Göcke

ScriptCollection-3.5.15.dist-info/RECORD

@@ -0,0 +1,16 @@
+ScriptCollection/Executables.py,sha256=Ui9omPvmBjnsgFZXpeXMoZXmk17sjPyO1mS_7B7w8aY,19951
+ScriptCollection/GeneralUtilities.py,sha256=AElXv2NO30cTw-Qs3qVmO-YCOQ5FvBQM3RZMywuKQ_Y,35121
+ScriptCollection/ProcessesRunner.py,sha256=3mu4ZxzZleQo0Op6o9EYTCFiJfb6kx5ov2YfZfT89mU,1395
+ScriptCollection/ProgramRunnerBase.py,sha256=7QAjoqOz6XPmJH19F2k-Z1fFQB_uZnPFvn-T54IJcHQ,2324
+ScriptCollection/ProgramRunnerEpew.py,sha256=C2Rs3YWOWWWJct7XmKphp5CF1tf0j4Fp-ljV2drLTfs,6349
+ScriptCollection/ProgramRunnerPopen.py,sha256=G3LgQUVCfaq7XjBsGzalElH31Hbr0etttGR2_H87YzA,3512
+ScriptCollection/RPStream.py,sha256=NRRHL3YSP3D9MuAV2jB_--0KUKCsvJGxeKnxgrRZ9kY,1545
+ScriptCollection/ScriptCollectionCore.py,sha256=YjhExLE-EnEarXD72pToTIF-6UYMid3wXs31-M8_rSA,100035
+ScriptCollection/TasksForCommonProjectStructure.py,sha256=_JYOAmB0W5S_KKvyI3a0CbjWImt7lQHUraPQ0dEFUsk,184076
+ScriptCollection/UpdateCertificates.py,sha256=Eynbgu7k9jLxApP2D_8Il77B6BFjJap6K7oTeEAZYbk,7790
+ScriptCollection/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+ScriptCollection-3.5.15.dist-info/METADATA,sha256=kOCRDbe9JAms1tzXKdJm8ZbYQOnGi4XJwnBXYH8uScs,7680
+ScriptCollection-3.5.15.dist-info/WHEEL,sha256=GV9aMThwP_4oNCtvEC2ec3qUYutgWeAzklro_0m4WJQ,91
+ScriptCollection-3.5.15.dist-info/entry_points.txt,sha256=yASwR6hWZ_b5d4W49YeX1htD8ngfWbwgjpfQiJdtUAU,2322
+ScriptCollection-3.5.15.dist-info/top_level.txt,sha256=hY2hOVH0V0Ce51WB76zKkIWTUNwMUdHo4XDkR2vYVwg,17
+ScriptCollection-3.5.15.dist-info/RECORD,,

{ScriptCollection-3.5.13.dist-info → ScriptCollection-3.5.15.dist-info}/WHEEL

@@ -1,5 +1,5 @@
 Wheel-Version: 1.0
-Generator: setuptools (74.1.0)
+Generator: setuptools (75.1.0)
 Root-Is-Purelib: true
 Tag: py3-none-any
 

{ScriptCollection-3.5.13.dist-info → ScriptCollection-3.5.15.dist-info}/entry_points.txt

@@ -11,6 +11,7 @@ sccreateisofilewithobfuscatedfiles = ScriptCollection.Executables:CreateISOFileW
 sccreatesimplemergewithoutrelease = ScriptCollection.Executables:CreateSimpleMergeWithoutRelease
 scextractpdfpages = ScriptCollection.Executables:ExtractPDFPages
 scfilenameobfuscator = ScriptCollection.Executables:FilenameObfuscator
+scgeneratearc42referencetemplate = ScriptCollection.Executables:GenerateARC42ReferenceTemplate
 scgeneratecertificate = ScriptCollection.Executables:GenerateCertificate
 scgeneratecertificateauthority = ScriptCollection.Executables:GenerateCertificateAuthority
 scgeneratecertificatesignrequest = ScriptCollection.Executables:GenerateCertificateSignRequest

ScriptCollection-3.5.13.dist-info/RECORD

@@ -1,16 +0,0 @@
-ScriptCollection/Executables.py,sha256=msAlVLjgrxCxW-5Uu7Gk8NI1CNQLK2i6TjNR1fppaCY,19535
-ScriptCollection/GeneralUtilities.py,sha256=1Q5ML9RwwS5e1mZPuJps3Z3ceVCGF5taFhh0GEG6MlY,35167
-ScriptCollection/ProcessesRunner.py,sha256=3mu4ZxzZleQo0Op6o9EYTCFiJfb6kx5ov2YfZfT89mU,1395
-ScriptCollection/ProgramRunnerBase.py,sha256=7QAjoqOz6XPmJH19F2k-Z1fFQB_uZnPFvn-T54IJcHQ,2324
-ScriptCollection/ProgramRunnerEpew.py,sha256=C2Rs3YWOWWWJct7XmKphp5CF1tf0j4Fp-ljV2drLTfs,6349
-ScriptCollection/ProgramRunnerPopen.py,sha256=ECx35Yz-MKPeoRa_42Bsq8qmbHd13I40vXUJSpZPrI4,3475
-ScriptCollection/RPStream.py,sha256=NRRHL3YSP3D9MuAV2jB_--0KUKCsvJGxeKnxgrRZ9kY,1545
-ScriptCollection/ScriptCollectionCore.py,sha256=cWn10QGcBDP4C6u5TtzGYn6OiYV5OpY8BRkeNGQo00w,97421
-ScriptCollection/TasksForCommonProjectStructure.py,sha256=-QxOB01yFHrcPpTNnDA0GY0rv9McvQ95DZ3PNHRCrFE,184090
-ScriptCollection/UpdateCertificates.py,sha256=Eynbgu7k9jLxApP2D_8Il77B6BFjJap6K7oTeEAZYbk,7790
-ScriptCollection/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-ScriptCollection-3.5.13.dist-info/METADATA,sha256=LxH_9vYMJRCIrEukh8lc02T6npy78tCjQTrpaOtYB1A,7680
-ScriptCollection-3.5.13.dist-info/WHEEL,sha256=ixB2d4u7mugx_bCBycvM9OzZ5yD7NmPXFRtKlORZS2Y,91
-ScriptCollection-3.5.13.dist-info/entry_points.txt,sha256=Jz1pyS3Q6lqpuOWVHogt00jGwrpcHYtPrHGY0_Ltjbo,2227
-ScriptCollection-3.5.13.dist-info/top_level.txt,sha256=hY2hOVH0V0Ce51WB76zKkIWTUNwMUdHo4XDkR2vYVwg,17
-ScriptCollection-3.5.13.dist-info/RECORD,,