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

ScriptCollection/GeneralUtilities.py

@@ -1,30 +1,68 @@
+import re
+import os
+from os import listdir
+from os.path import isfile, join, isdir
 import codecs
+import platform
 import inspect
 import ctypes
 import hashlib
-import re
-import os
+import subprocess
 import shutil
+import time
+import urllib
 import stat
+import fnmatch
+import secrets
+import string as strin
 import sys
+from enum import Enum
 import traceback
-from datetime import datetime, timedelta
-from os import listdir
-from os.path import isfile, join, isdir
+import warnings
+import functools
 from pathlib import Path
-from shutil import copyfile
+from datetime import datetime, timedelta, date, timezone
 import typing
+from packaging.version import Version
+import psutil
 from defusedxml.minidom import parse
+from OpenSSL import crypto
+
+class VersionEcholon(Enum):
+    LatestPatch = 0
+    LatestPatchOrLatestMinor = 1
+    LatestPatchOrLatestMinorOrNextMajor = 2
+    LatestVersion = 3
+
+
+class Dependency:
+    dependencyname:str
+    current_version:str
 
+    def __init__(self,dependencyname:str,current_version:str):
+        self.dependencyname=dependencyname
+        self.current_version=current_version
 
 class GeneralUtilities:
 
-    __date_format: str = "%Y-%m-%dT%H:%M:%S"
+    __datetime_format_with_offset: str = "%Y-%m-%d %H:%M:%S %z"
+    __datetime_format: str = "%Y-%m-%dT%H:%M:%S"
+    __date_format: str = "%Y-%m-%d"
+
+    empty_string: str = ""
+
+    @staticmethod
+    def get_modest_dark_url() -> str:
+        return "https://aniondev.github.io/CDN/ScriptCollectionDesigns/ModestDark/Style.css"
 
     @staticmethod
     def is_generic(t: typing.Type):
         return hasattr(t, "__origin__")
 
+    @staticmethod
+    def is_debugger_attached():
+        return sys.gettrace() is not None
+
     @staticmethod
     def check_arguments(function):
         def __check_function(*args, **named_args):
@@ -39,19 +77,27 @@ class GeneralUtilities:
                         # Check type of arguments if the type is a generic type seems to be impossible.
                         if not GeneralUtilities.is_generic(function.__annotations__[parameters[index]]):
                             if not isinstance(argument, function.__annotations__[parameters[index]]):
-                                raise TypeError(f"Argument with index {index} for function {function.__name__} ('{str(argument)}') is not of type " +
-                                                f"{ function.__annotations__[parameters[index]]} but has type "+str(type(argument)))
+                                raise TypeError(f"Argument with index {index} for function {function.__name__} ('{str(argument)}') is not of type {function.__annotations__[parameters[index]]} but has type "+str(type(argument)))
             for index, named_argument in enumerate(named_args):
                 if named_args[named_argument] is not None:
                     if parameters[index] in function.__annotations__:
                         if not GeneralUtilities.is_generic(function.__annotations__.get(named_argument)):
                             if not isinstance(named_args[named_argument], function.__annotations__.get(named_argument)):
-                                raise TypeError(f"Argument with name {named_argument} for function {function.__name__} ('{str(named_args[named_argument])}') " +
-                                                f"is not of type { function.__annotations__.get(named_argument)}")
+                                raise TypeError(f"Argument with name {named_argument} for function {function.__name__} ('{str(named_args[named_argument])}') is not of type {function.__annotations__.get(named_argument)}")
             return function(*args, **named_args)
         __check_function.__doc__ = function.__doc__
         return __check_function
 
+    @staticmethod
+    def deprecated(func):
+        @functools.wraps(func)
+        def new_func(*args, **kwargs):
+            warnings.simplefilter('always', DeprecationWarning)
+            warnings.warn(f"Call to deprecated function {func.__name__}", category=DeprecationWarning, stacklevel=2)
+            warnings.simplefilter('default', DeprecationWarning)
+            return func(*args, **kwargs)
+        return new_func
+
     @staticmethod
     @check_arguments
     def args_array_surround_with_quotes_if_required(arguments: list[str]) -> list[str]:
@@ -66,10 +112,10 @@ class GeneralUtilities:
     @staticmethod
     @check_arguments
     def string_to_lines(string: str, add_empty_lines: bool = True, adapt_lines: bool = True) -> list[str]:
-        result = list()
-        if(string is not None):
-            lines = list()
-            if("\n" in string):
+        result : list[str] = list[str]()
+        lines : list[str] = list[str]()
+        if (string is not None):
+            if ("\n" in string):
                 lines = string.split("\n")
             else:
                 lines.append(string)
@@ -85,55 +131,161 @@ class GeneralUtilities:
                 result.append(line)
         return result
 
+    @staticmethod
+    @check_arguments
+    def string_to_datetime(value: str) -> datetime:
+        if "." in value:
+            value = value.split(".")[0]
+        return datetime.strptime(value, GeneralUtilities.__datetime_format)  # value ="2022-10-06T19:26:01" for example
+
     @staticmethod
     @check_arguments
     def datetime_to_string(value: datetime) -> str:
-        return value.strftime(GeneralUtilities.__date_format)  # returns "2022-10-06T19:26:01" for example
+        value = datetime(year=value.year, month=value.month, day=value.day, hour=value.hour, minute=value.minute, second=value.second)
+        return value.strftime(GeneralUtilities.__datetime_format)  # returns "2022-10-06T19:26:01" for example
 
     @staticmethod
     @check_arguments
-    def string_to_datetime(value: str) -> datetime:
-        return datetime.strptime(value, GeneralUtilities.__date_format)  # value ="2022-10-06T19:26:01" for example
+    def datetime_to_string_with_timezone(value: datetime) -> str:
+        return value.strftime(GeneralUtilities.__datetime_format_with_offset)  # returns "2025-08-21 15:30:00 +0200" for example
 
     @staticmethod
     @check_arguments
-    def move_content_of_folder(srcDir, dstDir, overwrite_existing_files=False) -> None:
-        srcDirFull = GeneralUtilities.resolve_relative_path_from_current_working_directory(srcDir)
-        dstDirFull = GeneralUtilities.resolve_relative_path_from_current_working_directory(dstDir)
-        if(os.path.isdir(srcDir)):
-            GeneralUtilities.ensure_directory_exists(dstDir)
+    def string_to_date(value: str) -> date:
+        splitted = value.split("-")
+        return date(int(splitted[0]), int(splitted[1]), int(splitted[2]))  # value ="2022-10-06" for example
+
+    @staticmethod
+    @check_arguments
+    def date_to_string(value: date) -> str:
+        return value.strftime(GeneralUtilities.__date_format)  # returns "2022-10-06" for example
+
+    @staticmethod
+    @check_arguments
+    def copy_content_of_folder(source_directory: str, target_directory: str, overwrite_existing_files=False, ignored_glob_patterms: list[str] = None) -> None:
+        GeneralUtilities.__copy_or_move_content_of_folder(source_directory, target_directory, overwrite_existing_files, False, ignored_glob_patterms)
+
+    @staticmethod
+    @check_arguments
+    def move_content_of_folder(source_directory: str, target_directory: str, overwrite_existing_files=False, ignored_glob_patterms: list[str] = None) -> None:
+        GeneralUtilities.__copy_or_move_content_of_folder(source_directory, target_directory, overwrite_existing_files, True, ignored_glob_patterms)
+
+    @staticmethod
+    @check_arguments
+    def merge_dependency_lists(versions:list[list[Dependency]]) -> dict[str,set[str]]:
+        result:dict[str,set[str]]=dict[str,set[str]]()
+        for dlist in versions:
+            for ditem in dlist:
+                if not ditem.dependencyname in result:
+                    result[ditem.dependencyname]=set[str]()
+                result[ditem.dependencyname].add(ditem.current_version)
+        return result
+    
+    @staticmethod
+    @check_arguments
+    def choose_version(available_versions:list[str],current_version:str,echolon:VersionEcholon) -> str:
+        match echolon:
+            case VersionEcholon.LatestPatch:
+                return GeneralUtilities.get_latest_version(GeneralUtilities.filter_versions_by_prefix(available_versions,f"{GeneralUtilities.get_major_part_of_version(current_version)}.{GeneralUtilities.get_minor_part_of_version(current_version)}."))
+            case VersionEcholon.LatestPatchOrLatestMinor:
+                return GeneralUtilities.get_latest_version(GeneralUtilities.filter_versions_by_prefix(available_versions,f"{GeneralUtilities.get_major_part_of_version(current_version)}."))
+            case VersionEcholon.LatestPatchOrLatestMinorOrNextMajor:
+                raise  ValueError("not implemented")#TODO
+            case VersionEcholon.LatestVersion:
+                return GeneralUtilities.get_latest_version(available_versions)
+            case _:
+                raise  ValueError("Unknown echolon-value: "+str(echolon))
+    
+    @staticmethod
+    @check_arguments
+    def get_latest_version(versions:list[str]) -> str:
+        GeneralUtilities.assert_condition(0<len(versions),"Version-list can not be empty.")
+        latest = max(versions, key=Version)
+        return latest
+    
+    @staticmethod
+    @check_arguments
+    def filter_versions_by_prefix(versions:list[str],prefix:str) -> list[str]:
+        return [v for v in versions if v.startswith(prefix)]
+    
+    @staticmethod
+    @check_arguments
+    def get_major_part_of_version(version:str) -> int:
+        return GeneralUtilities.get_version_parts(version)[0]
+    
+    @staticmethod
+    @check_arguments
+    def get_minor_part_of_version(version:str) -> int:
+        return GeneralUtilities.get_version_parts(version)[1]
+    
+    @staticmethod
+    @check_arguments
+    def get_patch_part_of_version(version:str) -> int:
+        return GeneralUtilities.get_version_parts(version)[2]
+    
+    @staticmethod
+    @check_arguments
+    def get_version_parts(version:str) -> tuple[int,int,int]:
+        match = re.match(r"^(\d+).(\d+).(\d+)$", version)
+        GeneralUtilities.assert_condition(match is not None,f"string \"{version}\" is not a valid version.")
+        return (int(match.group(1)),int(match.group(2)),int(match.group(3)))
+    
+    @staticmethod
+    @check_arguments
+    def is_ignored_by_glob_pattern(source_directory:str,path:str, ignored_glob_patterms: list[str]) -> bool:
+        source_directory=source_directory.replace("\\","/")
+        path=path.replace("\\","/")
+        GeneralUtilities.assert_condition(path.startswith(source_directory), f"Path '{path}' is not located in source directory '{source_directory}'.")
+        if ignored_glob_patterms is None:
+            return False
+        relative_path = os.path.relpath(path, source_directory)
+        for pattern in ignored_glob_patterms:
+            if fnmatch.filter([relative_path], pattern):
+                return True
+        return False
+    
+    
+    @staticmethod
+    @check_arguments
+    def __copy_or_move_content_of_folder(source_directory: str, target_directory: str, overwrite_existing_files:bool, remove_source: bool,ignored_glob_patterms: list[str] = None) -> None:
+        srcDirFull = GeneralUtilities.resolve_relative_path_from_current_working_directory(source_directory)
+        dstDirFull = GeneralUtilities.resolve_relative_path_from_current_working_directory(target_directory)
+        if (os.path.isdir(source_directory)):
+            GeneralUtilities.ensure_directory_exists(target_directory)
             for file in GeneralUtilities.get_direct_files_of_folder(srcDirFull):
                 filename = os.path.basename(file)
-                targetfile = os.path.join(dstDirFull, filename)
-                if(os.path.isfile(targetfile)):
-                    if overwrite_existing_files:
-                        GeneralUtilities.ensure_file_does_not_exist(targetfile)
+                if not GeneralUtilities.is_ignored_by_glob_pattern(source_directory,file, ignored_glob_patterms):
+                    targetfile = os.path.join(dstDirFull, filename)
+                    if (os.path.isfile(targetfile)):
+                        if overwrite_existing_files:
+                            GeneralUtilities.ensure_file_does_not_exist(targetfile)
+                        else:
+                            raise ValueError(f"Targetfile '{targetfile}' does already exist.")
+                    if remove_source:
+                        shutil.move(file, dstDirFull)
                     else:
-                        raise ValueError(f"Targetfile {targetfile} does already exist")
-                shutil.move(file, dstDirFull)
+                        shutil.copy(file, dstDirFull)
             for sub_folder in GeneralUtilities.get_direct_folders_of_folder(srcDirFull):
-                foldername = os.path.basename(sub_folder)
-                sub_target = os.path.join(dstDirFull, foldername)
-                GeneralUtilities.move_content_of_folder(sub_folder, sub_target, overwrite_existing_files)
-                GeneralUtilities.ensure_directory_does_not_exist(sub_folder)
+                if not GeneralUtilities.is_ignored_by_glob_pattern(source_directory,sub_folder, ignored_glob_patterms):
+                    foldername = os.path.basename(sub_folder)
+                    sub_target = os.path.join(dstDirFull, foldername)
+                    GeneralUtilities.__copy_or_move_content_of_folder(sub_folder, sub_target, overwrite_existing_files, remove_source,ignored_glob_patterms)
+                    if remove_source:
+                        GeneralUtilities.ensure_directory_does_not_exist(sub_folder)
         else:
-            raise ValueError(f"Folder '{srcDir}' does not exist")
+            raise ValueError(f"Folder '{source_directory}' does not exist")
 
     @staticmethod
     @check_arguments
     def replace_regex_each_line_of_file(file: str, replace_from_regex: str, replace_to_regex: str, encoding="utf-8", verbose: bool = False) -> None:
-        """This function iterates over each line in the file and replaces it by the line which applied regex.
-        Note: The lines will be taken from open(...).readlines(). So the lines may contain '\\n' or '\\r\\n' for example."""
         if verbose:
             GeneralUtilities.write_message_to_stdout(f"Replace '{replace_from_regex}' to '{replace_to_regex}' in '{file}'")
-        with open(file, encoding=encoding, mode="r") as f:
-            lines = f.readlines()
-            replaced_lines = []
-            for line in lines:
-                replaced_line = re.sub(replace_from_regex, replace_to_regex, line)
-                replaced_lines.append(replaced_line)
-        with open(file, encoding=encoding, mode="w") as f:
-            f.writelines(replaced_lines)
+        lines=GeneralUtilities.read_lines_from_file(file,encoding)
+        replaced_lines = []
+        for line in lines:
+            replaced_line = re.sub(replace_from_regex, replace_to_regex, line)
+            replaced_lines.append(replaced_line)
+        GeneralUtilities.write_lines_to_file(file,replaced_lines,encoding)
 
     @staticmethod
     @check_arguments
@@ -147,6 +299,7 @@ class GeneralUtilities:
     @staticmethod
     @check_arguments
     def replace_xmltag_in_file(file: str, tag: str, new_value: str, encoding="utf-8") -> None:
+        GeneralUtilities.assert_condition(tag.isalnum(tag), f"Invalid tag: \"{tag}\"")
         GeneralUtilities.replace_regex_in_file(file, f"<{tag}>.*</{tag}>", f"<{tag}>{new_value}</{tag}>", encoding)
 
     @staticmethod
@@ -165,7 +318,7 @@ class GeneralUtilities:
             for key, value in replacements.items():
                 previousValue = text
                 text = text.replace(f"__{key}__", value)
-                if(not text == previousValue):
+                if (not text == previousValue):
                     changed = True
         return text
 
@@ -176,17 +329,78 @@ class GeneralUtilities:
         text = GeneralUtilities.replace_underscores_in_text(text, replacements)
         GeneralUtilities.write_text_to_file(file, text, encoding)
 
+    @staticmethod
+    @check_arguments
+    def print_text(text: str, print_to_stdout: bool = True):
+        stream: object = sys.stdout if print_to_stdout else sys.stderr
+        GeneralUtilities.__print_text_to_console(text, stream)
+
+    @staticmethod
+    @check_arguments
+    def print_text_in_green(text: str, print_to_stdout: bool = True, print_as_color: bool = True):
+        GeneralUtilities.print_text_in_color(text, 32, print_to_stdout, print_as_color)
+
+    @staticmethod
+    @check_arguments
+    def print_text_in_yellow(text: str, print_to_stdout: bool = True, print_as_color: bool = True):
+        GeneralUtilities.print_text_in_color(text, 33, print_to_stdout, print_as_color)
+
+    @staticmethod
+    @check_arguments
+    def print_text_in_red(text: str, print_to_stdout: bool = True, print_as_color: bool = True):
+        GeneralUtilities.print_text_in_color(text, 31, print_to_stdout, print_as_color)
+
+    @staticmethod
+    @check_arguments
+    def print_text_in_cyan(text: str, print_to_stdout: bool = True, print_as_color: bool = True):
+        GeneralUtilities.print_text_in_color(text, 36, print_to_stdout, print_as_color)
+
+    @staticmethod
+    @check_arguments
+    def print_text_in_color(text: str, colorcode: int, print_to_stdout: bool = True, print_as_color: bool = True):
+        stream: object = sys.stdout if print_to_stdout else sys.stderr
+        if print_as_color:
+            text = f"\033[{colorcode}m{text}\033[0m"
+        GeneralUtilities.__print_text_to_console(text, stream)
+
+    @staticmethod
+    @check_arguments
+    def __print_text_to_console(text: str, stream: object):
+        stream.write(text)
+        stream.flush()
+
+    @staticmethod
+    @check_arguments
+    def reconfigure_standrd_input_and_outputs():
+        sys.stdin.reconfigure(encoding='utf-8')
+        sys.stderr.reconfigure(encoding='utf-8')
+        sys.stdout.reconfigure(encoding='utf-8')
+
+    @staticmethod
+    @check_arguments
+    def write_message_to_stdout_advanced(message: str, add_empty_lines: bool = True, adapt_lines: bool = True, append_linebreak: bool = True):
+        new_line_character: str = "\n" if append_linebreak else GeneralUtilities.empty_string
+        for line in GeneralUtilities.string_to_lines(message, add_empty_lines, adapt_lines):
+            sys.stdout.write(GeneralUtilities.str_none_safe(line)+new_line_character)
+            sys.stdout.flush()
+
     @staticmethod
     @check_arguments
     def write_message_to_stdout(message: str):
-        sys.stdout.write(GeneralUtilities.str_none_safe(message)+"\n")
-        sys.stdout.flush()
+        GeneralUtilities.write_message_to_stdout_advanced(message, True, True, True)
+
+    @staticmethod
+    @check_arguments
+    def write_message_to_stderr_advanced(message: str, add_empty_lines: bool = True, adapt_lines: bool = True, append_linebreak: bool = True):
+        new_line_character: str = "\n" if append_linebreak else GeneralUtilities.empty_string
+        for line in GeneralUtilities.string_to_lines(message, add_empty_lines, adapt_lines):
+            sys.stderr.write(GeneralUtilities.str_none_safe(line)+new_line_character)
+            sys.stderr.flush()
 
     @staticmethod
     @check_arguments
     def write_message_to_stderr(message: str):
-        sys.stderr.write(GeneralUtilities.str_none_safe(message)+"\n")
-        sys.stderr.flush()
+        GeneralUtilities.write_message_to_stderr_advanced(message, True, True, True)
 
     @staticmethod
     @check_arguments
@@ -194,7 +408,7 @@ class GeneralUtilities:
         if GeneralUtilities.string_has_content(os_error.filename2):
             secondpath = f" {os_error.filename2}"
         else:
-            secondpath = ""
+            secondpath = GeneralUtilities.empty_string
         return f"Related path(s): {os_error.filename}{secondpath}"
 
     @staticmethod
@@ -208,7 +422,7 @@ class GeneralUtilities:
         GeneralUtilities.write_message_to_stderr("Exception(")
         GeneralUtilities.write_message_to_stderr("Type: " + str(type(exception)))
         GeneralUtilities.write_message_to_stderr("Message: " + str(exception))
-        if str is not None:
+        if extra_message is not None:
             GeneralUtilities.write_message_to_stderr("Extra-message: " + str(extra_message))
         if isinstance(exception, OSError):
             GeneralUtilities.write_message_to_stderr(GeneralUtilities.get_advanced_errormessage_for_os_error(exception))
@@ -222,17 +436,30 @@ class GeneralUtilities:
         if string is None:
             return False
         else:
-            return len(string) > 0
+            return len(string.strip()) > 0
 
     @staticmethod
     @check_arguments
-    def datetime_to_string_for_logfile_name(datetime_object: datetime) -> str:
-        return datetime_object.strftime('%Y-%m-%d_%H-%M-%S')
+    def datetime_to_string_for_logfile_name(datetime_object: datetime, add_timezone_info_to_log: bool = True) -> str:
+        base_pattern: str = "%Y-%m-%d_%H-%M-%S"
+        if add_timezone_info_to_log:
+            return datetime_object.strftime(f'{base_pattern}_%z')
+        else:
+            return datetime_object.strftime(base_pattern)
 
     @staticmethod
     @check_arguments
-    def datetime_to_string_for_logfile_entry(datetime_object: datetime) -> str:
-        return datetime_object.strftime('%Y-%m-%d %H:%M:%S')
+    def datetime_to_string_for_logfile_entry(datetime_object: datetime, add_milliseconds: bool = False) -> str:
+        if datetime_object.tzinfo is None:
+            datetime_object = datetime_object.replace(tzinfo=timezone.utc)  # assume utc when no timezone is given
+        pattern: str = None
+        if add_milliseconds:
+            pattern = "%Y-%m-%dT%H:%M:%S.%f%z"
+        else:
+            pattern = "%Y-%m-%dT%H:%M:%S%z"
+        s = datetime_object.strftime(pattern)
+        s = s[:-2] + ":" + s[-2:]
+        return s
 
     @staticmethod
     @check_arguments
@@ -249,9 +476,9 @@ class GeneralUtilities:
             return True
         type_of_argument = type(argument)
         if type_of_argument == str:
-            return argument == ""
+            return argument == GeneralUtilities.empty_string
         else:
-            raise Exception(f"expected string-variable in argument of string_is_none_or_empty but the type was '{str(type_of_argument)}'")
+            raise ValueError(f"expected string-variable in argument of string_is_none_or_empty but the type was '{str(type_of_argument)}'")
 
     @staticmethod
     @check_arguments
@@ -259,7 +486,7 @@ class GeneralUtilities:
         if GeneralUtilities.string_is_none_or_empty(string):
             return True
         else:
-            return string.strip() == ""
+            return string.strip() == GeneralUtilities.empty_string
 
     @staticmethod
     @check_arguments
@@ -291,29 +518,60 @@ class GeneralUtilities:
     @staticmethod
     @check_arguments
     def ends_with_newline_character(content: bytes) -> bool:
-        return content.endswith(b'\x0a')
+        result = content.endswith(GeneralUtilities.string_to_bytes("\n"))
+        return result
 
     @staticmethod
     @check_arguments
-    def __get_new_line_character_if_required(file: str) -> bool:
+    def file_ends_with_content(file: str) -> bool:
         content = GeneralUtilities.read_binary_from_file(file)
         if len(content) == 0:
-            return ""
+            return False
         else:
             if GeneralUtilities.ends_with_newline_character(content):
-                return ""
+                return False
             else:
-                return "\n"
+                return True
+
+    @staticmethod
+    @check_arguments
+    def get_new_line_character_for_textfile_if_required(file: str) -> bool:
+        if GeneralUtilities.file_ends_with_content(file):
+            return "\n"
+        else:
+            return GeneralUtilities.empty_string
 
     @staticmethod
     @check_arguments
     def append_line_to_file(file: str, line: str, encoding: str = "utf-8") -> None:
-        line = GeneralUtilities.__get_new_line_character_if_required(file)+line
-        GeneralUtilities.append_to_file(file, line, encoding)
+        GeneralUtilities.append_lines_to_file(file, [line], encoding)
+
+    @staticmethod
+    @check_arguments
+    def append_lines_to_file(file: str, lines: list[str], encoding: str = "utf-8") -> None:
+        if len(lines) == 0:
+            return
+        is_first_line = True
+        for line in lines:
+            insert_linebreak: bool
+            if is_first_line:
+                insert_linebreak = GeneralUtilities.file_ends_with_content(file)
+            else:
+                insert_linebreak = True
+            line_to_write: str = None
+            if insert_linebreak:
+                line_to_write = "\n"+line
+            else:
+                line_to_write = line
+            with open(file, "r+b") as fileObject:
+                fileObject.seek(0, os.SEEK_END)
+                fileObject.write(GeneralUtilities.string_to_bytes(line_to_write, encoding))
+            is_first_line = False
 
     @staticmethod
     @check_arguments
     def append_to_file(file: str, content: str, encoding: str = "utf-8") -> None:
+        GeneralUtilities.assert_condition(not "\n" in content, "Appending multiple lines is not allowed. Use append_lines_to_file instead.")
         with open(file, "a", encoding=encoding) as fileObject:
             fileObject.write(content)
 
@@ -326,7 +584,7 @@ class GeneralUtilities:
     @staticmethod
     @check_arguments
     def ensure_file_exists(path: str) -> None:
-        if(not os.path.isfile(path)):
+        if (not os.path.isfile(path)):
             with open(path, "a+", encoding="utf-8"):
                 pass
 
@@ -338,21 +596,21 @@ class GeneralUtilities:
 
     @staticmethod
     @check_arguments
-    def rmtree(directory: str) -> None:
-        shutil.rmtree(directory, onerror=GeneralUtilities.__remove_readonly)
+    def __rmtree(directory: str) -> None:
+        shutil.rmtree(directory, onerror=GeneralUtilities.__remove_readonly)  # pylint: disable=deprecated-argument
 
     @staticmethod
     @check_arguments
     def ensure_directory_does_not_exist(path: str) -> None:
-        if(os.path.isdir(path)):
+        if (os.path.isdir(path)):
             for root, dirs, files in os.walk(path, topdown=False):
                 for name in files:
                     filename = os.path.join(root, name)
                     os.chmod(filename, stat.S_IWUSR)
                     os.remove(filename)
                 for name in dirs:
-                    GeneralUtilities.rmtree(os.path.join(root, name))
-            GeneralUtilities.rmtree(path)
+                    GeneralUtilities.__rmtree(os.path.join(root, name))
+            GeneralUtilities.__rmtree(path)
 
     @staticmethod
     @check_arguments
@@ -370,9 +628,17 @@ class GeneralUtilities:
     @staticmethod
     @check_arguments
     def ensure_file_does_not_exist(path: str) -> None:
-        if(os.path.isfile(path)):
+        if (os.path.isfile(path)):
             os.remove(path)
 
+    @staticmethod
+    @check_arguments
+    def ensure_path_does_not_exist(path: str) -> None:
+        if (os.path.isfile(path)):
+            GeneralUtilities.ensure_file_does_not_exist(path)
+        if (os.path.isdir(path)):
+            GeneralUtilities.ensure_directory_does_not_exist(path)
+
     @staticmethod
     @check_arguments
     def format_xml_file(filepath: str) -> None:
@@ -390,6 +656,7 @@ class GeneralUtilities:
     @staticmethod
     @check_arguments
     def get_clusters_and_sectors_of_disk(diskpath: str) -> None:
+        GeneralUtilities.assert_condition(GeneralUtilities.current_system_is_windows(), "get_clusters_and_sectors_of_disk(diskpath) is only available on windows.")
         sectorsPerCluster = ctypes.c_ulonglong(0)
         bytesPerSector = ctypes.c_ulonglong(0)
         rootPathName = ctypes.c_wchar_p(diskpath)
@@ -418,32 +685,61 @@ class GeneralUtilities:
                 result.append(fileB)
         return result
 
+    @staticmethod
+    @check_arguments
+    def to_pascal_case(s: str) -> str:
+        return ''.join(current.lower() if prev.isalnum() else current.upper() for prev, current in zip(' ' + s, s) if current.isalnum())
+
+    @staticmethod
+    @check_arguments
+    def find_between(s: str, start: str, end: str) -> str:
+        return s.split(start)[1].split(end)[0]
+
     @staticmethod
     @check_arguments
     def write_lines_to_file(file: str, lines: list, encoding="utf-8") -> None:
         lines = [GeneralUtilities.strip_new_line_character(line) for line in lines]
-        content = os.linesep.join(lines)
+        content = "\n".join(lines)
         GeneralUtilities.write_text_to_file(file, content, encoding)
 
     @staticmethod
     @check_arguments
     def write_text_to_file(file: str, content: str, encoding="utf-8") -> None:
-        GeneralUtilities.write_binary_to_file(file, bytearray(content, encoding))
+        GeneralUtilities.write_binary_to_file(file, bytes(bytearray(content, encoding)))
 
     @staticmethod
     @check_arguments
-    def write_binary_to_file(file: str, content: bytearray) -> None:
+    def write_binary_to_file(file: str, content: bytes) -> None:
         with open(file, "wb") as file_object:
             file_object.write(content)
 
+    @staticmethod
+    def is_binary_file(path: str):
+        content = GeneralUtilities.read_binary_from_file(path)
+        binary_content_indicators = [b'\x00', b'\x01', b'\x02', b'\x03', b'\x04', b'\x05', b'\x06', b'\x07', b'\x08', b'\x0E', b'\x1F']
+        for binary_content_indicator in binary_content_indicators:
+            if binary_content_indicator in content:
+                return True
+        return False
+
     @staticmethod
     @check_arguments
     def read_lines_from_file(file: str, encoding="utf-8") -> list[str]:
-        return [GeneralUtilities.strip_new_line_character(line) for line in GeneralUtilities.read_text_from_file(file, encoding).split(os.linesep)]
+        content = GeneralUtilities.read_text_from_file(file, encoding)
+        if len(content) == 0:
+            return []
+        else:
+            return [GeneralUtilities.strip_new_line_character(line) for line in content.split('\n')]
+
+    @staticmethod
+    @check_arguments
+    def read_nonempty_lines_from_file(file: str, encoding="utf-8") -> list[str]:
+        return [line for line in GeneralUtilities.read_lines_from_file(file, encoding) if GeneralUtilities.string_has_content(line)]
 
     @staticmethod
     @check_arguments
     def read_text_from_file(file: str, encoding="utf-8") -> str:
+        GeneralUtilities.assert_file_exists(file)
         return GeneralUtilities.bytes_to_string(GeneralUtilities.read_binary_from_file(file), encoding)
 
     @staticmethod
@@ -465,7 +761,7 @@ class GeneralUtilities:
     @staticmethod
     @check_arguments
     def resolve_relative_path(path: str, base_path: str):
-        if(os.path.isabs(path)):
+        if (os.path.isabs(path)):
             return path
         else:
             return str(Path(os.path.join(base_path, path)).resolve())
@@ -492,7 +788,7 @@ class GeneralUtilities:
                 with open(target_file, 'w', encoding='utf8') as f:
                     f.write(GeneralUtilities.get_metadata_for_file_for_clone_folder_structure(source_file))
             else:
-                copyfile(source_file, target_file)
+                shutil.copyfile(source_file, target_file)
 
     @staticmethod
     @check_arguments
@@ -502,6 +798,12 @@ class GeneralUtilities:
         except AttributeError:
             return ctypes.windll.shell32.IsUserAnAdmin() == 1
 
+    @staticmethod
+    @check_arguments
+    def ensure_elevated_privileges() -> None:
+        if (not GeneralUtilities.current_user_has_elevated_privileges()):
+            raise ValueError("Not enough privileges.")
+
     @staticmethod
     @check_arguments
     def rename_names_of_all_files_and_folders(folder: str, replace_from: str, replace_to: str, replace_only_full_match=False):
@@ -515,12 +817,14 @@ class GeneralUtilities:
     @check_arguments
     def get_direct_files_of_folder(folder: str) -> list[str]:
         result = [os.path.join(folder, f) for f in listdir(folder) if isfile(join(folder, f))]
+        result = sorted(result, key=str.casefold)
         return result
 
     @staticmethod
     @check_arguments
     def get_direct_folders_of_folder(folder: str) -> list[str]:
         result = [os.path.join(folder, f) for f in listdir(folder) if isdir(join(folder, f))]
+        result = sorted(result, key=str.casefold)
         return result
 
     @staticmethod
@@ -530,6 +834,7 @@ class GeneralUtilities:
         result.extend(GeneralUtilities.get_direct_files_of_folder(folder))
         for subfolder in GeneralUtilities.get_direct_folders_of_folder(folder):
             result.extend(GeneralUtilities.get_all_files_of_folder(subfolder))
+        result = sorted(result, key=str.casefold)
         return result
 
     @staticmethod
@@ -540,18 +845,19 @@ class GeneralUtilities:
         result.extend(subfolders)
         for subfolder in subfolders:
             result.extend(GeneralUtilities.get_all_folders_of_folder(subfolder))
+        result = sorted(result, key=str.casefold)
         return result
 
     @staticmethod
     @check_arguments
     def get_all_objects_of_folder(folder: str) -> list[str]:
-        return GeneralUtilities.get_all_files_of_folder(folder) + GeneralUtilities.get_all_folders_of_folder(folder)
+        return sorted(GeneralUtilities.get_all_files_of_folder(folder) + GeneralUtilities.get_all_folders_of_folder(folder), key=str.casefold)
 
     @staticmethod
     @check_arguments
     def replace_in_filename(file: str, replace_from: str, replace_to: str, replace_only_full_match=False):
         filename = Path(file).name
-        if(GeneralUtilities.__should_get_replaced(filename, replace_from, replace_only_full_match)):
+        if (GeneralUtilities.__should_get_replaced(filename, replace_from, replace_only_full_match)):
             folder_of_file = os.path.dirname(file)
             os.rename(file, os.path.join(folder_of_file, filename.replace(replace_from, replace_to)))
 
@@ -559,7 +865,7 @@ class GeneralUtilities:
     @check_arguments
     def replace_in_foldername(folder: str, replace_from: str, replace_to: str, replace_only_full_match=False):
         foldername = Path(folder).name
-        if(GeneralUtilities.__should_get_replaced(foldername, replace_from, replace_only_full_match)):
+        if (GeneralUtilities.__should_get_replaced(foldername, replace_from, replace_only_full_match)):
             folder_of_folder = os.path.dirname(folder)
             os.rename(folder, os.path.join(folder_of_folder, foldername.replace(replace_from, replace_to)))
 
@@ -624,12 +930,12 @@ class GeneralUtilities:
     @check_arguments
     def string_to_boolean(value: str) -> bool:
         value = value.strip().lower()
-        if value in ('yes', 'true', 't', 'y', '1'):
+        if value in ('yes', 'y', 'true', 't', '1'):
             return True
-        elif value in ('no', 'false', 'f', 'n', '0'):
+        elif value in ('no', 'n', 'false', 'f', '0'):
             return False
         else:
-            raise Exception(f"Can not convert '{value}' to a boolean value")
+            raise ValueError(f"Can not convert '{value}' to a boolean value")
 
     @staticmethod
     @check_arguments
@@ -643,16 +949,18 @@ class GeneralUtilities:
 
     @staticmethod
     @check_arguments
-    def get_time_based_logfile_by_folder(folder: str, name: str = "Log", in_utc: bool = False) -> str:
-        return os.path.join(GeneralUtilities.resolve_relative_path_from_current_working_directory(folder), f"{GeneralUtilities.get_time_based_logfilename(name, in_utc)}.log")
+    def get_time_based_logfile_by_folder(folder: str, name: str = "Log") -> str:
+        return os.path.join(GeneralUtilities.resolve_relative_path_from_current_working_directory(folder), f"{GeneralUtilities.get_time_based_logfilename(name)}.log")
 
     @staticmethod
     @check_arguments
-    def get_time_based_logfilename(name: str = "Log", in_utc: bool = False) -> str:
-        if(in_utc):
-            d = datetime.utcnow()
-        else:
-            d = datetime.now()
+    def get_now() -> datetime:
+        return datetime.now().astimezone()
+
+    @staticmethod
+    @check_arguments
+    def get_time_based_logfilename(name: str = "Log") -> str:
+        d = GeneralUtilities.get_now()
         return f"{name}_{GeneralUtilities.datetime_to_string_for_logfile_name(d)}"
 
     @staticmethod
@@ -669,14 +977,13 @@ class GeneralUtilities:
     @check_arguments
     def contains_line(lines, regex: str) -> bool:
         for line in lines:
-            if(re.match(regex, line)):
+            if (re.match(regex, line)):
                 return True
         return False
 
     @staticmethod
     @check_arguments
-    def read_csv_file(file: str, ignore_first_line: bool = False, treat_number_sign_at_begin_of_line_as_comment: bool = True, trim_values: bool = True,
-                      encoding="utf-8", ignore_empty_lines: bool = True, separator_character: str = ";", values_are_surrounded_by_quotes: bool = False) -> list[str]:
+    def read_csv_file(file: str, ignore_first_line: bool = False, treat_number_sign_at_begin_of_line_as_comment: bool = True, trim_values: bool = True, encoding="utf-8", ignore_empty_lines: bool = True, separator_character: str = ";", values_are_surrounded_by_quotes: bool = False) -> list[list[str]]:
         lines = GeneralUtilities.read_lines_from_file(file, encoding)
 
         if ignore_first_line:
@@ -718,22 +1025,21 @@ 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
 
     @staticmethod
     @check_arguments
+    @deprecated
     def absolute_file_paths(directory: str) -> list[str]:
-        for dirpath, _, filenames in os.walk(directory):
-            for filename in filenames:
-                yield os.path.abspath(os.path.join(dirpath, filename))
-
-    @staticmethod
-    @check_arguments
-    def os_is_linux() -> bool:
-        return sys.platform in ('linux', 'linux2')
+        return GeneralUtilities.get_all_files_of_folder(directory)
 
     @staticmethod
     @check_arguments
@@ -741,7 +1047,7 @@ class GeneralUtilities:
         result = list()
         if list_as_string is not None:
             list_as_string = list_as_string.strip()
-            if list_as_string == "":
+            if list_as_string == GeneralUtilities.empty_string:
                 pass
             elif separator in list_as_string:
                 for item in list_as_string.split(separator):
@@ -765,6 +1071,202 @@ class GeneralUtilities:
 
     @staticmethod
     @check_arguments
-    def assert_condition(condition: bool, information: str) -> None:
-        if(not condition):
+    def generate_password(length: int = 16, alphabet: str = None) -> None:
+        if alphabet is None:
+            alphabet = strin.ascii_letters + strin.digits+"_"
+        return ''.join(secrets.choice(alphabet) for i in range(length))
+
+    @staticmethod
+    @check_arguments
+    def assert_condition(condition: bool, information: str = None) -> None:
+        """Throws an exception if the condition is false."""
+        if (not condition):
+            if information is None:
+                information = "Internal assertion error."
             raise ValueError("Condition failed. "+information)
+
+    @staticmethod
+    def current_system_is_windows():
+        return platform.system() == 'Windows'
+
+    @staticmethod
+    def current_system_is_linux():
+        return platform.system() == 'Linux'
+
+    @staticmethod
+    @check_arguments
+    def get_line():
+        return "--------------------------"
+
+    @staticmethod
+    def get_longline():
+        return GeneralUtilities.get_line() + GeneralUtilities.get_line()
+
+    @staticmethod
+    @check_arguments
+    def get_icon_check_empty(positive: bool) -> str:
+        if positive:
+            return "✅"
+        else:
+            return GeneralUtilities.empty_string
+
+    @staticmethod
+    @check_arguments
+    def get_icon_check_cross(positive: bool) -> str:
+        if positive:
+            return "✅"
+        else:
+            return "❌"
+
+    @staticmethod
+    @check_arguments
+    def get_certificate_expiry_date(certificate_file: str) -> datetime:
+        with open(certificate_file, encoding="utf-8") as certificate_file_content:
+            cert = crypto.load_certificate(crypto.FILETYPE_PEM, certificate_file_content.read())
+            date_as_bytes = cert.get_notAfter()
+            date_as_string = date_as_bytes.decode("utf-8")
+            result = datetime.strptime(date_as_string, '%Y%m%d%H%M%SZ')
+            return result
+
+    @staticmethod
+    @check_arguments
+    def certificate_is_expired(certificate_file: str) -> bool:
+        return GeneralUtilities.get_certificate_expiry_date(certificate_file) < GeneralUtilities.get_now()
+
+    @staticmethod
+    @check_arguments
+    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://www.google.com") as url_result:
+                return (url_result.code // 100) == 2
+        except:
+            pass
+        return False
+
+    @staticmethod
+    @check_arguments
+    def replace_variable_in_string(input_string: str, variable_name: str, variable_value: str) -> None:
+        GeneralUtilities.assert_condition(not "__" in variable_name, f"'{variable_name}' is an invalid variable name because it contains '__' which is treated as control-sequence.")
+        return input_string.replace(f"__[{variable_name}]__", variable_value)
+
+    @staticmethod
+    @check_arguments
+    def input(prompt: str, print_result: bool) -> str:  # This function is a workaround for usescases like python scripts which calls input(...) using epew because then the prompt is not printed by the built-in-input-function.
+        GeneralUtilities.write_message_to_stdout(prompt)
+        result: str = input()
+        if print_result:
+            GeneralUtilities.write_message_to_stdout(f"Result: {result}")
+        return result
+
+    @staticmethod
+    @check_arguments
+    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
+    def assert_file_exists(file: str,message=None) -> None:
+        if message is None:
+            message=f"File '{file}' does not exist."
+        GeneralUtilities.assert_condition(os.path.isfile(file), message)
+
+    @staticmethod
+    @check_arguments
+    def assert_file_does_not_exist(file: str,message=None) -> None:
+        if message is None:
+            message=f"File '{file}' exists."
+        GeneralUtilities.assert_condition(not os.path.isfile(file), message)
+
+    @staticmethod
+    @check_arguments
+    def assert_folder_exists(folder: str,message=None) -> None:
+        if message is None:
+            message=f"Folder '{folder}' does not exist."
+        GeneralUtilities.assert_condition(os.path.isdir(folder),message )
+
+    @staticmethod
+    @check_arguments
+    def assert_folder_does_not_exist(folder: str,message=None) -> None:
+        if message is None:
+            message= f"Folder '{folder}' exists."
+        GeneralUtilities.assert_condition(not os.path.isdir(folder), f"Folder '{folder}' exists.")
+
+    @staticmethod
+    @check_arguments
+    def assert_not_null(obj,message:str=None) -> str:
+        if message is None:
+            message="Variable is not set"
+        GeneralUtilities.assert_condition(obj is not None, message)
+
+    @staticmethod
+    @check_arguments
+    def retry_action(action, amount_of_attempts: int, action_name: str = None) -> None:
+        amount_of_fails = 0
+        enabled = True
+        while enabled:
+            try:
+                result = action()
+                return result
+            except Exception:
+                time.sleep(1.1)
+                amount_of_fails = amount_of_fails+1
+                GeneralUtilities.assert_condition(not (amount_of_attempts < amount_of_fails))
+                message = f"Action failed {amount_of_attempts} times."
+                if action_name is not None:
+                    message = f"{message} Name of action: {action_name}"
+                GeneralUtilities.write_message_to_stderr(message)
+                raise
+        return None
+
+    @staticmethod
+    @check_arguments
+    def int_to_string(number: int, leading_zeroplaces: int, trailing_zeroplaces: int) -> str:
+        return GeneralUtilities.float_to_string(float(number), leading_zeroplaces, trailing_zeroplaces)
+
+    @staticmethod
+    @check_arguments
+    def float_to_string(number: float, leading_zeroplaces: int, trailing_zeroplaces: int) -> str:
+        plain_str = str(number)
+        GeneralUtilities.assert_condition("." in plain_str)
+        splitted: list[str] = plain_str.split(".")
+        return splitted[0].zfill(leading_zeroplaces)+"."+splitted[1].ljust(trailing_zeroplaces, '0')
+
+    @staticmethod
+    @check_arguments
+    def process_is_running_by_name(process_name: str) -> bool:
+        processes: list[psutil.Process] = list(psutil.process_iter())
+        for p in processes:
+            if p.name() == process_name:
+                return True
+        return False
+
+    @staticmethod
+    @check_arguments
+    def process_is_running_by_id(process_id: int) -> bool:
+        processes: list[psutil.Process] = list(psutil.process_iter())
+        for p in processes:
+            if p.pid == process_id:
+                return True
+        return False
+
+    @staticmethod
+    @check_arguments
+    def kill_process(process_id: int, include_child_processes: bool) -> bool:
+        if GeneralUtilities. process_is_running_by_id(process_id):
+            GeneralUtilities.write_message_to_stdout(f"Process with id {process_id} is running. Terminating it...")
+            process = psutil.Process(process_id)
+            if include_child_processes:
+                for child in process.children(recursive=True):
+                    if GeneralUtilities.process_is_running_by_id(child.pid):
+                        child.kill()
+            if GeneralUtilities.process_is_running_by_id(process_id):
+                process.kill()
+        else:
+            GeneralUtilities.write_message_to_stdout(f"Process with id {process_id} is not running anymore.")