scriptcollection 4.2.81__py3-none-any.whl

ScriptCollection/HTTPMaintenanceOverheadHelper.py

@@ -0,0 +1,36 @@
+import re
+from .GeneralUtilities import GeneralUtilities
+
+class HTTPMaintenanceOverheadHelper:
+
+    __culture_regex = re.compile(r"^[a-zA-Z]+(-[a-zA-Z]+)?$")
+
+    def is_valid_culture(self,culture_string: str) -> bool:
+        """
+        Checks if a string is in a valid language/culture format.
+        result:
+        de, de-DE, en, en-US, fr, fr-FR, etc. is allowed.
+        de3, zh-Hans-CN, en_US, etc. is not allowed.
+        """
+        return bool(self.__culture_regex.fullmatch(culture_string)) 
+
+    def get_index_html(self,site_title:str) -> str:
+        content = GeneralUtilities._internal_load_resource("CultureChooser/index.html")
+        content_as_string = content.decode("utf-8")
+        result=GeneralUtilities.replace_variable("<!--","title","-->", site_title, content_as_string)
+        return result
+    
+    def get_culture_chooser_script(self,supported_languages:list[str]) -> str:
+        GeneralUtilities.assert_condition("en" in supported_languages, "The default language 'en' must be included in the list of supported languages.")
+        for supported_language in supported_languages:
+            GeneralUtilities.assert_condition(self.is_valid_culture(supported_language), f"Invalid language code '{supported_language}'. Supported languages must be in the format 'en' or 'en-US'.") 
+        content = GeneralUtilities._internal_load_resource("CultureChooser/CultureChooser.js")
+        content_as_string = content.decode("utf-8")
+        result=GeneralUtilities.replace_variable("/*","supportedCultures","*/", ", ".join([f"\"{supported_language}\"" for supported_language in supported_languages]), content_as_string)
+        return result
+    
+    def get_maintenance_file(self,site_title:str) -> str:
+        content = GeneralUtilities._internal_load_resource("MaintenanceSite/MaintenanceSite.html")
+        content_as_string = content.decode("utf-8")
+        result=GeneralUtilities.replace_variable("<!--","title","-->", site_title, content_as_string)
+        return result

ScriptCollection/OCIImages/AbstractImageHandler.py

@@ -0,0 +1,38 @@
+from abc import ABC, abstractmethod
+from packaging.version import Version
+from ..GeneralUtilities import GeneralUtilities, VersionEcholon
+
+class AbstractImageHandler(ABC):
+    
+    @abstractmethod
+    def can_handle(self,image_name:str)->bool:
+        raise NotImplementedError()#because it is abstract
+    
+    def _protected_get_credentials_for_registry(self,registry_address:str,username_str:str)->tuple[str,str]:
+        """return (username, password) for basic auth.
+        Data will be taken from "~/.ScriptCollection/GlobalCache/RegistryCredentials.csv" if available.
+        If no credentials are available then None will be returned for the missing values."""
+        raise NotImplementedError()
+    
+    def _protected_get_tags_from_images_from_custom_registry(self,registry_address:str)->list[str]:
+        raise NotImplementedError()
+    
+    def _protected_get_tags_from_images_from_docker_hub(self,registry_address:str,tag_filter:str)->list[str]:
+        GeneralUtilities.assert_condition(registry_address.startswith("docker.io/",f"Image \"{registry_address}\" is not from docker-hub."))
+        raise NotImplementedError()
+    
+    @abstractmethod
+    def get_available_tags_of_image(self,image_name:str,registry_address:str)->list[str]:
+        raise NotImplementedError()#because it is abstract
+
+    @abstractmethod
+    def tag_to_version(self,image_name:str,tag:str)->Version:
+        raise NotImplementedError()#because it is abstract
+
+    @abstractmethod
+    def version_to_tag(self,image_name:str,version:Version)->str:
+        raise NotImplementedError()#because it is abstract
+
+    @abstractmethod
+    def get_default_echolon_for_update(self,image_name:str)->VersionEcholon:
+        raise NotImplementedError()#because it is abstract

ScriptCollection/OCIImages/ConcreteImageHandlers/ImageHandlerDebian.py

@@ -0,0 +1,20 @@
+from packaging.version import Version
+from ...GeneralUtilities import VersionEcholon
+from ..AbstractImageHandler import AbstractImageHandler
+
+class ImageHandlerDebian(AbstractImageHandler):
+
+    def can_handle(self,image_name:str)->bool:
+        raise NotImplementedError()#TODO
+
+    def get_available_tags_of_image(self,image_name:str,registry_address:str)->list[str]:
+        raise NotImplementedError()
+
+    def tag_to_version(self,image_name:str,tag:str)->Version:
+        raise NotImplementedError()
+    
+    def version_to_tag(self,image_name:str,version:Version)->str:
+        raise NotImplementedError()
+
+    def get_default_echolon_for_update(self,image_name:str)->VersionEcholon:
+        return VersionEcholon.LatestPatch

ScriptCollection/OCIImages/ConcreteImageHandlers/ImageHandlerDebianSlim.py

@@ -0,0 +1,20 @@
+from packaging.version import Version
+from ...GeneralUtilities import VersionEcholon
+from ..AbstractImageHandler import AbstractImageHandler
+
+class ImageHandlerDebianSlim(AbstractImageHandler):
+
+    def can_handle(self,image_name:str)->bool:
+        raise NotImplementedError()#TODO
+
+    def get_available_tags_of_image(self,image_name:str,registry_address:str)->list[str]:
+        raise NotImplementedError()
+
+    def tag_to_version(self,image_name:str,tag:str)->Version:
+        raise NotImplementedError()
+    
+    def version_to_tag(self,image_name:str,version:Version)->str:
+        raise NotImplementedError()
+
+    def get_default_echolon_for_update(self,image_name:str)->VersionEcholon:
+        return VersionEcholon.LatestPatch

ScriptCollection/OCIImages/ConcreteImageHandlers/ImageHandlerGeneric.py

@@ -0,0 +1,20 @@
+from packaging.version import Version
+from ...GeneralUtilities import VersionEcholon
+from ..AbstractImageHandler import AbstractImageHandler
+
+class ImageHandlerGeneric(AbstractImageHandler):
+
+    def can_handle(self,image_name:str)->bool:
+        raise NotImplementedError()#TODO
+
+    def get_available_tags_of_image(self,image_name:str,registry_address:str)->list[str]:
+        raise NotImplementedError()
+
+    def tag_to_version(self,image_name:str,tag:str)->Version:
+        raise NotImplementedError()
+
+    def version_to_tag(self,image_name:str,version:Version)->str:
+        raise NotImplementedError()
+
+    def get_default_echolon_for_update(self,image_name:str)->VersionEcholon:
+        raise NotImplementedError()

ScriptCollection/OCIImages/ConcreteImageHandlers/ImageHandlerGenericV.py

@@ -0,0 +1,20 @@
+from packaging.version import Version
+from ...GeneralUtilities import VersionEcholon
+from ..AbstractImageHandler import AbstractImageHandler
+
+class ImageHandlerGenericV(AbstractImageHandler):
+
+    def can_handle(self,image_name:str)->bool:
+        raise NotImplementedError()#TODO
+
+    def get_available_tags_of_image(self,image_name:str,registry_address:str)->list[str]:
+        raise NotImplementedError()
+
+    def tag_to_version(self,image_name:str,tag:str)->Version:
+        raise NotImplementedError()
+
+    def version_to_tag(self,image_name:str,version:Version)->str:
+        raise NotImplementedError()
+
+    def get_default_echolon_for_update(self,image_name:str)->VersionEcholon:
+        raise NotImplementedError()

ScriptCollection/OCIImages/ConcreteImageHandlers/ImageHandlerGitlabCE.py

@@ -0,0 +1,20 @@
+from packaging.version import Version
+from ...GeneralUtilities import VersionEcholon
+from ..AbstractImageHandler import AbstractImageHandler
+
+class ImageHandlerGitlabCE(AbstractImageHandler):
+
+    def can_handle(self,image_name:str)->bool:
+        raise NotImplementedError()#TODO
+
+    def get_available_tags_of_image(self,image_name:str,registry_address:str)->list[str]:
+        raise NotImplementedError()
+
+    def tag_to_version(self,image_name:str,tag:str)->Version:
+        raise NotImplementedError()
+    
+    def version_to_tag(self,image_name:str,version:Version)->str:
+        raise NotImplementedError()
+
+    def get_default_echolon_for_update(self,image_name:str)->VersionEcholon:
+        return VersionEcholon.CustomAlgorithm

ScriptCollection/OCIImages/ConcreteImageHandlers/ImageHandlerGitlabEE.py

@@ -0,0 +1,20 @@
+from packaging.version import Version
+from ...GeneralUtilities import VersionEcholon
+from ..AbstractImageHandler import AbstractImageHandler
+
+class ImageHandlerGitlabEE(AbstractImageHandler):
+
+    def can_handle(self,image_name:str)->bool:
+        raise NotImplementedError()#TODO
+
+    def get_available_tags_of_image(self,image_name:str,registry_address:str)->list[str]:
+        raise NotImplementedError()
+
+    def tag_to_version(self,image_name:str,tag:str)->Version:
+        raise NotImplementedError()
+    
+    def version_to_tag(self,image_name:str,version:Version)->str:
+        raise NotImplementedError()
+
+    def get_default_echolon_for_update(self,image_name:str)->VersionEcholon:
+        return VersionEcholon.CustomAlgorithm

ScriptCollection/OCIImages/OCIImageManager.py

@@ -0,0 +1,190 @@
+import os
+from packaging.version import Version
+from ..GeneralUtilities import GeneralUtilities
+from ..ScriptCollectionCore import ScriptCollectionCore
+from ..GeneralUtilities import VersionEcholon
+from ..SCLog import LogLevel
+from .AbstractImageHandler import AbstractImageHandler
+from .ConcreteImageHandlers.ImageHandlerDebian import ImageHandlerDebian
+from .ConcreteImageHandlers.ImageHandlerDebianSlim import ImageHandlerDebianSlim
+from .ConcreteImageHandlers.ImageHandlerGeneric import ImageHandlerGeneric
+from .ConcreteImageHandlers.ImageHandlerGenericV import ImageHandlerGenericV
+from .ConcreteImageHandlers.ImageHandlerGitlabCE import ImageHandlerGitlabCE
+from .ConcreteImageHandlers.ImageHandlerGitlabEE import ImageHandlerGitlabEE
+
+class OCIImageManager:
+
+    __sc:ScriptCollectionCore=None
+    image_handler:list[AbstractImageHandler]
+
+    def __init__(self,sc:ScriptCollectionCore):
+        if sc is None:
+            sc=ScriptCollectionCore()
+        self.__sc=sc
+        self.image_handler=[
+            ImageHandlerDebian(),
+            ImageHandlerDebianSlim(),
+            ImageHandlerGeneric(),
+            ImageHandlerGenericV(),
+            ImageHandlerGitlabCE(),
+            ImageHandlerGitlabEE(),
+        ]
+
+    @GeneralUtilities.check_arguments
+    def get_image_handler(self,image_name:str)->AbstractImageHandler:
+        for image_handler in self.image_handler: 
+            if image_handler.can_handle(image_name):
+                return image_handler
+        raise ValueError(f"No image-handler available for image \"{image_name}\".")
+
+    @GeneralUtilities.check_arguments
+    def get_repository_image_definition_file(self,repository:str)->str:
+        self.__sc.assert_is_git_repository(repository)
+        sc_folder_in_repo=os.path.join(repository,".ScriptCollection","OCIImages")
+        GeneralUtilities.ensure_directory_exists(sc_folder_in_repo)
+        image_definition_file=os.path.join(sc_folder_in_repo,"ImageDefinition.csv")
+        if not os.path.isfile(image_definition_file):
+            GeneralUtilities.ensure_file_exists(image_definition_file)
+            GeneralUtilities.write_text_to_file(image_definition_file,"ImageName;UpstreamRegistryAddress;DefaultTag")
+        return image_definition_file
+    
+    @GeneralUtilities.check_arguments
+    def get_global_docker_image_registries_file(self)->str:
+        folder=os.path.join(self.__sc.get_global_cache_folder(),"OCIImages")
+        GeneralUtilities.ensure_directory_exists(folder)
+        result=os.path.join(folder,"ImageRegistries.csv")
+        if not os.path.isfile(result):
+            GeneralUtilities.ensure_file_exists(result)
+            GeneralUtilities.write_lines_to_file(result,["ImageName;RegistryAddress"])
+        return result
+    
+    @GeneralUtilities.check_arguments
+    def get_used_images_in_repository(self,repository:str)->list[str]:
+        result:list[str]=[]
+        repository_image_definition_file=self.get_repository_image_definition_file(repository)
+        for line in [f.split(";") for f in GeneralUtilities.read_nonempty_lines_from_file(repository_image_definition_file)[1:]]:
+            result.append(line[0])
+        return result
+
+    @GeneralUtilities.check_arguments
+    def custom_registry_is_defined(self,image_name:str)->bool:
+        global_docker_image_registries_file=self.get_global_docker_image_registries_file()
+        for line in  GeneralUtilities.read_nonempty_lines_from_file(global_docker_image_registries_file)[1:]:
+            splitted_line=line.split(";")
+            if image_name==splitted_line[0]:
+                GeneralUtilities.assert_condition(GeneralUtilities.string_has_content(splitted_line[1]),f"No registry defined for image {image_name}.")
+                return True
+        return False
+
+    @GeneralUtilities.check_arguments
+    def get_tag_for_image(self,repository:str,image_name:str,strict_mode:bool)->str:
+        repository_image_definition_file=self.get_repository_image_definition_file(repository)
+        for line in [f.split(";") for f in GeneralUtilities.read_nonempty_lines_from_file(repository_image_definition_file)[1:]]:
+            if image_name==line[0]:
+                return line[2]
+        raise ValueError(f"No tag defined for image \"{image_name}\".")
+
+    @GeneralUtilities.check_arguments
+    def get_registry_address_for_image(self,repository:str,image_name:str)->str:
+        """if image_name==Debian this function returns something like "myregistry.example.com/debian", always without tag."""
+        if self.custom_registry_is_defined(image_name):
+            #return image from custom registry-address
+            global_docker_image_registries_file=self.get_global_docker_image_registries_file()
+            for line in [f.split(";") for f in GeneralUtilities.read_nonempty_lines_from_file(global_docker_image_registries_file)[1:]]:
+                if image_name==line[0]:
+                    return line[1]
+        else:
+            #return fallback-registry-address
+            repository_image_definition_file=self.get_repository_image_definition_file(repository)
+            for line in [f.split(";") for f in GeneralUtilities.read_nonempty_lines_from_file(repository_image_definition_file)[1:]]:
+                if image_name==line[0]:
+                    return line[1]
+        raise ValueError(f"No registry defined for image \"{image_name}\".")
+
+    @GeneralUtilities.check_arguments
+    def get_registry_address_for_image_with_default_tag(self,repository:str,image_name:str,strict_mode:bool=True)->str:
+        return f"{self.get_registry_address_for_image(repository,image_name)}:{self.get_tag_for_image(repository,image_name,strict_mode)}"
+
+    @GeneralUtilities.check_arguments
+    def update_default_tag_for_images_in_image_definitions_file(self,repository:str,search_in_custom_registry_only_if_available:bool)->None:
+        file=f"{repository}/.ScriptCollection/OCIImages/ImageDefinition.csv"
+        GeneralUtilities.assert_file_exists(file)
+        lines=GeneralUtilities.read_nonempty_lines_from_file(file)
+        new_lines:list[str]=[]
+        #file looks like:
+        #ImageName;UpstreamRegistryAddress;DefaultTag
+        #Debian;docker.io/library/debian;13.4-slim
+        for line in lines:
+            if line.startswith("ImageName;"): #header line
+                new_lines.append(line)
+                continue
+            splitted_line=line.split(";")
+            image_name=splitted_line[0]
+            registry_address=splitted_line[1]
+            default_tag=splitted_line[2]
+            tag=default_tag
+            try:
+                addresses_to_check=[]
+                if self.custom_registry_is_defined(image_name):
+                    addresses_to_check.append(self.get_registry_address_for_image(repository,image_name))
+                else:
+                    if search_in_custom_registry_only_if_available:
+                        raise ValueError(f"No custom registry defined for image {image_name}.")
+                if not search_in_custom_registry_only_if_available:
+                    addresses_to_check.append(registry_address)
+                newest_versions:set[Version]={default_tag}
+                current_version=Version(default_tag)
+                for address in addresses_to_check:
+                    newest_versions_for_address=self.get_available_versions_of_image_which_are_newer(image_name,address,current_version,VersionEcholon.LatestVersion)
+                    if newest_versions_for_address is not None:
+                        newest_versions.update(newest_versions_for_address)
+                GeneralUtilities.assert_condition(len(newest_versions)>0,f"Could not find any version for image {image_name} in registry {registry_address}.")
+                newest_version=max(newest_versions)
+                tag=self.version_to_tag(image_name,newest_version)
+            except Exception as e:
+                self.__sc.log.log(f"Could not get tag for image {image_name} from registry {registry_address}. Reason: {str(e)}",LogLevel.Warning)
+            new_lines.append(f"{image_name};{registry_address};{tag}")
+        GeneralUtilities.write_lines_to_file(file,new_lines)
+
+    @GeneralUtilities.check_arguments
+    def get_available_versions_of_image_which_are_newer(self,image_name:str,registry_address:str,current_version:Version,echolon: VersionEcholon)->Version:
+        #image_handler=self.get_image_handler(image_name)
+        result= None #TODO calculate result using get_available_tags_of_image.
+        #TODO if echolon is not none, then use echolon instead of the default echolon of the image-handler.
+        #TODO return the versions sorted.
+        #TODO if result is empty: return None
+        return result
+    
+    @GeneralUtilities.check_arguments
+    def get_available_tags_of_image(self,image_name:str,registry_address:str)->list[str]:
+        """registry_address must have one of theese formats: "myregistry.example.com/debian" or "docker.io/debian" or "docker.io/myuser/debian".
+        returns something like ["13.2-slim", "13.2", "13.3-slim", "13.3"]."""
+        return self.get_image_handler(image_name).get_available_tags_of_image(image_name,registry_address)
+
+    @GeneralUtilities.check_arguments
+    def tag_to_version(self,image_name:str,tag:str)->Version:
+        """registry_address must have one of theese formats: "myregistry.example.com/debian" or "docker.io/debian" or "docker.io/myuser/debian"."""
+        return self.get_image_handler(image_name).tag_to_version(image_name, tag)
+
+    @GeneralUtilities.check_arguments
+    def version_to_tag(self,image_name:str,version:Version)->str:
+        """registry_address must have one of theese formats: "myregistry.example.com/debian" or "docker.io/debian" or "docker.io/myuser/debian".
+        returns something like "13.3-slim".
+        If there are multiple tags available for a certain version then the image-handler decides which one will be returned."""
+        return self.get_image_handler(image_name).version_to_tag(image_name,version)
+
+    @GeneralUtilities.check_arguments
+    def get_images_used_in_docker_compose_file(self,docker_compose_file:str)->dict[str,tuple[str,str,str]]:#returns dict[service_name,[image_name,image_address,current_tag]]
+        GeneralUtilities.assert_file_exists(docker_compose_file)
+        return {}#TODO implement function
+
+    @GeneralUtilities.check_arguments
+    def update_image_in_docker_compose_file(self,docker_compose_file:str)->None:
+        for service,service_information in self.get_images_used_in_docker_compose_file(docker_compose_file).items():#pylint:disable=unused-variable
+            image_name=service_information[0]
+            image_address=service_information[1]
+            current_tag=service_information[2]
+            image_handler=self.get_image_handler(image_name)
+            new_versions_for_address=self.get_available_versions_of_image_which_are_newer(image_name,image_address,self.tag_to_version(image_name,current_tag),image_handler.get_default_echolon_for_update())
+            new_tag=self.version_to_tag(image_name,new_versions_for_address)#pylint:disable=unused-variable
+            #TODO update tag for service in docker-compose-file to new_tag

ScriptCollection/ProcessesRunner.py

@@ -0,0 +1,43 @@
+import psutil
+from .GeneralUtilities import GeneralUtilities
+from .ScriptCollectionCore import ScriptCollectionCore
+
+# runs multiple processes in parallel and terminate all if at least one is terminated
+
+
+class ProcessStartInformation:
+    workingdirectory: str = None
+    program: str = None
+    arguments: str = None
+
+    def __init__(self, workingdirectory: str, program: str, arguments: str):
+        self.workingdirectory = workingdirectory
+        self.program = program
+        self.arguments = arguments
+
+
+class ProcessesRunner:
+    sc: ScriptCollectionCore
+    processes: list[ProcessStartInformation]
+
+    def __init__(self, processes: list[ProcessStartInformation]):
+        self.sc = ScriptCollectionCore()
+        self.processes = processes
+
+    @GeneralUtilities.check_arguments
+    def run(self):
+        pids: list[int] = list[int]()
+        for processstartinfo in self.processes:
+            pids.append(self.sc.run_program_async(processstartinfo.program, processstartinfo.argumentss, processstartinfo.workingdirectory))
+        enabled = True
+        while enabled:
+            for pid in pids:
+                if not psutil.pid_exists(pid):
+                    enabled = False
+        # one program terminate so exit and terminate all now
+        processes = psutil.process_iter()
+        for pid in pids:
+            if psutil.pid_exists(pid):
+                for proc in processes:
+                    if proc.pid == pid:
+                        proc.kill()

ScriptCollection/ProgramRunnerBase.py

@@ -0,0 +1,47 @@
+from abc import abstractmethod
+from subprocess import Popen
+from .GeneralUtilities import GeneralUtilities
+
+
+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:
+        raise NotImplementedError
+
+    # Return-values program_runner: Exitcode, StdOut, StdErr, Pid
+    @abstractmethod
+    @GeneralUtilities.check_arguments
+    def wait(self, process: Popen, custom_argument: object) -> tuple[int, str, str, int]:
+        raise NotImplementedError
+
+    # 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]:
+        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]:
+        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:
+        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:
+        raise NotImplementedError
+
+    @abstractmethod
+    @GeneralUtilities.check_arguments
+    def will_be_executed_locally(self) -> bool:
+        raise NotImplementedError

ScriptCollection/ProgramRunnerMock.py

@@ -0,0 +1,2 @@
+class ProgramRunnerPopen():
+    pass

ScriptCollection/ProgramRunnerPopen.py

@@ -0,0 +1,57 @@
+import sys
+from subprocess import PIPE, Popen
+from .GeneralUtilities import GeneralUtilities
+from .ProgramRunnerBase import ProgramRunnerBase
+
+
+class ProgramRunnerPopen(ProgramRunnerBase):
+
+    @GeneralUtilities.check_arguments
+    def run_program_argsasarray_async_helper(self, program: str, arguments_as_array: list[str] = [], working_directory: str = None, custom_argument: object = None, interactive: bool = False) -> Popen:
+        arguments_for_process = [program]
+        arguments_for_process.extend(arguments_as_array)
+        # "shell=True" is not allowed because it is not recommended and also something like
+        # "ScriptCollectionCore().run_program('curl', 'https://example.com/dataset?id=1&format=json')"
+        # would not be possible anymore because the ampersand will be treated as shell-command.
+        try:
+            if interactive:
+                result = Popen(arguments_for_process, cwd=working_directory, stdout=PIPE, stderr=PIPE, shell=False, text=True, stdin=sys.stdin)  # pylint: disable=consider-using-with
+            else:
+                result = Popen(arguments_for_process, cwd=working_directory,  stdout=PIPE, stderr=PIPE, shell=False, text=True)  # pylint: disable=consider-using-with
+        except FileNotFoundError as fileNotFoundError:
+            raise FileNotFoundError(f"Starting '{program}' in '{working_directory}' resulted in a FileNotFoundError: '{str(fileNotFoundError)}'")
+        except NotADirectoryError as notADirectoryError:
+            raise NotADirectoryError(f"Starting '{program}' in '{working_directory}' resulted in a NotADirectoryError: '{str(notADirectoryError)}'")
+        return result
+
+    # Return-values program_runner: Exitcode, StdOut, StdErr, Pid
+    @GeneralUtilities.check_arguments
+    def wait(self, process: Popen, custom_argument: object) -> tuple[int, str, str, int]:
+        pid = process.pid
+        stdout, stderr = process.communicate()
+        exit_code = process.wait()
+        stdout = GeneralUtilities.bytes_to_string(stdout).replace('\r', '')
+        stderr = GeneralUtilities.bytes_to_string(stderr).replace('\r', '')
+        result = (exit_code, stdout, stderr, pid)
+        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)
+        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)
+
+    @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
+
+    @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/ProgramRunnerSudo.py

@@ -0,0 +1,108 @@
+from subprocess import Popen
+from .GeneralUtilities import GeneralUtilities
+from .ProgramRunnerBase import ProgramRunnerBase
+from .ScriptCollectionCore import ScriptCollectionCore
+
+
+class SudoPopenReader:
+    content: bytes = None
+
+    def __init__(self, content: bytes):
+        self.content = content
+
+    def readable(self) -> bool:
+        return True
+
+    def read(self) -> bytes:
+        return self.content
+
+
+class SudoPopen:
+    returncode: int = None
+    stdout_str: str = None
+    stderr_str: str = None
+    pid: int = None
+    stdout: bytes = None
+    stderr: bytes = None
+
+    def __init__(self, exitcode: int, stdout: str, stderr: str, pid: int):
+        self.returncode: int = exitcode
+        self.stdout_str: str = stdout
+        self.stdout = str.encode(self.stdout_str)
+        self.stderr_str: str = stderr
+        self.stderr = str.encode(self.stderr_str)
+        self.pid = pid
+
+    def communicate(self):
+        return (self.stdout, self.stderr)
+
+    def wait(self):
+        return self.returncode
+
+    def poll(self) -> object:
+        return self.returncode
+
+    def __enter__(self):
+        return self
+
+    def __exit__(self, exc_type, exc_value, traceback):
+        pass
+
+
+class ProgramRunnerSudo(ProgramRunnerBase):
+    __sc: ScriptCollectionCore
+    __password: str
+
+    @GeneralUtilities.check_arguments
+    def __init__(self,user_password:str):
+        GeneralUtilities.assert_condition(GeneralUtilities.current_system_is_linux(), "SudoRunner can only be only executed on Linux.")
+        self.__sc = ScriptCollectionCore()
+        self.__password = user_password
+
+    @GeneralUtilities.check_arguments
+    def will_be_executed_locally(self) -> bool:
+        return True
+
+    @GeneralUtilities.check_arguments
+    def run_program_internal(self, program: str, arguments_as_array: list[str] = [], working_directory: str = None, custom_argument: object = None) -> tuple[int, str, str, int]:
+        argument = program+" " + ' '.join(GeneralUtilities.args_array_surround_with_quotes_if_required(arguments_as_array))
+        argument = f"echo {self.__password} | sudo -k -S {argument}"  # TODO maybe add "exit" somewhere before argument or before sudo to correctly return the exit-code"
+        result = self.__sc.run_program_argsasarray("sh", ["-c", argument], working_directory)
+        return result
+
+    @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:
+        if interactive:
+            raise ValueError("Interactive execution is not supported in Sudo-runner")
+        r: tuple[int, str, str, int] = self.run_program_internal(program, arguments_as_array, working_directory, custom_argument)
+        popen: SudoPopen = SudoPopen(r[0], r[1], r[2], r[3])
+        return popen
+
+    # Return-values program_runner: Exitcode, StdOut, StdErr, Pid
+    @GeneralUtilities.check_arguments
+    def wait(self, process: Popen, custom_argument: object) -> tuple[int, str, str, int]:
+        raise ValueError("Wait is not supported in Sudo-runner")
+
+    # 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, custom_argument: object = None, interactive: bool = False) -> tuple[int, str, str, int]:
+        if interactive:
+            raise ValueError("Interactive execution is not supported in Sudo-runner")
+        return self.run_program_internal(program, arguments_as_array, working_directory, custom_argument)
+
+    # Return-values program_runner: Exitcode, StdOut, StdErr, Pid
+    @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]:
+        if interactive:
+            raise ValueError("Interactive execution is not supported in Sudo-runner")
+        return self.run_program_internal(program, arguments.split(" "), working_directory, custom_argument)
+
+    # 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, custom_argument: object = None, interactive: bool = False) -> int:
+        raise ValueError("Async execution is not supported in Sudo-runner")
+
+    # Return-values program_runner: Pid
+    @GeneralUtilities.check_arguments
+    def run_program_async(self, program: str, arguments: str,  working_directory: str, custom_argument: object, interactive: bool = False) -> int:
+        raise ValueError("Async execution is not supported in Sudo-runner")