ScriptCollection 4.2.58__py3-none-any.whl → 4.2.60__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):
+    Windows_AMD64 = 0
+    Linux_AMD64 = 1
+    Linux_ARM64 = 2
+    MacOS_ARM64 = 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.Windows_AMD64
+        elif system == "linux" and machine in ("x86_64", "amd64"):
+            return Platform.Linux_AMD64
+        elif system == "linux" and machine in ("arm64", "aarch64"):
+            return Platform.Linux_ARM64
+        elif system == "darwin" and machine in ("x86_64", "amd64"):
+            return Platform.MacOS_ARM64
+        else:
+            raise ValueError(f"Unsupported platform: {system}/{machine}")
+
+    @staticmethod
+    @check_arguments
+    def platform_to_short_str(platform_value: Platform) -> str:
+        mapping = {
+            Platform.Windows_AMD64: "win-x64",
+            Platform.Linux_AMD64:   "linux-x64",
+            Platform.Linux_ARM64:   "linux-arm64",
+            Platform.MacOS_ARM64:   "osx-arm64",
+        }
+        return mapping[platform_value]
+    
+    @staticmethod
+    @check_arguments
+    def platform_from_short_str(platform_str: str) -> Platform:
+        mapping = {
+            "win-x64": Platform.Windows_AMD64,
+            "linux-x64":   Platform.Linux_AMD64,
+            "linux-arm64": Platform.Linux_ARM64,
+            "osx-arm64":   Platform.MacOS_ARM64,
+        }
+        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.Windows_AMD64: "Windows-x64",
+            Platform.Linux_AMD64:   "Linux-x64",
+            Platform.Linux_ARM64:   "Linux-arm64",
+            Platform.MacOS_ARM64:   "MacOS-arm64",
+        }
+        return mapping[platform_value]
+
+    @staticmethod
+    @check_arguments
+    def platform_from_dash_str(platform_str: str) -> Platform:
+        mapping = {
+            "Windows-x64": Platform.Windows_AMD64,
+            "Linux-x64":   Platform.Linux_AMD64,
+            "Linux-arm64": Platform.Linux_ARM64,
+            "MacOS-arm64":   Platform.MacOS_ARM64,
+        }
+        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.Windows_AMD64: "windows/amd64",
+            Platform.Linux_AMD64:   "linux/amd64",
+            Platform.Linux_ARM64:   "linux/arm64",
+            Platform.MacOS_ARM64:   "linux/arm64",  # macOS → linux container
+        }
+        return mapping[platform_value]
+    
+    @staticmethod
+    @check_arguments
+    def platform_to_dotnet_runtime_identifier(platform_value: Platform) -> str:
+        mapping = {
+            Platform.Windows_AMD64: "win-x64",
+            Platform.Linux_AMD64:   "linux-x64",
+            Platform.Linux_ARM64:   "linux-arm64",
+            Platform.MacOS_ARM64:   "osx-arm64",
+        }
+        return mapping[platform_value]
+
+    @staticmethod
+    @check_arguments
+    def get_all_platforms() -> list[Platform]:
+        return [
+            Platform.Windows_AMD64, 
+            Platform.Linux_AMD64, 
+            Platform.Linux_ARM64, 
+            Platform.MacOS_ARM64,
+        ]
+    

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.58"
+version = "4.2.60"
 __version__ = version
 
 class VSCodeWorkspaceShellTask:
@@ -215,29 +215,49 @@ class ScriptCollectionCore:
 
     def registry_contains_image(self,registry_url:str,image:str,registry_username:str,registry_password:str)->bool:
         """This function assumes that the registry is a custom deployed docker-registry (see https://hub.docker.com/_/registry )"""
-        if "/" in image:
-            image=image.rsplit("/", 1)[-1]
-        registry_username,registry_password=self.__load_credentials_if_required_and_available(registry_url,registry_username,registry_password)
-        catalog_url = f"{registry_url}/v2/_catalog"
-        response = requests.get(catalog_url, auth=(registry_username, registry_password),timeout=20)
-        response.raise_for_status() # check if statuscode = 200
-        data = response.json()
-        # expected: {"repositories": ["nginx", "myapp"]}
-        images = data.get("repositories", [])
-        result=image in images
-        return result
+        try:
+            if "/" in image:
+                image=image.rsplit("/", 1)[-1]
+            registry_username,registry_password=self.__load_credentials_if_required_and_available(registry_url,registry_username,registry_password)
+            catalog_url = f"{registry_url}/v2/_catalog"
+            response = requests.get(catalog_url, auth=(registry_username, registry_password),timeout=20)
+            response.raise_for_status() # check if statuscode = 200
+            data = response.json()
+            # expected: {"repositories": ["nginx", "myapp"]}
+            images = data.get("repositories", [])
+            if not (image in images):
+                return False
+        
+            if self.get_tags_of_images_from_registry(registry_url,image,registry_username,registry_password)<1:
+                return False
+            
+            return True
+        except Exception:
+            return False
     
-    @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.Linux_AMD64:
+            return "linux-amd64"
+        elif platform_value == Platform.Linux_ARM64:
+            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 +2890,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
@@ -3202,9 +3223,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)
@@ -3212,10 +3235,29 @@ 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)
+
+    @GeneralUtilities.check_arguments
+    def get_all_commits_in_git_repository(self,repository_folder:str,include_all_heads:bool=False) -> list[str]:
+        """Returns a textual visualization of all commits in a git-repository."""
+        #do 'git log --reverse --all --pretty=format:"%ci | %H | %cn <%ce> | %s"'
+        args = ["log", "--reverse", "--pretty=format:%ci | %H | %cn <%ce> | %s"]
+        if include_all_heads:
+            args.append("--all")
+        result=self.run_program_argsasarray("git", args, repository_folder, throw_exception_if_exitcode_is_not_zero=True)
+        return result[1]
+
+    @GeneralUtilities.check_arguments
+    def write_commit_list_for_repository(self,repository_folder:str,target_file:str,include_all_heads:bool=False) -> None:
+        if os.path.isabs(target_file):
+            target_file=GeneralUtilities.resolve_relative_path(target_file,repository_folder)
+        target_file=GeneralUtilities.normalize_path(target_file)
+        commits=self.get_all_commits_in_git_repository(repository_folder, include_all_heads)
+        GeneralUtilities.ensure_file_exists(target_file)
+        GeneralUtilities.write_lines_to_file(target_file, commits)

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()
+        GeneralUtilities.ensure_folder_exists_and_is_empty(app_artifacts_folder)
+        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())}", "--build-arg", f"Platform={GeneralUtilities.platform_to_dash_str(platform)}", "--build-arg", f"DotNetRuntime={GeneralUtilities.platform_to_dotnet_runtime_identifier(platform)}"]
+            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("--load")
+            args.append(".")
+            codeunit_content_folder = 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)
+            
+            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,22 @@ 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()
+        platform_for_test:Platform=None
+        if current_platform == Platform.Windows_AMD64:
+            platform_for_test=Platform.Linux_AMD64
+        elif current_platform == Platform.Linux_AMD64:
+            platform_for_test=Platform.Linux_AMD64
+        elif current_platform == Platform.Linux_ARM64:
+            platform_for_test=Platform.Linux_ARM64
+        elif current_platform == Platform.MacOS_ARM64:
+            platform_for_test=Platform.Linux_ARM64
+        else:
+            raise ValueError(f"Current platform {current_platform} is not supported for testing.")
         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,platform_for_test)
         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/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.Windows_AMD64:
+                        platform_str = "windows_amd64"
+                    case Platform.Linux_ARM64:
+                        platform_str = "linux_arm64"
+                    case Platform.Linux_AMD64:
+                        platform_str = "linux_amd64"
+                    case Platform.MacOS_ARM64:
+                        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.Windows_AMD64)
+        download_and_extract("Linux", "linux", "tar.gz",Platform.Linux_AMD64)
+        download_and_extract("Linux", "linux", "tar.gz",Platform.Linux_ARM64)
+        download_and_extract("MacOS", "darwin", "tar.gz",Platform.MacOS_ARM64)
  
     @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,7 +1160,6 @@ 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:
         folder_of_this_file = os.path.dirname(push_artifacts_file)
@@ -1154,33 +1169,87 @@ class TFCPS_Tools_General:
         if match := re.search(filename_regex, filename, re.IGNORECASE):
             codeunitname = match.group(1)
         else:
-            raise ValueError(f"Expected push-artifacts-file to match the regex \"{filename_regex}\" where \"{codeunitname_regex}\" represents the codeunit-name.")
-        
+            raise ValueError(f"Expected push-artifacts-file to match the regex \"{filename_regex}\" where \"{codeunitname_regex}\" represents the codeunit-name.")        
         repository_folder = GeneralUtilities.resolve_relative_path(f"..{os.path.sep}..{os.path.sep}Submodules{os.path.sep}{repository_folder_name}", folder_of_this_file)
         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}")
+        tar_files=[f for f in GeneralUtilities.get_direct_files_of_folder(applicationimage_folder) if f.endswith(".tar")]
+        target_image_address=f"{registry}/{remote_image_name}"
+        tar_files_with_platforms: list[tuple[str, str, str]] = []
+        for tar_file in tar_files:
+            filename=os.path.basename(tar_file)#filename looks like "{codeunitname}_v{codeunitversion}_{GeneralUtilities.platform_to_dash_str(platform)}.tar"
+            platform:Platform=self.platform_from_filename(filename)#GeneralUtilities.platform_from_dash_str( filename.split("_")[-1].split(".")[0])
+            platform_os_in_docker_format :str = None
+            platform_arch_in_docker_format :str = None
+            if platform==Platform.Windows_AMD64:
+                raise NotImplementedError("Building docker images for Windows is not implemented yet.")
+            elif platform==Platform.Linux_AMD64:
+                platform_os_in_docker_format = "linux"
+                platform_arch_in_docker_format = "amd64"
+            elif platform==Platform.Linux_ARM64: 
+                platform_os_in_docker_format = "linux"
+                platform_arch_in_docker_format = "arm64"
+            elif platform==Platform.MacOS_ARM64:
+                raise NotImplementedError("Building docker images for MacOS is not implemented yet.")
+            else:
+                raise ValueError(f"Unsupported platform {platform} extracted from filename {filename}.")
+            tar_files_with_platforms.append((tar_file, platform_os_in_docker_format, platform_arch_in_docker_format))
+        self.push_docker_build_artifact_as_multi_arch_artifact(tar_files_with_platforms,target_image_address, "v"+codeunit_version)
+        self.push_docker_build_artifact_as_multi_arch_artifact(tar_files_with_platforms,target_image_address, "latest")
         if push_readme:
-            self.__sc.run_program_with_retry("docker-pushrm", f"{remote_repo}", codeunit_folder)
-
+            self.__sc.run_program_with_retry("docker-pushrm", target_image_address, codeunit_folder)
+
+    def push_docker_build_artifact_as_multi_arch_artifact(self,tar_files: list[tuple[str, str, str]], image_address: str, tag: str):
+        """
+        tar_files: list of (tar_path, os, arch) tuples
+        for example [
+            ("MyApp.Linux.arm64.tar", "linux", "arm64"),
+            ("MyApp.Linux.amd64.tar", "linux", "amd64")
+        ]
+        image_address for example: "myregistry.example.com/myapp"
+        tag for example: "1.0.0"
+        """
+        arch_tags = []
+
+        for tar_path, os_name, arch in tar_files:
+            arch_tag = f"{image_address}:{tag}-{os_name}-{arch}"
+            arch_tags.append(arch_tag)
+
+            # Load tar → local image
+            print(f"Loading {tar_path}...")
+            result = self.__sc.run_program_argsasarray("docker",[ "load", "-i", tar_path], capture_output=True)
+            # docker load outputs: "Loaded image: sha256:abc123..." or "Loaded image ID: ..."
+            # we need the loaded image ID
+            loaded_id = None
+            for line in GeneralUtilities.string_to_lines(result[1]):
+                if "Loaded image" in line:
+                    loaded_id = line.split(":", 1)[1].strip()
+                    break
+
+            if not loaded_id:
+                raise RuntimeError(f"Could not determine loaded image from output: \"{result[1]}\"")
+
+            # Retag + push
+            self.__sc.run_program_argsasarray("docker",[ "tag", loaded_id, arch_tag])
+            self.__sc.run_program_argsasarray("docker",[ "push", arch_tag])
+
+        # Create multi-arch manifest
+        final_tag = f"{image_address}:{tag}"
+        self.__sc.run_program_argsasarray("docker", [ "buildx", "imagetools", "create", "--tag", final_tag] + arch_tags)
+
+
+    @GeneralUtilities.check_arguments
+    def platform_from_filename(self,filename: str) -> Platform:
+        match = re.search(r'_([^_]+)\.tar', filename)
+        if match:
+            return GeneralUtilities.platform_from_dash_str(match.group(1))
+        else:
+            raise ValueError(f"Cannot extract platform from filename: \"{filename}\"")
+    
     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 +1276,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 +1298,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.58.dist-info → scriptcollection-4.2.60.dist-info}/METADATA

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

{scriptcollection-4.2.58.dist-info → scriptcollection-4.2.60.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=FEjJEfA3riVT7G4sL8bzKPb7w0SN8YjONNWMtiBo_j8,64882
 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=c-wSuEa8_T_-GC-iE3fNO7Yr7gB92b4R1zAwQN2-QSM,174896
+ScriptCollection/ScriptCollectionCore.py,sha256=k9Jxim56NM5dr6wAZrITk-bxZhKKxeXi1gb1zkfcDUo,176930
 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=RCwtEwuZUds-gyHa2qCitWZUgapM3-IZJKF9e5Zwxck,98000
 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=xMuj-GoEwDnmUWbmdF536dNQL7jnTaw9aQ-gcDqUkgQ,11743
 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
@@ -45,10 +45,10 @@ ScriptCollection/TFCPS/Go/TFCPS_CodeUnitSpecific_Go.py,sha256=kyx26AnT1-LySFA46w
 ScriptCollection/TFCPS/Go/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 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.58.dist-info/METADATA,sha256=Lm4CyXwLiuq4Qr6srolxs5gr6CRuojWuzOeD9x0qonY,7690
-scriptcollection-4.2.58.dist-info/WHEEL,sha256=aeYiig01lYGDzBgS8HxWXOg3uV61G9ijOsup-k9o1sk,91
-scriptcollection-4.2.58.dist-info/entry_points.txt,sha256=27XwAJEcaMEc1be0Ec1vKHCbiU4Ziu8jKL-SqsrYOIQ,4680
-scriptcollection-4.2.58.dist-info/top_level.txt,sha256=hY2hOVH0V0Ce51WB76zKkIWTUNwMUdHo4XDkR2vYVwg,17
-scriptcollection-4.2.58.dist-info/RECORD,,
+scriptcollection-4.2.60.dist-info/METADATA,sha256=dQYQcvTQgiDemUjezOsxBCyPOkzYt6DkBe7HSGQUxf4,7690
+scriptcollection-4.2.60.dist-info/WHEEL,sha256=aeYiig01lYGDzBgS8HxWXOg3uV61G9ijOsup-k9o1sk,91
+scriptcollection-4.2.60.dist-info/entry_points.txt,sha256=27XwAJEcaMEc1be0Ec1vKHCbiU4Ziu8jKL-SqsrYOIQ,4680
+scriptcollection-4.2.60.dist-info/top_level.txt,sha256=hY2hOVH0V0Ce51WB76zKkIWTUNwMUdHo4XDkR2vYVwg,17
+scriptcollection-4.2.60.dist-info/RECORD,,