ScriptCollection 4.2.57__py3-none-any.whl → 4.2.59__py3-none-any.whl

ScriptCollection/Executables.py

@@ -900,7 +900,7 @@ def AddImageToCustomRegistry()->int:
     sc:ScriptCollectionCore=ScriptCollectionCore()
     verbosity=int(args.verbosity)
     sc.log.loglevel=LogLevel(verbosity)
-    sc.add_image_to_custom_docker_image_registry(args.remotehub,args.imagenameonremotehub,args.ownregistryaddress,args.imagenameonownregistry,args.tag,args.username,args.password,args.removeimagelocally)
+    sc.add_image_to_custom_docker_image_registry(args.remotehub,args.imagenameonremotehub,args.ownregistryaddress,args.imagenameonownregistry,args.tag,args.username,args.password)
     return 0
 
 def SyncXlfFiles()->int:

ScriptCollection/GeneralUtilities.py

@@ -35,6 +35,12 @@ class VersionEcholon(Enum):
     LatestPatchOrLatestMinorOrNextMajor = 2
     LatestVersion = 3
 
+class Platform(Enum):
+    WindowsAMD64 = 0
+    LinuxAMD64 = 1
+    LinuxARM64 = 2
+    MacOSARM64 = 3
+
 
 class Dependency:
     dependencyname:str
@@ -1429,4 +1435,102 @@ class GeneralUtilities:
         result= GeneralUtilities.escape_json_property_value(str_value)
         #do other adaptions here if desired/required
         return result
-    
+    
+        
+    @staticmethod
+    @check_arguments
+    def get_current_platform() -> Platform:
+        system = platform.system().lower()
+        machine = platform.machine().lower()
+
+        if system == "windows" and machine in ("x86_64", "amd64"):
+            return Platform.WindowsAMD64
+        elif system == "linux" and machine in ("x86_64", "amd64"):
+            return Platform.LinuxAMD64
+        elif system == "linux" and machine in ("arm64", "aarch64"):
+            return Platform.LinuxARM64
+        elif system == "darwin" and machine in ("x86_64", "amd64"):
+            return Platform.MacOSARM64
+        else:
+            raise ValueError(f"Unsupported platform: {system}/{machine}")
+
+    @staticmethod
+    @check_arguments
+    def platform_to_short_str(platform_value: Platform) -> str:
+        mapping = {
+            Platform.WindowsAMD64: "win-x64",
+            Platform.LinuxAMD64:   "linux-x64",
+            Platform.LinuxARM64:   "linux-arm64",
+            Platform.MacOSARM64:   "osx-arm64",
+        }
+        return mapping[platform_value]
+    
+    @staticmethod
+    @check_arguments
+    def platform_from_short_str(platform_str: str) -> Platform:
+        mapping = {
+            "win-x64": Platform.WindowsAMD64,
+            "linux-x64":   Platform.LinuxAMD64,
+            "linux-arm64": Platform.LinuxARM64,
+            "osx-arm64":   Platform.MacOSARM64,
+        }
+        if platform_str not in mapping:
+            raise ValueError(f"Unsupported platform string: {platform_str}")
+        return mapping[platform_str]
+    
+    @staticmethod
+    @check_arguments
+    def platform_to_dash_str(platform_value: Platform) -> str:
+        mapping = {
+            Platform.WindowsAMD64: "Windows-x64",
+            Platform.LinuxAMD64:   "Linux-x64",
+            Platform.LinuxARM64:   "Linux-arm64",
+            Platform.MacOSARM64:   "MacOS-arm64",
+        }
+        return mapping[platform_value]
+
+    @staticmethod
+    @check_arguments
+    def platform_from_dash_str(platform_str: str) -> Platform:
+        mapping = {
+            "Windows-x64": Platform.WindowsAMD64,
+            "Linux-x64":   Platform.LinuxAMD64,
+            "Linux-arm64": Platform.LinuxARM64,
+            "MacOS-arm64":   Platform.MacOSARM64,
+        }
+        if platform_str not in mapping:
+            raise ValueError(f"Unsupported platform string: {platform_str}")
+        return mapping[platform_str]
+
+    @staticmethod
+    @check_arguments
+    def platform_to_docker_platform_str(platform_value: Platform) -> str:
+        mapping = {
+            Platform.WindowsAMD64: "windows/amd64",
+            Platform.LinuxAMD64:   "linux/amd64",
+            Platform.LinuxARM64:   "linux/arm64",
+            Platform.MacOSARM64:   "linux/arm64",  # macOS → linux container
+        }
+        return mapping[platform_value]
+    
+    @staticmethod
+    @check_arguments
+    def platform_to_dotnet_runtime_identifier(platform_value: Platform) -> str:
+        mapping = {
+            Platform.WindowsAMD64: "win-x64",
+            Platform.LinuxAMD64:   "linux-x64",
+            Platform.LinuxARM64:   "linux-arm64",
+            Platform.MacOSARM64:   "osx-arm64",
+        }
+        return mapping[platform_value]
+
+    @staticmethod
+    @check_arguments
+    def get_all_platforms() -> list[Platform]:
+        return [
+            Platform.WindowsAMD64, 
+            Platform.LinuxAMD64, 
+            Platform.LinuxARM64, 
+            Platform.MacOSARM64,
+        ]
+    

ScriptCollection/ScriptCollectionCore.py

@@ -31,12 +31,12 @@ import qrcode
 import pycdlib
 import send2trash
 from pypdf import PdfReader, PdfWriter
-from .GeneralUtilities import GeneralUtilities
+from .GeneralUtilities import GeneralUtilities,Platform
 from .ProgramRunnerBase import ProgramRunnerBase
 from .ProgramRunnerPopen import ProgramRunnerPopen
 from .SCLog import SCLog, LogLevel
 
-version = "4.2.57"
+version = "4.2.59"
 __version__ = version
 
 class VSCodeWorkspaceShellTask:
@@ -227,17 +227,29 @@ class ScriptCollectionCore:
         result=image in images
         return result
     
-    @GeneralUtilities.check_arguments
-    def add_image_to_custom_docker_image_registry(self,remote_hub:str,imagename_on_remote_hub:str,own_registry_address:str,imagename_on_own_registry:str,tag:str,registry_username:str,registry_password:str,remove_locally_in_the_end:bool)->None:
-        registry_username,registry_password=self.__load_credentials_if_required_and_available(remote_hub,registry_username,registry_password)
-        source_address=f"{remote_hub}/{imagename_on_remote_hub}:{tag}"
-        target_address=f"{own_registry_address}/{imagename_on_own_registry}:{tag}"
-        self.run_program("docker",f"pull {source_address}")
-        self.run_program("docker",f"tag {source_address} {target_address}")
-        self.run_program("docker",f"push {target_address}")
-        if remove_locally_in_the_end:
-            self.run_program("docker",f"rmi {source_address}")
-            self.run_program("docker",f"rmi {target_address}")
+    def docker_platform_to_slug(self,platform_value: Platform) -> str:
+        if platform_value == Platform.LinuxAMD64:
+            return "linux-amd64"
+        elif platform_value == Platform.LinuxARM64:
+            return "linux-arm64"
+        raise ValueError(f"Unsupported platform: {platform_value}")
+
+    @GeneralUtilities.check_arguments
+    def add_image_to_custom_docker_image_registry(
+        self,
+        remote_hub: str,
+        imagename_on_remote_hub: str,
+        own_registry_address: str,
+        imagename_on_own_registry: str,
+        tag: str,
+        registry_username: str,
+        registry_password: str,
+    ) -> None:
+        registry_username, registry_password = self.__load_credentials_if_required_and_available(remote_hub, registry_username, registry_password)
+        source_address = f"{remote_hub}/{imagename_on_remote_hub}:{tag}"
+        target_address = f"{own_registry_address}/{imagename_on_own_registry}:{tag}"
+        self.run_program("docker", f"buildx imagetools create --tag {target_address} {source_address}")#this does pull and push for each platform
+
 
     def get_tags_of_images_from_registry(self,registry_base_url:str,image:str,registry_username:str,registry_password:str)->list[str]:
         """registry_base_url must be in the format 'https://myregistry.example.com'
@@ -2870,6 +2882,7 @@ OCR-content:
         if remove_images:
             self.run_program_with_retry("docker","image prune -a -f",amount_of_attempts=amount_of_attempts)
         self.run_program_with_retry("docker","builder prune -a -f",amount_of_attempts=amount_of_attempts)
+        self.run_program_with_retry("docker","buildx prune -f",amount_of_attempts=amount_of_attempts,throw_exception_if_exitcode_is_not_zero=False) # buildx prune is not available on every machine.
         self.run_program_with_retry("docker","system df",print_live_output=self.log.loglevel==LogLevel.Debug,amount_of_attempts=amount_of_attempts)
 
     @GeneralUtilities.check_arguments
@@ -3123,6 +3136,7 @@ OCR-content:
         #sync existing files
         self.__sync_xlf2_files(base_file_xml, language_files_with_content)
             
+
     @GeneralUtilities.check_arguments
     def translate_xlf_files_in_folder(self, folder: str, base_language: str, libre_translate_api_server: str):
         """Translates all .xlf files directly in the given folder (non-recursive)."""
@@ -3201,9 +3215,11 @@ OCR-content:
         return results[0]["language"]
 
     @GeneralUtilities.check_arguments
-    def get_all_files_in_git_repository(self,repository_folder:str,include_submodules: bool = True) -> list[str]:
-        """returns all files in a git-repository except ignored files"""
-        cmd = ["ls-files", "--cached", "--exclude-standard"]
+    def get_all_files_in_git_repository(self,repository_folder:str,ignore_ignored_files:bool=True,include_submodules: bool = True) -> list[str]:
+        """Returns a list of all files in a git-repository."""
+        cmd = ["ls-files", "--cached"]
+        if ignore_ignored_files:
+            cmd.append("--exclude-standard")
         if include_submodules:
             cmd.append("--recurse-submodules")
         output=self.run_program_argsasarray("git", cmd,repository_folder)
@@ -3211,10 +3227,10 @@ OCR-content:
         return files
 
     @GeneralUtilities.check_arguments
-    def write_file_list_for_repository(self,repository_folder:str,target_file:str="./FileList.txt") -> None:
+    def write_file_list_for_repository(self,repository_folder:str,target_file:str="./FileList.txt",ignore_ignored_files:bool=True,include_submodules: bool = True) -> None:
         if os.path.isabs(target_file):
             target_file=GeneralUtilities.resolve_relative_path(target_file,repository_folder)
         target_file=GeneralUtilities.normalize_path(target_file)
-        files=self.get_all_files_in_git_repository(repository_folder)
+        files=self.get_all_files_in_git_repository(repository_folder,ignore_ignored_files,include_submodules)
         GeneralUtilities.ensure_file_exists(target_file)
         GeneralUtilities.write_lines_to_file(target_file, files)

ScriptCollection/TFCPS/Docker/TFCPS_CodeUnitSpecific_Docker.py

@@ -3,7 +3,7 @@ from urllib import request
 import time
 import ssl
 from datetime import timedelta,datetime
-from ...GeneralUtilities import GeneralUtilities
+from ...GeneralUtilities import GeneralUtilities, Platform
 from ...SCLog import  LogLevel
 from ..TFCPS_CodeUnitSpecific_Base import TFCPS_CodeUnitSpecific_Base,TFCPS_CodeUnitSpecific_Base_CLI
 
@@ -13,32 +13,36 @@ class TFCPS_CodeUnitSpecific_Docker_Functions(TFCPS_CodeUnitSpecific_Base):
     def __init__(self,current_file:str,verbosity:LogLevel,targetenvironmenttype:str,use_cache:bool,is_pre_merge:bool):
         super().__init__(current_file, verbosity,targetenvironmenttype,use_cache,is_pre_merge)
 
+    
     @GeneralUtilities.check_arguments
-    def build(self,custom_arguments:dict[str,str]) -> None:
+    def build(self,platforms:list[Platform],custom_arguments:dict[str,str]) -> None:
         codeunitname: str =self.get_codeunit_name()
-        codeunit_folder =self.get_codeunit_folder() 
+        codeunit_folder =self.get_codeunit_folder()
         codeunitname_lower = codeunitname.lower()
         codeunit_file =self.get_codeunit_file()
         codeunitversion = self.tfcps_Tools_General.get_version_of_codeunit(codeunit_file)
-        args = ["image", "build", "--pull", "--force-rm", "--progress=plain", "--build-arg", f"TargetEnvironmentType={self.get_target_environment_type()}", "--build-arg", f"CodeUnitName={codeunitname}", "--build-arg", f"CodeUnitVersion={codeunitversion}", "--build-arg", f"CodeUnitOwnerName={self.tfcps_Tools_General.get_codeunit_owner_name(self.get_codeunit_file())}", "--build-arg", f"CodeUnitOwnerEMailAddress={self.tfcps_Tools_General.get_codeunit_owner_emailaddress(self.get_codeunit_file())}"]
         if custom_arguments is None:
             custom_arguments=dict[str,str]()
-        for custom_argument_key, custom_argument_value in custom_arguments.items():
-            args.append("--build-arg")
-            args.append(f"{custom_argument_key}={custom_argument_value}")
-        args = args+["--tag", f"{codeunitname_lower}:latest", "--tag", f"{codeunitname_lower}:{codeunitversion}", "--file", f"{codeunitname}/Dockerfile"]
-        if not self.use_cache():
-            args.append("--no-cache")
-        args.append(".")
-        codeunit_content_folder = os.path.join(codeunit_folder)
-        GeneralUtilities.retry_action(lambda: self._protected_sc.run_program_argsasarray("docker", args, codeunit_content_folder, print_errors_as_information=True), 3)
-        artifacts_folder = GeneralUtilities.resolve_relative_path("Other/Artifacts", codeunit_folder)
-        app_artifacts_folder = os.path.join(artifacts_folder, "BuildResult_OCIImage")
-        GeneralUtilities.ensure_directory_does_not_exist(app_artifacts_folder)
-        GeneralUtilities.ensure_directory_exists(app_artifacts_folder)
-        self._protected_sc.run_program_argsasarray("docker", ["save", "--output", f"{codeunitname}_v{codeunitversion}.tar", f"{codeunitname_lower}:{codeunitversion}"], app_artifacts_folder, print_errors_as_information=True)
-        self.copy_source_files_to_output_directory()
+        for platform in platforms:
+            #builder must be created once before with "docker buildx create --use"
+            args = ["buildx","build", "--platform",GeneralUtilities.platform_to_docker_platform_str(platform), "--pull", "--force-rm", "--progress=plain", "--build-arg", f"TargetEnvironmentType={self.get_target_environment_type()}", "--build-arg", f"CodeUnitName={codeunitname}", "--build-arg", f"CodeUnitVersion={codeunitversion}", "--build-arg", f"CodeUnitOwnerName={self.tfcps_Tools_General.get_codeunit_owner_name(self.get_codeunit_file())}", "--build-arg", f"CodeUnitOwnerEMailAddress={self.tfcps_Tools_General.get_codeunit_owner_emailaddress(self.get_codeunit_file())}"]
+            for custom_argument_key, custom_argument_value in custom_arguments.items():
+                args.append("--build-arg")
+                args.append(f"{custom_argument_key}={custom_argument_value}")
+            args = args+["--tag", f"{codeunitname_lower}:latest", "--tag", f"{codeunitname_lower}:{codeunitversion}", "--file", f"{codeunitname}/Dockerfile"]
+            if not self.use_cache():
+                args.append("--no-cache")
+            args.append(".")
+            codeunit_content_folder = os.path.join(codeunit_folder)
+            GeneralUtilities.retry_action(lambda a=args, f=codeunit_content_folder: self._protected_sc.run_program_argsasarray("docker", a, f, print_errors_as_information=True), 3)
+            artifacts_folder = GeneralUtilities.resolve_relative_path("Other/Artifacts", codeunit_folder)
+            app_artifacts_folder = os.path.join(artifacts_folder, "BuildResult_OCIImage")
+            GeneralUtilities.ensure_directory_does_not_exist(app_artifacts_folder)
+            GeneralUtilities.ensure_directory_exists(app_artifacts_folder)
+            
+            self._protected_sc.run_program_argsasarray("docker", ["save", "--output", f"{codeunitname}_v{codeunitversion}_{GeneralUtilities.platform_to_dash_str(platform)}.tar", f"{codeunitname_lower}:{codeunitversion}"], app_artifacts_folder, print_errors_as_information=True)
         self.__generate_sbom_for_docker_image()
+        self.copy_source_files_to_output_directory()
 
 
     @GeneralUtilities.check_arguments
@@ -93,10 +97,11 @@ class TFCPS_CodeUnitSpecific_Docker_Functions(TFCPS_CodeUnitSpecific_Base):
             timeout=timedelta(seconds=120)
         if environment_variables is None:
             environment_variables={}
+        current_platform = GeneralUtilities.get_current_platform()
         oci_image_artifacts_folder :str= GeneralUtilities.resolve_relative_path("Other/Artifacts/BuildResult_OCIImage", self.get_codeunit_folder())
         container_name:str=f"{self.get_codeunit_name()}finaltest".lower()
         self.tfcps_Tools_General.ensure_containers_are_not_running([container_name])
-        self.tfcps_Tools_General.load_docker_image(oci_image_artifacts_folder)
+        self.tfcps_Tools_General.load_docker_image(oci_image_artifacts_folder,current_platform)
         codeunit_file:str=os.path.join(self.get_codeunit_folder(),f"{self.get_codeunit_name()}.codeunit.xml")
         image=f"{self.get_codeunit_name()}:{self.tfcps_Tools_General.get_version_of_codeunit(codeunit_file)}".lower()
         argument=f"run -d --name {container_name}"

ScriptCollection/TFCPS/NodeJS/TFCPS_CodeUnitSpecific_NodeJS.py

@@ -157,7 +157,7 @@ class TFCPS_CodeUnitSpecific_NodeJS_Functions(TFCPS_CodeUnitSpecific_Base):
     @GeneralUtilities.check_arguments
     def get_available_cultures_for_angular_app(self)->None:
         return self._protected_sc.get_available_cultures_for_angular_app(self.get_codeunit_folder()+"/angular.json")
-    
+
     @GeneralUtilities.check_arguments
     def __ensure_translations_exist(self,languages:list[str])->None:
         base_file=os.path.join(self.get_codeunit_folder(),"Other","Resources","Translations",f"messages.xlf")
@@ -166,7 +166,6 @@ class TFCPS_CodeUnitSpecific_NodeJS_Functions(TFCPS_CodeUnitSpecific_Base):
             if not os.path.isfile(target_file):
                 GeneralUtilities.ensure_file_exists(target_file)
                 GeneralUtilities.write_text_to_file(target_file, GeneralUtilities.read_text_from_file(base_file))
-                
                 #set new attribute
                 tree = ET.parse(target_file)
                 root = tree.getroot()
@@ -197,12 +196,22 @@ class TFCPS_CodeUnitSpecific_NodeJS_Functions(TFCPS_CodeUnitSpecific_Base):
         self._protected_sc.sync_xlf2_files("messages",languages,os.path.join(self.get_codeunit_folder(),"Other","Resources","Translations"))
 
     @GeneralUtilities.check_arguments
-    def translate_safe(self)->None:
-        pass#TODO if ~/.ScriptCollection/TranslationService.txt exists: use this and call translate(...)
-    
+    def translate_safe(self,base_language:str="en")->None:
+        """Translates XLF files if a translation service is configured. The translation service can be configured by creating a file at ~/.ScriptCollection/TranslationServiceProperties.txt with the content 'LibreTranslateAPI=your_api_server_url'."""
+        translationservice_file:str=self._protected_sc.get_global_cache_folder()+"/TranslationServiceProperties.txt"
+        api_server:str=None
+        if os.path.isfile(translationservice_file):
+            lines=GeneralUtilities.read_nonempty_lines_from_file(translationservice_file)
+            for line in lines:
+                if line.startswith("LibreTranslateAPI="):
+                    api_server=line.replace("LibreTranslateAPI=","").strip()
+        GeneralUtilities.assert_not_null(api_server,"No translation service configured. Please create a file at ~/.ScriptCollection/TranslationServiceProperties.txt with the content 'LibreTranslateAPI=your_api_server_url' to enable automatic translation of XLF files.")
+        self.translate(api_server,base_language)
+
     @GeneralUtilities.check_arguments
-    def translate(self,api_server:str)->None:
-        pass#TODO if Other/Resources/Translations exists: call sc.translate_messages_in_folder(...)
+    def translate(self,api_server:str,base_language:str="en")->None:
+        folder:str=os.path.join(self.get_codeunit_folder(),"Other","Resources","Translations")
+        self._protected_sc.translate_xlf_files_in_folder(folder, base_language, api_server)
 
 class TFCPS_CodeUnitSpecific_NodeJS_CLI:
 

ScriptCollection/TFCPS/Python/TFCPS_CodeUnitSpecific_Python.py

@@ -23,8 +23,7 @@ class TFCPS_CodeUnitSpecific_Python_Functions(TFCPS_CodeUnitSpecific_Base):
     def generate_bom_for_python_project(self) -> None:
         codeunit_folder: str=self.get_codeunit_folder()
         codeunitname: str=self.get_codeunit_name()
-        repository_folder = os.path.dirname(codeunit_folder) 
-        
+        repository_folder = os.path.dirname(codeunit_folder)
         codeunitversion = self.tfcps_Tools_General.get_version_of_codeunit(self.get_codeunit_file())
         bom_folder = "Other/Artifacts/BOM"
         bom_folder_full = os.path.join(codeunit_folder, bom_folder)
@@ -40,7 +39,7 @@ class TFCPS_CodeUnitSpecific_Python_Functions(TFCPS_CodeUnitSpecific_Base):
 
         GeneralUtilities.ensure_file_exists(bom_file_json)
         GeneralUtilities.write_text_to_file(bom_file_json, result[1])
-        cyclonedx_exe=self.tfcps_Tools_General.ensure_cyclonedxcli_is_available(repository_folder,not self.use_cache())
+        cyclonedx_exe=self.tfcps_Tools_General.ensure_cyclonedxcli_is_available(not self.use_cache())
         self._protected_sc.run_program(cyclonedx_exe, f"convert --input-file ./{codeunitname}/{bom_file_relative_json} --input-format json --output-file ./{codeunitname}/{bom_file_relative_xml} --output-format xml", repository_folder)
         self._protected_sc.format_xml_file(bom_file_xml)
         GeneralUtilities.ensure_file_does_not_exist(bom_file_json)

ScriptCollection/TFCPS/TFCPS_Tools_General.py

@@ -16,7 +16,7 @@ import urllib.request
 from packaging import version
 import requests
 from lxml import etree
-from ..GeneralUtilities import GeneralUtilities
+from ..GeneralUtilities import GeneralUtilities,Platform
 from ..ScriptCollectionCore import ScriptCollectionCore,VSCodeWorkspaceShellTask
 from ..SCLog import  LogLevel
 from ..OCIImages.AbstractImageHandler import AbstractImageHandler
@@ -38,7 +38,7 @@ class TFCPS_Tools_General:
         return GeneralUtilities.string_to_boolean(str(root.xpath('//cps:codeunit/@enabled', namespaces={'cps': 'https://projects.aniondev.de/PublicProjects/Common/ProjectTemplates/-/tree/main/Conventions/RepositoryStructure/CommonProjectStructure'})[0]))
 
     @GeneralUtilities.check_arguments
-    def ensure_cyclonedxcli_is_available(self, target_folder: str,enforce_update:bool) -> str:
+    def ensure_cyclonedxcli_is_available(self,enforce_update:bool) -> str:
         local_filename = "cyclonedx-cli"
         filename_on_github: str
         if GeneralUtilities.current_system_is_windows():
@@ -46,20 +46,20 @@ class TFCPS_Tools_General:
             local_filename = local_filename+".exe"
         else:
             filename_on_github = "cyclonedx-linux-x64"
-        return self.ensure_file_from_github_assets_is_available_with_retry(target_folder, "CycloneDX", "cyclonedx-cli", "CycloneDXCLI", local_filename, lambda latest_version: filename_on_github,enforce_update=enforce_update)
+        return self.ensure_file_from_github_assets_is_available_with_retry("CycloneDX",  "cyclonedx-cli", "CycloneDXCLI",local_filename,lambda latest_version: filename_on_github,enforce_update=enforce_update)
     
     @GeneralUtilities.check_arguments
-    def ensure_file_from_github_assets_is_available_with_retry(self, target_folder: str, githubuser: str, githubprojectname: str, resource_name: str, local_filename: str, get_filename_on_github, amount_of_attempts: int = 5,enforce_update:bool=False) -> str:
-        return GeneralUtilities.retry_action(lambda: self.ensure_file_from_github_assets_is_available(target_folder, githubuser, githubprojectname, resource_name, local_filename, get_filename_on_github,enforce_update), amount_of_attempts)
+    def ensure_file_from_github_assets_is_available_with_retry(self, githubuser: str, githubprojectname: str, local_resource_name: str, local_filename: str, get_filename_on_github, amount_of_attempts: int = 5,enforce_update:bool=False) -> str:
+        return GeneralUtilities.retry_action(lambda: self.ensure_file_from_github_assets_is_available(githubuser, githubprojectname, local_resource_name, local_filename, get_filename_on_github,enforce_update), amount_of_attempts)
 
     @GeneralUtilities.check_arguments
-    def ensure_file_from_github_assets_is_available(self, target_folder: str, githubuser: str, githubprojectname: str, resource_name: str, local_filename: str, get_filename_on_github,enforce_update:bool) -> str:
+    def ensure_file_from_github_assets_is_available(self,githubuser: str, githubprojectname: str, local_resource_name: str, local_filename: str, get_filename_on_github,enforce_update:bool) -> str:
         #TODO use or remove target_folder-parameter
-        resource_folder =os.path.join( self.__sc.get_global_cache_folder(),"Tools",resource_name)
+        resource_folder =os.path.join( self.__sc.get_global_cache_folder(),"Tools",local_resource_name)
         file = f"{resource_folder}/{local_filename}"
         file_exists = os.path.isfile(file)
         if not file_exists:
-            self.__sc.log.log(f"Download Asset \"{githubuser}/{githubprojectname}: {resource_name}\" from GitHub to global cache...", LogLevel.Information)
+            self.__sc.log.log(f"Download Asset \"{githubuser}/{githubprojectname}: {local_resource_name}\" from GitHub to global cache...", LogLevel.Information)
             GeneralUtilities.ensure_folder_exists_and_is_empty(resource_folder)
             headers = { 'User-Agent': 'Mozilla/5.0'}
             self.__add_github_api_key_if_available(headers)
@@ -459,7 +459,7 @@ class TFCPS_Tools_General:
         target_original_sbom_file_relative = os.path.dirname(target_sbom_file_relative)+"/"+os.path.basename(target_sbom_file_relative)+".original.xml"
         os.rename(os.path.join(repository_folder, target_sbom_file_relative), os.path.join(repository_folder, target_original_sbom_file_relative))
 
-        cyclonedx_exe:str=self.ensure_cyclonedxcli_is_available(repository_folder,not use_cache)
+        cyclonedx_exe:str=self.ensure_cyclonedxcli_is_available(not use_cache)
         self.__sc.run_program(cyclonedx_exe, f"merge --input-files {source_sbom_file_relative} {target_original_sbom_file_relative} --output-file {target_sbom_file_relative}", repository_folder)
         GeneralUtilities.ensure_file_does_not_exist(os.path.join(repository_folder, target_original_sbom_file_relative))
         self.__sc.format_xml_file(os.path.join(repository_folder, target_sbom_file_relative))
@@ -496,21 +496,20 @@ class TFCPS_Tools_General:
     def generate_svg_files_from_plantuml_files_for_repository(self, repository_folder: str,use_cache:bool) -> None:
         self.__sc.log.log("Generate svg-files from plantuml-files...")
         self.__sc.assert_is_git_repository(repository_folder)
-        plantuml_jar_file=self.ensure_plantuml_is_available(repository_folder,not use_cache)
+        plantuml_jar_file=self.ensure_plantuml_is_available(not use_cache)
         target_folder = os.path.join(repository_folder, "Other",  "Reference")
         self.__generate_svg_files_from_plantuml(target_folder, plantuml_jar_file)
 
     @GeneralUtilities.check_arguments
     def generate_svg_files_from_plantuml_files_for_codeunit(self, codeunit_folder: str,use_cache:bool) -> None:
         self.assert_is_codeunit_folder(codeunit_folder)
-        repository_folder = os.path.dirname(codeunit_folder)
-        plantuml_jar_file=self.ensure_plantuml_is_available(repository_folder,not use_cache)
+        plantuml_jar_file=self.ensure_plantuml_is_available(not use_cache)
         target_folder = os.path.join(codeunit_folder, "Other", "Reference")
         self.__generate_svg_files_from_plantuml(target_folder, plantuml_jar_file)
 
     @GeneralUtilities.check_arguments
-    def ensure_plantuml_is_available(self, target_folder: str,enforce_update:bool) -> str:
-        return self.ensure_file_from_github_assets_is_available_with_retry(target_folder, "plantuml", "plantuml", "PlantUML", "plantuml.jar", lambda latest_version: "plantuml.jar",enforce_update=enforce_update)
+    def ensure_plantuml_is_available(self,enforce_update:bool) -> str:
+        return self.ensure_file_from_github_assets_is_available_with_retry("plantuml", "plantuml", "PlantUML", "plantuml.jar", lambda latest_version: "plantuml.jar",enforce_update=enforce_update)
 
     @GeneralUtilities.check_arguments
     def __generate_svg_files_from_plantuml(self, diagrams_files_folder: str, plantuml_jar_file: str) -> None:
@@ -578,7 +577,7 @@ class TFCPS_Tools_General:
             target_folder_extracted = os.path.join(self.__sc.get_global_cache_folder(),"Tools",resource_name)
             update:bool=not os.path.isdir(target_folder_extracted) or GeneralUtilities.folder_is_empty(target_folder_extracted) or enforce_update
             if update:
-                downloaded_file=self.ensure_file_from_github_assets_is_available_with_retry(target_folder_unextracted, "trufflesecurity", "trufflehog", resource_name+"_Unextracted", zip_filename, lambda latest_version: f"trufflehog_{latest_version[1:]}_{osname_in_github_asset}_amd64.tar.gz",enforce_update=enforce_update)
+                downloaded_file=self.ensure_file_from_github_assets_is_available_with_retry( "trufflesecurity", "trufflehog", resource_name+"_Unextracted", zip_filename, lambda latest_version: f"trufflehog_{latest_version[1:]}_{osname_in_github_asset}_amd64.tar.gz",enforce_update=enforce_update)
                 #TODO add option to also download arm-version
                 local_zip_file: str = downloaded_file
                 GeneralUtilities.ensure_folder_exists_and_is_empty(target_folder_extracted)
@@ -639,33 +638,50 @@ class TFCPS_Tools_General:
 
     @GeneralUtilities.check_arguments
     def ensure_androidappbundletool_is_available(self, target_folder: str,enforce_update:bool) -> str:
-        return self.ensure_file_from_github_assets_is_available_with_retry(target_folder, "google", "bundletool", "AndroidAppBundleTool", "bundletool.jar", lambda latest_version: f"bundletool-all-{latest_version}.jar",enforce_update=enforce_update)
+        return self.ensure_file_from_github_assets_is_available_with_retry( "google", "bundletool", "AndroidAppBundleTool", "bundletool.jar", lambda latest_version: f"bundletool-all-{latest_version}.jar",enforce_update=enforce_update)
 
     @GeneralUtilities.check_arguments
     def ensure_mediamtx_is_available(self, target_folder: str,enforce_update:bool) -> None:
-        def download_and_extract(osname: str, osname_in_github_asset: str, extension: str):
-            resource_name: str = f"MediaMTX_{osname}"
-            zip_filename: str = f"{resource_name}.{extension}"
+        def download_and_extract(osname: str, osname_in_github_asset: str, extension: str,architecture:Platform):
+            resource_name: str = f"MediaMTX_{GeneralUtilities.platform_to_dash_str(architecture)}"
             resource_folder: str = os.path.join(target_folder, "Other", "Resources", resource_name)
             target_folder_extracted = os.path.join(resource_folder, "MediaMTX")
             update:bool=not os.path.isdir(target_folder_extracted) or GeneralUtilities.folder_is_empty(target_folder_extracted) or enforce_update
             if update:
-                self.ensure_file_from_github_assets_is_available_with_retry(target_folder, "bluenviron", "mediamtx", resource_name, zip_filename, lambda latest_version: f"mediamtx_{latest_version}_{osname_in_github_asset}_amd64.{extension}",enforce_update=enforce_update)
-                local_zip_file: str = os.path.join(resource_folder, f"{resource_name}.{extension}")
+                platform_str:str=None
+                match architecture:
+                    case Platform.WindowsAMD64:
+                        platform_str = "windows_amd64"
+                    case Platform.LinuxARM64:
+                        platform_str = "linux_arm64"
+                    case Platform.LinuxAMD64:
+                        platform_str = "linux_amd64"
+                    case Platform.MacOSARM64:
+                        platform_str = "darwin_arm64"
+                    case _:
+                        raise ValueError(f"Unknown platform: {str(architecture)}")
+
+                resource_filename_name_remote:str=f"mediamtx_{platform_str}.{extension}"
+                resource_name_local:str=f"MediaMTCX_{platform_str}"
+                global_cache_file=os.path.join( self.__sc.get_global_cache_folder(),"Tools",resource_name_local,resource_filename_name_remote)
+                if (not os.path.isfile( global_cache_file )) or enforce_update:
+                    self.ensure_file_from_github_assets_is_available_with_retry( "bluenviron", "mediamtx", resource_name_local, resource_filename_name_remote, lambda latest_version: f"mediamtx_{latest_version}_{platform_str}.{extension}",enforce_update=enforce_update)
+                    GeneralUtilities.assert_file_exists(global_cache_file)
+                GeneralUtilities.assert_file_exists(global_cache_file)
                 GeneralUtilities.ensure_folder_exists_and_is_empty(target_folder_extracted)
                 if extension == "zip":
-                    with zipfile.ZipFile(local_zip_file, 'r') as zip_ref:
+                    with zipfile.ZipFile(global_cache_file, 'r') as zip_ref:
                         zip_ref.extractall(target_folder_extracted)
                 elif extension == "tar.gz": 
-                    with tarfile.open(local_zip_file, "r:gz") as tar:
+                    with tarfile.open(global_cache_file, "r:gz") as tar:
                         tar.extractall(path=target_folder_extracted)
                 else:
                     raise ValueError(f"Unknown extension: \"{extension}\"")
-                GeneralUtilities.ensure_file_does_not_exist(local_zip_file)
 
-        download_and_extract("Windows", "windows", "zip")
-        download_and_extract("Linux", "linux", "tar.gz")
-        download_and_extract("MacOS", "darwin", "tar.gz")
+        download_and_extract("Windows", "windows", "zip",Platform.WindowsAMD64)
+        download_and_extract("Linux", "linux", "tar.gz",Platform.LinuxAMD64)
+        download_and_extract("Linux", "linux", "tar.gz",Platform.LinuxARM64)
+        download_and_extract("MacOS", "darwin", "tar.gz",Platform.MacOSARM64)
  
     @GeneralUtilities.check_arguments
     def clone_repository_as_resource(self, local_repository_folder: str, remote_repository_link: str, resource_name: str, repository_subname: str = None,use_cache:bool=True) -> None:
@@ -1144,9 +1160,8 @@ class TFCPS_Tools_General:
         if write_to_file:
             GeneralUtilities.write_text_to_file(version_file, latest_version_function)
 
-
     @GeneralUtilities.check_arguments
-    def push_docker_build_artifact(self, push_artifacts_file: str, registry: str, push_readme: bool, repository_folder_name: str, remote_image_name: str = None) -> None:
+    def push_docker_build_artifact(self, push_artifacts_file: str, registry: str, push_readme: bool, repository_folder_name: str, remote_image_name: str = None,default_platform:Platform=None) -> None:
         folder_of_this_file = os.path.dirname(push_artifacts_file)
         filename = os.path.basename(push_artifacts_file)
         codeunitname_regex: str = "([a-zA-Z0-9]+)"
@@ -1160,27 +1175,44 @@ class TFCPS_Tools_General:
         codeunit_folder = os.path.join(repository_folder, codeunitname)
         artifacts_folder = os.path.join(repository_folder,codeunitname, "Other", "Artifacts")
         applicationimage_folder = os.path.join(artifacts_folder, "BuildResult_OCIImage")
-        image_file = self.__sc.find_file_by_extension(applicationimage_folder, "tar")
-        image_filename = os.path.basename(image_file)
         codeunit_version = self.get_version_of_codeunit(os.path.join(codeunit_folder, f"{codeunitname}.codeunit.xml"))
         if remote_image_name is None:
             remote_image_name = codeunitname
-        remote_image_name = remote_image_name.lower()
-        local_image_name = codeunitname.lower()
-        remote_repo = f"{registry}/{remote_image_name}"
-        remote_image_latest = f"{remote_repo}:latest"
-        remote_image_version = f"{remote_repo}:{codeunit_version}"
-        self.__sc.log.log("Load image...")
-        self.__sc.run_program("docker", f"load --input {image_filename}", applicationimage_folder)
-        self.__sc.log.log("Tag image...")
-        self.__sc.run_program_with_retry("docker", f"tag {local_image_name}:{codeunit_version} {remote_image_latest}")
-        self.__sc.run_program_with_retry("docker", f"tag {local_image_name}:{codeunit_version} {remote_image_version}")
-        self.__sc.log.log("Push image...")
-        self.__sc.run_program_with_retry("docker", f"push {remote_image_latest}")
-        self.__sc.run_program_with_retry("docker", f"push {remote_image_version}")
-        if push_readme:
-            self.__sc.run_program_with_retry("docker-pushrm", f"{remote_repo}", codeunit_folder)
 
+        def push_image(tar_file:str,tag:str,remote_image_name:str):
+            GeneralUtilities.assert_condition(tag==tag.lower(), f"Tag \"{tag}\" must be in lower-case.")
+            remote_image_name = remote_image_name.lower()
+            local_image_name = codeunitname.lower()
+            remote_repo = f"{registry}/{remote_image_name}"
+            remote_image_version = f"{remote_repo}:{tag}"
+            self.__sc.log.log("Load image...")
+            self.__sc.run_program("docker", f"load --input {tar_file}", applicationimage_folder)
+            self.__sc.log.log("Tag image...")
+            self.__sc.run_program_with_retry("docker", f"tag {local_image_name}:{tag} {remote_image_version}")
+            self.__sc.log.log("Push image...")
+            self.__sc.run_program_with_retry("docker", f"push {remote_image_version}")
+            if push_readme:
+                self.__sc.run_program_with_retry("docker-pushrm", f"{remote_repo}", codeunit_folder)
+
+        default_tar_image_file:str=None
+        for image_file in GeneralUtilities.get_direct_files_of_folder(applicationimage_folder):
+            image_filename = os.path.basename(image_file)
+            platform:Platform=self.platform_from_filename(image_filename)
+            tag=codeunit_version+"-"+GeneralUtilities.platform_to_short_str(platform).lower()
+            if platform == default_platform:
+                default_tar_image_file:str=image_file
+            push_image(image_file,tag,remote_image_name)
+        if default_tar_image_file is not None:
+            push_image(default_tar_image_file,"latest",remote_image_name)
+            push_image(default_tar_image_file,codeunit_version,remote_image_name)
+
+    @GeneralUtilities.check_arguments
+    def platform_from_filename(self,filename: str) -> Platform:
+        match = re.search(r'_([^_]+)\.tar', filename)
+        if not match:
+            raise ValueError(f"Cannot extract platform from filename: {filename}")        
+        return GeneralUtilities.platform_from_dash_str(match.group(1))
+    
     def prepare_building_codeunits(self,repository_folder:str,use_cache:bool,generate_development_certificate:bool):        
         if generate_development_certificate:
             self.ensure_certificate_authority_for_development_purposes_is_generated(repository_folder)
@@ -1207,10 +1239,14 @@ class TFCPS_Tools_General:
             self.__sc.run_program("docker", f"container rm -f {container_name}", throw_exception_if_exitcode_is_not_zero=False)
         
     @GeneralUtilities.check_arguments
-    def load_docker_image(self, oci_image_artifacts_folder:str) -> None:
-        image_filename = os.path.basename(self.__sc.find_file_by_extension(oci_image_artifacts_folder, "tar"))
-        self.__sc.log.log("Load docker-image...")
-        self.__sc.run_program("docker", f"load -i {image_filename}", oci_image_artifacts_folder)
+    def load_docker_image(self, oci_image_artifacts_folder:str,platform:Platform) -> None:
+        for file in GeneralUtilities.get_direct_files_of_folder(oci_image_artifacts_folder):
+            if file.endswith(f"_{GeneralUtilities.platform_to_dash_str(platform)}.tar"):
+                image_filename = file
+                self.__sc.log.log("Load docker-image...")
+                self.__sc.run_program("docker", f"load -i {image_filename}", oci_image_artifacts_folder)
+                return
+        raise ValueError(f"No docker-image found for platform {GeneralUtilities.platform_to_dash_str(platform)} in folder {oci_image_artifacts_folder}.")
 
     @GeneralUtilities.check_arguments
     def start_dockerfile_example(self, current_file: str,remove_old_container: bool, remove_volumes_folder: bool, env_file: str) -> None:
@@ -1225,7 +1261,7 @@ class TFCPS_Tools_General:
             self.__sc.log.log(f"Ensure container of {docker_compose_file} do not exist...")
         oci_image_artifacts_folder = GeneralUtilities.resolve_relative_path("../../../../Artifacts/BuildResult_OCIImage", folder_of_current_file)
         self.ensure_containers_are_not_running(container_names_to_remove)
-        self.load_docker_image(oci_image_artifacts_folder)
+        self.load_docker_image(oci_image_artifacts_folder,GeneralUtilities.get_current_platform())
         example_name = os.path.basename(folder_of_current_file)
         codeunit_name = os.path.basename(GeneralUtilities.resolve_relative_path("../../../../..", folder_of_current_file))
         if remove_volumes_folder:

{scriptcollection-4.2.57.dist-info → scriptcollection-4.2.59.dist-info}/METADATA

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

{scriptcollection-4.2.57.dist-info → scriptcollection-4.2.59.dist-info}/RECORD

@@ -1,7 +1,7 @@
 ScriptCollection/AnionBuildPlatform.py,sha256=K-PHarX802A0PU8uRu0GNcEZiXujFoXHACe-X9YJsAQ,11711
 ScriptCollection/CertificateUpdater.py,sha256=Pa6eyjQSx7IIvj4PQVMI0IwMs01KQrNSB7Qa-7lRfBs,9375
-ScriptCollection/Executables.py,sha256=O2apj_jYLmYy9_0iK3SFgez4EvfthIW1JsAmlGwp-8M,44534
-ScriptCollection/GeneralUtilities.py,sha256=J136V1Xb5-Q8VCKzms3oTo6teMjYPA4sMds8lD8R1PE,61183
+ScriptCollection/Executables.py,sha256=qpo0g5peWdlK5uLIUCyLDB9c3JCk0ETbtmOJXZwuHh4,44510
+ScriptCollection/GeneralUtilities.py,sha256=_7R_t46G1u8JNeUEl4HsgQ2mBGARFR6nIX_NUY2VNQY,64846
 ScriptCollection/HTTPMaintenanceOverheadHelper.py,sha256=TToNtyO1XzsMbBsTBf3o0xgOK0v4Jf03qw2Z0xb2nCk,2007
 ScriptCollection/ProcessesRunner.py,sha256=o5raxIt3lknNPoPrjNzJ2bprRPJ3SnL0rrR7crraD7E,1523
 ScriptCollection/ProgramRunnerBase.py,sha256=4A2eQgSg_rRgQcgSi-LYtUlM-uSQEpS7qFWn0tWt4uo,2171
@@ -9,7 +9,7 @@ ScriptCollection/ProgramRunnerMock.py,sha256=uTu-aFle1W_oKjeQEmuPsFPQpvo0kRf2FrR
 ScriptCollection/ProgramRunnerPopen.py,sha256=BPY7-ZMIlqT7JOKz8qlB5c0laF2Js-ijzqk09GxZC48,3821
 ScriptCollection/ProgramRunnerSudo.py,sha256=_khC3xuTdrPoLluBJZWfldltmmuKltABJPcbjZSFW-4,4835
 ScriptCollection/SCLog.py,sha256=8TRy1LeYMsPOIuWUcnUNNbO5pd-cNBS-3cn-kdzP8FU,4768
-ScriptCollection/ScriptCollectionCore.py,sha256=jjGd7cbFB-FpsXsymVoFcF_M9wXIZ2AIttcRfiXl8IU,174895
+ScriptCollection/ScriptCollectionCore.py,sha256=8U9gYLcex7DcrafJ6zP6_CN6YP5ebd-aLh5givt8SHo,175443
 ScriptCollection/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 ScriptCollection/OCIImages/AbstractImageHandler.py,sha256=83qDMILwxhH9DbC0sb358Vu8PXEysmJJyap_6gECZqs,1627
 ScriptCollection/OCIImages/OCIImageManager.py,sha256=aBogkSXNDyi8NO11N-s03nuFJEv7PyJ-wjHuYYeZfvs,6662
@@ -30,9 +30,9 @@ ScriptCollection/TFCPS/TFCPS_Generic.py,sha256=O-0guM_LJCcZmPZJhMgTvXD2RXUJEBWWv
 ScriptCollection/TFCPS/TFCPS_MergeToMain.py,sha256=-Ev9D3bZDlUk2WFQhcmvzQ3FCS97OdsVUd0koAdmpZc,7474
 ScriptCollection/TFCPS/TFCPS_MergeToStable.py,sha256=Ajfy2pLajTuU6UpwItHt4C2a-gLF3gPc4z6BktL3Cio,22163
 ScriptCollection/TFCPS/TFCPS_PreBuildCodeunitsScript.py,sha256=f0Uq1cA_4LvmL72cal0crrbKF6PcxL13D9wBKuQ1YBw,2328
-ScriptCollection/TFCPS/TFCPS_Tools_General.py,sha256=WV67pHLrhD_qEjUqM-8tUpEdhQ4brwVentfIf7AMOP4,93942
+ScriptCollection/TFCPS/TFCPS_Tools_General.py,sha256=zkdO9kHgPY-BHb13E9TbEIy06JD3EnKe2CWTx-6i5tM,96034
 ScriptCollection/TFCPS/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-ScriptCollection/TFCPS/Docker/TFCPS_CodeUnitSpecific_Docker.py,sha256=BPJkoy2KVgB_38cAk5qjM4s4FpJvOkTp467nrvANIIU,10606
+ScriptCollection/TFCPS/Docker/TFCPS_CodeUnitSpecific_Docker.py,sha256=VE1jAEP7trndm8u_5UR7YgWbHOvZJvRDaKUmPvtT4CM,11052
 ScriptCollection/TFCPS/Docker/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 ScriptCollection/TFCPS/DotNet/CertificateGeneratorInformationBase.py,sha256=bT6Gd5pQpZCw4OQz6HWkPCSn5z__eUUEisABLDSxd0o,200
 ScriptCollection/TFCPS/DotNet/CertificateGeneratorInformationGenerate.py,sha256=QyjOfMY22JWCvKjMelHiDWbJiWqotOfebpJpgDUaoO4,237
@@ -43,12 +43,12 @@ ScriptCollection/TFCPS/Flutter/TFCPS_CodeUnitSpecific_Flutter.py,sha256=U8oBAOLR
 ScriptCollection/TFCPS/Flutter/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 ScriptCollection/TFCPS/Go/TFCPS_CodeUnitSpecific_Go.py,sha256=kyx26AnT1-LySFA46wfJ9yZUKYdMWTD0U2XZfSQbuB0,3497
 ScriptCollection/TFCPS/Go/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-ScriptCollection/TFCPS/NodeJS/TFCPS_CodeUnitSpecific_NodeJS.py,sha256=Kkyyof6DML7jUdES5GmIXQ_yVMJ1xnJbZmbIAqls3IE,11816
+ScriptCollection/TFCPS/NodeJS/TFCPS_CodeUnitSpecific_NodeJS.py,sha256=kL37qJNwH6E-CAJqcHbdnc0K0uGjHQ8XD1RXZOdcw1M,12850
 ScriptCollection/TFCPS/NodeJS/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-ScriptCollection/TFCPS/Python/TFCPS_CodeUnitSpecific_Python.py,sha256=nLw_eSUd_56jjgfcAvtUyzecSZ14mYmNJl0iu-1YNVk,13496
+ScriptCollection/TFCPS/Python/TFCPS_CodeUnitSpecific_Python.py,sha256=KFKDdfV9DFHE5n7TI6m1Ra1Qw2JwL_JQjneBfqcRQ_w,13467
 ScriptCollection/TFCPS/Python/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-scriptcollection-4.2.57.dist-info/METADATA,sha256=iMa7-_9uZdnhT-dv-aA7iTfCkOk5d8-Os0jqzuyFT1Y,7690
-scriptcollection-4.2.57.dist-info/WHEEL,sha256=aeYiig01lYGDzBgS8HxWXOg3uV61G9ijOsup-k9o1sk,91
-scriptcollection-4.2.57.dist-info/entry_points.txt,sha256=27XwAJEcaMEc1be0Ec1vKHCbiU4Ziu8jKL-SqsrYOIQ,4680
-scriptcollection-4.2.57.dist-info/top_level.txt,sha256=hY2hOVH0V0Ce51WB76zKkIWTUNwMUdHo4XDkR2vYVwg,17
-scriptcollection-4.2.57.dist-info/RECORD,,
+scriptcollection-4.2.59.dist-info/METADATA,sha256=2AVlFcG9tMUQIWyeWjV0L4xuq46zScDA77h04vgkmco,7690
+scriptcollection-4.2.59.dist-info/WHEEL,sha256=aeYiig01lYGDzBgS8HxWXOg3uV61G9ijOsup-k9o1sk,91
+scriptcollection-4.2.59.dist-info/entry_points.txt,sha256=27XwAJEcaMEc1be0Ec1vKHCbiU4Ziu8jKL-SqsrYOIQ,4680
+scriptcollection-4.2.59.dist-info/top_level.txt,sha256=hY2hOVH0V0Ce51WB76zKkIWTUNwMUdHo4XDkR2vYVwg,17
+scriptcollection-4.2.59.dist-info/RECORD,,