ScriptCollection 3.4.55__py3-none-any.whl → 3.5.44__py3-none-any.whl

ScriptCollection/GeneralUtilities.py

@@ -12,6 +12,8 @@ import secrets
 import string as strin
 import sys
 import traceback
+import warnings
+import functools
 from datetime import datetime, timedelta, date
 from os import listdir
 from os.path import isfile, join, isdir
@@ -49,19 +51,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]:
@@ -381,8 +391,8 @@ 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
@@ -394,8 +404,8 @@ class GeneralUtilities:
                     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
@@ -461,6 +471,16 @@ 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:
@@ -545,6 +565,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):
@@ -558,12 +584,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
@@ -573,6 +601,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
@@ -583,12 +612,13 @@ 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
@@ -718,8 +748,7 @@ class GeneralUtilities:
 
     @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[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:
@@ -768,10 +797,9 @@ class GeneralUtilities:
 
     @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))
+        return GeneralUtilities.get_all_files_of_folder(directory)
 
     @staticmethod
     @check_arguments
@@ -852,3 +880,12 @@ class GeneralUtilities:
     @check_arguments
     def replace_variable_in_string(input_string: str, variable_name: str, variable_value: str) -> None:
         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

ScriptCollection/ProcessesRunner.py

@@ -0,0 +1,41 @@
+import psutil
+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
+
+    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

@@ -1,42 +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) -> 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) -> 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) -> 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) -> 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) -> int:
-        raise NotImplementedError
+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:
+        # Verbosity:
+        # 0=Quiet (No output will be printed.)
+        # 1=Normal (If the exitcode of the executed program is not 0 then the StdErr will be printed.)
+        # 2=Full (Prints StdOut and StdErr of the executed program.)
+        # 3=Verbose (Same as "Full" but with some more information.)
+        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

ScriptCollection/ProgramRunnerEpew.py

@@ -1,122 +1,122 @@
-import os
-import base64
-import tempfile
-from subprocess import Popen
-from uuid import uuid4
-
-from .GeneralUtilities import GeneralUtilities
-from .ProgramRunnerBase import ProgramRunnerBase
-from .ProgramRunnerPopen import ProgramRunnerPopen
-
-
-class CustomEpewArgument:
-
-    print_errors_as_information: bool
-    log_file: str
-    timeoutInSeconds: int
-    addLogOverhead: bool
-    title: str
-    log_namespace: str
-    verbosity: int
-    arguments_for_log:  list[str]
-    tempdir = os.path.join(tempfile.gettempdir(), str(uuid4()))
-    stdoutfile = tempdir + ".epew.stdout.txt"
-    stderrfile = tempdir + ".epew.stderr.txt"
-    exitcodefile = tempdir + ".epew.exitcode.txt"
-    pidfile = tempdir + ".epew.pid.txt"
-
-    def __init__(self, print_errors_as_information: bool, log_file: str, timeoutInSeconds: int, addLogOverhead: bool, title: str, log_namespace: str, verbosity: int,  arguments_for_log:  list[str]):
-        self.print_errors_as_information = print_errors_as_information
-        self.log_file = log_file
-        self.timeoutInSeconds = timeoutInSeconds
-        self.addLogOverhead = addLogOverhead
-        self.title = title
-        self.log_namespace = log_namespace
-        self.verbosity = verbosity
-        self.arguments_for_log = arguments_for_log
-
-
-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) -> Popen:
-        if GeneralUtilities.epew_is_available():
-            custom_argument: CustomEpewArgument = custom_argument
-            args = []
-
-            base64argument = base64.b64encode(' '.join(arguments_as_array).encode('utf-8')).decode('utf-8')
-            args.append(f'-p "{program}"')
-            args.append(f'-a {base64argument}')
-            args.append('-b')
-            args.append(f'-w "{working_directory}"')
-            if custom_argument.stdoutfile is not None:
-                args.append(f'-o {custom_argument.stdoutfile}')
-            if custom_argument.stderrfile is not None:
-                args.append(f'-e {custom_argument.stderrfile}')
-            if custom_argument.exitcodefile is not None:
-                args.append(f'-x {custom_argument.exitcodefile}')
-            if custom_argument.pidfile is not None:
-                args.append(f'-r {custom_argument.pidfile}')
-            args.append(f'-d {str(custom_argument.timeoutInSeconds*1000)}')
-            args.append(f'-t "{custom_argument.title}"')
-            args.append(f'-l "{custom_argument.log_namespace}"')
-            if not GeneralUtilities.string_is_none_or_whitespace(custom_argument.log_file):
-                args.append(f'-f "{custom_argument.log_file}"')
-            if custom_argument.print_errors_as_information:
-                args.append("-i")
-            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)
-        else:
-            raise ValueError("Epew is not available.")
-
-    # Return-values program_runner: Exitcode, StdOut, StdErr, Pid
-    @GeneralUtilities.check_arguments
-    def wait(self, process: Popen, custom_argument: object = None) -> tuple[int, str, str, int]:
-        process.wait()
-        custom_argument: CustomEpewArgument = custom_argument
-        stdout = self.__load_text(custom_argument.output_file_for_stdout)
-        stderr = self.__load_text(custom_argument.output_file_for_stderr)
-        exit_code = self.__get_number_from_filecontent(self.__load_text(custom_argument.output_file_for_exit_code))
-        pid = self.__get_number_from_filecontent(self.__load_text(custom_argument.output_file_for_pid))
-        GeneralUtilities.ensure_directory_does_not_exist(custom_argument.tempdir)
-        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) -> tuple[int, str, str, int]:
-        process: Popen = self.run_program_argsasarray_async_helper(program, arguments_as_array, working_directory, custom_argument)
-        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) -> 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) -> int:
-        return self.run_program_argsasarray_async_helper(program, arguments_as_array, working_directory, custom_argument).pid
-
-    @GeneralUtilities.check_arguments
-    def run_program_async(self, program: str, arguments: str = "", working_directory: str = None, custom_argument: object = None) -> int:
-        return self.run_program_argsasarray_async(program, GeneralUtilities.arguments_to_array(arguments), working_directory, custom_argument)
-
-    @GeneralUtilities.check_arguments
-    def __get_number_from_filecontent(self, filecontent: str) -> int:
-        for line in filecontent.splitlines():
-            try:
-                striped_line = GeneralUtilities.strip_new_line_character(line)
-                result = int(striped_line)
-                return result
-            except:
-                pass
-        raise ValueError(f"'{filecontent}' does not containe an int-line")
-
-    @GeneralUtilities.check_arguments
-    def __load_text(self, file: str) -> str:
-        if os.path.isfile(file):
-            content = GeneralUtilities.read_text_from_file(file).replace('\r', '')
-            os.remove(file)
-            return content
-        else:
-            raise ValueError(f"File '{file}' does not exist")
+import os
+import base64
+import tempfile
+from subprocess import Popen
+from uuid import uuid4
+
+from .GeneralUtilities import GeneralUtilities
+from .ProgramRunnerBase import ProgramRunnerBase
+from .ProgramRunnerPopen import ProgramRunnerPopen
+
+
+class CustomEpewArgument:
+
+    print_errors_as_information: bool
+    log_file: str
+    timeoutInSeconds: int
+    addLogOverhead: bool
+    title: str
+    log_namespace: str
+    verbosity: int
+    arguments_for_log:  list[str]
+    tempdir = os.path.join(tempfile.gettempdir(), str(uuid4()))
+    stdoutfile = tempdir + ".epew.stdout.txt"
+    stderrfile = tempdir + ".epew.stderr.txt"
+    exitcodefile = tempdir + ".epew.exitcode.txt"
+    pidfile = tempdir + ".epew.pid.txt"
+
+    def __init__(self, print_errors_as_information: bool, log_file: str, timeoutInSeconds: int, addLogOverhead: bool, title: str, log_namespace: str, verbosity: int,  arguments_for_log:  list[str]):
+        self.print_errors_as_information = print_errors_as_information
+        self.log_file = log_file
+        self.timeoutInSeconds = timeoutInSeconds
+        self.addLogOverhead = addLogOverhead
+        self.title = title
+        self.log_namespace = log_namespace
+        self.verbosity = verbosity
+        self.arguments_for_log = arguments_for_log
+
+
+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:
+        if GeneralUtilities.epew_is_available():
+            custom_argument: CustomEpewArgument = custom_argument
+            args = []
+
+            base64argument = base64.b64encode(' '.join(arguments_as_array).encode('utf-8')).decode('utf-8')
+            args.append(f'-p "{program}"')
+            args.append(f'-a {base64argument}')
+            args.append('-b')
+            args.append(f'-w "{working_directory}"')
+            if custom_argument.stdoutfile is not None:
+                args.append(f'-o {custom_argument.stdoutfile}')
+            if custom_argument.stderrfile is not None:
+                args.append(f'-e {custom_argument.stderrfile}')
+            if custom_argument.exitcodefile is not None:
+                args.append(f'-x {custom_argument.exitcodefile}')
+            if custom_argument.pidfile is not None:
+                args.append(f'-r {custom_argument.pidfile}')
+            args.append(f'-d {str(custom_argument.timeoutInSeconds*1000)}')
+            args.append(f'-t "{custom_argument.title}"')
+            args.append(f'-l "{custom_argument.log_namespace}"')
+            if not GeneralUtilities.string_is_none_or_whitespace(custom_argument.log_file):
+                args.append(f'-f "{custom_argument.log_file}"')
+            if custom_argument.print_errors_as_information:
+                args.append("-i")
+            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)
+        else:
+            raise ValueError("Epew is not available.")
+
+    # Return-values program_runner: Exitcode, StdOut, StdErr, Pid
+    @GeneralUtilities.check_arguments
+    def wait(self, process: Popen, custom_argument: object = None) -> tuple[int, str, str, int]:
+        process.wait()
+        custom_argument: CustomEpewArgument = custom_argument
+        stdout = self.__load_text(custom_argument.output_file_for_stdout)
+        stderr = self.__load_text(custom_argument.output_file_for_stderr)
+        exit_code = self.__get_number_from_filecontent(self.__load_text(custom_argument.output_file_for_exit_code))
+        pid = self.__get_number_from_filecontent(self.__load_text(custom_argument.output_file_for_pid))
+        GeneralUtilities.ensure_directory_does_not_exist(custom_argument.tempdir)
+        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,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
+
+    @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 __get_number_from_filecontent(self, filecontent: str) -> int:
+        for line in filecontent.splitlines():
+            try:
+                striped_line = GeneralUtilities.strip_new_line_character(line)
+                result = int(striped_line)
+                return result
+            except:
+                pass
+        raise ValueError(f"'{filecontent}' does not containe an int-line")
+
+    @GeneralUtilities.check_arguments
+    def __load_text(self, file: str) -> str:
+        if os.path.isfile(file):
+            content = GeneralUtilities.read_text_from_file(file).replace('\r', '')
+            os.remove(file)
+            return content
+        else:
+            raise ValueError(f"File '{file}' does not exist")

ScriptCollection/ProgramRunnerPopen.py

@@ -1,52 +1,51 @@
-import os
-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) -> 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.
-        cwd = os.getcwd()
-        try:
-            os.chdir(working_directory)
-            result = Popen(arguments_for_process, stdout=PIPE, stderr=PIPE, shell=False)  # pylint: disable=consider-using-with
-        except FileNotFoundError as fileNotFoundError:
-            raise FileNotFoundError(f"Starting '{program}' in '{working_directory}' resulted in a FileNotFoundError: '{fileNotFoundError.filename}'")
-        finally:
-            os.chdir(cwd)
-        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) -> tuple[int, str, str, int]:
-        process: Popen = self.run_program_argsasarray_async_helper(program, arguments_as_array, working_directory, custom_argument)
-        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) -> 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) -> int:
-        return self.run_program_argsasarray_async_helper(program, arguments_as_array, working_directory, custom_argument).pid
-
-    @GeneralUtilities.check_arguments
-    def run_program_async(self, program: str, arguments: str = "", working_directory: str = None, custom_argument: object = None) -> int:
-        return self.run_program_argsasarray_async(program, GeneralUtilities.arguments_to_array(arguments), working_directory, custom_argument)
+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: '{fileNotFoundError.filename}'")
+        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)