ScriptCollection 3.5.16__py3-none-any.whl → 4.0.78__py3-none-any.whl

ScriptCollection/ScriptCollectionCore.py

@@ -1,20 +1,25 @@
-import sys
 from datetime import timedelta, datetime
 import json
 import binascii
 import filecmp
 import hashlib
+import multiprocessing
 import time
 from io import BytesIO
 import itertools
+import zipfile
 import math
+import base64
 import os
 from queue import Queue, Empty
 from concurrent.futures import ThreadPoolExecutor
+import xml.etree.ElementTree as ET
 from pathlib import Path
 from subprocess import Popen
 import re
 import shutil
+from typing import IO
+import fnmatch
 import uuid
 import tempfile
 import io
@@ -24,13 +29,13 @@ import yaml
 import qrcode
 import pycdlib
 import send2trash
-import PyPDF2
+from pypdf import PdfReader, PdfWriter
 from .GeneralUtilities import GeneralUtilities
 from .ProgramRunnerBase import ProgramRunnerBase
 from .ProgramRunnerPopen import ProgramRunnerPopen
-from .ProgramRunnerEpew import ProgramRunnerEpew, CustomEpewArgument
+from .SCLog import SCLog, LogLevel
 
-version = "3.5.16"
+version = "4.0.78"
 __version__ = version
 
 
@@ -38,15 +43,19 @@ class ScriptCollectionCore:
 
     # The purpose of this property is to use it when testing your code which uses scriptcollection for external program-calls.
     # Do not change this value for productive environments.
-    mock_program_calls: bool = False
+    mock_program_calls: bool = False#TODO remove this variable. When someone want to mock program-calls then the ProgramRunnerMock can be used instead
     # 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 = None
     program_runner: ProgramRunnerBase = None
+    call_program_runner_directly: bool = None
+    log: SCLog = None
 
     def __init__(self):
         self.program_runner = ProgramRunnerPopen()
+        self.call_program_runner_directly = None
         self.__mocked_program_calls = list[ScriptCollectionCore.__MockProgramCall]()
+        self.log = SCLog(None, LogLevel.Warning, False)
 
     @staticmethod
     @GeneralUtilities.check_arguments
@@ -58,14 +67,14 @@ class ScriptCollectionCore:
         errors = list()
         filename = os.path.relpath(file, working_directory)
         if treat_warnings_as_errors:
-            errorsonly_argument = ""
+            errorsonly_argument = GeneralUtilities.empty_string
         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)
         if (exit_code != 0):
             errors.append(f"Linting-issues of {file}:")
             errors.append(f"Pylint-exitcode: {exit_code}")
-            for line in GeneralUtilities.string_to_lines(stdout):
+            for line in GeneralUtilities.string_to_lines(stdout): 
                 errors.append(line)
             for line in GeneralUtilities.string_to_lines(stderr):
                 errors.append(line)
@@ -108,31 +117,48 @@ class ScriptCollectionCore:
             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):
+    def push_nuget_build_artifact(self, nupkg_file: str, registry_address: str, api_key: str = None):
         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)
+        argument = f"nuget push {nupkg_file_name} --force-english-output --source {registry_address}"
+        if api_key is not None:
+            argument = f"{argument} --api-key {api_key}" 
+        self.run_program("dotnet", argument, nupkg_file_folder)
 
     @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)
+    def dotnet_build(self, folder: str, projectname: str, configuration: str):
+        self.run_program("dotnet", f"clean -c {configuration}", folder)
+        self.run_program("dotnet", f"build {projectname}/{projectname}.csproj -c {configuration}", folder)
 
     @GeneralUtilities.check_arguments
-    def find_file_by_extension(self, folder: str, extension: str):
-        result = [file for file in GeneralUtilities.get_direct_files_of_folder(folder) if file.endswith(f".{extension}")]
+    def find_file_by_extension(self, folder: str, extension_without_dot: str):
+        """This function works platform-independent also for non-local-executions if the ScriptCollection commandline-commands are available as global command on the target-system."""
+        result = [file for file in self.list_content(folder, True, False, False) if file.endswith(f".{extension_without_dot}")]
         result_length = len(result)
         if result_length == 0:
-            raise FileNotFoundError(f"No file available in folder '{folder}' with extension '{extension}'.")
+            raise FileNotFoundError(f"No file available in folder '{folder}' with extension '{extension_without_dot}'.")
         if result_length == 1:
             return result[0]
         else:
-            raise ValueError(f"Multiple values available in folder '{folder}' with extension '{extension}'.")
+            raise ValueError(f"Multiple values available in folder '{folder}' with extension '{extension_without_dot}'.")
+
+    @GeneralUtilities.check_arguments
+    def find_last_file_by_extension(self, folder: str, extension_without_dot: str) -> str:
+        files: list[str] = GeneralUtilities.get_direct_files_of_folder(folder)
+        possible_results: list[str] = []
+        for file in files:
+            if file.endswith(f".{extension_without_dot}"):
+                possible_results.append(file)
+        result_length = len(possible_results)
+        if result_length == 0:
+            raise FileNotFoundError(f"No file available in folder '{folder}' with extension '{extension_without_dot}'.")
+        else:
+            return possible_results[-1]
 
     @GeneralUtilities.check_arguments
     def commit_is_signed_by_key(self, repository_folder: str, revision_identifier: str, key: str) -> bool:
-        result = self.run_program(
-            "git", f"verify-commit {revision_identifier}", repository_folder, throw_exception_if_exitcode_is_not_zero=False)
+        self.is_git_or_bare_git_repository(repository_folder)
+        result = self.run_program("git", f"verify-commit {revision_identifier}", repository_folder, throw_exception_if_exitcode_is_not_zero=False)
         if (result[0] != 0):
             return False
         if (not GeneralUtilities.contains_line(result[1].splitlines(), f"gpg\\:\\ using\\ [A-Za-z0-9]+\\ key\\ [A-Za-z0-9]+{key}")):
@@ -145,35 +171,18 @@ class ScriptCollectionCore:
 
     @GeneralUtilities.check_arguments
     def get_parent_commit_ids_of_commit(self, repository_folder: str, commit_id: str) -> str:
-        return self.run_program("git", f'log --pretty=%P -n 1 "{commit_id}"', repository_folder, throw_exception_if_exitcode_is_not_zero=True)[1].replace("\r", "").replace("\n", "").split(" ")
+        self.is_git_or_bare_git_repository(repository_folder)
+        return self.run_program("git", f'log --pretty=%P -n 1 "{commit_id}"', repository_folder, throw_exception_if_exitcode_is_not_zero=True)[1].replace("\r", GeneralUtilities.empty_string).replace("\n", GeneralUtilities.empty_string).split(" ")
 
-    @GeneralUtilities.check_arguments
-    def get_all_authors_and_committers_of_repository(self, repository_folder: str, subfolder: str = None, verbosity: int = 1) -> list[tuple[str, str]]:
-        space_character = "_"
-        if subfolder is None:
-            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)
-        plain_content: list[str] = list(
-            set([line for line in log_result[1].split("\n") if len(line) > 0]))
-        result: list[tuple[str, str]] = []
-        for item in plain_content:
-            if len(re.findall(space_character, item)) == 1:
-                splitted = item.split(space_character)
-                result.append((splitted[0], splitted[1]))
-            else:
-                raise ValueError(f'Unexpected author: "{item}"')
-        return result
 
     @GeneralUtilities.check_arguments
     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:
+        self.is_git_or_bare_git_repository(repository_folder)
         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", GeneralUtilities.empty_string))
         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)]
+            result = [commit_id for commit_id in result if self.git_commit_is_ancestor(repository_folder, commit_id)]
         return result
 
     @GeneralUtilities.check_arguments
@@ -182,44 +191,52 @@ 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]
+        self.is_git_or_bare_git_repository(repository_folder)
+        result = self.run_program_argsasarray("git", ["merge-base", "--is-ancestor", ancestor, descendant], repository_folder, throw_exception_if_exitcode_is_not_zero=False)
+        exit_code = result[0]
         if exit_code == 0:
             return True
         elif exit_code == 1:
             return False
         else:
-            raise ValueError(f"Can not calculate if {ancestor} is an ancestor of {descendant} in repository {repository_folder}.")
+            raise ValueError(f'Can not calculate if {ancestor} is an ancestor of {descendant} in repository {repository_folder}. Outout of "{repository_folder}> git merge-base --is-ancestor {ancestor} {descendant}": Exitcode: {exit_code}; StdOut: {result[1]}; StdErr: {result[2]}.')
 
     @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)
+        self.assert_is_git_repository(repository_folder)
+        lines = GeneralUtilities.string_to_lines(self.run_program_argsasarray("git", arguments_as_array, repository_folder, throw_exception_if_exitcode_is_not_zero=True)[1], False)
         for line in lines:
             if GeneralUtilities.string_has_content(line):
                 return True
         return False
 
     @GeneralUtilities.check_arguments
-    def git_repository_has_new_untracked_files(self, repositoryFolder: str):
-        return self.__git_changes_helper(repositoryFolder, ["ls-files", "--exclude-standard", "--others"])
+    def git_repository_has_new_untracked_files(self, repository_folder: str):
+        self.assert_is_git_repository(repository_folder)
+        return self.__git_changes_helper(repository_folder, ["ls-files", "--exclude-standard", "--others"])
 
     @GeneralUtilities.check_arguments
-    def git_repository_has_unstaged_changes_of_tracked_files(self, repositoryFolder: str):
-        return self.__git_changes_helper(repositoryFolder, ["diff"])
+    def git_repository_has_unstaged_changes_of_tracked_files(self, repository_folder: str):
+        self.assert_is_git_repository(repository_folder)
+        return self.__git_changes_helper(repository_folder, ["--no-pager", "diff"])
 
     @GeneralUtilities.check_arguments
-    def git_repository_has_staged_changes(self, repositoryFolder: str):
-        return self.__git_changes_helper(repositoryFolder, ["diff", "--cached"])
+    def git_repository_has_staged_changes(self, repository_folder: str):
+        self.assert_is_git_repository(repository_folder)
+        return self.__git_changes_helper(repository_folder, ["--no-pager", "diff", "--cached"])
 
     @GeneralUtilities.check_arguments
-    def git_repository_has_uncommitted_changes(self, repositoryFolder: str) -> bool:
-        if (self.git_repository_has_unstaged_changes(repositoryFolder)):
+    def git_repository_has_uncommitted_changes(self, repository_folder: str) -> bool:
+        self.assert_is_git_repository(repository_folder)
+        if (self.git_repository_has_unstaged_changes(repository_folder)):
             return True
-        if (self.git_repository_has_staged_changes(repositoryFolder)):
+        if (self.git_repository_has_staged_changes(repository_folder)):
             return True
         return False
 
     @GeneralUtilities.check_arguments
     def git_repository_has_unstaged_changes(self, repository_folder: str) -> bool:
+        self.assert_is_git_repository(repository_folder)
         if (self.git_repository_has_unstaged_changes_of_tracked_files(repository_folder)):
             return True
         if (self.git_repository_has_new_untracked_files(repository_folder)):
@@ -228,47 +245,73 @@ class ScriptCollectionCore:
 
     @GeneralUtilities.check_arguments
     def git_get_commit_id(self, repository_folder: str, commit: str = "HEAD") -> str:
-        result: tuple[int, str, str, int] = self.run_program_argsasarray("git", ["rev-parse", "--verify", commit], repository_folder, throw_exception_if_exitcode_is_not_zero=True, verbosity=0)
+        self.is_git_or_bare_git_repository(repository_folder)
+        result: tuple[int, str, str, int] = self.run_program_argsasarray("git", ["rev-parse", "--verify", commit], repository_folder, throw_exception_if_exitcode_is_not_zero=True)
         return result[1].replace('\n', '')
 
     @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)
+        self.is_git_or_bare_git_repository(repository_folder)
+        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)
         date_as_string = result[1].replace('\n', '')
         result = datetime.strptime(date_as_string, '%Y-%m-%d %H:%M:%S %z')
         return result
 
+    @GeneralUtilities.check_arguments
+    def git_fetch_with_retry(self, folder: str, remotename: str = "--all", amount_of_attempts: int = 5) -> None:
+        GeneralUtilities.retry_action(lambda: self.git_fetch(folder, remotename), amount_of_attempts)
+
     @GeneralUtilities.check_arguments
     def git_fetch(self, folder: str, remotename: str = "--all") -> None:
-        self.run_program_argsasarray("git", ["fetch", remotename, "--tags", "--prune"], folder, throw_exception_if_exitcode_is_not_zero=True, verbosity=0)
+        self.is_git_or_bare_git_repository(folder)
+        self.run_program_argsasarray("git", ["fetch", remotename, "--tags", "--prune"], folder, throw_exception_if_exitcode_is_not_zero=True)
 
     @GeneralUtilities.check_arguments
     def git_fetch_in_bare_repository(self, folder: str, remotename, localbranch: str, remotebranch: str) -> None:
-        self.run_program_argsasarray("git", ["fetch", remotename, f"{remotebranch}:{localbranch}"], folder, throw_exception_if_exitcode_is_not_zero=True, verbosity=0)
+        self.is_git_or_bare_git_repository(folder)
+        self.run_program_argsasarray("git", ["fetch", remotename, f"{remotebranch}:{localbranch}"], folder, throw_exception_if_exitcode_is_not_zero=True)
 
     @GeneralUtilities.check_arguments
     def git_remove_branch(self, folder: str, branchname: str) -> None:
-        self.run_program("git", f"branch -D {branchname}", folder, throw_exception_if_exitcode_is_not_zero=True, verbosity=0)
+        self.is_git_or_bare_git_repository(folder)
+        self.run_program("git", f"branch -D {branchname}", folder, throw_exception_if_exitcode_is_not_zero=True)
 
     @GeneralUtilities.check_arguments
-    def git_push(self, folder: str, remotename: str, localbranchname: str, remotebranchname: str, forcepush: bool = False, pushalltags: bool = True, verbosity: int = 0) -> None:
-        argument = ["push", "--recurse-submodules=on-demand", remotename, f"{localbranchname}:{remotebranchname}"]
+    def git_push_with_retry(self, folder: str, remotename: str, localbranchname: str, remotebranchname: str, forcepush: bool = False, pushalltags: bool = True, verbosity: LogLevel = LogLevel.Quiet, amount_of_attempts: int = 5) -> None:
+        GeneralUtilities.retry_action(lambda: self.git_push(folder, remotename, localbranchname, remotebranchname, forcepush, pushalltags, verbosity), amount_of_attempts)
+
+    @GeneralUtilities.check_arguments
+    def git_push(self, folder: str, remotename: str, localbranchname: str, remotebranchname: str, forcepush: bool = False, pushalltags: bool = True, verbosity: LogLevel = LogLevel.Quiet,resurse_submodules:bool=False) -> None:
+        self.is_git_or_bare_git_repository(folder)
+        argument = ["push"]
+        if resurse_submodules:
+            argument = argument + ["--recurse-submodules=on-demand"]
+        argument = argument + [remotename, f"{localbranchname}:{remotebranchname}"]
         if (forcepush):
             argument.append("--force")
         if (pushalltags):
             argument.append("--tags")
-        result: tuple[int, str, str, int] = self.run_program_argsasarray("git", argument, folder, throw_exception_if_exitcode_is_not_zero=True, verbosity=verbosity, print_errors_as_information=True)
+        result: tuple[int, str, str, int] = self.run_program_argsasarray("git", argument, folder, throw_exception_if_exitcode_is_not_zero=True, print_errors_as_information=True)
         return result[1].replace('\r', '').replace('\n', '')
 
     @GeneralUtilities.check_arguments
-    def git_pull(self, folder: str, remote: str, localbranchname: str, remotebranchname: str) -> None:
-        self.run_program("git", f"pull {remote} {remotebranchname}:{localbranchname}", folder, throw_exception_if_exitcode_is_not_zero=True, verbosity=0)
+    def git_pull_with_retry(self, folder: str, remote: str, localbranchname: str, remotebranchname: str, force: bool = False, amount_of_attempts: int = 5) -> None:
+        GeneralUtilities.retry_action(lambda: self.git_pull(folder, remote, localbranchname, remotebranchname), amount_of_attempts)
+
+    @GeneralUtilities.check_arguments
+    def git_pull(self, folder: str, remote: str, localbranchname: str, remotebranchname: str, force: bool = False) -> None:
+        self.is_git_or_bare_git_repository(folder)
+        argument = f"pull {remote} {remotebranchname}:{localbranchname}"
+        if force:
+            argument = f"{argument} --force"
+        self.run_program("git", argument, folder, throw_exception_if_exitcode_is_not_zero=True)
 
     @GeneralUtilities.check_arguments
     def git_list_remote_branches(self, folder: str, remote: str, fetch: bool) -> list[str]:
+        self.is_git_or_bare_git_repository(folder)
         if fetch:
             self.git_fetch(folder, remote)
-        run_program_result = self.run_program("git", f"branch -rl {remote}/*", folder, throw_exception_if_exitcode_is_not_zero=True, verbosity=0)
+        run_program_result = self.run_program("git", f"branch -rl {remote}/*", folder, throw_exception_if_exitcode_is_not_zero=True)
         output = GeneralUtilities.string_to_lines(run_program_result[1])
         result = list[str]()
         for item in output:
@@ -295,61 +338,72 @@ class ScriptCollectionCore:
                 args.append("--remote-submodules")
             if mirror:
                 args.append("--mirror")
-            self.run_program_argsasarray("git", args, os.getcwd(), throw_exception_if_exitcode_is_not_zero=True, verbosity=0)
+            self.run_program_argsasarray("git", args, os.getcwd(), throw_exception_if_exitcode_is_not_zero=True)
 
     @GeneralUtilities.check_arguments
     def git_get_all_remote_names(self, directory: str) -> list[str]:
-        result = GeneralUtilities.string_to_lines(self.run_program_argsasarray("git", ["remote"], directory, throw_exception_if_exitcode_is_not_zero=True, verbosity=0)[1], False)
+        self.is_git_or_bare_git_repository(directory)
+        result = GeneralUtilities.string_to_lines(self.run_program_argsasarray("git", ["remote"], directory, throw_exception_if_exitcode_is_not_zero=True)[1], False)
         return result
 
     @GeneralUtilities.check_arguments
     def git_get_remote_url(self, directory: str, remote_name: str) -> str:
-        result = GeneralUtilities.string_to_lines(self.run_program_argsasarray("git", ["remote", "get-url", remote_name], directory, throw_exception_if_exitcode_is_not_zero=True, verbosity=0)[1], False)
+        self.is_git_or_bare_git_repository(directory)
+        result = GeneralUtilities.string_to_lines(self.run_program_argsasarray("git", ["remote", "get-url", remote_name], directory, throw_exception_if_exitcode_is_not_zero=True)[1], False)
         return result[0].replace('\n', '')
 
     @GeneralUtilities.check_arguments
     def repository_has_remote_with_specific_name(self, directory: str, remote_name: str) -> bool:
+        self.is_git_or_bare_git_repository(directory)
         return remote_name in self.git_get_all_remote_names(directory)
 
     @GeneralUtilities.check_arguments
     def git_add_or_set_remote_address(self, directory: str, remote_name: str, remote_address: str) -> None:
+        self.assert_is_git_repository(directory)
         if (self.repository_has_remote_with_specific_name(directory, remote_name)):
-            self.run_program_argsasarray("git", ['remote', 'set-url', 'remote_name', remote_address], directory, throw_exception_if_exitcode_is_not_zero=True, verbosity=0)
+            self.run_program_argsasarray("git", ['remote', 'set-url', 'remote_name', remote_address], directory, throw_exception_if_exitcode_is_not_zero=True)
         else:
-            self.run_program_argsasarray("git", ['remote', 'add', remote_name, remote_address], directory, throw_exception_if_exitcode_is_not_zero=True, verbosity=0)
+            self.run_program_argsasarray("git", ['remote', 'add', remote_name, remote_address], directory, throw_exception_if_exitcode_is_not_zero=True)
 
     @GeneralUtilities.check_arguments
     def git_stage_all_changes(self, directory: str) -> None:
-        self.run_program_argsasarray("git", ["add", "-A"], directory, throw_exception_if_exitcode_is_not_zero=True, verbosity=0)
+        self.assert_is_git_repository(directory)
+        self.run_program_argsasarray("git", ["add", "-A"], directory, throw_exception_if_exitcode_is_not_zero=True)
 
     @GeneralUtilities.check_arguments
     def git_unstage_all_changes(self, directory: str) -> None:
-        self.run_program_argsasarray("git", ["reset"], directory, throw_exception_if_exitcode_is_not_zero=True, verbosity=0)
+        self.assert_is_git_repository(directory)
+        self.run_program_argsasarray("git", ["reset"], directory, throw_exception_if_exitcode_is_not_zero=True)
+        # TODO check if this will also be done for submodules
 
     @GeneralUtilities.check_arguments
     def git_stage_file(self, directory: str, file: str) -> None:
-        self.run_program_argsasarray("git", ['stage', file], directory, throw_exception_if_exitcode_is_not_zero=True, verbosity=0)
+        self.assert_is_git_repository(directory)
+        self.run_program_argsasarray("git", ['stage', file], directory, throw_exception_if_exitcode_is_not_zero=True)
 
     @GeneralUtilities.check_arguments
     def git_unstage_file(self, directory: str, file: str) -> None:
-        self.run_program_argsasarray("git", ['reset', file], directory, throw_exception_if_exitcode_is_not_zero=True, verbosity=0)
+        self.assert_is_git_repository(directory)
+        self.run_program_argsasarray("git", ['reset', file], directory, throw_exception_if_exitcode_is_not_zero=True)
 
     @GeneralUtilities.check_arguments
     def git_discard_unstaged_changes_of_file(self, directory: str, file: str) -> None:
         """Caution: This method works really only for 'changed' files yet. So this method does not work properly for new or renamed files."""
-        self.run_program_argsasarray("git", ['checkout', file], directory, throw_exception_if_exitcode_is_not_zero=True, verbosity=0)
+        self.assert_is_git_repository(directory)
+        self.run_program_argsasarray("git", ['checkout', file], directory, throw_exception_if_exitcode_is_not_zero=True)
 
     @GeneralUtilities.check_arguments
     def git_discard_all_unstaged_changes(self, directory: str) -> None:
         """Caution: This function executes 'git clean -df'. This can delete files which maybe should not be deleted. Be aware of that."""
-        self.run_program_argsasarray("git", ['clean', '-df'], directory, throw_exception_if_exitcode_is_not_zero=True, verbosity=0)
-        self.run_program_argsasarray("git", ['checkout', '.'], directory, throw_exception_if_exitcode_is_not_zero=True, verbosity=0)
+        self.assert_is_git_repository(directory)
+        self.run_program_argsasarray("git", ['clean', '-df'], directory, throw_exception_if_exitcode_is_not_zero=True)
+        self.run_program_argsasarray("git", ['checkout', '.'], directory, throw_exception_if_exitcode_is_not_zero=True)
+        # TODO check if this will also be done for submodules
 
     @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:
-        # no_changes_behavior=0 => No commit
-        # no_changes_behavior=1 => Commit anyway
-        # no_changes_behavior=2 => Exception
+    def git_commit(self, directory: str, message: str = "Saved changes.", 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"""
+        self.assert_is_git_repository(directory)
         author_name = GeneralUtilities.str_none_safe(author_name).strip()
         author_email = GeneralUtilities.str_none_safe(author_email).strip()
         argument = ['commit', '--quiet', '--allow-empty', '--message', message]
@@ -363,10 +417,10 @@ class ScriptCollectionCore:
                 self.git_stage_all_changes(directory)
         else:
             if no_changes_behavior == 0:
-                GeneralUtilities.write_message_to_stdout(f"Commit '{message}' will not be done because there are no changes to commit in repository '{directory}'")
+                self.log.log(f"Commit '{message}' will not be done because there are no changes to commit in repository '{directory}'", LogLevel.Debug)
                 do_commit = False
             elif no_changes_behavior == 1:
-                GeneralUtilities.write_message_to_stdout(f"There are no changes to commit in repository '{directory}'. Commit '{message}' will be done anyway.")
+                self.log.log(f"There are no changes to commit in repository '{directory}'. Commit '{message}' will be done anyway.", LogLevel.Debug)
                 do_commit = True
             elif no_changes_behavior == 2:
                 raise RuntimeError(f"There are no changes to commit in repository '{directory}'. Commit '{message}' will not be done.")
@@ -374,37 +428,75 @@ class ScriptCollectionCore:
                 raise ValueError(f"Unknown value for no_changes_behavior: {GeneralUtilities.str_none_safe(no_changes_behavior)}")
 
         if do_commit:
-            GeneralUtilities.write_message_to_stdout(f"Commit changes in '{directory}'")
-            self.run_program_argsasarray("git", argument, directory, throw_exception_if_exitcode_is_not_zero=True, verbosity=0)
+            self.log.log(f"Commit changes in '{directory}'", LogLevel.Information)
+            self.run_program_argsasarray("git", argument, directory, throw_exception_if_exitcode_is_not_zero=True)
 
         return self.git_get_commit_id(directory)
+    
+    def search_repository_folder(self,some_file_in_repository:str)->str:
+        current_path:str=os.path.dirname(some_file_in_repository)
+        enabled:bool=True
+        while enabled:
+            try:
+                current_path=GeneralUtilities.resolve_relative_path("..",current_path)
+                if self.is_git_repository(current_path):
+                    return current_path
+            except:
+                enabled=False
+        raise ValueError(f"Can not find git-repository for folder \"{some_file_in_repository}\".")
+    
 
     @GeneralUtilities.check_arguments
     def git_create_tag(self, directory: str, target_for_tag: str, tag: str, sign: bool = False, message: str = None) -> None:
+        self.is_git_or_bare_git_repository(directory)
         argument = ["tag", tag, target_for_tag]
         if sign:
             if message is None:
                 message = f"Created {target_for_tag}"
             argument.extend(["-s", '-m', message])
-        self.run_program_argsasarray(
-            "git", argument, directory, throw_exception_if_exitcode_is_not_zero=True, verbosity=0)
+        self.run_program_argsasarray("git", argument, directory, throw_exception_if_exitcode_is_not_zero=True)
 
     @GeneralUtilities.check_arguments
     def git_delete_tag(self, directory: str, tag: str) -> None:
-        self.run_program_argsasarray("git", ["tag", "--delete", tag], directory, throw_exception_if_exitcode_is_not_zero=True, verbosity=0)
-
-    @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.is_git_or_bare_git_repository(directory)
+        self.run_program_argsasarray("git", ["tag", "--delete", tag], directory, throw_exception_if_exitcode_is_not_zero=True)
+
+    @GeneralUtilities.check_arguments
+    def git_checkout(self, directory: str, branch: str, undo_all_changes_after_checkout: bool = True, assert_no_uncommitted_changes: bool = True) -> None:
+        self.assert_is_git_repository(directory)
+        if assert_no_uncommitted_changes:
+            GeneralUtilities.assert_condition(not self.git_repository_has_uncommitted_changes(directory), f"Repository '{directory}' has uncommitted changes.")
+        self.run_program_argsasarray("git", ["checkout", branch], directory, throw_exception_if_exitcode_is_not_zero=True)
+        self.run_program_argsasarray("git", ["submodule", "update", "--recursive"], directory, throw_exception_if_exitcode_is_not_zero=True)
+        if undo_all_changes_after_checkout:
+            self.git_undo_all_changes(directory)
+
+    @GeneralUtilities.check_arguments
+    def merge_repository(self, repository_folder: str, remote: str, branch: str, pull_first_if_there_are_no_uncommitted_changes: bool = True):
+        if pull_first_if_there_are_no_uncommitted_changes:
+            uncommitted_changes = self.git_repository_has_uncommitted_changes(repository_folder)
+            if not uncommitted_changes:
+                is_pullable: bool = self.git_commit_is_ancestor(repository_folder, branch, f"{remote}/{branch}")
+                if is_pullable:
+                    self.git_pull(repository_folder, remote, branch, branch)
+                    uncommitted_changes = self.git_repository_has_uncommitted_changes(repository_folder)
+                    GeneralUtilities.assert_condition(not uncommitted_changes, f"Pulling remote \"{remote}\" in \"{repository_folder}\" caused new uncommitted files.")
+        self.git_checkout(repository_folder, branch)
+        self.git_commit(repository_folder, "Automatic commit due to merge")
+        self.git_fetch(repository_folder, remote)
+        self.git_merge(repository_folder, f"{remote}/{branch}", branch)
+        self.git_push_with_retry(repository_folder, remote, branch, branch)
+        self.git_checkout(repository_folder, branch)
 
     @GeneralUtilities.check_arguments
     def git_merge_abort(self, directory: str) -> None:
-        self.run_program_argsasarray("git", ["merge", "--abort"], directory, throw_exception_if_exitcode_is_not_zero=True, verbosity=0)
+        self.assert_is_git_repository(directory)
+        self.run_program_argsasarray("git", ["merge", "--abort"], directory, throw_exception_if_exitcode_is_not_zero=True)
 
     @GeneralUtilities.check_arguments
-    def git_merge(self, directory: str, sourcebranch: str, targetbranch: str, fastforward: bool = True, commit: bool = True, commit_message: str = None) -> str:
-        self.git_checkout(directory, targetbranch)
+    def git_merge(self, directory: str, sourcebranch: str, targetbranch: str, fastforward: bool = True, commit: bool = True, commit_message: str = None, undo_all_changes_after_checkout: bool = True, assert_no_uncommitted_changes: bool = True) -> str:
+        self.assert_is_git_repository(directory)
+        self.git_checkout(directory, targetbranch, undo_all_changes_after_checkout, assert_no_uncommitted_changes)
         args = ["merge"]
         if not commit:
             args.append("--no-commit")
@@ -414,13 +506,14 @@ class ScriptCollectionCore:
             args.append("-m")
             args.append(commit_message)
         args.append(sourcebranch)
-        self.run_program_argsasarray(
-            "git", args, directory, throw_exception_if_exitcode_is_not_zero=True, verbosity=0)
+        self.run_program_argsasarray("git", args, directory, throw_exception_if_exitcode_is_not_zero=True)
+        self.run_program_argsasarray("git", ["submodule", "update"], directory, throw_exception_if_exitcode_is_not_zero=True)
         return self.git_get_commit_id(directory)
 
     @GeneralUtilities.check_arguments
     def git_undo_all_changes(self, directory: str) -> None:
         """Caution: This function executes 'git clean -df'. This can delete files which maybe should not be deleted. Be aware of that."""
+        self.assert_is_git_repository(directory)
         self.git_unstage_all_changes(directory)
         self.git_discard_all_unstaged_changes(directory)
 
@@ -438,22 +531,18 @@ class ScriptCollectionCore:
                     # clone
                     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)
+    def get_git_submodules(self, directory: str) -> list[str]:
+        self.is_git_or_bare_git_repository(directory)
+        e = self.run_program("git", "submodule status", directory)
         result = []
         for submodule_line in GeneralUtilities.string_to_lines(e[1], False, True):
             result.append(submodule_line.split(' ')[1])
         return result
 
-    @GeneralUtilities.check_arguments
-    def is_git_repository(self, folder: str) -> bool:
-        combined = os.path.join(folder, ".git")
-        # TODO consider check for bare-repositories
-        return os.path.isdir(combined) or os.path.isfile(combined)
-
     @GeneralUtilities.check_arguments
     def file_is_git_ignored(self, file_in_repository: str, repositorybasefolder: str) -> None:
-        exit_code = self.run_program_argsasarray("git", ['check-ignore', file_in_repository], repositorybasefolder, throw_exception_if_exitcode_is_not_zero=False, verbosity=0)[0]
+        self.is_git_or_bare_git_repository(repositorybasefolder)
+        exit_code = self.run_program_argsasarray("git", ['check-ignore', file_in_repository], repositorybasefolder, throw_exception_if_exitcode_is_not_zero=False)[0]
         if (exit_code == 0):
             return True
         if (exit_code == 1):
@@ -462,34 +551,39 @@ class ScriptCollectionCore:
 
     @GeneralUtilities.check_arguments
     def git_discard_all_changes(self, repository: str) -> None:
-        self.run_program_argsasarray("git", ["reset", "HEAD", "."], repository, throw_exception_if_exitcode_is_not_zero=True, verbosity=0)
-        self.run_program_argsasarray("git", ["checkout", "."], repository, throw_exception_if_exitcode_is_not_zero=True, verbosity=0)
+        self.assert_is_git_repository(repository)
+        self.run_program_argsasarray("git", ["reset", "HEAD", "."], repository, throw_exception_if_exitcode_is_not_zero=True)
+        self.run_program_argsasarray("git", ["checkout", "."], repository, throw_exception_if_exitcode_is_not_zero=True)
 
     @GeneralUtilities.check_arguments
     def git_get_current_branch_name(self, repository: str) -> str:
-        result = self.run_program_argsasarray("git", ["rev-parse", "--abbrev-ref", "HEAD"], repository, throw_exception_if_exitcode_is_not_zero=True, verbosity=0)
-        return result[1].replace("\r", "").replace("\n", "")
+        self.assert_is_git_repository(repository)
+        result = self.run_program_argsasarray("git", ["rev-parse", "--abbrev-ref", "HEAD"], repository, throw_exception_if_exitcode_is_not_zero=True)
+        return result[1].replace("\r", GeneralUtilities.empty_string).replace("\n", GeneralUtilities.empty_string)
 
     @GeneralUtilities.check_arguments
     def git_get_commitid_of_tag(self, repository: str, tag: str) -> str:
-        stdout = self.run_program_argsasarray("git", ["rev-list", "-n", "1", tag], repository, verbosity=0)
-        result = stdout[1].replace("\r", "").replace("\n", "")
+        self.is_git_or_bare_git_repository(repository)
+        stdout = self.run_program_argsasarray("git", ["rev-list", "-n", "1", tag], repository)
+        result = stdout[1].replace("\r", GeneralUtilities.empty_string).replace("\n", GeneralUtilities.empty_string)
         return result
 
     @GeneralUtilities.check_arguments
     def git_get_tags(self, repository: str) -> list[str]:
-        tags = [line.replace("\r", "") for line in self.run_program_argsasarray(
+        self.is_git_or_bare_git_repository(repository)
+        tags = [line.replace("\r", GeneralUtilities.empty_string) for line in self.run_program_argsasarray(
             "git", ["tag"], repository)[1].split("\n") if len(line) > 0]
         return tags
 
     @GeneralUtilities.check_arguments
     def git_move_tags_to_another_branch(self, repository: str, tag_source_branch: str, tag_target_branch: str, sign: bool = False, message: str = None) -> None:
+        self.is_git_or_bare_git_repository(repository)
         tags = self.git_get_tags(repository)
         tags_count = len(tags)
         counter = 0
         for tag in tags:
             counter = counter+1
-            GeneralUtilities.write_message_to_stdout(f"Process tag {counter}/{tags_count}.")
+            self.log.log(f"Process tag {counter}/{tags_count}.", LogLevel.Information)
             # tag is on source-branch
             if self.git_commit_is_ancestor(repository, tag, tag_source_branch):
                 commit_id_old = self.git_get_commitid_of_tag(repository, tag)
@@ -504,27 +598,36 @@ class ScriptCollectionCore:
 
     @GeneralUtilities.check_arguments
     def get_current_git_branch_has_tag(self, repository_folder: str) -> bool:
-        result = self.run_program_argsasarray("git", ["describe", "--tags", "--abbrev=0"], repository_folder, verbosity=0, throw_exception_if_exitcode_is_not_zero=False)
+        self.is_git_or_bare_git_repository(repository_folder)
+        result = self.run_program_argsasarray("git", ["describe", "--tags", "--abbrev=0"], repository_folder, throw_exception_if_exitcode_is_not_zero=False)
         return result[0] == 0
 
     @GeneralUtilities.check_arguments
     def get_latest_git_tag(self, repository_folder: str) -> str:
-        result = self.run_program_argsasarray(
-            "git", ["describe", "--tags", "--abbrev=0"], repository_folder, verbosity=0)
-        result = result[1].replace("\r", "").replace("\n", "")
+        self.is_git_or_bare_git_repository(repository_folder)
+        result = self.run_program_argsasarray("git", ["describe", "--tags", "--abbrev=0"], repository_folder)
+        result = result[1].replace("\r", GeneralUtilities.empty_string).replace("\n", GeneralUtilities.empty_string)
         return result
 
     @GeneralUtilities.check_arguments
     def get_staged_or_committed_git_ignored_files(self, repository_folder: str) -> list[str]:
-        tresult = self.run_program_argsasarray("git", ["ls-files", "-i", "-c", "--exclude-standard"], repository_folder, verbosity=0)
-        tresult = tresult[1].replace("\r", "")
-        result = [line for line in tresult.split("\n") if len(line) > 0]
+        self.assert_is_git_repository(repository_folder)
+        temp_result = self.run_program_argsasarray("git", ["ls-files", "-i", "-c", "--exclude-standard"], repository_folder)
+        temp_result = temp_result[1].replace("\r", GeneralUtilities.empty_string)
+        result = [line for line in temp_result.split("\n") if len(line) > 0]
         return result
 
     @GeneralUtilities.check_arguments
     def git_repository_has_commits(self, repository_folder: str) -> bool:
+        self.assert_is_git_repository(repository_folder)
         return self.run_program_argsasarray("git", ["rev-parse", "--verify", "HEAD"], repository_folder, throw_exception_if_exitcode_is_not_zero=False)[0] == 0
 
+    @GeneralUtilities.check_arguments
+    def run_git_command_in_repository_and_submodules(self, repository_folder: str, arguments: list[str]) -> None:
+        self.is_git_or_bare_git_repository(repository_folder)
+        self.run_program_argsasarray("git", arguments, repository_folder)
+        self.run_program_argsasarray("git", ["submodule", "foreach", "--recursive", "git"]+arguments, repository_folder)
+
     @GeneralUtilities.check_arguments
     def export_filemetadata(self, folder: str, target_file: str, encoding: str = "utf-8", filter_function=None) -> None:
         folder = GeneralUtilities.resolve_relative_path_from_current_working_directory(folder)
@@ -576,6 +679,245 @@ class ScriptCollectionCore:
         for renamed_item, original_name in renamed_items.items():
             os.rename(renamed_item, original_name)
 
+    @GeneralUtilities.check_arguments
+    def is_git_repository(self, folder: str) -> bool:
+        """This function works platform-independent also for non-local-executions if the ScriptCollection commandline-commands are available as global command on the target-system."""
+        folder=folder.replace("\\","/")
+        if folder.endswith("/"):
+            folder = folder[:-1]
+        if not self.is_folder(folder):
+            raise ValueError(f"Folder '{folder}' does not exist.")
+        git_folder_path = f"{folder}/.git"
+        return self.is_folder(git_folder_path) or self.is_file(git_folder_path)
+
+    @GeneralUtilities.check_arguments
+    def is_bare_git_repository(self, folder: str) -> bool:
+        """This function works platform-independent also for non-local-executions if the ScriptCollection commandline-commands are available as global command on the target-system."""
+        if folder.endswith("/") or folder.endswith("\\"):
+            folder = folder[:-1]
+        if not self.is_folder(folder):
+            raise ValueError(f"Folder '{folder}' does not exist.")
+        return folder.endswith(".git")
+
+    @GeneralUtilities.check_arguments
+    def is_git_or_bare_git_repository(self, folder: str) -> bool:
+        """This function works platform-independent also for non-local-executions if the ScriptCollection commandline-commands are available as global command on the target-system."""
+        return self.is_git_repository(folder) or self.is_bare_git_repository(folder)
+
+    @GeneralUtilities.check_arguments
+    def assert_is_git_repository(self, folder: str) -> str:
+        """This function works platform-independent also for non-local-executions if the ScriptCollection commandline-commands are available as global command on the target-system."""
+        GeneralUtilities.assert_condition(self.is_git_repository(folder), f"'{folder}' is not a git-repository.")
+
+    @GeneralUtilities.check_arguments
+    def convert_git_repository_to_bare_repository(self, repository_folder: str):
+        repository_folder = repository_folder.replace("\\", "/")
+        self.assert_is_git_repository(repository_folder)
+        git_folder = repository_folder + "/.git"
+        if not self.is_folder(git_folder):
+            raise ValueError(f"Converting '{repository_folder}' to a bare repository not possible. The folder '{git_folder}' does not exist. Converting is currently only supported when the git-folder is a direct folder in a repository and not a reference to another location.")
+        target_folder: str = repository_folder + ".git"
+        GeneralUtilities.ensure_directory_exists(target_folder)
+        GeneralUtilities.move_content_of_folder(git_folder, target_folder)
+        GeneralUtilities.ensure_directory_does_not_exist(repository_folder)
+        self.run_program_argsasarray("git", ["config", "--bool", "core.bare", "true"], target_folder)
+
+    @GeneralUtilities.check_arguments
+    def assert_no_uncommitted_changes(self, repository_folder: str):
+        if self.git_repository_has_uncommitted_changes(repository_folder):
+            raise ValueError(f"Repository '{repository_folder}' has uncommitted changes.")
+
+    @GeneralUtilities.check_arguments
+    def list_content(self, path: str, include_files: bool, include_folder: bool, printonlynamewithoutpath: bool) -> list[str]:
+        """This function works platform-independent also for non-local-executions if the ScriptCollection commandline-commands are available as global command on the target-system."""
+        result: list[str] = []
+        if self.program_runner.will_be_executed_locally():
+            if include_files:
+                result = result + GeneralUtilities.get_direct_files_of_folder(path)
+            if include_folder:
+                result = result + GeneralUtilities.get_direct_folders_of_folder(path)
+        else:
+            arguments = ["--path", path]
+            if not include_files:
+                arguments = arguments+["--excludefiles"]
+            if not include_folder:
+                arguments = arguments+["--excludedirectories"]
+            if printonlynamewithoutpath:
+                arguments = arguments+["--printonlynamewithoutpath"]
+            exit_code, stdout, stderr, _ = self.run_program_argsasarray("sclistfoldercontent", arguments)
+            if exit_code == 0:
+                for line in stdout.split("\n"):
+                    normalized_line = line.replace("\r", "")
+                    result.append(normalized_line)
+            else:
+                raise ValueError(f"Fatal error occurrs while checking whether file '{path}' exists. StdErr: '{stderr}'")
+        result = [item for item in result if GeneralUtilities.string_has_nonwhitespace_content(item)]
+        return result
+
+    @GeneralUtilities.check_arguments
+    def is_file(self, path: str) -> bool:
+        """This function works platform-independent also for non-local-executions if the ScriptCollection commandline-commands are available as global command on the target-system."""
+        if self.program_runner.will_be_executed_locally():
+            return os.path.isfile(path)  # works only locally, but much more performant than always running an external program
+        else:
+            exit_code, _, stderr, _ = self.run_program_argsasarray("scfileexists", ["--path", path], throw_exception_if_exitcode_is_not_zero=False)  # works platform-indepent
+            if exit_code == 0:
+                return True
+            elif exit_code == 1:
+                raise ValueError(f"Not calculatable whether file '{path}' exists. StdErr: '{stderr}'")
+            elif exit_code == 2:
+                return False
+            raise ValueError(f"Fatal error occurrs while checking whether file '{path}' exists. StdErr: '{stderr}'")
+
+    @GeneralUtilities.check_arguments
+    def is_folder(self, path: str) -> bool:
+        """This function works platform-independent also for non-local-executions if the ScriptCollection commandline-commands are available as global command on the target-system."""
+        if self.program_runner.will_be_executed_locally():  # works only locally, but much more performant than always running an external program
+            return os.path.isdir(path)
+        else:
+            exit_code, _, stderr, _ = self.run_program_argsasarray("scfolderexists", ["--path", path], throw_exception_if_exitcode_is_not_zero=False)  # works platform-indepent
+            if exit_code == 0:
+                return True
+            elif exit_code == 1:
+                raise ValueError(f"Not calculatable whether folder '{path}' exists. StdErr: '{stderr}'")
+            elif exit_code == 2:
+                return False
+            raise ValueError(f"Fatal error occurrs while checking whether folder '{path}' exists. StdErr: '{stderr}'")
+
+    @GeneralUtilities.check_arguments
+    def get_file_content(self, path: str, encoding: str = "utf-8") -> str:
+        """This function works platform-independent also for non-local-executions if the ScriptCollection commandline-commands are available as global command on the target-system."""
+        if self.program_runner.will_be_executed_locally():
+            return GeneralUtilities.read_text_from_file(path, encoding)
+        else:
+            result = self.run_program_argsasarray("scprintfilecontent", ["--path", path, "--encofing", encoding])  # works platform-indepent
+            return result[1].replace("\\n", "\n")
+
+    @GeneralUtilities.check_arguments
+    def set_file_content(self, path: str, content: str, encoding: str = "utf-8") -> None:
+        """This function works platform-independent also for non-local-executions if the ScriptCollection commandline-commands are available as global command on the target-system."""
+        if self.program_runner.will_be_executed_locally():
+            GeneralUtilities.write_text_to_file(path, content, encoding)
+        else:
+            content_bytes = content.encode('utf-8')
+            base64_bytes = base64.b64encode(content_bytes)
+            base64_string = base64_bytes.decode('utf-8')
+            self.run_program_argsasarray("scsetfilecontent", ["--path", path, "--argumentisinbase64", "--content", base64_string])  # works platform-indepent
+
+    @GeneralUtilities.check_arguments
+    def remove(self, path: str) -> None:
+        """This function works platform-independent also for non-local-executions if the ScriptCollection commandline-commands are available as global command on the target-system."""
+        if self.program_runner.will_be_executed_locally():  # works only locally, but much more performant than always running an external program
+            if os.path.isdir(path):
+                GeneralUtilities.ensure_directory_does_not_exist(path)
+            if os.path.isfile(path):
+                GeneralUtilities.ensure_file_does_not_exist(path)
+        else:
+            if self.is_file(path):
+                exit_code, _, stderr, _ = self.run_program_argsasarray("scremovefile", ["--path", path], throw_exception_if_exitcode_is_not_zero=False)  # works platform-indepent
+                if exit_code != 0:
+                    raise ValueError(f"Fatal error occurrs while removing file '{path}'. StdErr: '{stderr}'")
+            if self.is_folder(path):
+                exit_code, _, stderr, _ = self.run_program_argsasarray("scremovefolder", ["--path", path], throw_exception_if_exitcode_is_not_zero=False)  # works platform-indepent
+                if exit_code != 0:
+                    raise ValueError(f"Fatal error occurrs while removing folder '{path}'. StdErr: '{stderr}'")
+
+    @GeneralUtilities.check_arguments
+    def rename(self,  source: str, target: str) -> None:
+        """This function works platform-independent also for non-local-executions if the ScriptCollection commandline-commands are available as global command on the target-system."""
+        if self.program_runner.will_be_executed_locally():  # works only locally, but much more performant than always running an external program
+            os.rename(source, target)
+        else:
+            exit_code, _, stderr, _ = self.run_program_argsasarray("screname", ["--source", source, "--target", target], throw_exception_if_exitcode_is_not_zero=False)  # works platform-indepent
+            if exit_code != 0:
+                raise ValueError(f"Fatal error occurrs while renaming '{source}' to '{target}'. StdErr: '{stderr}'")
+
+    @GeneralUtilities.check_arguments
+    def copy(self, source: str, target: str) -> None:
+        """This function works platform-independent also for non-local-executions if the ScriptCollection commandline-commands are available as global command on the target-system."""
+        if self.program_runner.will_be_executed_locally():  # works only locally, but much more performant than always running an external program
+            if os.path.isfile(target) or os.path.isdir(target):
+                raise ValueError(f"Can not copy to '{target}' because the target already exists.")
+            if os.path.isfile(source):
+                shutil.copyfile(source, target)
+            elif os.path.isdir(source):
+                GeneralUtilities.ensure_directory_exists(target)
+                GeneralUtilities.copy_content_of_folder(source, target)
+            else:
+                raise ValueError(f"'{source}' can not be copied because the path does not exist.")
+        else:
+            exit_code, _, stderr, _ = self.run_program_argsasarray("sccopy", ["--source", source, "--target", target], throw_exception_if_exitcode_is_not_zero=False)  # works platform-indepent
+            if exit_code != 0:
+                raise ValueError(f"Fatal error occurrs while copying '{source}' to '{target}'. StdErr: '{stderr}'")
+
+    @GeneralUtilities.check_arguments
+    def create_file(self, path: str, error_if_already_exists: bool, create_necessary_folder: bool) -> None:
+        """This function works platform-independent also for non-local-executions if the ScriptCollection commandline-commands are available as global command on the target-system."""
+        if self.program_runner.will_be_executed_locally():
+            if not os.path.isabs(path):
+                path = os.path.join(os.getcwd(), path)
+
+            if os.path.isfile(path) and error_if_already_exists:
+                raise ValueError(f"File '{path}' already exists.")
+
+            # TODO maybe it should be checked if there is a folder with the same path which already exists.
+
+            folder = os.path.dirname(path)
+
+            if not os.path.isdir(folder):
+                if create_necessary_folder:
+                    GeneralUtilities.ensure_directory_exists(folder)  # TODO check if this also create nested folders if required
+                else:
+                    raise ValueError(f"Folder '{folder}' does not exist.")
+
+            GeneralUtilities.ensure_file_exists(path)
+        else:
+            arguments = ["--path", path]
+
+            if error_if_already_exists:
+                arguments = arguments+["--errorwhenexists"]
+
+            if create_necessary_folder:
+                arguments = arguments+["--createnecessaryfolder"]
+
+            exit_code, _, stderr, _ = self.run_program_argsasarray("sccreatefile", arguments, throw_exception_if_exitcode_is_not_zero=False)  # works platform-indepent
+            if exit_code != 0:
+                raise ValueError(f"Fatal error occurrs while create file '{path}'. StdErr: '{stderr}'")
+
+    @GeneralUtilities.check_arguments
+    def create_folder(self, path: str, error_if_already_exists: bool, create_necessary_folder: bool) -> None:
+        """This function works platform-independent also for non-local-executions if the ScriptCollection commandline-commands are available as global command on the target-system."""
+        if self.program_runner.will_be_executed_locally():
+            if not os.path.isabs(path):
+                path = os.path.join(os.getcwd(), path)
+
+            if os.path.isdir(path) and error_if_already_exists:
+                raise ValueError(f"Folder '{path}' already exists.")
+
+            # TODO maybe it should be checked if there is a file with the same path which already exists.
+
+            folder = os.path.dirname(path)
+
+            if not os.path.isdir(folder):
+                if create_necessary_folder:
+                    GeneralUtilities.ensure_directory_exists(folder)  # TODO check if this also create nested folders if required
+                else:
+                    raise ValueError(f"Folder '{folder}' does not exist.")
+
+            GeneralUtilities.ensure_directory_exists(path)
+        else:
+            arguments = ["--path", path]
+
+            if error_if_already_exists:
+                arguments = arguments+["--errorwhenexists"]
+
+            if create_necessary_folder:
+                arguments = arguments+["--createnecessaryfolder"]
+
+            exit_code, _, stderr, _ = self.run_program_argsasarray("sccreatefolder", arguments, throw_exception_if_exitcode_is_not_zero=False)  # works platform-indepent
+            if exit_code != 0:
+                raise ValueError(f"Fatal error occurrs while create folder '{path}'. StdErr: '{stderr}'")
+
     @GeneralUtilities.check_arguments
     def __sort_fmd(self, line: str):
         splitted: list = line.split(";")
@@ -619,7 +961,7 @@ class ScriptCollectionCore:
 
     @GeneralUtilities.check_arguments
     def __create_thumbnails(self, filename: str, fps: str, folder: str, tempname_for_thumbnails: str) -> list[str]:
-        argument = ['-i', filename, '-r', str(fps), '-vf', 'scale=-1:120', '-vcodec', 'png', f'{tempname_for_thumbnails}-%002d.png']
+        argument = ['-i', filename, '-r', fps, '-vf', 'scale=-1:120', '-vcodec', 'png', f'{tempname_for_thumbnails}-%002d.png']
         self.run_program_argsasarray("ffmpeg", argument, folder, throw_exception_if_exitcode_is_not_zero=True)
         files = GeneralUtilities.get_direct_files_of_folder(folder)
         result: list[str] = []
@@ -636,8 +978,17 @@ class ScriptCollectionCore:
     def __create_thumbnail(self, outputfilename: str, folder: str, length_in_seconds: float, tempname_for_thumbnails: str, amount_of_images: int) -> None:
         duration = timedelta(seconds=length_in_seconds)
         info = GeneralUtilities.timedelta_to_simple_string(duration)
-        rows: int = 5
-        columns: int = math.ceil(amount_of_images/rows)
+        next_square_number = GeneralUtilities.get_next_square_number(amount_of_images)
+        root = math.sqrt(next_square_number)
+        rows: int = root  # 5
+        columns: int = root  # math.ceil(amount_of_images/rows)
+        argument = ['-title', f'"{outputfilename} ({info})"', '-tile', f'{rows}x{columns}', f'{tempname_for_thumbnails}*.png', f'{outputfilename}.png']
+        self.run_program_argsasarray("montage", argument, folder, throw_exception_if_exitcode_is_not_zero=True)
+
+    @GeneralUtilities.check_arguments
+    def __create_thumbnail2(self, outputfilename: str, folder: str, length_in_seconds: float, rows: int, columns: int, tempname_for_thumbnails: str, amount_of_images: int) -> None:
+        duration = timedelta(seconds=length_in_seconds)
+        info = GeneralUtilities.timedelta_to_simple_string(duration)
         argument = ['-title', f'"{outputfilename} ({info})"', '-tile', f'{rows}x{columns}', f'{tempname_for_thumbnails}*.png', f'{outputfilename}.png']
         self.run_program_argsasarray("montage", argument, folder, throw_exception_if_exitcode_is_not_zero=True)
 
@@ -650,7 +1001,7 @@ class ScriptCollectionCore:
             return math.ceil(x * d) / d
 
     @GeneralUtilities.check_arguments
-    def generate_thumbnail(self, file: str, frames_per_second: str, tempname_for_thumbnails: str = None, hook=None) -> None:
+    def generate_thumbnail(self, file: str, frames_per_second: float, tempname_for_thumbnails: str = None, hook=None) -> None:
         if tempname_for_thumbnails is None:
             tempname_for_thumbnails = "t_"+str(uuid.uuid4())
 
@@ -661,16 +1012,9 @@ class ScriptCollectionCore:
         preview_files: list[str] = []
         try:
             length_in_seconds = self.__calculate_lengh_in_seconds(filename, folder)
-            if (frames_per_second.endswith("fps")):
-                # frames per second, example: frames_per_second="20fps" => 20 frames per second
-                frames_per_second = self.__roundup(float(frames_per_second[:-3]), 2)
-                frames_per_second_as_string = str(frames_per_second)
-                amounf_of_previewframes = int(math.floor(length_in_seconds*frames_per_second))
-            else:
-                # concrete amount of frame, examples: frames_per_second="16" => 16 frames for entire video
-                amounf_of_previewframes = int(float(frames_per_second))
-                # self.roundup((amounf_of_previewframes-2)/length_in_seconds, 2)
-                frames_per_second_as_string = f"{amounf_of_previewframes-2}/{length_in_seconds}"
+            # frames per second, example: frames_per_second="20fps" => 20 frames per second
+            frames_per_second = self.__roundup(float(frames_per_second[:-3]), 2)
+            frames_per_second_as_string = str(frames_per_second)
             preview_files = self.__create_thumbnails(filename, frames_per_second_as_string, folder, tempname_for_thumbnails)
             if hook is not None:
                 hook(file, preview_files)
@@ -680,10 +1024,33 @@ class ScriptCollectionCore:
             for thumbnail_to_delete in preview_files:
                 os.remove(thumbnail_to_delete)
 
+    @GeneralUtilities.check_arguments
+    def generate_thumbnail_by_amount_of_pictures(self, file: str, amount_of_columns: int, amount_of_rows: int, tempname_for_thumbnails: str = None, hook=None) -> None:
+        if tempname_for_thumbnails is None:
+            tempname_for_thumbnails = "t_"+str(uuid.uuid4())
+
+        file = GeneralUtilities.resolve_relative_path_from_current_working_directory(file)
+        filename = os.path.basename(file)
+        folder = os.path.dirname(file)
+        filename_without_extension = Path(file).stem
+        preview_files: list[str] = []
+        try:
+            length_in_seconds = self.__calculate_lengh_in_seconds(filename, folder)
+            amounf_of_previewframes = int(amount_of_columns*amount_of_rows)
+            frames_per_second_as_string = f"{amounf_of_previewframes-2}/{length_in_seconds}"
+            preview_files = self.__create_thumbnails(filename, frames_per_second_as_string, folder, tempname_for_thumbnails)
+            if hook is not None:
+                hook(file, preview_files)
+            actual_amounf_of_previewframes = len(preview_files)
+            self.__create_thumbnail2(filename_without_extension, folder, length_in_seconds, amount_of_rows, amount_of_columns, tempname_for_thumbnails, actual_amounf_of_previewframes)
+        finally:
+            for thumbnail_to_delete in preview_files:
+                os.remove(thumbnail_to_delete)
+
     @GeneralUtilities.check_arguments
     def extract_pdf_pages(self, file: str, from_page: int, to_page: int, outputfile: str) -> None:
-        pdf_reader = PyPDF2.PdfReader(file)
-        pdf_writer = PyPDF2.PdfWriter()
+        pdf_reader: PdfReader = PdfReader(file)
+        pdf_writer: PdfWriter = PdfWriter()
         start = from_page
         end = to_page
         while start <= end:
@@ -695,11 +1062,13 @@ class ScriptCollectionCore:
     @GeneralUtilities.check_arguments
     def merge_pdf_files(self, files: list[str], outputfile: str) -> None:
         # TODO add wildcard-option
-        pdfFileMerger = PyPDF2.PdfFileMerger()
+        pdfFileMerger: PdfWriter = PdfWriter()
         for file in files:
-            pdfFileMerger.append(file.strip())
-        pdfFileMerger.write(outputfile)
-        pdfFileMerger.close()
+            with open(file, "rb") as f:
+                pdfFileMerger.append(f)
+        with open(outputfile, "wb") as output:
+            pdfFileMerger.write(output)
+            pdfFileMerger.close()
 
     @GeneralUtilities.check_arguments
     def pdf_to_image(self, file: str, outputfilename_without_extension: str) -> None:
@@ -737,10 +1106,10 @@ class ScriptCollectionCore:
                 elif (size_string.endswith("gib")):
                     size = int(size_string[:-3]) * pow(2, 30)
                 else:
-                    GeneralUtilities.write_message_to_stderr("Wrong format")
+                    self.log.log("Wrong format", LogLevel.Error)
                     return 1
             else:
-                GeneralUtilities.write_message_to_stderr("Wrong format")
+                self.log.log("Wrong format", LogLevel.Error)
                 return 1
         with open(name, "wb") as f:
             f.seek(size-1)
@@ -804,7 +1173,7 @@ class ScriptCollectionCore:
 
             return 0
         else:
-            GeneralUtilities.write_message_to_stdout(f"File '{file}' does not exist")
+            self.log.log(f"File '{file}' does not exist.", LogLevel.Error)
             return 1
 
     @GeneralUtilities.check_arguments
@@ -880,11 +1249,19 @@ class ScriptCollectionCore:
         for file in GeneralUtilities.absolute_file_paths(folder):
             self.__check_file(file, searchstring)
 
+    @GeneralUtilities.check_arguments
+    def get_string_as_qr_code(self,string: str) -> None:
+        qr = qrcode.QRCode()
+        qr.add_data(string)
+        f = io.StringIO()
+        qr.print_ascii(out=f)
+        f.seek(0)
+        return f.read()
+
     @GeneralUtilities.check_arguments
     def __print_qr_code_by_csv_line(self, displayname: str, website: str, emailaddress: str, key: str, period: str) -> None:
         qrcode_content = f"otpauth://totp/{website}:{emailaddress}?secret={key}&issuer={displayname}&period={period}"
-        GeneralUtilities.write_message_to_stdout(
-            f"{displayname} ({emailaddress}):")
+        GeneralUtilities.write_message_to_stdout(f"{displayname} ({emailaddress}):")
         GeneralUtilities.write_message_to_stdout(qrcode_content)
         qr = qrcode.QRCode()
         qr.add_data(qrcode_content)
@@ -895,14 +1272,11 @@ class ScriptCollectionCore:
 
     @GeneralUtilities.check_arguments
     def SCShow2FAAsQRCode(self, csvfile: str) -> None:
-        separator_line = "--------------------------------------------------------"
         lines = GeneralUtilities.read_csv_file(csvfile, True)
         lines.sort(key=lambda items: ''.join(items).lower())
         for line in lines:
-            GeneralUtilities.write_message_to_stdout(separator_line)
-            self.__print_qr_code_by_csv_line(
-                line[0], line[1], line[2], line[3], line[4])
-        GeneralUtilities.write_message_to_stdout(separator_line)
+            self.__print_qr_code_by_csv_line(line[0], line[1], line[2], line[3], line[4])
+            GeneralUtilities.write_message_to_stdout(GeneralUtilities.get_longline())
 
     @GeneralUtilities.check_arguments
     def SCCalculateBitcoinBlockHash(self, block_version_number: str, previousblockhash: str, transactionsmerkleroot: str, timestamp: str, target: str, nonce: str) -> str:
@@ -935,7 +1309,7 @@ class ScriptCollectionCore:
     def __adjust_folder_name(self, folder: str) -> str:
         result = os.path.dirname(folder).replace("\\", "/")
         if result == "/":
-            return ""
+            return GeneralUtilities.empty_string
         else:
             return result
 
@@ -1068,15 +1442,15 @@ class ScriptCollectionCore:
 
     @GeneralUtilities.check_arguments
     def get_docker_debian_version(self, image_tag: str) -> str:
-        result = ScriptCollectionCore().run_program_argsasarray(
-            "docker", ['run', f'debian:{image_tag}', 'bash', '-c', 'apt-get -y update && apt-get -y install lsb-release && lsb_release -cs'])
-        result_line = GeneralUtilities.string_to_lines(result[1])[-2]
+        result = ScriptCollectionCore().run_program_argsasarray("docker", ['run', f'debian:{image_tag}', 'bash', '-c', 'apt-get -y update && apt-get -y install lsb-release && lsb_release -cs'])
+        result_line = GeneralUtilities.string_to_lines(result[1])[-1]
         return result_line
 
     @GeneralUtilities.check_arguments
     def get_latest_tor_version_of_debian_repository(self, debian_version: str) -> str:
         package_url: str = f"https://deb.torproject.org/torproject.org/dists/{debian_version}/main/binary-amd64/Packages"
-        r = requests.get(package_url, timeout=5)
+        headers = {'Cache-Control': 'no-cache'}
+        r = requests.get(package_url, timeout=5, headers=headers)
         if r.status_code != 200:
             raise ValueError(f"Checking for latest tor package resulted in HTTP-response-code {r.status_code}.")
         lines = GeneralUtilities.string_to_lines(GeneralUtilities.bytes_to_string(r.content))
@@ -1087,12 +1461,13 @@ class ScriptCollectionCore:
         return tor_version
 
     def run_testcases_for_python_project(self, repository_folder: str):
+        self.assert_is_git_repository(repository_folder)
         self.run_program("coverage", "run -m pytest", repository_folder)
         self.run_program("coverage", "xml", repository_folder)
         GeneralUtilities.ensure_directory_exists(os.path.join(repository_folder, "Other/TestCoverage"))
         coveragefile = os.path.join(repository_folder, "Other/TestCoverage/TestCoverage.xml")
         GeneralUtilities.ensure_file_does_not_exist(coveragefile)
-        os.rename(os.path.join(repository_folder,                "coverage.xml"), coveragefile)
+        os.rename(os.path.join(repository_folder, "coverage.xml"), coveragefile)
 
     @GeneralUtilities.check_arguments
     def get_file_permission(self, file: str) -> str:
@@ -1102,11 +1477,11 @@ class ScriptCollectionCore:
 
     @GeneralUtilities.check_arguments
     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]))
+        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
     def __to_octet(self, string: str) -> int:
-        return int(self.__to_octet_helper(string[0])+self.__to_octet_helper(string[1])+self.__to_octet_helper(string[2]), 2)
+        return int(self.__to_octet_helper(string[0]) + self.__to_octet_helper(string[1])+self.__to_octet_helper(string[2]), 2)
 
     @GeneralUtilities.check_arguments
     def __to_octet_helper(self, string: str) -> str:
@@ -1138,9 +1513,8 @@ class ScriptCollectionCore:
         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 = output.replace("\n", GeneralUtilities.empty_string)
         result = ' '.join(result.split())   # reduce multiple whitespaces to one
         return result
 
@@ -1151,7 +1525,6 @@ class ScriptCollectionCore:
         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
@@ -1182,54 +1555,93 @@ class ScriptCollectionCore:
     # <run programs>
 
     @GeneralUtilities.check_arguments
-    def __run_program_argsasarray_async_helper(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, custom_argument: object = None, interactive: bool = False) -> Popen:
-        # Verbosity:
-        # 0=Quiet (No output will be printed.)
-        # 1=Normal (If the exitcode of the executed program is not 0 then the StdErr will be printed.)
-        # 2=Full (Prints StdOut and StdErr of the executed program.)
-        # 3=Verbose (Same as "Full" but with some more information.)
-
-        if isinstance(self.program_runner, ProgramRunnerEpew):
-            custom_argument = CustomEpewArgument(print_errors_as_information, log_file, timeoutInSeconds, addLogOverhead, title, log_namespace, verbosity, arguments_for_log)
+    def __run_program_argsasarray_async_helper(self, program: str, arguments_as_array: list[str] = [], working_directory: str = None, 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, custom_argument: object = None, interactive: bool = False) -> Popen:
         popen: Popen = self.program_runner.run_program_argsasarray_async_helper(program, arguments_as_array, working_directory, custom_argument, interactive)
         return popen
 
     @staticmethod
-    def __enqueue_output(file, queue):
+    def __enqueue_output(file: IO, queue: Queue):
         for line in iter(file.readline, ''):
             queue.put(line)
         file.close()
 
     @staticmethod
-    def __read_popen_pipes(p: Popen):
+    def __continue_process_reading(pid: int, p: Popen, q_stdout: Queue, q_stderr: Queue, reading_stdout_last_time_resulted_in_exception: bool, reading_stderr_last_time_resulted_in_exception: bool):
+        if p.poll() is None:
+            return True
+
+        # if reading_stdout_last_time_resulted_in_exception and reading_stderr_last_time_resulted_in_exception:
+        #    return False
+
+        if not q_stdout.empty():
+            return True
+
+        if not q_stderr.empty():
+            return True
+
+        return False
+
+    @staticmethod
+    def __read_popen_pipes(p: Popen, print_live_output: bool, print_errors_as_information: bool, log: SCLog) -> tuple[list[str], list[str]]:
+        p_id = p.pid
         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
+            reading_stdout_last_time_resulted_in_exception: bool = False
+            reading_stderr_last_time_resulted_in_exception: bool = False
+
+            stdout_result: list[str] = []
+            stderr_result: list[str] = []
+
+            while (ScriptCollectionCore.__continue_process_reading(p_id, p, q_stdout, q_stderr, reading_stdout_last_time_resulted_in_exception, reading_stderr_last_time_resulted_in_exception)):
                 try:
-                    out_line = q_stdout.get_nowait()
+                    while not q_stdout.empty():
+                        out_line: str = q_stdout.get_nowait()
+                        out_line = out_line.replace("\r", GeneralUtilities.empty_string).replace("\n", GeneralUtilities.empty_string)
+                        if GeneralUtilities.string_has_content(out_line):
+                            stdout_result.append(out_line)
+                            reading_stdout_last_time_resulted_in_exception = False
+                            if print_live_output:
+                                loglevel = LogLevel.Information
+                                if out_line.startswith("Debug: "):
+                                    loglevel = LogLevel.Debug
+                                    out_line = out_line[len("Debug: "):]
+                                if out_line.startswith("Diagnostic: "):
+                                    loglevel = LogLevel.Diagnostic
+                                    out_line = out_line[len("Diagnostic: "):]
+                                log.log(out_line, loglevel)
                 except Empty:
-                    pass
+                    reading_stdout_last_time_resulted_in_exception = True
+
                 try:
-                    err_line = q_stderr.get_nowait()
+                    while not q_stderr.empty():
+                        err_line: str = q_stderr.get_nowait()
+                        err_line = err_line.replace("\r", GeneralUtilities.empty_string).replace("\n", GeneralUtilities.empty_string)
+                        if GeneralUtilities.string_has_content(err_line):
+                            stderr_result.append(err_line)
+                            reading_stderr_last_time_resulted_in_exception = False
+                            if print_live_output:
+                                loglevel = LogLevel.Error
+                                if err_line.startswith("Warning: "):
+                                    loglevel = LogLevel.Warning
+                                    err_line = err_line[len("Warning: "):]
+                                if print_errors_as_information:  # "errors" in "print_errors_as_information" means: all what is written to std-err
+                                    loglevel = LogLevel.Information
+                                log.log(err_line, loglevel)
                 except Empty:
-                    pass
+                    reading_stderr_last_time_resulted_in_exception = True
 
-                yield (out_line, err_line)
+                time.sleep(0.01)  # this is required to not finish too early
+
+            return (stdout_result, stderr_result)
 
-    # 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.
-        # verbosity 2: If the exitcode of the executed program is not 0 then the StdErr will be logged. This is supposed to be the default verbosity-level.
-        # verbosity 3: Logs and prints StdOut and StdErr of the executed program in realtime.
-        # verbosity 4: Same as loglevel 3 but with some more overhead-information.
+    def run_program_argsasarray(self, program: str, arguments_as_array: list[str] = [], working_directory: str = None, 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, print_live_output: bool = False) -> tuple[int, str, str, int]:
+        if self.call_program_runner_directly:
+            return self.program_runner.run_program_argsasarray(program, arguments_as_array, working_directory, custom_argument, interactive)
         try:
             arguments_as_str = ' '.join(arguments_as_array)
             mock_loader_result = self.__try_load_mock(program, arguments_as_str, working_directory)
@@ -1241,31 +1653,32 @@ class ScriptCollectionCore:
             if arguments_for_log is None:
                 arguments_for_log = arguments_as_array
 
-            arguments_for_log_as_string: str = ' '.join(arguments_for_log)
-            cmd = f'{working_directory}>{program} {arguments_for_log_as_string}'
+            cmd = f'{working_directory}>{program}'
+            if 0 < len(arguments_for_log):
+                arguments_for_log_as_string: str = ' '.join([f'"{argument_for_log}"' for argument_for_log in arguments_for_log])
+                cmd = f'{cmd} {arguments_for_log_as_string}'
 
             if GeneralUtilities.string_is_none_or_whitespace(title):
                 info_for_log = cmd
             else:
                 info_for_log = title
 
-            if verbosity >= 3:
-                GeneralUtilities.write_message_to_stdout(f"Run '{info_for_log}'.")
-
-            print_live_output = 1 < verbosity
+            self.log.log(f"Run '{info_for_log}'.", LogLevel.Debug)
 
             exit_code: int = None
-            stdout: str = ""
-            stderr: str = ""
+            stdout: str = GeneralUtilities.empty_string
+            stderr: str = GeneralUtilities.empty_string
             pid: int = None
 
-            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:
+            with self.__run_program_argsasarray_async_helper(program, arguments_as_array, working_directory,  print_errors_as_information, log_file, timeoutInSeconds, addLogOverhead, title, log_namespace, arguments_for_log, custom_argument, interactive) as process:
 
                 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
 
+                outputs: tuple[list[str], list[str]] = ScriptCollectionCore.__read_popen_pipes(process, print_live_output, print_errors_as_information, self.log)
+
+                for out_line_plain in outputs[0]:
                     if out_line_plain is not None:
                         out_line: str = None
                         if isinstance(out_line_plain, str):
@@ -1278,14 +1691,13 @@ class ScriptCollectionCore:
                         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)
 
+                for err_line_plain in outputs[1]:
                     if err_line_plain is not None:
                         err_line: str = None
                         if isinstance(err_line_plain, str):
@@ -1297,8 +1709,6 @@ class ScriptCollectionCore:
                         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
@@ -1306,34 +1716,49 @@ class ScriptCollectionCore:
                                 GeneralUtilities.append_line_to_file(log_file, err_line)
 
             exit_code = process.returncode
+            GeneralUtilities.assert_condition(exit_code is not None, f"Exitcode of program-run of '{info_for_log}' is None.")
+
+            result_message = f"Program '{info_for_log}' resulted in exitcode {exit_code}."
+
+            self.log.log(result_message, LogLevel.Debug)
 
             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}')")
+                raise ValueError(f"{result_message} (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
+        except Exception as e:#pylint:disable=unused-variable, try-except-raise
+            raise
 
     # Return-values program_runner: Exitcode, StdOut, StdErr, Pid
     @GeneralUtilities.check_arguments
-    def run_program(self, program: str, arguments:  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]:
-        return self.run_program_argsasarray(program, GeneralUtilities.arguments_to_array(arguments), working_directory, verbosity, print_errors_as_information, log_file, timeoutInSeconds, addLogOverhead, title, log_namespace, arguments_for_log, throw_exception_if_exitcode_is_not_zero, custom_argument, interactive)
+    def run_program_with_retry(self, program: str, arguments:  str = "", working_directory: str = None,  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, print_live_output: bool = False, amount_of_attempts: int = 5) -> tuple[int, str, str, int]:
+        return GeneralUtilities.retry_action(lambda: self.run_program(program, arguments, working_directory,  print_errors_as_information, log_file, timeoutInSeconds, addLogOverhead, title, log_namespace, arguments_for_log, throw_exception_if_exitcode_is_not_zero, custom_argument, interactive, print_live_output), amount_of_attempts)
+
+    # Return-values program_runner: Exitcode, StdOut, StdErr, Pid
+    @GeneralUtilities.check_arguments
+    def run_program(self, program: str, arguments:  str = "", working_directory: str = None,  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, print_live_output: bool = False) -> tuple[int, str, str, int]:
+        if self.call_program_runner_directly:
+            return self.program_runner.run_program(program, arguments, working_directory, custom_argument, interactive)
+        return self.run_program_argsasarray(program, GeneralUtilities.arguments_to_array(arguments), working_directory,  print_errors_as_information, log_file, timeoutInSeconds, addLogOverhead, title, log_namespace, arguments_for_log, throw_exception_if_exitcode_is_not_zero, custom_argument, interactive, print_live_output)
 
     # Return-values program_runner: Pid
     @GeneralUtilities.check_arguments
-    def run_program_argsasarray_async(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, custom_argument: object = None, interactive: bool = False) -> int:
+    def run_program_argsasarray_async(self, program: str, arguments_as_array: list[str] = [], working_directory: str = None,  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, custom_argument: object = None, interactive: bool = False) -> int:
+        if self.call_program_runner_directly:
+            return self.program_runner.run_program_argsasarray_async(program, arguments_as_array, working_directory, custom_argument, interactive)
         mock_loader_result = self.__try_load_mock(program, ' '.join(arguments_as_array), working_directory)
         if mock_loader_result[0]:
             return mock_loader_result[1]
-        process: Popen = 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)
+        process: Popen = self.__run_program_argsasarray_async_helper(program, arguments_as_array, working_directory,  print_errors_as_information, log_file, timeoutInSeconds, addLogOverhead, title, log_namespace, arguments_for_log, custom_argument, interactive)
         return process.pid
 
     # Return-values program_runner: Pid
     @GeneralUtilities.check_arguments
-    def run_program_async(self, program: str, arguments: 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, custom_argument: object = None, interactive: bool = False) -> int:
-        return self.run_program_argsasarray_async(program, GeneralUtilities.arguments_to_array(arguments), working_directory, verbosity, print_errors_as_information, log_file, timeoutInSeconds, addLogOverhead, title, log_namespace, arguments_for_log, custom_argument, interactive)
+    def run_program_async(self, program: str, arguments: str = "",  working_directory: str = None,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, custom_argument: object = None, interactive: bool = False) -> int:
+        if self.call_program_runner_directly:
+            return self.program_runner.run_program_argsasarray_async(program, arguments, working_directory, custom_argument, interactive)
+        return self.run_program_argsasarray_async(program, GeneralUtilities.arguments_to_array(arguments), working_directory,  print_errors_as_information, log_file, timeoutInSeconds, addLogOverhead, title, log_namespace, arguments_for_log, custom_argument, interactive)
 
     @GeneralUtilities.check_arguments
     def __try_load_mock(self, program: str, arguments: str, working_directory: str) -> tuple[bool, tuple[int, str, str, int]]:
@@ -1347,10 +1772,17 @@ class ScriptCollectionCore:
 
     @GeneralUtilities.check_arguments
     def __adapt_workingdirectory(self, workingdirectory: str) -> str:
+        result: str = None
         if workingdirectory is None:
-            return os.getcwd()
+            result = os.getcwd()
         else:
-            return GeneralUtilities.resolve_relative_path_from_current_working_directory(workingdirectory)
+            if os.path.isabs(workingdirectory):
+                result = workingdirectory
+            else:
+                result = GeneralUtilities.resolve_relative_path_from_current_working_directory(workingdirectory)
+        if not os.path.isdir(result):
+            raise ValueError(f"Working-directory '{workingdirectory}' does not exist.")
+        return result
 
     @GeneralUtilities.check_arguments
     def verify_no_pending_mock_program_calls(self):
@@ -1405,13 +1837,28 @@ class ScriptCollectionCore:
         stderr: str
         pid: int
 
+    @GeneralUtilities.check_arguments
+    def run_with_epew(self, program: str, argument: str = "", working_directory: str = None, 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,print_live_output:bool=False,encode_argument_in_base64:bool=False) -> tuple[int, str, str, int]:
+        epew_argument=["-p",program ,"-w", working_directory]
+        if encode_argument_in_base64:
+            if arguments_for_log is None:
+                arguments_for_log=epew_argument+["-a",f"\"{argument}\""]
+            base64_string = base64.b64encode(argument.encode("utf-8")).decode("utf-8")
+            epew_argument=epew_argument+["-a",base64_string,"-b"]
+        else:
+            epew_argument=epew_argument+["-a",argument]
+            if arguments_for_log is None:
+                arguments_for_log=epew_argument
+        return self.run_program_argsasarray("epew", epew_argument, working_directory, print_errors_as_information, log_file, timeoutInSeconds, addLogOverhead, title, log_namespace, arguments_for_log, throw_exception_if_exitcode_is_not_zero, custom_argument, interactive,print_live_output=print_live_output)
+
+
     # </run programs>
 
     @GeneralUtilities.check_arguments
-    def extract_archive_with_7z(self, unzip_program_file: str, zipfile: str, password: str, output_directory: str) -> None:
+    def extract_archive_with_7z(self, unzip_program_file: str, zip_file: str, password: str, output_directory: str) -> None:
         password_set = not password is None
-        file_name = Path(zipfile).name
-        file_folder = os.path.dirname(zipfile)
+        file_name = Path(zip_file).name
+        file_folder = os.path.dirname(zip_file)
         argument = "x"
         if password_set:
             argument = f"{argument} -p\"{password}\""
@@ -1426,7 +1873,7 @@ class ScriptCollectionCore:
 
     @GeneralUtilities.check_arguments
     def system_time_equals_internet_time(self, maximal_tolerance_difference: timedelta) -> bool:
-        return abs(datetime.now() - self.get_internet_time()) < maximal_tolerance_difference
+        return abs(GeneralUtilities.get_now() - self.get_internet_time()) < maximal_tolerance_difference
 
     @GeneralUtilities.check_arguments
     def system_time_equals_internet_time_with_default_tolerance(self) -> bool:
@@ -1462,6 +1909,7 @@ class ScriptCollectionCore:
 
     @GeneralUtilities.check_arguments
     def get_semver_version_from_gitversion(self, repository_folder: str) -> str:
+        self.assert_is_git_repository(repository_folder)
         if (self.git_repository_has_commits(repository_folder)):
             result = self.get_version_from_gitversion(repository_folder, "MajorMinorPatch")
             if self.git_repository_has_uncommitted_changes(repository_folder):
@@ -1483,8 +1931,8 @@ class ScriptCollectionCore:
     @GeneralUtilities.check_arguments
     def get_version_from_gitversion(self, folder: str, variable: str) -> str:
         # called twice as workaround for issue 1877 in gitversion ( https://github.com/GitTools/GitVersion/issues/1877 )
-        result = self.run_program_argsasarray("gitversion", ["/showVariable", variable], folder, verbosity=0)
-        result = self.run_program_argsasarray("gitversion", ["/showVariable", variable], folder, verbosity=0)
+        result = self.run_program_argsasarray("gitversion", ["/showVariable", variable], folder)
+        result = self.run_program_argsasarray("gitversion", ["/showVariable", variable], folder)
         result = GeneralUtilities.strip_new_line_character(result[1])
 
         return result
@@ -1496,7 +1944,7 @@ class ScriptCollectionCore:
         if password is None:
             password = GeneralUtilities.generate_password()
         GeneralUtilities.ensure_directory_exists(folder)
-        self.run_program("openssl", f'req -new -newkey ec -pkeyopt ec_paramgen_curve:prime256v1 -days {days_until_expire} -nodes -x509 -subj /C={subj_c}/ST={subj_st}/L={subj_l}/O={subj_o}/CN={name}/OU={subj_ou} -passout pass:{password} -keyout {name}.key -out {name}.crt', folder)
+        self.run_program_argsasarray("openssl", ['req', '-new', '-newkey', 'ec', '-pkeyopt', 'ec_paramgen_curve:prime256v1', '-days', str(days_until_expire), '-nodes', '-x509', '-subj', f'/C={subj_c}/ST={subj_st}/L={subj_l}/O={subj_o}/CN={name}/OU={subj_ou}', '-passout', f'pass:{password}', '-keyout', f'{name}.key', '-out', f'{name}.crt'], folder)
 
     @GeneralUtilities.check_arguments
     def generate_certificate(self, folder: str,  domain: str, filename: str, subj_c: str, subj_st: str, subj_l: str, subj_o: str, subj_ou: str, days_until_expire: int = None, password: str = None) -> None:
@@ -1505,9 +1953,9 @@ class ScriptCollectionCore:
         if password is None:
             password = GeneralUtilities.generate_password()
         rsa_key_length = 4096
-        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)
+        self.run_program_argsasarray("openssl", ['genrsa', '-out', f'{filename}.key', f'{rsa_key_length}'], folder)
+        self.run_program_argsasarray("openssl", ['req', '-new', '-subj', f'/C={subj_c}/ST={subj_st}/L={subj_l}/O={subj_o}/CN={domain}/OU={subj_ou}', '-x509', '-key', f'{filename}.key', '-out', f'{filename}.unsigned.crt', '-days', f'{days_until_expire}'], folder)
+        self.run_program_argsasarray("openssl", ['pkcs12', '-export', '-out', f'{filename}.selfsigned.pfx', '-password', f'pass:{password}', '-inkey', f'{filename}.key', '-in', f'{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}.san.conf"), f"""[ req ]
 default_bits        = {rsa_key_length}
@@ -1534,7 +1982,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_argsasarray("openssl", ['req', '-new', '-subj', f'/C={subj_c}/ST={subj_st}/L={subj_l}/O={subj_o}/CN={domain}/OU={subj_ou}', '-key', f'{filename}.key', f'-out', f'{filename}.csr', f'-config', f'{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:
@@ -1543,11 +1991,12 @@ DNS                 = {domain}
         ca = os.path.join(ca_folder, ca_name)
         password_file = os.path.join(folder, f"{filename}.password")
         password = GeneralUtilities.read_text_from_file(password_file)
-        self.run_program("openssl", f'x509 -req -in {filename}.csr -CA {ca}.crt -CAkey {ca}.key -CAcreateserial -CAserial {ca}.srl -out {filename}.crt -days {days_until_expire} -sha256 -extensions v3_req -extfile {filename}.san.conf', folder)
-        self.run_program("openssl", f'pkcs12 -export -out {filename}.pfx -inkey {filename}.key -in {filename}.crt -password pass:{password}', folder)
+        self.run_program_argsasarray("openssl", ['x509', '-req', '-in', f'{filename}.csr', '-CA', f'{ca}.crt', '-CAkey', f'{ca}.key', '-CAcreateserial', '-CAserial', f'{ca}.srl', '-out', f'{filename}.crt', '-days', str(days_until_expire),  '-sha256', '-extensions', 'v3_req', '-extfile', f'{filename}.san.conf'], folder)
+        self.run_program_argsasarray("openssl", ['pkcs12', '-export', '-out', f'{filename}.pfx', f'-inkey', f'{filename}.key', '-in', f'{filename}.crt', '-password', f'pass:{password}'], folder)
 
     @GeneralUtilities.check_arguments
-    def update_dependencies_of_python_in_requirementstxt_file(self, file: str, verbosity: int):
+    def update_dependencies_of_python_in_requirementstxt_file(self, file: str, ignored_dependencies: list[str]):
+        # TODO consider ignored_dependencies
         lines = GeneralUtilities.read_lines_from_file(file)
         new_lines = []
         for line in lines:
@@ -1565,7 +2014,8 @@ DNS                 = {domain}
                 # (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)
+                headers = {'Cache-Control': 'no-cache'}
+                response = requests.get(f'https://pypi.org/pypi/{package}/json', timeout=5, headers=headers)
                 latest_version = response.json()['info']['version']
                 # TODO update only minor- and patch-version
                 # TODO print info if there is a new major-version
@@ -1576,7 +2026,8 @@ DNS                 = {domain}
             raise ValueError(f'Unexpected line in requirements-file: "{line}"')
 
     @GeneralUtilities.check_arguments
-    def update_dependencies_of_python_in_setupcfg_file(self, setup_cfg_file: str, verbosity: int):
+    def update_dependencies_of_python_in_setupcfg_file(self, setup_cfg_file: str, ignored_dependencies: list[str]):
+        # TODO consider ignored_dependencies
         lines = GeneralUtilities.read_lines_from_file(setup_cfg_file)
         new_lines = []
         requirement_parsing_mode = False
@@ -1595,21 +2046,22 @@ DNS                 = {domain}
         GeneralUtilities.write_lines_to_file(setup_cfg_file, new_lines)
 
     @GeneralUtilities.check_arguments
-    def update_dependencies_of_dotnet_project(self, csproj_file: str, verbosity: int, ignored_dependencies: list[str]):
+    def update_dependencies_of_dotnet_project(self, csproj_file: str,  ignored_dependencies: list[str]):
         folder = os.path.dirname(csproj_file)
         csproj_filename = os.path.basename(csproj_file)
-        GeneralUtilities.write_message_to_stderr(f"Check for updates in {csproj_filename}")
-        result = self.run_program("dotnet", f"list {csproj_filename} package --outdated", folder)
-        for line in result[1].replace("\r", "").split("\n"):
+        self.log.log(f"Check for updates in {csproj_filename}", LogLevel.Information)
+        result = self.run_program_with_retry("dotnet", f"list {csproj_filename} package --outdated", folder, print_errors_as_information=True)
+        for line in result[1].replace("\r", GeneralUtilities.empty_string).split("\n"):
             # Relevant output-lines are something like "    > NJsonSchema             10.7.0        10.7.0      10.9.0"
             if ">" in line:
-                package_name = line.replace(">", "").strip().split(" ")[0]
-                if not (ignored_dependencies in package_name):
-                    GeneralUtilities.write_message_to_stderr(f"Update package {package_name}")
-                    self.run_program("dotnet", f"add {csproj_filename} package {package_name}", folder)
+                package_name = line.replace(">", GeneralUtilities.empty_string).strip().split(" ")[0]
+                if not (package_name in ignored_dependencies):
+                    self.log.log(f"Update package {package_name}...", LogLevel.Debug)
+                    time.sleep(1.1)  # attempt to prevent rate-limit
+                    self.run_program_with_retry("dotnet", f"add {csproj_filename} package {package_name}", folder, print_errors_as_information=True)
 
     @GeneralUtilities.check_arguments
-    def create_deb_package(self, toolname: str, binary_folder: str, control_file_content: str, deb_output_folder: str, verbosity: int, permission_of_executable_file_as_octet_triple: int) -> None:
+    def create_deb_package(self, toolname: str, binary_folder: str, control_file_content: str, deb_output_folder: str, permission_of_executable_file_as_octet_triple: int) -> None:
 
         # prepare
         GeneralUtilities.ensure_directory_exists(deb_output_folder)
@@ -1672,9 +2124,9 @@ chmod {permission} {link_file}
 
         # 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("tar", ["czf", f"../{entireresult_content_folder_name}/control.tar.gz", "*"], packagecontent_control_folder)
+        self.run_program_argsasarray("tar", ["czf", f"../{entireresult_content_folder_name}/data.tar.gz", "*"], packagecontent_data_folder)
+        self.run_program_argsasarray("ar", ["r", deb_filename, "debian-binary", "control.tar.gz", "data.tar.gz"], packagecontent_entireresult_folder)
         result_file = os.path.join(packagecontent_entireresult_folder, deb_filename)
         shutil.copy(result_file, os.path.join(deb_output_folder, deb_filename))
 
@@ -1683,7 +2135,7 @@ chmod {permission} {link_file}
 
     @GeneralUtilities.check_arguments
     def update_year_in_copyright_tags(self, file: str) -> None:
-        current_year = str(datetime.now().year)
+        current_year = str(GeneralUtilities.get_now().year)
         lines = GeneralUtilities.read_lines_from_file(file)
         lines_result = []
         for line in lines:
@@ -1698,31 +2150,28 @@ chmod {permission} {link_file}
 
     @GeneralUtilities.check_arguments
     def update_year_in_first_line_of_file(self, file: str) -> None:
-        current_year = str(datetime.now().year)
+        current_year = str(GeneralUtilities.get_now().year)
         lines = GeneralUtilities.read_lines_from_file(file)
         lines[0] = re.sub("\\d\\d\\d\\d", current_year, lines[0])
         GeneralUtilities.write_lines_to_file(file, lines)
 
     @GeneralUtilities.check_arguments
-    def get_external_ip(self, proxy: str) -> str:
-        information = self.get_externalnetworkinformation_as_json_string(proxy)
+    def get_external_ip_address(self) -> str:
+        information = self.get_externalnetworkinformation_as_json_string()
         parsed = json.loads(information)
-        return parsed.ip
+        return parsed["IPAddress"]
 
     @GeneralUtilities.check_arguments
-    def get_country_of_external_ip(self, proxy: str) -> str:
-        information = self.get_externalnetworkinformation_as_json_string(proxy)
+    def get_country_of_external_ip_address(self) -> str:
+        information = self.get_externalnetworkinformation_as_json_string()
         parsed = json.loads(information)
-        return parsed.country
+        return parsed["Country"]
 
     @GeneralUtilities.check_arguments
-    def get_externalnetworkinformation_as_json_string(self, proxy: str) -> str:
-        proxies = None
-        if GeneralUtilities.string_has_content(proxy):
-            proxies = {"http": proxy}
-        response = requests.get('https://ipinfo.io',  proxies=proxies, timeout=5)
-        network_information_as_json_string = GeneralUtilities.bytes_to_string(
-            response.content)
+    def get_externalnetworkinformation_as_json_string(self,clientinformation_link:str='https://clientinformation.anion327.de') -> str:
+        headers = {'Cache-Control': 'no-cache'}
+        response = requests.get(clientinformation_link,  timeout=5, headers=headers)
+        network_information_as_json_string = GeneralUtilities.bytes_to_string(response.content)
         return network_information_as_json_string
 
     @GeneralUtilities.check_arguments
@@ -1757,11 +2206,13 @@ chmod {permission} {link_file}
 """.replace("XDX", "ODO"))
 
     @GeneralUtilities.check_arguments
-    def generate_arc42_reference_template(self, repository: str, productname: str = None):
+    def generate_arc42_reference_template(self, repository: str, productname: str = None, subfolder: str = None):
         productname: str
         if productname is None:
             productname = os.path.basename(repository)
-        reference_root_folder = f"{repository}/Other/Resources/Reference"
+        if subfolder is None:
+            subfolder = "Other/Reference"
+        reference_root_folder = f"{repository}/{subfolder}"
         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.")
@@ -1770,7 +2221,7 @@ chmod {permission} {link_file}
         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
@@ -1780,11 +2231,11 @@ TXDX add minimal service-description here.
 
 TXDX
 
-# Quality goals
+## Quality goals
 
- TXDX
+TXDX
 
-# Stakeholder
+## Stakeholder
 
 | Name | How to contact | Reason |
 | ---- | -------------- | ------ |""")
@@ -1803,7 +2254,7 @@ TXDX
 
 ## Scope
 
- TXDX""")
+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""")
@@ -1817,8 +2268,7 @@ TXDX
 
 ## Deployment-proecsses
 
-TXDX
-""")
+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
 
@@ -1861,5 +2311,231 @@ TXDX
 - [Repository](TXDX)
 - [Productive-System](TXDX)
 - [QualityCheck-system](TXDX)
+""".replace("XDX", "ODO"))
 
-""")
+    @GeneralUtilities.check_arguments
+    def run_with_timeout(self, method, timeout_in_seconds: float) -> bool:
+        # Returns true if the method was terminated due to a timeout
+        # Returns false if the method terminates in the given time
+        p = multiprocessing.Process(target=method)
+        p.start()
+        p.join(timeout_in_seconds)
+        if p.is_alive():
+            p.kill()
+            p.join()
+            return True
+        else:
+            return False
+
+    @GeneralUtilities.check_arguments
+    def ensure_local_docker_network_exists(self, network_name: str) -> None:
+        if not self.local_docker_network_exists(network_name):
+            self.create_local_docker_network(network_name)
+
+    @GeneralUtilities.check_arguments
+    def ensure_local_docker_network_does_not_exist(self, network_name: str) -> None:
+        if self.local_docker_network_exists(network_name):
+            self.remove_local_docker_network(network_name)
+
+    @GeneralUtilities.check_arguments
+    def local_docker_network_exists(self, network_name: str) -> bool:
+        return network_name in self.get_all_local_existing_docker_networks()
+
+    @GeneralUtilities.check_arguments
+    def get_all_local_existing_docker_networks(self) -> list[str]:
+        program_call_result = self.run_program("docker", "network list")
+        std_out = program_call_result[1]
+        std_out_lines = std_out.split("\n")[1:]
+        result: list[str] = []
+        for std_out_line in std_out_lines:
+            normalized_line = ';'.join(std_out_line.split())
+            splitted = normalized_line.split(";")
+            result.append(splitted[1])
+        return result
+
+    @GeneralUtilities.check_arguments
+    def remove_local_docker_network(self, network_name: str) -> None:
+        self.run_program("docker", f"network remove {network_name}")
+
+    @GeneralUtilities.check_arguments
+    def create_local_docker_network(self, network_name: str) -> None:
+        self.run_program("docker", f"network create {network_name}")
+
+    @GeneralUtilities.check_arguments
+    def format_xml_file(self, file: str) -> None:
+        encoding = "utf-8"
+        element = ET.XML(GeneralUtilities.read_text_from_file(file, encoding))
+        ET.indent(element)
+        GeneralUtilities.write_text_to_file(file, ET.tostring(element, encoding="unicode"), encoding)
+
+    @GeneralUtilities.check_arguments
+    def install_requirementstxt_file(self, requirements_txt_file: str):
+        folder: str = os.path.dirname(requirements_txt_file)
+        filename: str = os.path.basename(requirements_txt_file)
+        self.run_program_argsasarray("pip", ["install", "-r", filename], folder)
+
+    @GeneralUtilities.check_arguments
+    def ocr_analysis_of_folder(self, folder: str, serviceaddress: str, extensions: list[str], languages: list[str]) -> list[str]:  # Returns a list of changed files due to ocr-analysis.
+        GeneralUtilities.write_message_to_stdout("Starting OCR analysis of folder " + folder)
+        supported_extensions = ['png', 'jpg', 'jpeg', 'tiff', 'bmp', 'gif', 'pdf', 'docx', 'doc', 'xlsx', 'xls', 'pptx', 'ppt']
+        changes_files: list[str] = []
+        if extensions is None:
+            extensions = supported_extensions
+        for file in GeneralUtilities.get_direct_files_of_folder(folder):
+            file_lower = file.lower()
+            for extension in extensions:
+                if file_lower.endswith("."+extension):
+                    if self.ocr_analysis_of_file(file, serviceaddress, languages):
+                        changes_files.append(file)
+                    break
+        for subfolder in GeneralUtilities.get_direct_folders_of_folder(folder):
+            for file in self.ocr_analysis_of_folder(subfolder, serviceaddress, extensions, languages):
+                changes_files.append(file)
+        return changes_files
+
+    @GeneralUtilities.check_arguments
+    def ocr_analysis_of_file(self, file: str, serviceaddress: str, languages: list[str]) -> bool:  # Returns true if the ocr-file was generated or updated. Returns false if the existing ocr-file was not changed.
+        GeneralUtilities.write_message_to_stdout("Do OCR analysis of file " + file)
+        supported_extensions = ['png', 'jpg', 'jpeg', 'tiff', 'bmp', 'webp', 'gif', 'pdf', 'rtf', 'docx', 'doc', 'odt', 'xlsx', 'xls', 'ods', 'pptx', 'ppt', 'odp']
+        for extension in supported_extensions:
+            if file.lower().endswith("."+extension):
+                raise ValueError(f"Extension '{extension}' is not supported. Supported extensions are: {', '.join(supported_extensions)}")
+        target_file = file+".ocr.txt"
+        hash_of_current_file: str = GeneralUtilities. get_sha256_of_file(file)
+        if os.path.isfile(target_file):
+            lines = GeneralUtilities.read_lines_from_file(target_file)
+            previous_hash_of_current_file: str = lines[1].split(":")[1].strip()
+            if hash_of_current_file == previous_hash_of_current_file:
+                return False
+        ocr_content = self.get_ocr_content_of_file(file, serviceaddress, languages)
+        GeneralUtilities.ensure_file_exists(target_file)
+        GeneralUtilities.write_text_to_file(file, f"""Name of file: \"{os.path.basename(file)}\""
+Hash of file: {hash_of_current_file}
+OCR-content:
+\"{ocr_content}\"""")
+        return True
+
+    @GeneralUtilities.check_arguments
+    def get_ocr_content_of_file(self, file: str, serviceaddress: str, languages: list[str]) -> str:  # serviceaddress = None means local executable
+        result: str = None
+        extension = Path(file).suffix
+        if serviceaddress is None:
+            program_result = self.run_program_argsasarray("simpleocr", ["--File", file, "--Languages", "+".join(languages)] + languages)
+            result = program_result[1]
+        else:
+            languages_for_url = '%2B'.join(languages)
+            package_url: str = f"https://{serviceaddress}/GetOCRContent?languages={languages_for_url}&fileType={extension}"
+            headers = {'Cache-Control': 'no-cache'}
+            r = requests.put(package_url, timeout=5, headers=headers, data=GeneralUtilities.read_binary_from_file(file))
+            if r.status_code != 200:
+                raise ValueError(f"Checking for latest tor package resulted in HTTP-response-code {r.status_code}.")
+            result = GeneralUtilities.bytes_to_string(r.content)
+        return result
+
+    @GeneralUtilities.check_arguments
+    def ocr_analysis_of_repository(self, folder: str, serviceaddress: str, extensions: list[str], languages: list[str]) -> None:
+        self.assert_is_git_repository(folder)
+        changed_files = self.ocr_analysis_of_folder(folder, serviceaddress, extensions, languages)
+        for changed_ocr_file in changed_files:
+            GeneralUtilities.assert_condition(changed_ocr_file.endswith(".ocr.txt"), f"File '{changed_ocr_file}' is not an OCR-file. It should end with '.ocr.txt'.")
+            base_file = changed_ocr_file[:-len(".ocr.txt")]
+            GeneralUtilities.assert_condition(os.path.isfile(base_file), f"Base file '{base_file}' does not exist. The OCR-file '{changed_ocr_file}' is not valid.")
+            base_file_relative_path = os.path.relpath(base_file, folder)
+            base_file_diff_program_result = self.run_program("git", f"diff --quiet -- \"{base_file_relative_path}\"", folder, throw_exception_if_exitcode_is_not_zero=False)
+            has_staged_changes: bool = None
+            if base_file_diff_program_result[0] == 0:
+                has_staged_changes = False
+            elif base_file_diff_program_result[0] == 1:
+                has_staged_changes = True
+            else:
+                raise RuntimeError(f"Unexpected exit code {base_file_diff_program_result[0]} when checking for staged changes of file '{base_file_relative_path}'.")
+            if has_staged_changes:
+                changed_ocr_file_relative_path = os.path.relpath(changed_ocr_file, folder)
+                self.run_program_argsasarray("git", ["add", changed_ocr_file_relative_path], folder)
+
+    @GeneralUtilities.check_arguments
+    def update_timestamp_in_file(self, target_file: str) -> None:
+        lines = GeneralUtilities.read_lines_from_file(target_file)
+        new_lines = []
+        prefix: str = "# last update: "
+        for line in lines:
+            if line.startswith(prefix):
+                new_lines.append(prefix+GeneralUtilities.datetime_to_string_with_timezone(GeneralUtilities.get_now()))
+            else:
+                new_lines.append(line)
+        GeneralUtilities.write_lines_to_file(target_file, new_lines)
+
+    def do_and_log_task(self, name_of_task: str, task):
+        try:
+            self.log.log(f"Start action \"{name_of_task}\".", LogLevel.Information)
+            result = task()
+            if result is None:
+                result = 0
+            return result
+        except Exception as e:
+            self.log.log_exception(f"Error while running action \"{name_of_task}\".", e, LogLevel.Error)
+            return 1
+        finally:
+            self.log.log(f"Finished action \"{name_of_task}\".", LogLevel.Information)
+
+    def get_lines_of_code_with_default_excluded_patterns(self, repository: str) -> int:
+        return self.get_lines_of_code(repository, self.default_excluded_patterns_for_loc)
+
+    default_excluded_patterns_for_loc: list[str] = [".txt", ".md", ".vscode", "Resources", "Reference", ".gitignore", ".gitattributes", "Other/Metrics"]
+
+    def get_lines_of_code(self, repository: str, excluded_pattern: list[str]) -> int:
+        self.assert_is_git_repository(repository)
+        result: int = 0
+        self.log.log(f"Calculate lines of code in repository '{repository}' with excluded patterns: {', '.join(excluded_pattern)}",LogLevel.Debug)
+        git_response = self.run_program("git", "ls-files", repository)
+        files: list[str] = GeneralUtilities.string_to_lines(git_response[1])
+        for file in files:
+            if os.path.isfile(os.path.join(repository, file)):
+                if self.__is_excluded_by_glob_pattern(file, excluded_pattern):
+                    self.log.log(f"File '{file}' is ignored because it matches an excluded pattern.",LogLevel.Diagnostic)
+                else:
+                    full_file: str = os.path.join(repository, file)
+                    if GeneralUtilities.is_binary_file(full_file):
+                        self.log.log(f"File '{file}' is ignored because it is a binary-file.",LogLevel.Diagnostic)
+                    else:
+                        self.log.log(f"Count lines of file '{file}'.",LogLevel.Diagnostic)
+                        length = len(GeneralUtilities.read_nonempty_lines_from_file(full_file))
+                        result = result+length
+            else:
+                self.log.log(f"File '{file}' is ignored because it does not exist.",LogLevel.Diagnostic)
+        return result
+
+    def __is_excluded_by_glob_pattern(self, file: str, excluded_patterns: list[str]) -> bool:
+        for pattern in excluded_patterns:
+            if fnmatch.fnmatch(file, f"*{pattern}*"):
+                return True
+        return False
+    
+    @GeneralUtilities.check_arguments
+    def create_zip_archive(self, folder:str,zip_file:str) -> None:
+        GeneralUtilities.assert_folder_exists(folder)
+        GeneralUtilities.assert_file_does_not_exist(zip_file)
+        folder = os.path.abspath(folder)
+        with zipfile.ZipFile(zip_file, "w", zipfile.ZIP_DEFLATED) as zipf:
+            for root, _, files in os.walk(folder):
+                for file in files:
+                    file_path = os.path.join(root, file)
+                    arcname = os.path.relpath(file_path, start=folder)
+                    zipf.write(file_path, arcname)
+
+    @GeneralUtilities.check_arguments
+    def start_local_test_service(self, file: str):
+        example_folder = os.path.dirname(file)
+        docker_compose_file = os.path.join(example_folder, "docker-compose.yml")
+        for service in self.get_services_from_yaml_file(docker_compose_file):
+            self.kill_docker_container(service)
+        example_name = os.path.basename(example_folder)
+        title = f"Test{example_name}"
+        self.run_program("docker", f"compose -p {title.lower()} up --detach", example_folder, title=title)
+
+    @GeneralUtilities.check_arguments
+    def stop_local_test_service(self, file: str):
+        example_folder = os.path.dirname(file)
+        example_name = os.path.basename(example_folder)
+        title = f"Test{example_name}"
+        self.run_program("docker", f"compose -p {title.lower()} down", example_folder, title=title)