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

ScriptCollection/ProgramRunnerBase.py

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

ScriptCollection/ProgramRunnerMock.py

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

ScriptCollection/ProgramRunnerPopen.py

@@ -19,7 +19,9 @@ class ProgramRunnerPopen(ProgramRunnerBase):
             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}'")
+            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
@@ -49,3 +51,7 @@ class ProgramRunnerPopen(ProgramRunnerBase):
     @GeneralUtilities.check_arguments
     def run_program_async(self, program: str, arguments: str = "", working_directory: str = None, custom_argument: object = None, interactive: bool = False) -> int:
         return self.run_program_argsasarray_async(program, GeneralUtilities.arguments_to_array(arguments), working_directory, custom_argument, interactive)
+
+    @GeneralUtilities.check_arguments
+    def will_be_executed_locally(self) -> bool:
+        return True

ScriptCollection/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")

ScriptCollection/SCLog.py

@@ -0,0 +1,115 @@
+import traceback
+from enum import Enum
+from datetime import datetime
+from .GeneralUtilities import GeneralUtilities
+
+
+class LogLevel(Enum):
+    Quiet = 0
+    Error = 1
+    Warning = 2
+    Information = 3
+    Debug = 4
+    Diagnostic = 5
+
+    def __int__(self):
+        return self.value
+
+
+class SCLog:
+    loglevel: LogLevel#minimum loglevel
+    log_file: str
+    add_overhead_to_console: bool
+    add_overhead_to_logfile: bool
+    print_as_color: bool
+    add_milliseconds_to_logfile_entry: bool
+
+    def __init__(self, log_file: str = None, loglevel: LogLevel = None, print_as_color: bool = True):
+        self.log_file = log_file
+        if loglevel is None:
+            self.loglevel = LogLevel.Information
+        else:
+            self.loglevel = loglevel
+        self.add_overhead_to_console = False
+        self.add_overhead_to_logfile = False
+        self.add_milliseconds_to_logfile_entry = False
+        self.print_as_color = print_as_color
+
+    @GeneralUtilities.check_arguments
+    def log_exception(self, message: str, ex: Exception,loglevel:LogLevel = LogLevel.Error):
+        self.log(f"Exception: {message}; Exception-details: {str(ex)}; Traceback: {traceback.format_exc()}", loglevel)
+
+    @GeneralUtilities.check_arguments
+    def log(self, message: str, loglevel: LogLevel = None):
+        for line in GeneralUtilities.string_to_lines(message, True, False):
+            self.__log_line(line, loglevel)
+
+    @GeneralUtilities.check_arguments
+    def __log_line(self, message: str, loglevel: LogLevel = None):
+
+        print_to_console: bool = True
+        print_to_logfile: bool = self.log_file is not None
+
+        if loglevel is None:
+            loglevel = LogLevel.Information
+
+        if int(self.loglevel)<int(loglevel):
+            return
+
+        if message.endswith("\n"):
+            GeneralUtilities.write_message_to_stderr(f"invalid line: '{message}'") # TODO remove this
+
+        part1: str = GeneralUtilities.empty_string
+        part2: str = GeneralUtilities.empty_string
+        part3: str = message
+
+        if loglevel == LogLevel.Warning:
+            part3 = f"Warning: {message}"
+        if loglevel == LogLevel.Debug:
+            part3 = f"Debug: {message}"
+        if loglevel == LogLevel.Diagnostic:
+            part3 = f"Diagnostic: {message}"
+
+        moment: datetime = datetime.now(datetime.now().astimezone().tzinfo)
+
+        part1 = f"[{GeneralUtilities.datetime_to_string_for_logfile_entry(moment, self.add_milliseconds_to_logfile_entry)}] ["
+        if loglevel == LogLevel.Information:
+            part2 = f"Information"
+        elif loglevel == LogLevel.Error:
+            part2 = f"Error"
+        elif loglevel == LogLevel.Warning:
+            part2 = f"Warning"
+        elif loglevel == LogLevel.Debug:
+            part2 = f"Debug"
+        elif loglevel == LogLevel.Diagnostic:
+            part2 = f"Diagnostic"
+        else:
+            raise ValueError("Unknown loglevel.")
+        part3 = f"] {message}"
+
+        if print_to_console:
+            print_to_std_out: bool = loglevel in (LogLevel.Debug, LogLevel.Information)
+            if self.add_overhead_to_console:
+                GeneralUtilities.print_text(part1, print_to_std_out)
+                if loglevel == LogLevel.Information:
+                    GeneralUtilities.print_text_in_green(part2, print_to_std_out, self.print_as_color)
+                elif loglevel == LogLevel.Error:
+                    GeneralUtilities.print_text_in_red(part2, print_to_std_out, self.print_as_color)
+                elif loglevel == LogLevel.Warning:
+                    GeneralUtilities.print_text_in_yellow(part2, print_to_std_out, self.print_as_color)
+                elif loglevel == LogLevel.Debug:
+                    GeneralUtilities.print_text_in_cyan(part2, print_to_std_out, self.print_as_color)
+                elif loglevel == LogLevel.Diagnostic:
+                    GeneralUtilities.print_text_in_cyan(part2, print_to_std_out, self.print_as_color)
+                else:
+                    raise ValueError("Unknown loglevel.")
+                GeneralUtilities.print_text(part3+"\n", print_to_std_out)
+            else:
+                GeneralUtilities.print_text(message+"\n", print_to_std_out)
+
+        if print_to_logfile:
+            GeneralUtilities.ensure_file_exists(self.log_file)
+            if self.add_overhead_to_logfile:
+                GeneralUtilities.append_line_to_file(self.log_file, part1+part2+part3)
+            else:
+                GeneralUtilities.append_line_to_file(self.log_file, message)