ScriptCollection 3.5.52__py3-none-any.whl → 3.5.54__py3-none-any.whl

ScriptCollection/Executables.py

@@ -387,3 +387,96 @@ def CreateChangelogEntry() -> int:
         folder = GeneralUtilities.resolve_relative_path(args.repositoryfolder, os.getcwd())
     TasksForCommonProjectStructure().create_changelog_entry(folder, args.message, args.commit)
     return 0
+
+
+def FileExists() -> int:
+    parser = argparse.ArgumentParser(description="This function returns 0 if the given file exists. Otherwise this function returns 2. If an error occurrs the exitcode is 1.")
+    parser.add_argument('-p', '--path', required=True)
+    args = parser.parse_args()
+    if os.path.isfile(args.path):
+        return 0
+    else:
+        return 2
+
+
+def FolderExists() -> int:
+    parser = argparse.ArgumentParser(description="This function returns 0 if the given folder exists. Otherwise this function returns 2. If an error occurrs the exitcode is 1.")
+    parser.add_argument('-p', '--path', required=True)
+    args = parser.parse_args()
+    if os.path.isdir(args.path):
+        return 0
+    else:
+        return 2
+
+
+def SetContentOfFile() -> int:
+    GeneralUtilities.write_exception_to_stderr("This function is not implemented yet.")
+    # TODO implement function
+    return 1
+
+
+def PrintFileContent() -> int:
+    GeneralUtilities.write_exception_to_stderr("This function is not implemented yet.")
+    # TODO implement function
+    return 1
+
+
+def CreateFile() -> int:
+    parser = argparse.ArgumentParser(description="This function creates an empty file.")
+    parser.add_argument('-p', '--path', required=True)
+    parser.add_argument('-e', '--errorwhenexists', action='store_true', required=False, default=False)
+    parser.add_argument('-c', '--createnecessaryfolder', action='store_true', required=False, default=False)
+    args = parser.parse_args()
+    sc = ScriptCollectionCore()
+    sc.create_file(args.path, args.errorwhenexists, args.createnecessaryfolder)
+    return 0
+
+
+def CreateFolder() -> int:
+    parser = argparse.ArgumentParser(description="This function creates an empty folder.")
+    parser.add_argument('-p', '--path', required=True)
+    parser.add_argument('-e', '--errorwhenexists', action='store_true', required=False, default=False)
+    parser.add_argument('-c', '--createnecessaryfolder', action='store_true', required=False, default=False)
+    args = parser.parse_args()
+    sc = ScriptCollectionCore()
+    sc.create_folder(args.path, args.errorwhenexists, args.createnecessaryfolder)
+    return 0
+
+
+def AppendLineToFile() -> int:
+    GeneralUtilities.write_exception_to_stderr("This function is not implemented yet.")
+    # TODO implement function
+    # TODO add switch to set if adding new line at begin of line should be skipped if the file already ends with a new-line-character
+    # TODO add switch to enable/disable appending another new-line-character at the end of the file
+    return 1
+
+
+def RegexReplaceInFile() -> int:
+    GeneralUtilities.write_exception_to_stderr("This function is not implemented yet.")
+    # TODO implement function
+    return 1
+
+
+def PrintFileSize() -> int:
+    GeneralUtilities.write_exception_to_stderr("This function is not implemented yet.")
+    # TODO implement function
+    return 1
+
+
+def FileContainsContent() -> int:
+    GeneralUtilities.write_exception_to_stderr("This function is not implemented yet.")
+    # TODO implement function
+    # TODO add switch to set if the input pattern should be treated as regex
+    return 1
+
+
+def RemoveFile() -> int:
+    GeneralUtilities.write_exception_to_stderr("This function is not implemented yet.")
+    # TODO implement function
+    return 1
+
+
+def RemoveFolder() -> int:
+    GeneralUtilities.write_exception_to_stderr("This function is not implemented yet.")
+    # TODO implement function
+    return 1

ScriptCollection/GeneralUtilities.py

@@ -5,6 +5,7 @@ import ctypes
 import hashlib
 import re
 import os
+import subprocess
 import shutil
 import urllib
 import stat
@@ -790,8 +791,13 @@ class GeneralUtilities:
     @staticmethod
     @check_arguments
     def epew_is_available() -> bool:
+        return GeneralUtilities.tool_is_available("epew")
+
+    @staticmethod
+    @check_arguments
+    def tool_is_available(toolname: str) -> bool:
         try:
-            return shutil.which("epew") is not None
+            return shutil.which(toolname) is not None
         except:
             return False
 
@@ -873,7 +879,7 @@ class GeneralUtilities:
     def internet_connection_is_available() -> bool:
         # TODO add more hosts to check to return true if at least one is available
         try:
-            with urllib.request.urlopen("https://google.com") as url_result:
+            with urllib.request.urlopen("https://www.google.com") as url_result:
                 return (url_result.code // 100) == 2
         except:
             pass
@@ -895,15 +901,14 @@ class GeneralUtilities:
 
     @staticmethod
     @check_arguments
-    def is_git_repository(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)
-
-    @staticmethod
-    @check_arguments
-    def assert_is_git_repository(folder: str) -> str:
-        GeneralUtilities.assert_condition(GeneralUtilities.is_git_repository(folder), f"'{folder}' is not a git-repository.")
+    def run_program_simple(program: str, arguments: list[str], cwd: str = None) -> tuple[int, str, str]:
+        if cwd is None:
+            cwd = os.getcwd()
+        cmd = [program]+arguments
+        with subprocess.Popen(cmd, cwd=cwd, stderr=subprocess.PIPE, stdout=subprocess.PIPE) as process:
+            stdout, stderr = process.communicate()
+            exit_code = process.wait()
+            return (exit_code, stdout, stderr)
 
     @staticmethod
     @check_arguments

ScriptCollection/ProgramRunnerBase.py

@@ -8,7 +8,7 @@ class ProgramRunnerBase:
     # Return-values program_runner: Pid
     @abstractmethod
     @GeneralUtilities.check_arguments
-    def run_program_argsasarray_async_helper(self, program: str, arguments_as_array: list[str] = [], working_directory: str = None, custom_argument: object = None, interactive:bool=False) -> Popen:
+    def run_program_argsasarray_async_helper(self, program: str, arguments_as_array: list[str] = [], working_directory: str = None, custom_argument: object = None, interactive: bool = False) -> Popen:
         # 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.)
@@ -25,23 +25,28 @@ class ProgramRunnerBase:
     # Return-values program_runner: Exitcode, StdOut, StdErr, Pid
     @abstractmethod
     @GeneralUtilities.check_arguments
-    def run_program_argsasarray(self, program: str, arguments_as_array: list[str] = [], working_directory: str = None, custom_argument: object = None, interactive:bool=False) -> tuple[int, str, str, int]:
+    def run_program_argsasarray(self, program: str, arguments_as_array: list[str] = [], working_directory: str = None, custom_argument: object = None, interactive: bool = False) -> tuple[int, str, str, int]:
         raise NotImplementedError
 
     # Return-values program_runner: Exitcode, StdOut, StdErr, Pid
     @abstractmethod
     @GeneralUtilities.check_arguments
-    def run_program(self, program: str, arguments:  str = "", working_directory: str = None, custom_argument: object = None, interactive:bool=False) -> tuple[int, str, str, int]:
+    def run_program(self, program: str, arguments:  str = "", working_directory: str = None, custom_argument: object = None, interactive: bool = False) -> tuple[int, str, str, int]:
         raise NotImplementedError
 
     # Return-values program_runner: Pid
     @abstractmethod
     @GeneralUtilities.check_arguments
-    def run_program_argsasarray_async(self, program: str, arguments_as_array: list[str] = [], working_directory: str = None, custom_argument: object = None, interactive:bool=False) -> int:
+    def run_program_argsasarray_async(self, program: str, arguments_as_array: list[str] = [], working_directory: str = None, custom_argument: object = None, interactive: bool = False) -> int:
         raise NotImplementedError
 
     # Return-values program_runner: Pid
     @abstractmethod
     @GeneralUtilities.check_arguments
-    def run_program_async(self, program: str, arguments: str,  working_directory: str, custom_argument: object, interactive:bool=False) -> int:
+    def run_program_async(self, program: str, arguments: str,  working_directory: str, custom_argument: object, interactive: bool = False) -> int:
+        raise NotImplementedError
+
+    @abstractmethod
+    @GeneralUtilities.check_arguments
+    def will_be_executed_locally(self) -> bool:
         raise NotImplementedError

ScriptCollection/ProgramRunnerEpew.py

@@ -39,7 +39,7 @@ class CustomEpewArgument:
 class ProgramRunnerEpew(ProgramRunnerBase):
 
     @GeneralUtilities.check_arguments
-    def run_program_argsasarray_async_helper(self, program: str, arguments_as_array: list[str] = [], working_directory: str = None, custom_argument: object = None, interactive:bool=False) -> Popen:
+    def run_program_argsasarray_async_helper(self, program: str, arguments_as_array: list[str] = [], working_directory: str = None, custom_argument: object = None, interactive: bool = False) -> Popen:
         if GeneralUtilities.epew_is_available():
             custom_argument: CustomEpewArgument = custom_argument
             args = []
@@ -67,7 +67,7 @@ class ProgramRunnerEpew(ProgramRunnerBase):
             if custom_argument.addLogOverhead:
                 args.append("-g")
             args.append("-v "+str(custom_argument.verbosity))
-            return ProgramRunnerPopen().run_program_argsasarray_async_helper("epew", args, working_directory,custom_argument,interactive)
+            return ProgramRunnerPopen().run_program_argsasarray_async_helper("epew", args, working_directory, custom_argument, interactive)
         else:
             raise ValueError("Epew is not available.")
 
@@ -85,21 +85,21 @@ class ProgramRunnerEpew(ProgramRunnerBase):
         return result
 
     @GeneralUtilities.check_arguments
-    def run_program_argsasarray(self, program: str, arguments_as_array: list[str] = [], working_directory: str = None, custom_argument: object = None, interactive:bool=False) -> tuple[int, str, str, int]:
-        process: Popen = self.run_program_argsasarray_async_helper(program, arguments_as_array, working_directory, custom_argument,interactive)
+    def run_program_argsasarray(self, program: str, arguments_as_array: list[str] = [], working_directory: str = None, custom_argument: object = None, interactive: bool = False) -> tuple[int, str, str, int]:
+        process: Popen = self.run_program_argsasarray_async_helper(program, arguments_as_array, working_directory, custom_argument, interactive)
         return self.wait(process, custom_argument)
 
     @GeneralUtilities.check_arguments
-    def run_program(self, program: str, arguments: str = "", working_directory: str = None, custom_argument: object = None, interactive:bool=False) -> tuple[int, str, str, int]:
-        return self.run_program_argsasarray(program, GeneralUtilities.arguments_to_array(arguments), working_directory, custom_argument,interactive)
+    def run_program(self, program: str, arguments: str = "", working_directory: str = None, custom_argument: object = None, interactive: bool = False) -> tuple[int, str, str, int]:
+        return self.run_program_argsasarray(program, GeneralUtilities.arguments_to_array(arguments), working_directory, custom_argument, interactive)
 
     @GeneralUtilities.check_arguments
-    def run_program_argsasarray_async(self, program: str, arguments_as_array: list[str] = [], working_directory: str = None, custom_argument: object = None, interactive:bool=False) -> int:
-        return self.run_program_argsasarray_async_helper(program, arguments_as_array, working_directory, custom_argument,interactive).pid
+    def run_program_argsasarray_async(self, program: str, arguments_as_array: list[str] = [], working_directory: str = None, custom_argument: object = None, interactive: bool = False) -> int:
+        return self.run_program_argsasarray_async_helper(program, arguments_as_array, working_directory, custom_argument, interactive).pid
 
     @GeneralUtilities.check_arguments
-    def run_program_async(self, program: str, arguments: str = "", working_directory: str = None, custom_argument: object = None, interactive:bool=False) -> int:
-        return self.run_program_argsasarray_async(program, GeneralUtilities.arguments_to_array(arguments), working_directory, custom_argument,interactive)
+    def run_program_async(self, program: str, arguments: str = "", working_directory: str = None, custom_argument: object = None, interactive: bool = False) -> int:
+        return self.run_program_argsasarray_async(program, GeneralUtilities.arguments_to_array(arguments), working_directory, custom_argument, interactive)
 
     @GeneralUtilities.check_arguments
     def __get_number_from_filecontent(self, filecontent: str) -> int:
@@ -120,3 +120,7 @@ class ProgramRunnerEpew(ProgramRunnerBase):
             return content
         else:
             raise ValueError(f"File '{file}' does not exist")
+
+    @GeneralUtilities.check_arguments
+    def will_be_executed_locally(self) -> bool:
+        return True

ScriptCollection/ProgramRunnerPopen.py

@@ -51,3 +51,7 @@ class ProgramRunnerPopen(ProgramRunnerBase):
     @GeneralUtilities.check_arguments
     def run_program_async(self, program: str, arguments: str = "", working_directory: str = None, custom_argument: object = None, interactive: bool = False) -> int:
         return self.run_program_argsasarray_async(program, GeneralUtilities.arguments_to_array(arguments), working_directory, custom_argument, interactive)
+
+    @GeneralUtilities.check_arguments
+    def will_be_executed_locally(self) -> bool:
+        return True

ScriptCollection/ScriptCollectionCore.py

@@ -25,13 +25,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
 
-version = "3.5.52"
+version = "3.5.54"
 __version__ = version
 
 
@@ -147,7 +147,7 @@ class ScriptCollectionCore:
 
     @GeneralUtilities.check_arguments
     def commit_is_signed_by_key(self, repository_folder: str, revision_identifier: str, key: str) -> bool:
-        GeneralUtilities.assert_is_git_repository(repository_folder)
+        self.assert_is_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
@@ -161,12 +161,12 @@ class ScriptCollectionCore:
 
     @GeneralUtilities.check_arguments
     def get_parent_commit_ids_of_commit(self, repository_folder: str, commit_id: str) -> str:
-        GeneralUtilities.assert_is_git_repository(repository_folder)
+        self.assert_is_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", "").replace("\n", "").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]]:
-        GeneralUtilities.assert_is_git_repository(repository_folder)
+        self.assert_is_git_repository(repository_folder)
         space_character = "_"
         if subfolder is None:
             subfolder_argument = ""
@@ -186,7 +186,7 @@ class ScriptCollectionCore:
 
     @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:
-        GeneralUtilities.assert_is_git_repository(repository_folder)
+        self.assert_is_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", ""))
@@ -201,7 +201,7 @@ class ScriptCollectionCore:
 
     @GeneralUtilities.check_arguments
     def git_commit_is_ancestor(self, repository_folder: str,  ancestor: str, descendant: str = "HEAD") -> bool:
-        GeneralUtilities.assert_is_git_repository(repository_folder)
+        self.assert_is_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:
@@ -213,7 +213,7 @@ class ScriptCollectionCore:
 
     @GeneralUtilities.check_arguments
     def __git_changes_helper(self, repository_folder: str, arguments_as_array: list[str]) -> bool:
-        GeneralUtilities.assert_is_git_repository(repository_folder)
+        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, verbosity=0)[1], False)
         for line in lines:
             if GeneralUtilities.string_has_content(line):
@@ -222,22 +222,22 @@ class ScriptCollectionCore:
 
     @GeneralUtilities.check_arguments
     def git_repository_has_new_untracked_files(self, repository_folder: str):
-        GeneralUtilities.assert_is_git_repository(repository_folder)
+        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, repository_folder: str):
-        GeneralUtilities.assert_is_git_repository(repository_folder)
+        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, repository_folder: str):
-        GeneralUtilities.assert_is_git_repository(repository_folder)
+        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, repository_folder: str) -> bool:
-        GeneralUtilities.assert_is_git_repository(repository_folder)
+        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(repository_folder)):
@@ -246,7 +246,7 @@ class ScriptCollectionCore:
 
     @GeneralUtilities.check_arguments
     def git_repository_has_unstaged_changes(self, repository_folder: str) -> bool:
-        GeneralUtilities.assert_is_git_repository(repository_folder)
+        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)):
@@ -255,13 +255,13 @@ class ScriptCollectionCore:
 
     @GeneralUtilities.check_arguments
     def git_get_commit_id(self, repository_folder: str, commit: str = "HEAD") -> str:
-        GeneralUtilities.assert_is_git_repository(repository_folder)
+        self.assert_is_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, verbosity=0)
         return result[1].replace('\n', '')
 
     @GeneralUtilities.check_arguments
     def git_get_commit_date(self, repository_folder: str, commit: str = "HEAD") -> datetime:
-        GeneralUtilities.assert_is_git_repository(repository_folder)
+        self.assert_is_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, verbosity=0)
         date_as_string = result[1].replace('\n', '')
         result = datetime.strptime(date_as_string, '%Y-%m-%d %H:%M:%S %z')
@@ -464,7 +464,7 @@ class ScriptCollectionCore:
     def git_fetch_or_clone_all_in_directory(self, source_directory: str, target_directory: str) -> None:
         for subfolder in GeneralUtilities.get_direct_folders_of_folder(source_directory):
             foldername = os.path.basename(subfolder)
-            if GeneralUtilities.is_git_repository(subfolder):
+            if self.is_git_repository(subfolder):
                 source_repository = subfolder
                 target_repository = os.path.join(target_directory, foldername)
                 if os.path.isdir(target_directory):
@@ -534,20 +534,20 @@ class ScriptCollectionCore:
 
     @GeneralUtilities.check_arguments
     def get_current_git_branch_has_tag(self, repository_folder: str) -> bool:
-        GeneralUtilities.assert_is_git_repository(repository_folder)
+        self.assert_is_git_repository(repository_folder)
         result = self.run_program_argsasarray("git", ["describe", "--tags", "--abbrev=0"], repository_folder, verbosity=0, 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:
-        GeneralUtilities.assert_is_git_repository(repository_folder)
+        self.assert_is_git_repository(repository_folder)
         result = self.run_program_argsasarray("git", ["describe", "--tags", "--abbrev=0"], repository_folder, verbosity=0)
         result = result[1].replace("\r", "").replace("\n", "")
         return result
 
     @GeneralUtilities.check_arguments
     def get_staged_or_committed_git_ignored_files(self, repository_folder: str) -> list[str]:
-        GeneralUtilities.assert_is_git_repository(repository_folder)
+        self.assert_is_git_repository(repository_folder)
         temp_result = self.run_program_argsasarray("git", ["ls-files", "-i", "-c", "--exclude-standard"], repository_folder, verbosity=0)
         temp_result = temp_result[1].replace("\r", "")
         result = [line for line in temp_result.split("\n") if len(line) > 0]
@@ -555,7 +555,7 @@ class ScriptCollectionCore:
 
     @GeneralUtilities.check_arguments
     def git_repository_has_commits(self, repository_folder: str) -> bool:
-        GeneralUtilities.assert_is_git_repository(repository_folder)
+        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
@@ -609,6 +609,44 @@ class ScriptCollectionCore:
         for renamed_item, original_name in renamed_items.items():
             os.rename(renamed_item, original_name)
 
+    @GeneralUtilities.check_arguments
+    def is_file(self, path: str) -> bool:
+        if self.program_runner.will_be_executed_locally():
+            return os.path.isfile(path)  # much more performant than always running an external program
+        else:
+            exit_code, _, stderr = self.run_program("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:
+        if self.program_runner.will_be_executed_locally():  # much more performant than always running an external program
+            return os.path.isdir(path)
+        else:
+            exit_code, _, stderr = self.run_program("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 is_git_repository(self, folder: str) -> bool:
+        combined = f"{folder}/.git"
+        # TODO consider check for bare-repositories
+        return self.is_file(combined) or self.is_folder(combined)
+
+    @GeneralUtilities.check_arguments
+    def assert_is_git_repository(self, folder: str) -> str:
+        GeneralUtilities.assert_condition(self.is_git_repository(folder), f"'{folder}' is not a git-repository.")
+
     @GeneralUtilities.check_arguments
     def __sort_fmd(self, line: str):
         splitted: list = line.split(";")
@@ -715,8 +753,8 @@ class ScriptCollectionCore:
 
     @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:
@@ -728,11 +766,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:
@@ -1120,7 +1160,7 @@ class ScriptCollectionCore:
         return tor_version
 
     def run_testcases_for_python_project(self, repository_folder: str):
-        GeneralUtilities.assert_is_git_repository(repository_folder)
+        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"))
@@ -1534,7 +1574,7 @@ class ScriptCollectionCore:
 
     @GeneralUtilities.check_arguments
     def get_semver_version_from_gitversion(self, repository_folder: str) -> str:
-        GeneralUtilities.assert_is_git_repository(repository_folder)
+        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):
@@ -1569,7 +1609,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:
@@ -1578,9 +1618,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}
@@ -1607,7 +1647,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:
@@ -1616,8 +1656,8 @@ 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):
@@ -1984,3 +2024,43 @@ TXDX
     @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 create_file(self, path: str, error_if_already_exists: bool, create_necessary_folder: bool) -> None:
+        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)
+
+    @GeneralUtilities.check_arguments
+    def create_folder(self, path: str, error_if_already_exists: bool, create_necessary_folder: bool) -> None:
+        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)