ScriptCollection 3.5.12__py3-none-any.whl → 3.5.14__py3-none-any.whl

ScriptCollection/GeneralUtilities.py

@@ -67,7 +67,7 @@ class GeneralUtilities:
         @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.warn(f"Call to deprecated function {func.__name__}", category=DeprecationWarning, stacklevel=2)
             warnings.simplefilter('default', DeprecationWarning)
             return func(*args, **kwargs)
         return new_func
@@ -574,12 +574,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
@@ -589,6 +591,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
@@ -599,12 +602,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

ScriptCollection/ProgramRunnerPopen.py

@@ -7,7 +7,7 @@ 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:
+    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
@@ -15,9 +15,9 @@ class ProgramRunnerPopen(ProgramRunnerBase):
         # 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, stdin = sys.stdin)  # pylint: disable=consider-using-with
+                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)  # pylint: disable=consider-using-with
+                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
@@ -34,18 +34,18 @@ class ProgramRunnerPopen(ProgramRunnerBase):
         return result
 
     @GeneralUtilities.check_arguments
-    def run_program_argsasarray(self, program: str, arguments_as_array: list[str] = [], working_directory: str = None, custom_argument: object = None, interactive:bool=False) -> tuple[int, str, str, int]:
-        process: Popen = self.run_program_argsasarray_async_helper(program, arguments_as_array, working_directory, custom_argument,interactive)
+    def run_program_argsasarray(self, program: str, arguments_as_array: list[str] = [], working_directory: str = None, custom_argument: object = None, interactive: bool = False) -> tuple[int, str, str, int]:
+        process: Popen = self.run_program_argsasarray_async_helper(program, arguments_as_array, working_directory, custom_argument, interactive)
         return self.wait(process, custom_argument)
 
     @GeneralUtilities.check_arguments
-    def run_program(self, program: str, arguments: str = "", working_directory: str = None, custom_argument: object = None, interactive:bool=False) -> tuple[int, str, str, int]:
+    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
+    def run_program_argsasarray_async(self, program: str, arguments_as_array: list[str] = [], working_directory: str = None, custom_argument: object = None, interactive: bool = False) -> int:
+        return self.run_program_argsasarray_async_helper(program, arguments_as_array, working_directory, custom_argument, interactive).pid
 
     @GeneralUtilities.check_arguments
-    def run_program_async(self, program: str, arguments: str = "", working_directory: str = None, custom_argument: object = None, interactive:bool=False) -> int:
-        return self.run_program_argsasarray_async(program, GeneralUtilities.arguments_to_array(arguments), working_directory, custom_argument,interactive)
+    def run_program_async(self, program: str, arguments: str = "", working_directory: str = None, custom_argument: object = None, interactive: bool = False) -> int:
+        return self.run_program_argsasarray_async(program, GeneralUtilities.arguments_to_array(arguments), working_directory, custom_argument, interactive)

ScriptCollection/ScriptCollectionCore.py

@@ -1,19 +1,19 @@
-import time
 from datetime import timedelta, datetime
 import json
 import binascii
 import filecmp
+import time
 import hashlib
-from io import BufferedReader, BytesIO
+from io import BytesIO
 import itertools
 import math
 import os
+from queue import Queue, Empty
+from concurrent.futures import ThreadPoolExecutor
 from pathlib import Path
-from random import randrange
 from subprocess import Popen
 import re
 import shutil
-import traceback
 import uuid
 import tempfile
 import io
@@ -29,7 +29,7 @@ from .ProgramRunnerBase import ProgramRunnerBase
 from .ProgramRunnerPopen import ProgramRunnerPopen
 from .ProgramRunnerEpew import ProgramRunnerEpew, CustomEpewArgument
 
-version = "3.5.12"
+version = "3.5.14"
 __version__ = version
 
 
@@ -59,8 +59,7 @@ class ScriptCollectionCore:
             errorsonly_argument = ""
         else:
             errorsonly_argument = " --errors-only"
-        (exit_code, stdout, stderr, _) = self.run_program("pylint", filename +
-                                                          errorsonly_argument, working_directory, throw_exception_if_exitcode_is_not_zero=False)
+        (exit_code, stdout, stderr, _) = self.run_program("pylint", filename + errorsonly_argument, working_directory, throw_exception_if_exitcode_is_not_zero=False)
         if (exit_code != 0):
             errors.append(f"Linting-issues of {file}:")
             errors.append(f"Pylint-exitcode: {exit_code}")
@@ -74,18 +73,15 @@ class ScriptCollectionCore:
 
     @GeneralUtilities.check_arguments
     def replace_version_in_dockerfile_file(self, dockerfile: str, new_version_value: str) -> None:
-        GeneralUtilities.write_text_to_file(dockerfile, re.sub(
-            "ARG Version=\"\\d+\\.\\d+\\.\\d+\"", f"ARG Version=\"{new_version_value}\"", GeneralUtilities.read_text_from_file(dockerfile)))
+        GeneralUtilities.write_text_to_file(dockerfile, re.sub("ARG Version=\"\\d+\\.\\d+\\.\\d+\"", f"ARG Version=\"{new_version_value}\"", GeneralUtilities.read_text_from_file(dockerfile)))
 
     @GeneralUtilities.check_arguments
     def replace_version_in_python_file(self, file: str, new_version_value: str):
-        GeneralUtilities.write_text_to_file(file, re.sub(
-            "version = \"\\d+\\.\\d+\\.\\d+\"", f"version = \"{new_version_value}\"", GeneralUtilities.read_text_from_file(file)))
+        GeneralUtilities.write_text_to_file(file, re.sub("version = \"\\d+\\.\\d+\\.\\d+\"", f"version = \"{new_version_value}\"", GeneralUtilities.read_text_from_file(file)))
 
     @GeneralUtilities.check_arguments
     def replace_version_in_ini_file(self, file: str, new_version_value: str):
-        GeneralUtilities.write_text_to_file(file, re.sub(
-            "version = \\d+\\.\\d+\\.\\d+", f"version = {new_version_value}", GeneralUtilities.read_text_from_file(file)))
+        GeneralUtilities.write_text_to_file(file, re.sub("version = \\d+\\.\\d+\\.\\d+", f"version = {new_version_value}", GeneralUtilities.read_text_from_file(file)))
 
     @GeneralUtilities.check_arguments
     def replace_version_in_nuspec_file(self, nuspec_file: str, new_version: str) -> None:
@@ -96,8 +92,7 @@ class ScriptCollectionCore:
         if pattern.match(new_version):
             GeneralUtilities.write_text_to_file(nuspec_file, re.sub(f"<version>{versionregex}<\\/version>", f"<version>{new_version}</version>", GeneralUtilities.read_text_from_file(nuspec_file)))
         else:
-            raise ValueError(
-                f"Version '{new_version}' does not match version-regex '{versiononlyregex}'")
+            raise ValueError(f"Version '{new_version}' does not match version-regex '{versiononlyregex}'")
 
     @GeneralUtilities.check_arguments
     def replace_version_in_csproj_file(self, csproj_file: str, current_version: str):
@@ -106,25 +101,20 @@ class ScriptCollectionCore:
         pattern = re.compile(versiononlyregex)
         if pattern.match(current_version):
             for tag in ["Version", "AssemblyVersion", "FileVersion"]:
-                GeneralUtilities.write_text_to_file(csproj_file, re.sub(
-                    f"<{tag}>{versionregex}(.\\d+)?<\\/{tag}>", f"<{tag}>{current_version}</{tag}>", GeneralUtilities.read_text_from_file(csproj_file)))
+                GeneralUtilities.write_text_to_file(csproj_file, re.sub(f"<{tag}>{versionregex}(.\\d+)?<\\/{tag}>", f"<{tag}>{current_version}</{tag}>", GeneralUtilities.read_text_from_file(csproj_file)))
         else:
-            raise ValueError(
-                f"Version '{current_version}' does not match version-regex '{versiononlyregex}'")
+            raise ValueError(f"Version '{current_version}' does not match version-regex '{versiononlyregex}'")
 
     @GeneralUtilities.check_arguments
     def push_nuget_build_artifact(self, nupkg_file: str, registry_address: str, api_key: str, verbosity: int = 1):
         nupkg_file_name = os.path.basename(nupkg_file)
         nupkg_file_folder = os.path.dirname(nupkg_file)
-        self.run_program(
-            "dotnet", f"nuget push {nupkg_file_name} --force-english-output --source {registry_address} --api-key {api_key}", nupkg_file_folder, verbosity)
+        self.run_program("dotnet", f"nuget push {nupkg_file_name} --force-english-output --source {registry_address} --api-key {api_key}", nupkg_file_folder, verbosity)
 
     @GeneralUtilities.check_arguments
     def dotnet_build(self, repository_folder: str, projectname: str, configuration: str):
-        self.run_program(
-            "dotnet", f"clean -c {configuration}", repository_folder)
-        self.run_program(
-            "dotnet", f"build {projectname}/{projectname}.csproj -c {configuration}", repository_folder)
+        self.run_program("dotnet", f"clean -c {configuration}", repository_folder)
+        self.run_program("dotnet", f"build {projectname}/{projectname}.csproj -c {configuration}", repository_folder)
 
     @GeneralUtilities.check_arguments
     def find_file_by_extension(self, folder: str, extension: str):
@@ -162,8 +152,7 @@ class ScriptCollectionCore:
             subfolder_argument = ""
         else:
             subfolder_argument = f" -- {subfolder}"
-        log_result = self.run_program(
-            "git", f'log --pretty=%aN{space_character}%aE%n%cN{space_character}%cE HEAD{subfolder_argument}', repository_folder, verbosity=0)
+        log_result = self.run_program("git", f'log --pretty=%aN{space_character}%aE%n%cN{space_character}%cE HEAD{subfolder_argument}', repository_folder, verbosity=0)
         plain_content: list[str] = list(
             set([line for line in log_result[1].split("\n") if len(line) > 0]))
         result: list[tuple[str, str]] = []
@@ -179,8 +168,7 @@ class ScriptCollectionCore:
     def get_commit_ids_between_dates(self, repository_folder: str, since: datetime, until: datetime, ignore_commits_which_are_not_in_history_of_head: bool = True) -> None:
         since_as_string = self.__datetime_to_string_for_git(since)
         until_as_string = self.__datetime_to_string_for_git(until)
-        result = filter(lambda line: not GeneralUtilities.string_is_none_or_whitespace(line), self.run_program(
-            "git", f'log --since "{since_as_string}" --until "{until_as_string}" --pretty=format:"%H" --no-patch', repository_folder, throw_exception_if_exitcode_is_not_zero=True)[1].split("\n").replace("\r", ""))
+        result = filter(lambda line: not GeneralUtilities.string_is_none_or_whitespace(line), self.run_program("git", f'log --since "{since_as_string}" --until "{until_as_string}" --pretty=format:"%H" --no-patch', repository_folder, throw_exception_if_exitcode_is_not_zero=True)[1].split("\n").replace("\r", ""))
         if ignore_commits_which_are_not_in_history_of_head:
             result = [commit_id for commit_id in result if self.git_commit_is_ancestor(
                 repository_folder, commit_id)]
@@ -192,8 +180,7 @@ class ScriptCollectionCore:
 
     @GeneralUtilities.check_arguments
     def git_commit_is_ancestor(self, repository_folder: str,  ancestor: str, descendant: str = "HEAD") -> bool:
-        exit_code = self.run_program_argsasarray(
-            "git", ["merge-base", "--is-ancestor", ancestor, descendant], repository_folder, throw_exception_if_exitcode_is_not_zero=False)[0]
+        exit_code = self.run_program_argsasarray("git", ["merge-base", "--is-ancestor", ancestor, descendant], repository_folder, throw_exception_if_exitcode_is_not_zero=False)[0]
         if exit_code == 0:
             return True
         elif exit_code == 1:
@@ -203,8 +190,7 @@ class ScriptCollectionCore:
 
     @GeneralUtilities.check_arguments
     def __git_changes_helper(self, repository_folder: str, arguments_as_array: list[str]) -> bool:
-        lines = GeneralUtilities.string_to_lines(self.run_program_argsasarray(
-            "git", arguments_as_array, repository_folder, throw_exception_if_exitcode_is_not_zero=True, verbosity=0)[1], False)
+        lines = GeneralUtilities.string_to_lines(self.run_program_argsasarray("git", arguments_as_array, repository_folder, throw_exception_if_exitcode_is_not_zero=True, verbosity=0)[1], False)
         for line in lines:
             if GeneralUtilities.string_has_content(line):
                 return True
@@ -245,8 +231,7 @@ class ScriptCollectionCore:
 
     @GeneralUtilities.check_arguments
     def git_get_commit_date(self, repository_folder: str, commit: str = "HEAD") -> datetime:
-        result: tuple[int, str, str, int] = self.run_program_argsasarray(
-            "git", ["show", "-s", "--format=%ci", commit], repository_folder, throw_exception_if_exitcode_is_not_zero=True, verbosity=0)
+        result: tuple[int, str, str, int] = self.run_program_argsasarray("git", ["show", "-s", "--format=%ci", commit], repository_folder, throw_exception_if_exitcode_is_not_zero=True, verbosity=0)
         date_as_string = result[1].replace('\n', '')
         result = datetime.strptime(date_as_string, '%Y-%m-%d %H:%M:%S %z')
         return result
@@ -359,8 +344,7 @@ class ScriptCollectionCore:
         self.run_program_argsasarray("git", ['checkout', '.'], directory, throw_exception_if_exitcode_is_not_zero=True, verbosity=0)
 
     @GeneralUtilities.check_arguments
-    def git_commit(self, directory: str, message: str, author_name: str = None, author_email: str = None, stage_all_changes: bool = True,
-                   no_changes_behavior: int = 0) -> str:
+    def git_commit(self, directory: str, message: str, author_name: str = None, author_email: str = None, stage_all_changes: bool = True, no_changes_behavior: int = 0) -> str:
         # no_changes_behavior=0 => No commit
         # no_changes_behavior=1 => Commit anyway
         # no_changes_behavior=2 => Exception
@@ -410,7 +394,7 @@ class ScriptCollectionCore:
     @GeneralUtilities.check_arguments
     def git_checkout(self, directory: str, branch: str) -> None:
         self.run_program_argsasarray("git", ["checkout", branch], directory, throw_exception_if_exitcode_is_not_zero=True, verbosity=0)
-        self.run_program_argsasarray("git", ["submodule", "update", "--recursive"],                                     directory, throw_exception_if_exitcode_is_not_zero=True, verbosity=0)
+        self.run_program_argsasarray("git", ["submodule", "update", "--recursive"], directory, throw_exception_if_exitcode_is_not_zero=True, verbosity=0)
 
     @GeneralUtilities.check_arguments
     def git_merge_abort(self, directory: str) -> None:
@@ -450,7 +434,7 @@ class ScriptCollectionCore:
                     self.git_fetch(target_directory)
                 else:
                     # clone
-                    self.git_clone(target_repository, source_repository,                                   include_submodules=True, mirror=True)
+                    self.git_clone(target_repository, source_repository, include_submodules=True, mirror=True)
 
     def get_git_submodules(self, folder: str) -> list[str]:
         e = self.run_program("git", "submodule status", folder)
@@ -472,8 +456,7 @@ class ScriptCollectionCore:
             return True
         if (exit_code == 1):
             return False
-        raise ValueError(
-            f"Unable to calculate whether '{file_in_repository}' in repository '{repositorybasefolder}' is ignored due to git-exitcode {exit_code}.")
+        raise ValueError(f"Unable to calculate whether '{file_in_repository}' in repository '{repositorybasefolder}' is ignored due to git-exitcode {exit_code}.")
 
     @GeneralUtilities.check_arguments
     def git_discard_all_changes(self, repository: str) -> None:
@@ -562,9 +545,11 @@ class ScriptCollectionCore:
         with open(target_file, "w", encoding=encoding) as file_object:
             file_object.write("\n".join(lines))
 
+    @GeneralUtilities.check_arguments
     def escape_git_repositories_in_folder(self, folder: str) -> dict[str, str]:
         return self.__escape_git_repositories_in_folder_internal(folder, dict[str, str]())
 
+    @GeneralUtilities.check_arguments
     def __escape_git_repositories_in_folder_internal(self, folder: str, renamed_items: dict[str, str]) -> dict[str, str]:
         for file in GeneralUtilities.get_direct_files_of_folder(folder):
             filename = os.path.basename(file)
@@ -586,10 +571,12 @@ class ScriptCollectionCore:
             self.__escape_git_repositories_in_folder_internal(subfolder2, renamed_items)
         return renamed_items
 
+    @GeneralUtilities.check_arguments
     def deescape_git_repositories_in_folder(self, renamed_items: dict[str, str]):
         for renamed_item, original_name in renamed_items.items():
             os.rename(renamed_item, original_name)
 
+    @GeneralUtilities.check_arguments
     def __sort_fmd(self, line: str):
         splitted: list = line.split(";")
         filetype: str = splitted[1]
@@ -626,29 +613,36 @@ class ScriptCollectionCore:
 
     @GeneralUtilities.check_arguments
     def __calculate_lengh_in_seconds(self, filename: str, folder: str) -> float:
-        argument = ['-v', 'error', '-show_entries', 'format=duration',
-                    '-of', 'default=noprint_wrappers=1:nokey=1', filename]
+        argument = ['-v', 'error', '-show_entries', 'format=duration', '-of', 'default=noprint_wrappers=1:nokey=1', filename]
         result = self.run_program_argsasarray("ffprobe", argument, folder, throw_exception_if_exitcode_is_not_zero=True)
         return float(result[1].replace('\n', ''))
 
     @GeneralUtilities.check_arguments
-    def __create_thumbnails(self, filename: str, fps: str, folder: str, tempname_for_thumbnails: str) -> None:
-        argument = ['-i', filename, '-r', str(fps), '-vf', 'scale=-1:120',
-                    '-vcodec', 'png', f'{tempname_for_thumbnails}-%002d.png']
+    def __create_thumbnails(self, filename: str, fps: str, folder: str, tempname_for_thumbnails: str) -> list[str]:
+        argument = ['-i', filename, '-r', str(fps), '-vf', 'scale=-1:120', '-vcodec', 'png', f'{tempname_for_thumbnails}-%002d.png']
         self.run_program_argsasarray("ffmpeg", argument, folder, throw_exception_if_exitcode_is_not_zero=True)
+        files = GeneralUtilities.get_direct_files_of_folder(folder)
+        result: list[str] = []
+        regex = "^"+re.escape(tempname_for_thumbnails)+"\\-\\d+\\.png$"
+        regex_for_files = re.compile(regex)
+        for file in files:
+            filename = os.path.basename(file)
+            if regex_for_files.match(filename):
+                result.append(file)
+        GeneralUtilities.assert_condition(0 < len(result), "No thumbnail-files found.")
+        return result
 
     @GeneralUtilities.check_arguments
     def __create_thumbnail(self, outputfilename: str, folder: str, length_in_seconds: float, tempname_for_thumbnails: str, amount_of_images: int) -> None:
         duration = timedelta(seconds=length_in_seconds)
         info = GeneralUtilities.timedelta_to_simple_string(duration)
-        next_square_number = str(int(math.sqrt(GeneralUtilities.get_next_square_number(amount_of_images))))
-        argument = ['-title', f'"{outputfilename} ({info})"', '-tile', f'{next_square_number}x{next_square_number}',
-                    f'{tempname_for_thumbnails}*.png', f'{outputfilename}.png']
-        self.run_program_argsasarray(
-            "montage", argument, folder, throw_exception_if_exitcode_is_not_zero=True)
+        rows: int = 5
+        columns: int = math.ceil(amount_of_images/rows)
+        argument = ['-title', f'"{outputfilename} ({info})"', '-tile', f'{rows}x{columns}', f'{tempname_for_thumbnails}*.png', f'{outputfilename}.png']
+        self.run_program_argsasarray("montage", argument, folder, throw_exception_if_exitcode_is_not_zero=True)
 
     @GeneralUtilities.check_arguments
-    def roundup(self, x: float, places: int) -> int:
+    def __roundup(self, x: float, places: int) -> int:
         d = 10 ** places
         if x < 0:
             return math.floor(x * d) / d
@@ -656,33 +650,35 @@ class ScriptCollectionCore:
             return math.ceil(x * d) / d
 
     @GeneralUtilities.check_arguments
-    def generate_thumbnail(self, file: str, frames_per_second: str, tempname_for_thumbnails: str = None) -> None:
+    def generate_thumbnail(self, file: str, frames_per_second: str, tempname_for_thumbnails: str = None, hook=None) -> None:
         if tempname_for_thumbnails is None:
-            tempname_for_thumbnails = "t"+str(uuid.uuid4())
+            tempname_for_thumbnails = "t_"+str(uuid.uuid4())
 
         file = GeneralUtilities.resolve_relative_path_from_current_working_directory(file)
         filename = os.path.basename(file)
         folder = os.path.dirname(file)
         filename_without_extension = Path(file).stem
-
+        preview_files: list[str] = []
         try:
             length_in_seconds = self.__calculate_lengh_in_seconds(filename, folder)
             if (frames_per_second.endswith("fps")):
                 # frames per second, example: frames_per_second="20fps" => 20 frames per second
-                x = self.roundup(float(frames_per_second[:-3]), 2)
-                frames_per_secondx = str(x)
-                amounf_of_previewframes = int(math.floor(length_in_seconds*x))
+                frames_per_second = self.__roundup(float(frames_per_second[:-3]), 2)
+                frames_per_second_as_string = str(frames_per_second)
+                amounf_of_previewframes = int(math.floor(length_in_seconds*frames_per_second))
             else:
                 # concrete amount of frame, examples: frames_per_second="16" => 16 frames for entire video
                 amounf_of_previewframes = int(float(frames_per_second))
                 # self.roundup((amounf_of_previewframes-2)/length_in_seconds, 2)
-                frames_per_secondx = f"{amounf_of_previewframes-2}/{length_in_seconds}"
-            self.__create_thumbnails(filename, frames_per_secondx, folder, tempname_for_thumbnails)
-            self.__create_thumbnail(filename_without_extension, folder, length_in_seconds, tempname_for_thumbnails, amounf_of_previewframes)
+                frames_per_second_as_string = f"{amounf_of_previewframes-2}/{length_in_seconds}"
+            preview_files = self.__create_thumbnails(filename, frames_per_second_as_string, folder, tempname_for_thumbnails)
+            if hook is not None:
+                hook(file, preview_files)
+            actual_amounf_of_previewframes = len(preview_files)
+            self.__create_thumbnail(filename_without_extension, folder, length_in_seconds, tempname_for_thumbnails, actual_amounf_of_previewframes)
         finally:
-            for thumbnail_to_delete in Path(folder).rglob(tempname_for_thumbnails+"-*"):
-                file = str(thumbnail_to_delete)
-                os.remove(file)
+            for thumbnail_to_delete in preview_files:
+                os.remove(thumbnail_to_delete)
 
     @GeneralUtilities.check_arguments
     def extract_pdf_pages(self, file: str, from_page: int, to_page: int, outputfile: str) -> None:
@@ -908,29 +904,6 @@ class ScriptCollectionCore:
                 line[0], line[1], line[2], line[3], line[4])
         GeneralUtilities.write_message_to_stdout(separator_line)
 
-    @GeneralUtilities.check_arguments
-    def SCUploadFileToFileHost(self, file: str, host: str) -> int:
-        try:
-            GeneralUtilities.write_message_to_stdout(
-                self.upload_file_to_file_host(file, host))
-            return 0
-        except Exception as exception:
-            GeneralUtilities.write_exception_to_stderr_with_traceback(exception, traceback)
-            return 1
-
-    @GeneralUtilities.check_arguments
-    def SCFileIsAvailableOnFileHost(self, file: str) -> int:
-        try:
-            if self.file_is_available_on_file_host(file):
-                GeneralUtilities.write_message_to_stdout(f"'{file}' is available")
-                return 0
-            else:
-                GeneralUtilities.write_message_to_stdout(f"'{file}' is not available")
-                return 1
-        except Exception as exception:
-            GeneralUtilities.write_exception_to_stderr_with_traceback(exception, traceback)
-            return 2
-
     @GeneralUtilities.check_arguments
     def SCCalculateBitcoinBlockHash(self, block_version_number: str, previousblockhash: str, transactionsmerkleroot: str, timestamp: str, target: str, nonce: str) -> str:
         # Example-values:
@@ -1119,44 +1092,6 @@ class ScriptCollectionCore:
         tor_version = version_with_overhead.split("~")[0]
         return tor_version
 
-    @GeneralUtilities.check_arguments
-    def upload_file_to_file_host(self, file: str, host: str) -> int:
-        if (host is None):
-            return self.upload_file_to_random_filesharing_service(file)
-        elif host == "anonfiles.com":
-            return self.upload_file_to_anonfiles(file)
-        elif host == "bayfiles.com":
-            return self.upload_file_to_bayfiles(file)
-        GeneralUtilities.write_message_to_stderr("Unknown host: "+host)
-        return 1
-
-    @GeneralUtilities.check_arguments
-    def upload_file_to_random_filesharing_service(self, file: str) -> int:
-        host = randrange(2)
-        if host == 0:
-            return self.upload_file_to_anonfiles(file)
-        if host == 1:
-            return self.upload_file_to_bayfiles(file)
-        return 1
-
-    @GeneralUtilities.check_arguments
-    def upload_file_to_anonfiles(self, file) -> int:
-        return self.upload_file_by_using_simple_curl_request("https://api.anonfiles.com/upload", file)
-
-    @GeneralUtilities.check_arguments
-    def upload_file_to_bayfiles(self, file) -> int:
-        return self.upload_file_by_using_simple_curl_request("https://api.bayfiles.com/upload", file)
-
-    @GeneralUtilities.check_arguments
-    def upload_file_by_using_simple_curl_request(self, api_url: str, file: str) -> int:
-        # TODO implement
-        return 1
-
-    @GeneralUtilities.check_arguments
-    def file_is_available_on_file_host(self, file) -> int:
-        # TODO implement
-        return 1
-
     def run_testcases_for_python_project(self, repository_folder: str):
         self.run_program("coverage", "run -m pytest", repository_folder)
         self.run_program("coverage", "xml", repository_folder)
@@ -1167,7 +1102,7 @@ class ScriptCollectionCore:
 
     @GeneralUtilities.check_arguments
     def get_file_permission(self, file: str) -> str:
-        """This function returns an usual octet-triple, for example "0700"."""
+        """This function returns an usual octet-triple, for example "700"."""
         ls_output = self.__ls(file)
         return self.__get_file_permission_helper(ls_output)
 
@@ -1210,12 +1145,10 @@ class ScriptCollectionCore:
     @GeneralUtilities.check_arguments
     def __ls(self, file: str) -> str:
         file = file.replace("\\", "/")
-        GeneralUtilities.assert_condition(os.path.isfile(file) or os.path.isdir(
-            file), f"Can not execute 'ls' because '{file}' does not exist")
+        GeneralUtilities.assert_condition(os.path.isfile(file) or os.path.isdir(file), f"Can not execute 'ls' because '{file}' does not exist.")
         result = self.run_program_argsasarray("ls", ["-ld", file])
         GeneralUtilities.assert_condition(result[0] == 0, f"'ls -ld {file}' resulted in exitcode {str(result[0])}. StdErr: {result[2]}")
-        GeneralUtilities.assert_condition(not GeneralUtilities.string_is_none_or_whitespace(
-            result[1]), f"'ls' of '{file}' had an empty output. StdErr: '{result[2]}'")
+        GeneralUtilities.assert_condition(not GeneralUtilities.string_is_none_or_whitespace(result[1]), f"'ls' of '{file}' had an empty output. StdErr: '{result[2]}'")
         return result[1]
 
     @GeneralUtilities.check_arguments
@@ -1255,8 +1188,39 @@ class ScriptCollectionCore:
         popen: Popen = self.program_runner.run_program_argsasarray_async_helper(program, arguments_as_array, working_directory, custom_argument, interactive)
         return popen
 
-    # Return-values program_runner: Exitcode, StdOut, StdErr, Pid
+    @staticmethod
+    @GeneralUtilities.check_arguments
+    def __enqueue_output(file, queue):
+        for line in iter(file.readline, ''):
+            queue.put(line)
+        file.close()
 
+    @staticmethod
+    @GeneralUtilities.check_arguments
+    def __read_popen_pipes(p: Popen):
+
+        with ThreadPoolExecutor(2) as pool:
+            q_stdout, q_stderr = Queue(), Queue()
+
+            pool.submit(ScriptCollectionCore.__enqueue_output, p.stdout, q_stdout)
+            pool.submit(ScriptCollectionCore.__enqueue_output, p.stderr, q_stderr)
+            while True:
+                time.sleep(0.2)
+                if p.poll() is not None and q_stdout.empty() and q_stderr.empty():
+                    break
+
+                out_line = ''
+                err_line = ''
+
+                try:
+                    out_line = q_stdout.get_nowait()
+                    err_line = q_stderr.get_nowait()
+                except Empty:
+                    pass
+
+                yield (out_line, err_line)
+
+    # 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, verbosity: int = 1, print_errors_as_information: bool = False, log_file: str = None, timeoutInSeconds: int = 600, addLogOverhead: bool = False, title: str = None, log_namespace: str = "", arguments_for_log:  list[str] = None, throw_exception_if_exitcode_is_not_zero: bool = True, custom_argument: object = None, interactive: bool = False) -> tuple[int, str, str, int]:
         # verbosity 1: No output will be logged.
@@ -1284,82 +1248,37 @@ class ScriptCollectionCore:
 
             if verbosity >= 3:
                 GeneralUtilities.write_message_to_stdout(f"Run '{info_for_log}'.")
+
+            print_live_output = 1 < verbosity
+
+            exit_code: int = None
+            stdout: str = ""
+            stderr: str = ""
+            pid: int = None
+
             with self.__run_program_argsasarray_async_helper(program, arguments_as_array, working_directory, verbosity, print_errors_as_information, log_file, timeoutInSeconds, addLogOverhead, title, log_namespace, arguments_for_log, custom_argument, interactive) as process:
+
                 pid = process.pid
+                for out_line, err_line in ScriptCollectionCore.__read_popen_pipes(process):
+                    if print_live_output:
+                        #print(out_line, end='')
+                        GeneralUtilities.write_message_to_stdout(out_line)
+                        #print(err_line, end='')
+                        GeneralUtilities.write_message_to_stderr(err_line)
 
-                stdout_lines = list[str]()
-                stderr_lines = list[str]()
-
-                live_console_output_printing = 2 < verbosity and interactive
-
-                log_to_file = log_file is not None
-                if log_to_file:
-                    GeneralUtilities.ensure_file_exists(log_file)
-
-                if interactive:
-                    # there are 2 issues in this part:
-                    # 1.: ctrl+c
-                    # 2.: sometimes this function does not terminate even if the started process exited
-                    def stream_process(process) -> bool:
-                        try:
-                            go: bool = process.poll() is None
-
-                            stdoutreader: BufferedReader = process.stdout
-                            if stdoutreader.readable():
-                                stdoutresultb: bytes = stdoutreader.read()
-                                stdoutresult = GeneralUtilities.bytes_to_string(
-                                    stdoutresultb)
-                                stdoutlines = GeneralUtilities.string_to_lines(stdoutresult)
-                                for line in stdoutlines:
-                                    line_stripped = line.replace("\r", "").strip()
-                                    if len(line_stripped) > 0:
-                                        line_str = line_stripped
-                                        stdout_lines.append(line_str)
-                                        if live_console_output_printing:
-                                            GeneralUtilities.write_message_to_stdout(line_str)
-                                        if log_to_file:
-                                            GeneralUtilities.append_line_to_file(
-                                                log_file, line_str)
-
-                            stderrreader: BufferedReader = process.stderr
-                            if stderrreader.readable():
-                                stderrresultb: bytes = stderrreader.read()
-                                stderrresult = GeneralUtilities.bytes_to_string(stderrresultb)
-                                stderrlines = GeneralUtilities.string_to_lines(stderrresult)
-                                for line in stderrlines:
-                                    line_stripped = line.replace("\r", "").strip()
-                                    if len(line_stripped) > 0:
-                                        line_str = line_stripped
-                                        stderr_lines.append(line_str)
-                                        if live_console_output_printing:
-                                            if print_errors_as_information:
-                                                GeneralUtilities.write_message_to_stdout(line_str)
-                                            else:
-                                                GeneralUtilities.write_message_to_stderr(line_str)
-                                        if log_to_file:
-                                            GeneralUtilities.append_line_to_file(log_file, line_str)
-
-                            return go
-                        except Exception:
-                            return False
-
-                    while stream_process(process):
-                        time.sleep(0.1)
-
-                    exit_code = process.poll()
-                    stdout = '\n'.join(stdout_lines)
-                    stderr = '\n'.join(stderr_lines)
-                else:
-                    stdout, stderr = process.communicate()
-                    exit_code = process.wait()
-                    stdout = GeneralUtilities.bytes_to_string(stdout).replace('\r', '')
-                    stderr = GeneralUtilities.bytes_to_string(stderr).replace('\r', '')
+                    if out_line is not None and GeneralUtilities.string_has_content(out_line):
+                        stdout = stdout+"\n"+out_line
+                    if err_line is not None and GeneralUtilities.string_has_content(err_line):
+                        stderr = stderr+"\n"+err_line
 
-                if throw_exception_if_exitcode_is_not_zero and exit_code != 0:
-                    raise ValueError(f"Program '{working_directory}>{program} {arguments_for_log_as_string}' resulted in exitcode {exit_code}. (StdOut: '{stdout}', StdErr: '{stderr}')")
+                process.poll()
+                exit_code = process.returncode
 
-                result = (exit_code, stdout, stderr, pid)
-                return result
+            if throw_exception_if_exitcode_is_not_zero and exit_code != 0:
+                raise ValueError(f"Program '{working_directory}>{program} {arguments_for_log_as_string}' resulted in exitcode {exit_code}. (StdOut: '{stdout}', StdErr: '{stderr}')")
+
+            result = (exit_code, stdout, stderr, pid)
+            return result
         except Exception as e:
             raise e
 
@@ -1516,8 +1435,7 @@ class ScriptCollectionCore:
             result = self.get_version_from_gitversion(repository_folder, "MajorMinorPatch")
             if self.git_repository_has_uncommitted_changes(repository_folder):
                 if self.get_current_git_branch_has_tag(repository_folder):
-                    id_of_latest_tag = self.git_get_commitid_of_tag(
-                        repository_folder, self.get_latest_git_tag(repository_folder))
+                    id_of_latest_tag = self.git_get_commitid_of_tag(repository_folder, self.get_latest_git_tag(repository_folder))
                     current_commit = self.git_get_commit_id(repository_folder)
                     current_commit_is_on_latest_tag = id_of_latest_tag == current_commit
                     if current_commit_is_on_latest_tag:
@@ -1560,8 +1478,7 @@ class ScriptCollectionCore:
         self.run_program("openssl", f'genrsa -out {filename}.key {rsa_key_length}', folder)
         self.run_program("openssl", f'req -new -subj /C={subj_c}/ST={subj_st}/L={subj_l}/O={subj_o}/CN={domain}/OU={subj_ou} -x509 -key {filename}.key -out {filename}.unsigned.crt -days {days_until_expire}', folder)
         self.run_program("openssl", f'pkcs12 -export -out {filename}.selfsigned.pfx -password pass:{password} -inkey {filename}.key -in {filename}.unsigned.crt', folder)
-        GeneralUtilities.write_text_to_file(
-            os.path.join(folder, f"{filename}.password"), password)
+        GeneralUtilities.write_text_to_file(os.path.join(folder, f"{filename}.password"), password)
         GeneralUtilities.write_text_to_file(os.path.join(folder, f"{filename}.san.conf"), f"""[ req ]
 default_bits        = {rsa_key_length}
 distinguished_name  = req_distinguished_name
@@ -1587,8 +1504,7 @@ DNS                 = {domain}
 
     @GeneralUtilities.check_arguments
     def generate_certificate_sign_request(self, folder: str, domain: str, filename: str, subj_c: str, subj_st: str, subj_l: str, subj_o: str, subj_ou: str) -> None:
-        self.run_program(
-            "openssl", f'req -new -subj /C={subj_c}/ST={subj_st}/L={subj_l}/O={subj_o}/CN={domain}/OU={subj_ou} -key {filename}.key -out {filename}.csr -config {filename}.san.conf', folder)
+        self.run_program("openssl", f'req -new -subj /C={subj_c}/ST={subj_st}/L={subj_l}/O={subj_o}/CN={domain}/OU={subj_ou} -key {filename}.key -out {filename}.csr -config {filename}.san.conf', folder)
 
     @GeneralUtilities.check_arguments
     def sign_certificate(self, folder: str, ca_folder: str, ca_name: str, domain: str, filename: str, days_until_expire: int = None) -> None:
@@ -1616,11 +1532,13 @@ DNS                 = {domain}
         elif ">" in line:
             try:
                 # line is something like "cyclonedx-bom>=2.0.2" and the function must return with the updated version
-                # (something like "cyclonedx-bom>=3.11.0" for example)
+                # (something like "cyclonedx-bom>=2.11.0" for example)
                 package = line.split(">")[0]
                 operator = ">=" if ">=" in line else ">"
                 response = requests.get(f'https://pypi.org/pypi/{package}/json', timeout=5)
                 latest_version = response.json()['info']['version']
+                # TODO update only minor- and patch-version
+                # TODO print info if there is a new major-version
                 return package+operator+latest_version
             except:
                 return line
@@ -1683,8 +1601,7 @@ DNS                 = {domain}
         GeneralUtilities.ensure_directory_exists(packagecontent_entireresult_folder)
 
         # create "debian-binary"-file
-        debianbinary_file = os.path.join(
-            packagecontent_entireresult_folder, "debian-binary")
+        debianbinary_file = os.path.join(packagecontent_entireresult_folder, "debian-binary")
         GeneralUtilities.ensure_file_exists(debianbinary_file)
         GeneralUtilities.write_text_to_file(debianbinary_file, "2.0\n")
 
@@ -1701,10 +1618,10 @@ DNS                 = {domain}
         link_file = f"/usr/bin/{toolname.lower()}"
         permission = str(permission_of_executable_file_as_octet_triple)
         GeneralUtilities.write_text_to_file(postinst_file, f"""#!/bin/sh
-    ln -s {exe_file} {link_file}
-    chmod {permission} {exe_file}
-    chmod {permission} {link_file}
-    """)
+ln -s {exe_file} {link_file}
+chmod {permission} {exe_file}
+chmod {permission} {link_file}
+""")
 
         #  control
         control_file = os.path.join(packagecontent_control_folder, "control")
@@ -1775,24 +1692,22 @@ DNS                 = {domain}
         proxies = None
         if GeneralUtilities.string_has_content(proxy):
             proxies = {"http": proxy}
-        response = requests.get('https://ipinfo.io',
-                                proxies=proxies, timeout=5)
+        response = requests.get('https://ipinfo.io',  proxies=proxies, timeout=5)
         network_information_as_json_string = GeneralUtilities.bytes_to_string(
             response.content)
         return network_information_as_json_string
 
     @GeneralUtilities.check_arguments
     def change_file_extensions(self, folder: str, from_extension: str, to_extension: str, recursive: bool, ignore_case: bool) -> None:
-        extension_to_compare:str=None
+        extension_to_compare: str = None
         if ignore_case:
-            extension_to_compare=from_extension.lower()
+            extension_to_compare = from_extension.lower()
         else:
-            extension_to_compare=from_extension
+            extension_to_compare = from_extension
         for file in GeneralUtilities.get_direct_files_of_folder(folder):
-            if (ignore_case and file.lower().endswith(f".{extension_to_compare}")
-                    or not ignore_case and file.endswith(f".{extension_to_compare}")):
+            if (ignore_case and file.lower().endswith(f".{extension_to_compare}") or not ignore_case and file.endswith(f".{extension_to_compare}")):
                 p = Path(file)
                 p.rename(p.with_suffix('.'+to_extension))
         if recursive:
             for subfolder in GeneralUtilities.get_direct_folders_of_folder(folder):
-                self.change_file_extensions(subfolder, from_extension, to_extension, recursive,ignore_case)
+                self.change_file_extensions(subfolder, from_extension, to_extension, recursive, ignore_case)

{ScriptCollection-3.5.12.dist-info → ScriptCollection-3.5.14.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: ScriptCollection
-Version: 3.5.12
+Version: 3.5.14
 Summary: The ScriptCollection is the place for reusable scripts.
 Home-page: https://github.com/anionDev/ScriptCollection
 Author: Marius Göcke

{ScriptCollection-3.5.12.dist-info → ScriptCollection-3.5.14.dist-info}/RECORD

@@ -1,16 +1,16 @@
 ScriptCollection/Executables.py,sha256=msAlVLjgrxCxW-5Uu7Gk8NI1CNQLK2i6TjNR1fppaCY,19535
-ScriptCollection/GeneralUtilities.py,sha256=kfvlZaqbbC9ZPgEiNIHFdleUpu-686rRjcNKDreiqaE,34941
+ScriptCollection/GeneralUtilities.py,sha256=AElXv2NO30cTw-Qs3qVmO-YCOQ5FvBQM3RZMywuKQ_Y,35121
 ScriptCollection/ProcessesRunner.py,sha256=3mu4ZxzZleQo0Op6o9EYTCFiJfb6kx5ov2YfZfT89mU,1395
 ScriptCollection/ProgramRunnerBase.py,sha256=7QAjoqOz6XPmJH19F2k-Z1fFQB_uZnPFvn-T54IJcHQ,2324
 ScriptCollection/ProgramRunnerEpew.py,sha256=C2Rs3YWOWWWJct7XmKphp5CF1tf0j4Fp-ljV2drLTfs,6349
-ScriptCollection/ProgramRunnerPopen.py,sha256=ECx35Yz-MKPeoRa_42Bsq8qmbHd13I40vXUJSpZPrI4,3475
+ScriptCollection/ProgramRunnerPopen.py,sha256=G3LgQUVCfaq7XjBsGzalElH31Hbr0etttGR2_H87YzA,3512
 ScriptCollection/RPStream.py,sha256=NRRHL3YSP3D9MuAV2jB_--0KUKCsvJGxeKnxgrRZ9kY,1545
-ScriptCollection/ScriptCollectionCore.py,sha256=Xi9Htfv8F8AXQ04cbPpm2cf2KgqRpNyAWv2eFP2mMlM,96680
+ScriptCollection/ScriptCollectionCore.py,sha256=na1wwDDpUOZAyIqPREH5MeCn1IJfYvN0NEm-YeViCdE,92720
 ScriptCollection/TasksForCommonProjectStructure.py,sha256=-QxOB01yFHrcPpTNnDA0GY0rv9McvQ95DZ3PNHRCrFE,184090
 ScriptCollection/UpdateCertificates.py,sha256=Eynbgu7k9jLxApP2D_8Il77B6BFjJap6K7oTeEAZYbk,7790
 ScriptCollection/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-ScriptCollection-3.5.12.dist-info/METADATA,sha256=KluMvH8NET-JxQTy_phEnaAkKFOrWzEzP5dFBSZR36o,7680
-ScriptCollection-3.5.12.dist-info/WHEEL,sha256=UvcQYKBHoFqaQd6LKyqHw9fxEolWLQnlzP0h_LgJAfI,91
-ScriptCollection-3.5.12.dist-info/entry_points.txt,sha256=Jz1pyS3Q6lqpuOWVHogt00jGwrpcHYtPrHGY0_Ltjbo,2227
-ScriptCollection-3.5.12.dist-info/top_level.txt,sha256=hY2hOVH0V0Ce51WB76zKkIWTUNwMUdHo4XDkR2vYVwg,17
-ScriptCollection-3.5.12.dist-info/RECORD,,
+ScriptCollection-3.5.14.dist-info/METADATA,sha256=e_vy24P8qOOWX0xn2ds4jO7IrEojsfAR4c5pCa1FcgM,7680
+ScriptCollection-3.5.14.dist-info/WHEEL,sha256=GV9aMThwP_4oNCtvEC2ec3qUYutgWeAzklro_0m4WJQ,91
+ScriptCollection-3.5.14.dist-info/entry_points.txt,sha256=Jz1pyS3Q6lqpuOWVHogt00jGwrpcHYtPrHGY0_Ltjbo,2227
+ScriptCollection-3.5.14.dist-info/top_level.txt,sha256=hY2hOVH0V0Ce51WB76zKkIWTUNwMUdHo4XDkR2vYVwg,17
+ScriptCollection-3.5.14.dist-info/RECORD,,

{ScriptCollection-3.5.12.dist-info → ScriptCollection-3.5.14.dist-info}/WHEEL

@@ -1,5 +1,5 @@
 Wheel-Version: 1.0
-Generator: setuptools (74.0.0)
+Generator: setuptools (75.1.0)
 Root-Is-Purelib: true
 Tag: py3-none-any